pagination/templatetags/pagination_tags.py

   1 try:
   2     set
   3 except NameError:
   4     from sets import Set as set
   5
   6 from django import template
   7 from django.http import Http404
   8 from django.core.paginator import Paginator, InvalidPage
   9 from django.conf import settings
  10
  11 register = template.Library()
  12
  13 DEFAULT_PAGINATION = getattr(settings, 'PAGINATION_DEFAULT_PAGINATION', 20)
  14 DEFAULT_WINDOW = getattr(settings, 'PAGINATION_DEFAULT_WINDOW', 4)
  15 DEFAULT_ORPHANS = getattr(settings, 'PAGINATION_DEFAULT_ORPHANS', 0)
  16 INVALID_PAGE_RAISES_404 = getattr(settings,
  17     'PAGINATION_INVALID_PAGE_RAISES_404', False)
  18
  19 def do_autopaginate(parser, token):
  20     """
  21     Splits the arguments to the autopaginate tag and formats them correctly.
  22     """
  23     split = token.split_contents()
  24     as_index = None
  25     context_var = None
  26     for i, bit in enumerate(split):
  27         if bit == 'as':
  28             as_index = i
  29             break
  30     if as_index is not None:
  31         try:
  32             context_var = split[as_index + 1]
  33         except IndexError:
  34             raise template.TemplateSyntaxError("Context variable assignment " +
  35                 "must take the form of {%% %r object.example_set.all ... as " +
  36                 "context_var_name %%}" % split[0])
  37         del split[as_index:as_index + 2]
  38     if len(split) == 2:
  39         return AutoPaginateNode(split[1])
  40     elif len(split) == 3:
  41         return AutoPaginateNode(split[1], paginate_by=split[2],
  42             context_var=context_var)
  43     elif len(split) == 4:
  44         try:
  45             orphans = int(split[3])
  46         except ValueError:
  47             raise template.TemplateSyntaxError(u'Got %s, but expected integer.'
  48                 % split[3])
  49         return AutoPaginateNode(split[1], paginate_by=split[2], orphans=orphans,
  50             context_var=context_var)
  51     else:
  52         raise template.TemplateSyntaxError('%r tag takes one required ' +
  53             'argument and one optional argument' % split[0])
  54
  55 class AutoPaginateNode(template.Node):
  56     """
  57     Emits the required objects to allow for Digg-style pagination.
  58
  59     First, it looks in the current context for the variable specified, and using
  60     that object, it emits a simple ``Paginator`` and the current page object
  61     into the context names ``paginator`` and ``page_obj``, respectively.
  62
  63     It will then replace the variable specified with only the objects for the
  64     current page.
  65
  66     .. note::
  67
  68         It is recommended to use *{% paginate %}* after using the autopaginate
  69         tag.  If you choose not to use *{% paginate %}*, make sure to display the
  70         list of available pages, or else the application may seem to be buggy.
  71     """
  72     def __init__(self, queryset_var, paginate_by=DEFAULT_PAGINATION,
  73         orphans=DEFAULT_ORPHANS, context_var=None):
  74         self.queryset_var = template.Variable(queryset_var)
  75         if isinstance(paginate_by, int):
  76             self.paginate_by = paginate_by
  77         else:
  78             self.paginate_by = template.Variable(paginate_by)
  79         self.orphans = orphans
  80         self.context_var = context_var
  81
  82     def render(self, context):
  83         key = self.queryset_var.var
  84         value = self.queryset_var.resolve(context)
  85         if isinstance(self.paginate_by, int):
  86             paginate_by = self.paginate_by
  87         else:
  88             paginate_by = self.paginate_by.resolve(context)
  89         paginator = Paginator(value, paginate_by, self.orphans)
  90         try:
  91             page_obj = paginator.page(context['request'].page)
  92         except InvalidPage:
  93             if INVALID_PAGE_RAISES_404:
  94                 raise Http404('Invalid page requested.  If DEBUG were set to ' +
  95                     'False, an HTTP 404 page would have been shown instead.')
  96             context[key] = []
  97             context['invalid_page'] = True
  98             return u''
  99         if self.context_var is not None:
 100             context[self.context_var] = page_obj.object_list
 101         else:
 102             context[key] = page_obj.object_list
 103         context['paginator'] = paginator
 104         context['page_obj'] = page_obj
 105         return u''
 106
 107 def paginate(context, window=DEFAULT_WINDOW):
 108     """
 109     Renders the ``pagination/pagination.html`` template, resulting in a
 110     Digg-like display of the available pages, given the current page.  If there
 111     are too many pages to be displayed before and after the current page, then
 112     elipses will be used to indicate the undisplayed gap between page numbers.
 113
 114     Requires one argument, ``context``, which should be a dictionary-like data
 115     structure and must contain the following keys:
 116
 117     ``paginator``
 118         A ``Paginator`` or ``QuerySetPaginator`` object.
 119
 120     ``page_obj``
 121         This should be the result of calling the page method on the
 122         aforementioned ``Paginator`` or ``QuerySetPaginator`` object, given
 123         the current page.
 124
 125     This same ``context`` dictionary-like data structure may also include:
 126
 127     ``getvars``
 128         A dictionary of all of the **GET** parameters in the current request.
 129         This is useful to maintain certain types of state, even when requesting
 130         a different page.
 131         """
 132     try:
 133         paginator = context['paginator']
 134         page_obj = context['page_obj']
 135         page_range = paginator.page_range
 136         # First and last are simply the first *n* pages and the last *n* pages,
 137         # where *n* is the current window size.
 138         first = set(page_range[:window])
 139         last = set(page_range[-window:])
 140         # Now we look around our current page, making sure that we don't wrap
 141         # around.
 142         current_start = page_obj.number-1-window
 143         if current_start < 0:
 144             current_start = 0
 145         current_end = page_obj.number-1+window
 146         if current_end < 0:
 147             current_end = 0
 148         current = set(page_range[current_start:current_end])
 149         pages = []
 150         # If there's no overlap between the first set of pages and the current
 151         # set of pages, then there's a possible need for elusion.
 152         if len(first.intersection(current)) == 0:
 153             first_list = list(first)
 154             first_list.sort()
 155             second_list = list(current)
 156             second_list.sort()
 157             pages.extend(first_list)
 158             diff = second_list[0] - first_list[-1]
 159             # If there is a gap of two, between the last page of the first
 160             # set and the first page of the current set, then we're missing a
 161             # page.
 162             if diff == 2:
 163                 pages.append(second_list[0] - 1)
 164             # If the difference is just one, then there's nothing to be done,
 165             # as the pages need no elusion and are correct.
 166             elif diff == 1:
 167                 pass
 168             # Otherwise, there's a bigger gap which needs to be signaled for
 169             # elusion, by pushing a None value to the page list.
 170             else:
 171                 pages.append(None)
 172             pages.extend(second_list)
 173         else:
 174             unioned = list(first.union(current))
 175             unioned.sort()
 176             pages.extend(unioned)
 177         # If there's no overlap between the current set of pages and the last
 178         # set of pages, then there's a possible need for elusion.
 179         if len(current.intersection(last)) == 0:
 180             second_list = list(last)
 181             second_list.sort()
 182             diff = second_list[0] - pages[-1]
 183             # If there is a gap of two, between the last page of the current
 184             # set and the first page of the last set, then we're missing a
 185             # page.
 186             if diff == 2:
 187                 pages.append(second_list[0] - 1)
 188             # If the difference is just one, then there's nothing to be done,
 189             # as the pages need no elusion and are correct.
 190             elif diff == 1:
 191                 pass
 192             # Otherwise, there's a bigger gap which needs to be signaled for
 193             # elusion, by pushing a None value to the page list.
 194             else:
 195                 pages.append(None)
 196             pages.extend(second_list)
 197         else:
 198             differenced = list(last.difference(current))
 199             differenced.sort()
 200             pages.extend(differenced)
 201         to_return = {
 202             'pages': pages,
 203             'page_obj': page_obj,
 204             'paginator': paginator,
 205             'is_paginated': paginator.count > paginator.per_page,
 206         }
 207         if 'request' in context:
 208             getvars = context['request'].GET.copy()
 209             if 'page' in getvars:
 210                 del getvars['page']
 211             if len(getvars.keys()) > 0:
 212                 to_return['getvars'] = "&%s" % getvars.urlencode()
 213             else:
 214                 to_return['getvars'] = ''
 215         return to_return
 216     except KeyError, AttributeError:
 217         return {}
 218
 219 register.inclusion_tag('pagination/pagination.html', takes_context=True)(
 220     paginate)
 221 register.tag('autopaginate', do_autopaginate)