def set_next_prev_urls(page,max_page,uri):
    if page < max_page:
        nexturi = replace_query_param(uri, 'page', page + 1)
    else:
        nexturi = None
    if page > 1:
        previous = replace_query_param(uri, 'page', page - 1)
    else:
        previous = None
    return nexturi, previous

 def to_native(self, value):
     if not value.has_next():
         return None
     page = value.next_page_number()
     request = self.context.get('request')
     url = request and request.build_absolute_uri() or ''
     return replace_query_param(url, self.page_field, page)

 def to_native(self, page_range):
     response = []
     request = self.context.get('request')
     url = request and request.build_absolute_uri() or ''
     for page in page_range:
         response.append(replace_query_param(url, self.page_field, page))
     return response

 def get_previous_link(self):
     url = self.request.build_absolute_uri()
     page = self.get_page()
     if page < 2:
         return None
     return replace_query_param(
         url, self.page_query_param, self.get_page() - 1)

 def to_representation(self, value):
     if not value.has_previous():
         return None
     page = value.previous_page_number()
     request = self.context.get('request')
     url = request and request.build_absolute_uri() or ''
     return replace_query_param(url, self.page_field, page)

 def reverse(self, viewname, args=None, kwargs=None, request=None, format=None, **extra):
     url = super(QueryParameterVersioning, self).reverse(
         viewname, args, kwargs, request, format, **extra
     )
     if request.version is not None:
         return replace_query_param(url, self.version_param, request.version)
     return url

    def build_page_url(self, page_identifier):
        """
        Builds a URL which can be used to access the given page identifer.

        In the general case, the page identifiers do not have to be numbers.
        """
        url = self.request.build_absolute_uri()
        return replace_query_param(url, self.paging_parameter, page_identifier)

def paginate_words(words, request):
    """Generate paginated output from a word query set"""
    page_size = _get_page_size(request)
    page_num = int(request.query_params.get('page', 1))
    paginator = Paginator(words, page_size)
    page = paginator.page(page_num)

    serializer = WordSerializer()
    response = {'count': paginator.count,
                'page_count': paginator.num_pages,
                'page': page_num,
                'results': serializer.serialize_many(page.object_list)}
    request_url = request.build_absolute_uri()
    if page.has_previous():
        response['previous'] = replace_query_param(request_url, 'page', page.previous_page_number())
    if page.has_next():
        response['next'] = replace_query_param(request_url, 'page', page.next_page_number())
    return Response(response)

    def paginate_queryset(self, queryset, page_size=None):
        page = super().paginate_queryset(queryset=queryset, page_size=page_size)

        if page is None:
            return page

        self.headers["x-pagination-count"] = page.paginator.count
        self.headers["x-paginated"] = "true"
        self.headers["x-paginated-by"] = page.paginator.per_page
        self.headers["x-pagination-current"] = page.number

        if page.has_next():
            num = page.next_page_number()
            url = self.request.build_absolute_uri()
            url = replace_query_param(url, "page", num)
            self.headers["X-Pagination-Next"] = url

        if page.has_previous():
            num = page.previous_page_number()
            url = self.request.build_absolute_uri()
            url = replace_query_param(url, "page", num)
            self.headers["X-Pagination-Prev"] = url

        return page

 def build_link(self, index):
     if not index:
         return None
     url = self.request and self.request.build_absolute_uri() or ''
     return replace_query_param(url, 'page', index)

def MongoDataPagination(DB_MongoClient, database, collection, query=None, page=1, nPerPage=None, uri=''):
    db = DB_MongoClient
    if query:
        query = ast.literal_eval(query)
        q = [(k, v) for k, v in query['spec'].items()]
        query['spec'] = dict(q)
        #print query
        count = db[database][collection].find(**query).count()
        #print count
        if nPerPage == 0:
            page=1
            offset=0
            max_page=1
        else:
            max_page = math.ceil(float(count) / nPerPage)
            # Page min is 1
            if page < 1:
                page = 1
            #Change page to last page with data
            if page * nPerPage > count:
                page = int(max_page)
            #Cover count =0
            if page < 1:
                page = 1
            offset = (page - 1) * nPerPage
        data = [row for row in db[database][collection].find(**query).skip(offset).limit(nPerPage)]
        #replace_query_param(uri, 'page', page)
    else:
        count = db[database][collection].find().count()
        if nPerPage == 0:
            page=1
            offset=0
            max_page=1
        else:
            max_page = math.ceil(float(count) / nPerPage)
            print max_page
            # Page min is 1
            if page < 1:
                page = 1
            #Change page to last page with data
            if page * nPerPage > count:
                page = int(max_page)
            #Cover count =0
            if page < 1:
                page = 1
            offset = (page - 1) * nPerPage
        data = [row for row in db[database][collection].find().skip(offset).limit(nPerPage)]
    if page < max_page:
        next = replace_query_param(uri, 'page', page + 1)
    else:
        next = None
    if page > 1:
        previous = replace_query_param(uri, 'page', page - 1)
    else:
        previous = None
    result = {'count': count, 'meta': {'page': page, 'page_size': nPerPage, 'pages': int(max_page)}, 'next': next,
              'previous': previous, 'results': data}

    try:
        od = collections.OrderedDict(sorted(result.items()))
    except:
        # older python versions < 2.7
        od = OrderedDict(sorted(result.items()))
    return od

 def get_next_link(self):
     url = self.request.build_absolute_uri()
     return replace_query_param(
         url, self.page_query_param, self.get_page() + 1)

 def _get_page_link(self, value, page):
     if not value.paginator.count:
         return None
     uri = self._get_current_uri()
     return self._get_link_object(replace_query_param(uri, self.page_field, page))

 def to_native(self, value):
     if not value.has_next():
         return None
     page = value.next_page_number()
     return replace_query_param('', self.page_field, page)

    def paginate(self, queryset, request):
        # first get paging parameters.
        limit_p = settings.REST_FRAMEWORK.get('PAGINATE_BY_PARAM', 'limit')
        offset_p = settings.REST_FRAMEWORK.get('PAGINATE_PARAM', 'offset')
        max_limit = settings.REST_FRAMEWORK.get('MAX_PAGINATE_BY', 500)
        default_limit = settings.REST_FRAMEWORK.get('PAGINATE_BY', 10)
        offset = int(request.QUERY_PARAMS.get(offset_p, 0))
        limit = int(request.QUERY_PARAMS.get(limit_p, default_limit))
        limit = max_limit if limit > max_limit else limit
        page = queryset[offset:offset+limit]

        # make sure the end row num is not > the total count of the queryset
        total_count = queryset.count()
        if total_count > 0:
            end_row = offset + limit - 1
            end_row = total_count - 1 if end_row > total_count - 1 else end_row
        else:
            end_row = None
            offset = None

        url = request.build_absolute_uri()

        # determine the previous and next offsets for the previous and next
        # pages of results
        if offset is None or offset == 0:
            prev_offset = None
        else:
            prev_offset = offset - limit if offset - limit >= 0 else 0

        if offset is None or end_row == total_count - 1:
            next_offset = None
        else:
            next_offset = offset + limit

        prev_page = None
        if prev_offset is not None:
            prev_page = urllib.unquote(replace_query_param(url, offset_p, 
                                                           prev_offset))
        next_page = None
        if next_offset is not None:
            next_page = urllib.unquote(replace_query_param(url, offset_p,
                                                           next_offset))

        resource_name = render.underscoreToCamel(self.resource_name)
        resource_list = self.get_serializer(instance=page, force_refresh=True,
                                            context={'request': request,
                                                     'view': self}).data

        # page_data elements dictate what shows up in the API for page-level
        # metadata
        page_data = OrderedDict()
        page_data['totalCount'] = total_count
        if offset is not None:
            page_data['startRow'] = offset
        if end_row is not None:
            page_data['endRow'] = end_row
        page_data['_links'] = OrderedDict()
        page_data['_links']['self'] = {'href': url}
        if prev_page is not None:
            page_data['_links']['previous'] = {'href': prev_page}
        if next_page is not None:
            page_data['_links']['next'] = {'href': next_page}
        if resource_list:
            page_data['_embedded'] = {resource_name: resource_list}

        return page_data

def add_query_param(url, **query):
    for key, val in query.items():
        url = replace_query_param(url, key, val)
    return url