"""Ephemeral models used to represent a page and a list of pages."""
from __future__ import unicode_literals
from django.template import (
loader,
Context,
)
from django.utils.encoding import iri_to_uri, python_2_unicode_compatible, force_text
from el_pagination import (
loaders,
settings,
utils,
)
# Page templates cache.
_template_cache = {}
class ELPage(object):
"""A page link representation.
Interesting attributes:
- *self.number*: the page number;
- *self.label*: the label of the link
(usually the page number as string);
- *self.url*: the url of the page (strting with "?");
- *self.path*: the path of the page;
- *self.is_current*: return True if page is the current page displayed;
- *self.is_first*: return True if page is the first page;
- *self.is_last*: return True if page is the last page.
"""
def __init__(
self, request, number, current_number, total_number,
querystring_key, label=None, default_number=1, override_path=None,
context=None):
self._request = request
self.number = number
self.label = force_text(number) if label is None else label
self.querystring_key = querystring_key
self.context = context or {}
self.context['request'] = request
self.is_current = number == current_number
self.is_first = number == 1
self.is_last = number == total_number
if settings.USE_NEXT_PREVIOUS_LINKS:
self.is_previous = label and number == current_number - 1
self.is_next = label and number == current_number + 1
self.url = utils.get_querystring_for_page(
request, number,
self.querystring_key,
default_number=default_number
)
path = iri_to_uri(override_path or request.path)
self.path = '{0}{1}'.format(path, self.url)
def render_link(self):
"""Render the page as a link."""
extra_context = {
'add_nofollow': settings.ADD_NOFOLLOW,
'page': self,
'querystring_key': self.querystring_key,
}
if self.is_current:
template_name = 'el_pagination/current_link.html'
else:
template_name = 'el_pagination/page_link.html'
if settings.USE_NEXT_PREVIOUS_LINKS:
if self.is_previous:
template_name = 'el_pagination/previous_link.html'
if self.is_next:
template_name = 'el_pagination/next_link.html'
if template_name not in _template_cache:
_template_cache[template_name] = loader.get_template(template_name)
template = _template_cache[template_name]
with self.context.push(**extra_context):
return template.render(self.context.flatten())
python_2_unicode_compatible
class PageList(object):
"""A sequence of endless pages."""
def __init__(
self, request, page, querystring_key, context,
default_number=None, override_path=None):
self._request = request
self._page = page
self.context = context
self.context['request'] = request
if default_number is None:
self._default_number = 1
else:
self._default_number = int(default_number)
self._querystring_key = querystring_key
self._override_path = override_path
self._pages_list = []
def _endless_page(self, number, label=None):
"""Factory function that returns a *ELPage* instance.
This method works just like a partial constructor.
"""
return ELPage(
self._request,
number,
self._page.number,
len(self),
self._querystring_key,
label=label,
default_number=self._default_number,
override_path=self._override_path,
context=self.context
)
def __getitem__(self, value):
# The type conversion is required here because in templates Django
# performs a dictionary lookup before the attribute lokups
# (when a dot is encountered).
try:
value = int(value)
except (TypeError, ValueError):
# A TypeError says to django to continue with an attribute lookup.
raise TypeError
if 1 <= value <= len(self):
return self._endless_page(value)
raise IndexError('page list index out of range')
def __len__(self):
"""The length of the sequence is the total number of pages."""
return self._page.paginator.num_pages
def __iter__(self):
"""Iterate over all the endless pages (from first to last)."""
for i in range(len(self)):
yield self[i + 1]
def __str__(self):
"""Return a rendered Digg-style pagination (by default).
The callable *settings.PAGE_LIST_CALLABLE* can be used to customize
how the pages are displayed. The callable takes the current page number
and the total number of pages, and must return a sequence of page
numbers that will be displayed. The sequence can contain other values:
- *'previous'*: will display the previous page in that position;
- *'next'*: will display the next page in that position;
- *'first'*: will display the first page as an arrow;
- *'last'*: will display the last page as an arrow;
- *None*: a separator will be displayed in that position.
Here is an example of custom calable that displays the previous page,
then the first page, then a separator, then the current page, and
finally the last page::
def get_page_numbers(current_page, num_pages):
return ('previous', 1, None, current_page, 'last')
If *settings.PAGE_LIST_CALLABLE* is None an internal callable is used,
generating a Digg-style pagination. The value of
*settings.PAGE_LIST_CALLABLE* can also be a dotted path to a callable.
"""
return ''
def get_pages_list(self):
if not self._pages_list:
callable_or_path = settings.PAGE_LIST_CALLABLE
if callable_or_path:
if callable(callable_or_path):
pages_callable = callable_or_path
else:
pages_callable = loaders.load_object(callable_or_path)
else:
pages_callable = utils.get_page_numbers
pages = []
for item in pages_callable(self._page.number, len(self)):
if item is None:
pages.append(None)
elif item == 'previous':
pages.append(self.previous())
elif item == 'next':
pages.append(self.next())
elif item == 'first':
pages.append(self.first_as_arrow())
elif item == 'last':
pages.append(self.last_as_arrow())
else:
pages.append(self[item])
self._pages_list = pages
return self._pages_list
def get_rendered(self):
if len(self) > 1:
template = loader.get_template('el_pagination/show_pages.html')
with self.context.push(pages=self.get_pages_list()):
return template.render(self.context.flatten())
return ''
def current(self):
"""Return the current page."""
return self._endless_page(self._page.number)
def current_start_index(self):
"""Return the 1-based index of the first item on the current page."""
return self._page.start_index()
def current_end_index(self):
"""Return the 1-based index of the last item on the current page."""
return self._page.end_index()
def total_count(self):
"""Return the total number of objects, across all pages."""
return self._page.paginator.count
def first(self, label=None):
"""Return the first page."""
return self._endless_page(1, label=label)
def last(self, label=None):
"""Return the last page."""
return self._endless_page(len(self), label=label)
def first_as_arrow(self):
"""Return the first page as an arrow.
The page label (arrow) is defined in ``settings.FIRST_LABEL``.
"""
return self.first(label=settings.FIRST_LABEL)
def last_as_arrow(self):
"""Return the last page as an arrow.
The page label (arrow) is defined in ``settings.LAST_LABEL``.
"""
return self.last(label=settings.LAST_LABEL)
def previous(self):
"""Return the previous page.
The page label is defined in ``settings.PREVIOUS_LABEL``.
Return an empty string if current page is the first.
"""
if self._page.has_previous():
return self._endless_page(
self._page.previous_page_number(),
label=settings.PREVIOUS_LABEL)
return ''
def next(self):
"""Return the next page.
The page label is defined in ``settings.NEXT_LABEL``.
Return an empty string if current page is the last.
"""
if self._page.has_next():
return self._endless_page(
self._page.next_page_number(),
label=settings.NEXT_LABEL)
return ''
def paginated(self):
"""Return True if this page list contains more than one page."""
return len(self) > 1
def per_page_number(self):
"""Return the numbers of objects are normally display in per page."""
return self._page.paginator.per_page