def get_paginated_data(request, results, page_num, per_page):
    """
    Return a dict with the following values:

    next: The URL for the next page
    previous: The URL for the previous page
    results: The results on this page
    """
    # Note: Previous versions of this function used Django Rest Framework's
    # paginated serializer.  With the upgrade to DRF 3.1, paginated serializers
    # have been removed.  We *could* use DRF's paginator classes, but there are
    # some slight differences between how DRF does pagination and how we're doing
    # pagination here.  (For example, we respond with a next_url param even if
    # there is only one result on the current page.)  To maintain backwards
    # compatability, we simulate the behavior that DRF used to provide.
    page = _Page(results, page_num, per_page)
    next_url, previous_url = None, None
    base_url = request.build_absolute_uri()

    if page.has_next():
        next_url = replace_query_param(base_url, "page", page.next_page_number())

    if page.has_previous():
        previous_url = replace_query_param(base_url, "page", page.previous_page_number())

    return {
        "next": next_url,
        "previous": previous_url,
        "results": results,
    }

    def get_paginated_response(self, data):
        self_link = self.request.build_absolute_uri()
        if self_link.endswith(".api"):
            self_link = self_link[:-4]

        if self.page.has_next():
            next_link = replace_query_param(
                self_link, self.page_query_param, self.page.next_page_number())
        else:
            next_link = None

        if self.page.has_previous():
            prev_link = replace_query_param(
                self_link, self.page_query_param,
                self.page.previous_page_number())
        else:
            prev_link = None

        return response.Response(OrderedDict([
            ('_links', OrderedDict([
                ('self', dict(href=self_link)),
                ('next', dict(href=next_link)),
                ('previous', dict(href=prev_link)),
            ])),
            ('count', self.page.paginator.count),
            ('_embedded', data)
        ]))

    def test_valid_unicode_preserved(self):
        q = '/?q=%E6%9F%A5%E8%AF%A2'
        new_key = 'page'
        new_value = 2
        value = '%E6%9F%A5%E8%AF%A2'

        assert new_key in replace_query_param(q, new_key, new_value)
        assert value in replace_query_param(q, new_key, new_value)

    def test_valid_unicode_replaced(self):
        q = '/?page=1'
        value = '1'
        new_key = 'q'
        new_value = '%E6%9F%A5%E8%AF%A2'

        assert new_key in replace_query_param(q, new_key, new_value)
        assert value in replace_query_param(q, new_key, new_value)

    def get_previous_link(self):
        if self.page == 1:
            return None

        url = self.request.build_absolute_uri()
        url = replace_query_param(url, self.page_size_query_param, self.limit)
        url = replace_query_param(url, self.page_query_param, self.page - 1)

        return url

    def get_next_link(self, data=[]):
        if len(data) < self.limit:
            return None

        url = self.request.build_absolute_uri()
        url = replace_query_param(url, self.limit_query_param, self.limit)

        offset = data[-1]['ranking']
        return replace_query_param(url, self.offset_query_param, offset)

    def get_next_link(self):
        if not self.has_next_page:
            return None

        url = self.request.build_absolute_uri()
        url = replace_query_param(url, self.page_size_query_param, self.limit)
        url = replace_query_param(url, self.page_query_param, self.page + 1)

        return url

    def get_next_link(self):
        if self.offset + self.limit >= self.count:
            return None

        url = self.request.build_absolute_uri()
        url = replace_query_param(url, self.limit_query_param, self.limit)

        offset = self.offset + self.limit
        return replace_query_param(url, self.offset_query_param, offset)

    def get_previous_link(self):
        if self.offset <= 0:
            return None

        url = self.request.build_absolute_uri()
        url = replace_query_param(url, self.limit_query_param, self.limit)

        if self.offset - self.limit <= 0:
            return remove_query_param(url, self.offset_query_param)

        offset = self.offset - self.limit
        return replace_query_param(url, self.offset_query_param, offset)

    def get_last_link(self):
        if self.count == 0:
            return None

        url = self.request.build_absolute_uri()
        url = replace_query_param(url, self.limit_query_param, self.limit)

        offset = self.count - self.limit

        if offset <= 0:
            return remove_query_param(url, self.offset_query_param)

        return replace_query_param(url, self.offset_query_param, offset)

    def test_invalid_unicode(self):
        # Encoded string: '��<script>alert(313)</script>=1'
        q = '/e/?%FF%FE%3C%73%63%72%69%70%74%3E%61%6C%65%72%74%28%33%31%33%29%3C%2F%73%63%72%69%70%74%3E=1'
        key = 'from'
        value = 'login'

        assert key in replace_query_param(q, key, value)

 def get_first_link(self, display_page_query_param=True):
     url = self.request.build_absolute_uri()
     if display_page_query_param:
         page_number = self.page.paginator.validate_number(1)
         return replace_query_param(url, self.page_query_param, page_number)
     else:
         return remove_query_param(url, self.page_query_param)

def add_query_param(request, key, val):
    """
    Add a query parameter to the current request url, and return the new url.
    """
    iri = request.get_full_path()
    uri = iri_to_uri(iri)
    return escape(replace_query_param(uri, key, val))

    def get_last_link(self):
        url = self.request.build_absolute_uri()
        page_number = self.paginator.num_pages

        # only add a 'last' link if it isn't going to be the same as the 'first' link.
        if page_number != 1:
            return replace_query_param(url, self.page_query_param, page_number)

 def adjust_offset(self, url, page_offset):
     if url is None:
         return
     (scheme, netloc, path, query, fragment) = urlparse.urlsplit(force_str(url))
     query_dict = QueryDict(query)
     try:
         offset = pagination._positive_int(
             query_dict[self.offset_query_param],
         )
     except (KeyError, ValueError):
         pass
     else:
         if offset > page_offset:
             url = replace_query_param(url, self.offset_query_param, max(0, offset - self.overlapping))
         elif offset < page_offset:
             url = replace_query_param(url, self.offset_query_param, offset + self.overlapping)
     return url

 def get_previous_link(self):
     """
     Returns absolute url of the previous page if there's a previous page available
     otherwise returns None
     """
     previous_url = None
     if self.page.has_previous():
         previous_url = replace_query_param(self.base_url, "page", self.page.previous_page_number())
     return previous_url

 def get_next_link(self):
     """
     Returns absolute url of the next page if there's a next page available
     otherwise returns None
     """
     next_url = None
     if self.page.has_next():
         next_url = replace_query_param(self.base_url, "page", self.page.next_page_number())
     return next_url

    def test_valid_offset_limit(self):
        """
        Basic test, assumes offset and limit are given.
        """
        offset = 10
        limit = 5
        count = len(self.queryset)
        last_offset = (count // limit) * limit
        next_offset = 15
        prev_offset = 5

        request = self.get_test_request({
            self.pagination.limit_query_param: limit,
            self.pagination.offset_query_param: offset
        })
        base_url = replace_query_param(self.base_url, self.pagination.limit_query_param, limit)
        last_url = replace_query_param(base_url, self.pagination.offset_query_param, last_offset)
        first_url = base_url
        next_url = replace_query_param(base_url, self.pagination.offset_query_param, next_offset)
        prev_url = replace_query_param(base_url, self.pagination.offset_query_param, prev_offset)
        queryset = self.paginate_queryset(request)
        content = self.get_paginated_content(queryset)
        next_offset = offset + limit

        expected_content = {
            'results': list(range(offset + 1, next_offset + 1)),
            'links': OrderedDict([
                ('first', first_url),
                ('last', last_url),
                ('next', next_url),
                ('prev', prev_url),
            ]),
            'meta': {
                'pagination': OrderedDict([
                    ('count', count),
                    ('limit', limit),
                    ('offset', offset),
                ])
            }
        }

        assert queryset == list(range(offset + 1, next_offset + 1))
        assert content == expected_content

    def page_number_query(self, url, page_number):
        """
        Builds uri and adds page param.
        """
        url = remove_query_param(self.request.build_absolute_uri(url), '_')
        paginated_url = replace_query_param(url, self.page_query_param, page_number)

        if page_number == 1:
            return remove_query_param(paginated_url, self.page_query_param)

        return paginated_url

    def get_last_link(self):
        """ Return the URL of the last paginated page """

        if not self.get_next_link():
            return None

        return replace_query_param(
            self.request.build_absolute_uri(),
            self.offset_query_param,
            self.count - self.limit,
        )