set
except NameError:
from sets import Set as set
+
from django import template
-from django.db.models.query import QuerySet
+from django.http import Http404
from django.core.paginator import Paginator, InvalidPage
from django.conf import settings
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):
"""
tag. If you choose not to use *{% paginate %}*, make sure to display the
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)
- paginator = Paginator(value, self.paginate_by, self.orphans)
+ if isinstance(self.paginate_by, int):
+ paginate_by = self.paginate_by
+ else:
+ 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.inclusion_tag('pagination/pagination.html', takes_context=True)(
+ paginate)
register.tag('autopaginate', do_autopaginate)