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.core.paginator import Paginator, InvalidPage
+from django.conf import settings
register = template.Library()
-DEFAULT_PAGINATION = 20
-DEFAULT_WINDOW = 4
+DEFAULT_PAGINATION = getattr(settings, 'PAGINATION_DEFAULT_PAGINATION', 20)
+DEFAULT_WINDOW = getattr(settings, 'PAGINATION_DEFAULT_WINDOW', 4)
+DEFAULT_ORPHANS = getattr(settings, 'PAGINATION_DEFAULT_ORPHANS', 0)
def do_autopaginate(parser, token):
"""
except ValueError:
raise template.TemplateSyntaxError(u'Got %s, but expected integer.' % split[2])
return AutoPaginateNode(split[1], paginate_by=paginate_by)
+ 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)
else:
raise template.TemplateSyntaxError('%r tag takes one required argument and one optional argument' % split[0])
"""
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):
+ def __init__(self, queryset_var, paginate_by=DEFAULT_PAGINATION, orphans=DEFAULT_ORPHANS):
self.queryset_var = template.Variable(queryset_var)
self.paginate_by = paginate_by
+ self.orphans = orphans
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
- else:
- value = list(value)
- try:
- model = value[0].__class__
- except IndexError:
- return u''
- paginator_class = Paginator
- paginator = paginator_class(value, self.paginate_by)
+ paginator = Paginator(value, self.paginate_by, self.orphans)
try:
page_obj = paginator.page(context['request'].page)
- except:
+ except InvalidPage:
+ context[key] = []
+ context['invalid_page'] = True
return u''
context[key] = page_obj.object_list
context['paginator'] = paginator
# 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(second)
+ 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 = {
'pages': pages,
'page_obj': page_obj,
getvars = context['request'].GET.copy()
if 'page' in getvars:
del getvars['page']
- to_return['getvars'] = "&%s" % getvars.urlencode()
+ if len(getvars.keys()) > 0:
+ to_return['getvars'] = "&%s" % getvars.urlencode()
+ else:
+ to_return['getvars'] = ''
return to_return
except KeyError:
return {}
register.inclusion_tag('pagination/pagination.html', takes_context=True)(paginate)
-register.tag('autopaginate', do_autopaginate)
\ No newline at end of file
+register.tag('autopaginate', do_autopaginate)
fnp / django-pagination.git / blobdiff