Updated new pagination feature.

Author: Antoliny0919

base/__init__.py

@@ -0,0 +1,6 @@
+class IncorectLookupParameter(Exception):
+    """
+    Raised when a query parameter contains an incorrect value.
+    """
+
+    pass

base/exceptions.py

@@ -0,0 +1,58 @@
+from django.core.paginator import InvalidPage, Paginator
+
+from .exceptions import IncorectLookupParameter
+
+PAGE_VAR = "page"
+
+
+class Pagination:
+    def __init__(
+        self,
+        request,
+        model,
+        queryset,
+        list_per_page,
+    ):
+        self.model = model
+        self.opts = model._meta
+        self.queryset = queryset
+        self.list_per_page = list_per_page
+        try:
+            # Get the current page from the query string.
+            self.page_num = int(request.GET.get(PAGE_VAR, 1))
+        except ValueError:
+            self.page_num = 1
+        self.params = dict(request.GET.lists())
+        self.setup()
+
+    @property
+    def page_range(self):
+        """
+        Returns the full range of pages.
+        """
+        return (
+            self.paginator.get_elided_page_range(self.page_num)
+            if self.multi_page
+            else []
+        )
+
+    def setup(self):
+        paginator = Paginator(self.queryset, self.list_per_page)
+        result_count = paginator.count
+        # Determine use pagination.
+        multi_page = result_count > self.list_per_page
+
+        self.result_count = result_count
+        self.multi_page = multi_page
+        self.paginator = paginator
+        self.page = paginator.get_page(self.page_num)
+
+    def get_objects(self):
+        if not self.multi_page:
+            result_list = self.queryset._clone()
+        else:
+            try:
+                result_list = self.paginator.page(self.page_num).object_list
+            except InvalidPage:
+                raise IncorectLookupParameter
+        return result_list

base/migrations/__init__.py

@@ -0,0 +1,69 @@
+from collections.abc import Iterable, Mapping
+
+from django import template
+from django.http import QueryDict
+from django.template.exceptions import TemplateSyntaxError
+
+register = template.Library()
+
+
+# This template tag is scheduled to be added in Django 6.0.
+# Imported for use before the release of Django 6.0.
+@register.simple_tag(name="querystring", takes_context=True)
+def querystring(context, *args, **kwargs):
+    """
+    Build a query string using `args` and `kwargs` arguments.
+
+    This tag constructs a new query string by adding, removing, or modifying
+    parameters from the given positional and keyword arguments. Positional
+    arguments must be mappings (such as `QueryDict` or `dict`), and
+    `request.GET` is used as the starting point if `args` is empty.
+
+    Keyword arguments are treated as an extra, final mapping. These mappings
+    are processed sequentially, with later arguments taking precedence.
+
+    A query string prefixed with `?` is returned.
+
+    Raise TemplateSyntaxError if a positional argument is not a mapping or if
+    keys are not strings.
+
+    For example::
+
+        {# Set a parameter on top of `request.GET` #}
+        {% querystring foo=3 %}
+
+        {# Remove a key from `request.GET` #}
+        {% querystring foo=None %}
+
+        {# Use with pagination #}
+        {% querystring page=page_obj.next_page_number %}
+
+        {# Use a custom ``QueryDict`` #}
+        {% querystring my_query_dict foo=3 %}
+
+        {# Use multiple positional and keyword arguments #}
+        {% querystring my_query_dict my_dict foo=3 bar=None %}
+    """
+    if not args:
+        args = [context.request.GET]
+    params = QueryDict(mutable=True)
+    for d in [*args, kwargs]:
+        if not isinstance(d, Mapping):
+            raise TemplateSyntaxError(
+                "querystring requires mappings for positional arguments (got "
+                "%r instead)." % d
+            )
+        for key, value in d.items():
+            if not isinstance(key, str):
+                raise TemplateSyntaxError(
+                    "querystring requires strings for mapping keys (got %r "
+                    "instead)." % key
+                )
+            if value is None:
+                params.pop(key, None)
+            elif isinstance(value, Iterable) and not isinstance(value, str):
+                params.setlist(key, value)
+            else:
+                params[key] = value
+    query_string = params.urlencode() if params else ""
+    return f"?{query_string}"

base/pagination.py

@@ -0,0 +1,39 @@
+from django import template
+from django.utils.html import format_html
+from django.utils.safestring import mark_safe
+
+from base.pagination import PAGE_VAR
+from .base_templatetags import querystring
+
+register = template.Library()
+
+
+@register.simple_tag
+def pagination_number(pagination, i):
+    """
+    Generate an individual page index link in a paginated list.
+    """
+    if i == pagination.paginator.ELLIPSIS:
+        return format_html("{} ", pagination.paginator.ELLIPSIS)
+    elif i == pagination.page_num:
+        return format_html('<em class="current-page" aria-current="page">{}</em> ', i)
+    else:
+        link = querystring(None, pagination.params, {PAGE_VAR: i})
+        return format_html(
+            '<a href="{}" aria-label="page {}" {}>{}</a> ',
+            link,
+            i,
+            mark_safe(' class="end"' if i == pagination.paginator.num_pages else ""),
+            i,
+        )
+
+
+@register.inclusion_tag("base/components/pagination.html", name="pagination")
+def pagination_tag(pagination):
+    previous_page_link = f"?{PAGE_VAR}={pagination.page_num - 1}"
+    next_page_link = f"?{PAGE_VAR}={pagination.page_num + 1}"
+    return {
+        "pagination": pagination,
+        "previous_page_link": previous_page_link,
+        "next_page_link": next_page_link,
+    }

base/templatetags/__init__.py

@@ -2,18 +2,18 @@
 
 import bleach
 from django.core.exceptions import ObjectDoesNotExist
-from django.core.paginator import InvalidPage, Paginator
 from django.http import Http404, HttpResponse
 from django.template import loader
 from django.utils.safestring import mark_safe
 from markdown import markdown as markdown_func
 
+from base.pagination import Pagination
+
 
 def object_list(
     request,
     queryset,
     paginate_by=None,
-    page=None,
     allow_empty=True,
     template_name=None,
     template_loader=loader,
@@ -28,101 +28,43 @@ def object_list(
     Context:
         object_list
             list of objects
-        is_paginated
-            are the results paginated?
-        results_per_page
-            number of objects per page (if paginated)
-        has_next
-            is there a next page?
-        has_previous
-            is there a prev page?
-        page
-            the current page
-        next
-            the next page
-        previous
-            the previous page
-        pages
-            number of pages, total
+        pagination
+            This is a pagination object that holds attributes
+            related to pagination.
+            For more detail, please refer to the `base.pagination.Pagination` class.
         hits
             number of objects, total
-        last_on_page
-            the result number of the last of object in the
-            object_list (1-indexed)
-        first_on_page
-            the result number of the first object in the
-            object_list (1-indexed)
-        page_range:
-            A list of the page numbers (1-indexed).
     """
     if extra_context is None:
         extra_context = {}
     queryset = queryset._clone()
+    model = queryset.model
+    opts = model._meta
     if paginate_by:
-        paginator = Paginator(queryset, paginate_by, allow_empty_first_page=allow_empty)
-        if not page:
-            page = request.GET.get("page", 1)
+        pagination = Pagination(request, model, queryset, paginate_by)
+        object_list = pagination.get_objects()
 
-        if page == "last":
-            page_number = paginator.num_pages
-        else:
-            try:
-                page_number = int(page)
-            except ValueError:
-                # Page is not 'last', nor can it be converted to an int.
-                raise Http404
-        try:
-            page_obj = paginator.page(page_number)
-        except InvalidPage:
-            raise Http404
-        try:
-            next_page = page_obj.next_page_number()
-        except InvalidPage:
-            next_page = None
-        try:
-            previous_page = page_obj.previous_page_number()
-        except InvalidPage:
-            previous_page = None
-
-        c = {
-            "%s_list" % template_object_name: page_obj.object_list,
-            "paginator": paginator,
-            "page_obj": page_obj,
-            "is_paginated": page_obj.has_other_pages(),
-            # Legacy template context stuff. New templates should use page_obj
-            # to access this instead.
-            "results_per_page": paginator.per_page,
-            "has_next": page_obj.has_next(),
-            "has_previous": page_obj.has_previous(),
-            "page": page_obj.number,
-            "next": next_page,
-            "previous": previous_page,
-            "first_on_page": page_obj.start_index(),
-            "last_on_page": page_obj.end_index(),
-            "pages": paginator.num_pages,
-            "hits": paginator.count,
-            "page_range": paginator.page_range,
+        context = {
+            "%s_list" % template_object_name: object_list,
+            "pagination": pagination,
+            "hits": pagination.result_count,
         }
     else:
-        c = {
-            "%s_list" % template_object_name: queryset,
-            "paginator": None,
-            "page_obj": None,
-            "is_paginated": False,
+        context = {
+            "%s_list" % template_object_name: object_list,
         }
         if not allow_empty and len(queryset) == 0:
             raise Http404
 
     for key, value in extra_context.items():
         if callable(value):
-            c[key] = value()
+            context[key] = value()
         else:
-            c[key] = value
+            context[key] = value
     if not template_name:
-        model = queryset.model
-        template_name = "%s/%s_list.html" % (model._meta.app_label, model._meta.object_name.lower())
-    t = template_loader.get_template(template_name)
-    return HttpResponse(t.render(c, request=request), content_type=content_type)
+        template_name = "%s/%s_list.html" % (opts.app_label, opts.object_name.lower())
+    template = template_loader.get_template(template_name)
+    return HttpResponse(template.render(context, request=request), content_type=content_type)
 
 
 def object_detail(

base/templatetags/base_templatetags.py

@@ -56,6 +56,7 @@ def user_url(user):
     "allauth.socialaccount.providers.bitbucket",
     "allauth.socialaccount.providers.github",
     "allauth.socialaccount.providers.twitter",
+    "base",
     "cab",
     "comments_spamfighter",
     "ratings",