set
except NameError:
from sets import Set as set
+
from django import template
-from django.db.models.query import QuerySet
-from django.core.paginator import Paginator, QuerySetPaginator, InvalidPage
+from django.http import Http404
+from django.core.paginator import Paginator, InvalidPage
+from django.conf import settings
register = template.Library()
-DEFAULT_PAGINATION = 20
-DEFAULT_WINDOW = 4
-DEFAULT_ORPHANS = 0
+DEFAULT_PAGINATION = getattr(settings, 'PAGINATION_DEFAULT_PAGINATION', 20)
+DEFAULT_WINDOW = getattr(settings, 'PAGINATION_DEFAULT_WINDOW', 4)
+DEFAULT_ORPHANS = getattr(settings, 'PAGINATION_DEFAULT_ORPHANS', 0)
+INVALID_PAGE_RAISES_404 = getattr(settings,
+ 'PAGINATION_INVALID_PAGE_RAISES_404', False)
def do_autopaginate(parser, token):
"""
Splits the arguments to the autopaginate tag and formats them correctly.
"""
split = token.split_contents()
+ as_index = None
+ context_var = None
+ for i, bit in enumerate(split):
+ if bit == 'as':
+ as_index = i
+ break
+ if as_index is not None:
+ try:
+ context_var = split[as_index + 1]
+ except IndexError:
+ raise template.TemplateSyntaxError("Context variable assignment " +
+ "must take the form of {%% %r object.example_set.all ... as " +
+ "context_var_name %%}" % split[0])
+ del split[as_index:as_index + 2]
if len(split) == 2:
return AutoPaginateNode(split[1])
elif len(split) == 3:
- try:
- paginate_by = int(split[2])
- except ValueError:
- raise template.TemplateSyntaxError(u'Got %s, but expected integer.' % split[2])
- return AutoPaginateNode(split[1], paginate_by=paginate_by)
+ return AutoPaginateNode(split[1], paginate_by=split[2],
+ context_var=context_var)
elif len(split) == 4:
- try:
- paginate_by = int(split[2])
- except ValueError:
- raise template.TemplateSyntaxError(u'Got %s, but expected integer.' % split[2])
try:
orphans = int(split[3])
except ValueError:
- raise template.TemplateSyntaxError(u'Got %s, but expected integer.' % split[3])
- return AutoPaginateNode(split[1], paginate_by=paginate_by, orphans=orphans)
+ raise template.TemplateSyntaxError(u'Got %s, but expected integer.'
+ % split[3])
+ return AutoPaginateNode(split[1], paginate_by=split[2], orphans=orphans,
+ context_var=context_var)
else:
- raise template.TemplateSyntaxError('%r tag takes one required argument and one optional argument' % split[0])
+ raise template.TemplateSyntaxError('%r tag takes one required ' +
+ 'argument and one optional argument' % split[0])
class AutoPaginateNode(template.Node):
"""
Emits the required objects to allow for Digg-style pagination.
- First, it looks in the current context for the variable specified. This
- should be either a QuerySet or a list.
-
- 1. If it is a QuerySet, this ``AutoPaginateNode`` will emit a
- ``QuerySetPaginator`` and the current page object into the context names
- ``paginator`` and ``page_obj``, respectively.
-
- 2. If it is a list, this ``AutoPaginateNode`` will emit a simple
- ``Paginator`` and the current page object into the context names
- ``paginator`` and ``page_obj``, respectively.
+ First, it looks in the current context for the variable specified, and using
+ that object, it emits a simple ``Paginator`` and the current page object
+ into the context names ``paginator`` and ``page_obj``, respectively.
It will then replace the variable specified with only the objects for the
current page.
It is recommended to use *{% paginate %}* after using the autopaginate
tag. If you choose not to use *{% paginate %}*, make sure to display the
- list of availabale pages, or else the application may seem to be buggy.
+ list of available pages, or else the application may seem to be buggy.
"""
- def __init__(self, queryset_var, paginate_by=DEFAULT_PAGINATION, orphans=DEFAULT_ORPHANS):
+ def __init__(self, queryset_var, paginate_by=DEFAULT_PAGINATION,
+ orphans=DEFAULT_ORPHANS, context_var=None):
self.queryset_var = template.Variable(queryset_var)
- self.paginate_by = paginate_by
+ if isinstance(paginate_by, int):
+ self.paginate_by = paginate_by
+ else:
+ self.paginate_by = template.Variable(paginate_by)
self.orphans = orphans
+ self.context_var = context_var
def render(self, context):
key = self.queryset_var.var
value = self.queryset_var.resolve(context)
- if issubclass(value.__class__, QuerySet):
- model = value.model
- paginator_class = QuerySetPaginator
+ if isinstance(self.paginate_by, int):
+ paginate_by = self.paginate_by
else:
- value = list(value)
- try:
- model = value[0].__class__
- except IndexError:
- return u''
- paginator_class = Paginator
- paginator = paginator_class(value, self.paginate_by, self.orphans)
+ paginate_by = self.paginate_by.resolve(context)
+ paginator = Paginator(value, paginate_by, self.orphans)
try:
page_obj = paginator.page(context['request'].page)
except InvalidPage:
+ if INVALID_PAGE_RAISES_404:
+ raise Http404('Invalid page requested. If DEBUG were set to ' +
+ 'False, an HTTP 404 page would have been shown instead.')
context[key] = []
context['invalid_page'] = True
return u''
- context[key] = page_obj.object_list
+ if self.context_var is not None:
+ context[self.context_var] = page_obj.object_list
+ else:
+ context[key] = page_obj.object_list
context['paginator'] = paginator
context['page_obj'] = page_obj
return u''
# If there's no overlap between the first set of pages and the current
# set of pages, then there's a possible need for elusion.
if len(first.intersection(current)) == 0:
- first_list = sorted(list(first))
- second_list = sorted(list(current))
+ first_list = list(first)
+ first_list.sort()
+ second_list = list(current)
+ second_list.sort()
pages.extend(first_list)
diff = second_list[0] - first_list[-1]
# If there is a gap of two, between the last page of the first
pages.append(None)
pages.extend(second_list)
else:
- pages.extend(sorted(list(first.union(current))))
+ unioned = list(first.union(current))
+ unioned.sort()
+ pages.extend(unioned)
# If there's no overlap between the current set of pages and the last
# set of pages, then there's a possible need for elusion.
if len(current.intersection(last)) == 0:
- second_list = sorted(list(last))
+ second_list = list(last)
+ second_list.sort()
diff = second_list[0] - pages[-1]
# If there is a gap of two, between the last page of the current
# set and the first page of the last set, then we're missing a
pages.append(None)
pages.extend(second_list)
else:
- pages.extend(sorted(list(last.difference(current))))
+ differenced = list(last.difference(current))
+ differenced.sort()
+ pages.extend(differenced)
to_return = {
+ 'MEDIA_URL': settings.MEDIA_URL,
'pages': pages,
'page_obj': page_obj,
'paginator': paginator,
else:
to_return['getvars'] = ''
return to_return
- except KeyError:
+ except KeyError, AttributeError:
return {}
-register.inclusion_tag('pagination/pagination.html', takes_context=True)(paginate)
-register.tag('autopaginate', do_autopaginate)
\ No newline at end of file
+
+register.inclusion_tag('pagination/pagination.html', takes_context=True)(
+ paginate)
+register.tag('autopaginate', do_autopaginate)