forum/utils/pagination.py

   1 import math
   2 from django.utils.datastructures import SortedDict
   3 from django import template
   4 from django.core.paginator import Paginator, EmptyPage
   5 from django.utils.translation import ugettext as _
   6 from django.utils.html import escape
   7 from django.http import Http404
   8 from django.utils.http import urlquote
   9 from django.utils.safestring import mark_safe
  10 from django.utils.html import strip_tags, escape
  11 from forum.utils.html import sanitize_html
  12 import logging
  13
  14 def generate_uri(querydict, exclude=None):
  15     all = []
  16
  17     for k, l in querydict.iterlists():
  18         if (not exclude) or (not k in exclude):
  19             all += ["%s=%s" % (k, escape(strip_tags(v))) for v in l]
  20
  21     return "&".join(all)
  22
  23 class SortBase(object):
  24     def __init__(self, label, description=''):
  25         self.label = label
  26         self.description = description
  27
  28 class SimpleSort(SortBase):
  29     def __init__(self, label, order_by, description=''):
  30         super(SimpleSort, self) .__init__(label, description)
  31         self.order_by = order_by
  32
  33     def _get_order_by(self):
  34         return isinstance(self.order_by, (list, tuple)) and self.order_by or [self.order_by]
  35
  36     def apply(self, objects):
  37         return objects.order_by(*self._get_order_by())
  38
  39 class PaginatorContext(object):
  40     visible_page_range = 5
  41     outside_page_range = 1
  42
  43     base_path = None
  44
  45     def __init__(self, id, sort_methods=None, default_sort=None, force_sort = None,
  46                  pagesizes=None, default_pagesize=None, prefix=''):
  47         self.id = id
  48         if sort_methods:
  49             self.has_sort = True
  50             self.sort_methods = SortedDict(data=sort_methods)
  51
  52             if not default_sort:
  53                 default_sort = sort_methods[0][0]
  54
  55             self.default_sort = default_sort
  56         else:
  57             self.has_sort = False
  58
  59
  60         if pagesizes:
  61             self.has_pagesize = True
  62             self.pagesizes = pagesizes
  63
  64             if not default_pagesize:
  65                 self.default_pagesize = pagesizes[int(math.ceil(float(len(pagesizes)) / 2)) - 1]
  66             else:
  67                 self.default_pagesize = default_pagesize
  68         else:
  69             self.has_pagesize = False
  70
  71         self.force_sort = force_sort
  72         self.prefix = prefix
  73
  74     def preferences(self, request):
  75         if request.user.is_authenticated():
  76             if request.user.prop.pagination:
  77                 preferences = request.user.prop.pagination.get(self.id, {})
  78             else:
  79                 preferences = {}
  80         else:
  81             preferences = request.session.get('paginator_%s%s' % (self.prefix, self.id), {})
  82
  83         return preferences
  84
  85     def set_preferences(self, request, preferences):
  86         if request.user.is_authenticated():
  87             all_preferences = request.user.prop.pagination or {}
  88             all_preferences[self.id] = preferences
  89             request.user.prop.pagination = all_preferences
  90         else:
  91             request.session['paginator_%s%s' % (self.prefix, self.id)] = preferences
  92
  93     def pagesize(self, request, session_prefs=None):
  94         if not session_prefs:
  95             session_prefs = self.preferences(request)
  96
  97
  98         if self.has_pagesize:
  99             if request.GET.get(self.PAGESIZE, None):
 100                 try:
 101                     pagesize = int(request.GET[self.PAGESIZE])
 102                 except ValueError:
 103                     logging.error('Found invalid page size "%s", loading %s, refered by %s' % (
 104                         request.GET.get(self.PAGESIZE, ''), request.path, request.META.get('HTTP_REFERER', 'UNKNOWN')
 105                     ))
 106                     raise Http404()
 107
 108                 session_prefs[self.PAGESIZE] = pagesize
 109             else:
 110                 pagesize = session_prefs.get(self.PAGESIZE, self.default_pagesize)
 111
 112             if not pagesize in self.pagesizes:
 113                 pagesize = self.default_pagesize
 114         else:
 115             pagesize = 30
 116
 117         return pagesize
 118
 119     def page(self, request):
 120         try:
 121             return int(request.GET.get(self.PAGE, "1").strip())
 122         except ValueError:
 123             logging.error('Found invalid page number "%s", loading %s, refered by %s' % (
 124                 request.GET.get(self.PAGE, ''), request.path, request.META.get('HTTP_REFERER', 'UNKNOWN')
 125             ))
 126             raise Http404()
 127
 128     def sort(self, request, session_prefs=None):
 129         if not session_prefs:
 130             session_prefs = self.preferences(request)
 131
 132         sort = None
 133         sticky = request.user.is_authenticated() and request.user.prop.preferences and request.user.prop.preferences.get('sticky_sorts', False)
 134
 135         if self.has_sort:
 136             if request.GET.get(self.SORT, None):
 137                 sort = request.GET[self.SORT]
 138
 139                 if sticky:
 140                     session_prefs[self.SORT] = sort
 141             else:
 142                 sort = self.force_sort or (sticky and session_prefs.get(self.SORT, None)) or self.default_sort
 143
 144             if not sort in self.sort_methods:
 145                 sort = self.default_sort
 146
 147         return sort
 148
 149     def sorted(self, objects, request, session_prefs=None):
 150         sort = self.sort(request, session_prefs)
 151
 152         if sort:
 153             objects = self.sort_methods[sort].apply(objects)
 154
 155         return sort, objects
 156
 157     @property
 158     def PAGESIZE(self):
 159         return self.prefix and "%s_%s" % (self.prefix, _('pagesize')) or _('pagesize')
 160
 161     @property
 162     def PAGE(self):
 163         return self.prefix and "%s_%s" % (self.prefix, _('page')) or _('page')
 164
 165     @property
 166     def SORT(self):
 167         return self.prefix and "%s_%s" % (self.prefix, _('sort')) or _('sort')
 168
 169 page_numbers_template = template.loader.get_template('paginator/page_numbers.html')
 170 page_sizes_template = template.loader.get_template('paginator/page_sizes.html')
 171 sort_tabs_template = template.loader.get_template('paginator/sort_tabs.html')
 172
 173 def paginated(request, paginators, tpl_context):
 174     if len(paginators) == 2 and isinstance(paginators[0], basestring):
 175         paginators = (paginators,)
 176
 177     for list_name, context in paginators:
 178         tpl_context[list_name] = _paginated(request, tpl_context[list_name], context)
 179
 180     return tpl_context
 181
 182 def _paginated(request, objects, context):
 183     session_prefs = context.preferences(request)
 184
 185     pagesize = context.pagesize(request, session_prefs)
 186     page = context.page(request)
 187     sort, objects = context.sorted(objects, request, session_prefs)
 188
 189     paginator = Paginator(objects, pagesize)
 190
 191     try:
 192         page_obj = paginator.page(page)
 193     except EmptyPage:
 194         logging.error('Found invalid page number "%s", loading %s, refered by %s' % (
 195             request.GET.get(context.PAGE, ''), request.path, request.META.get('HTTP_REFERER', 'UNKNOWN')
 196         ))
 197         raise Http404()
 198
 199     if context.base_path:
 200         base_path = context.base_path
 201     else:
 202         base_path = request.path
 203         get_params = generate_uri(request.GET, (context.PAGE, context.PAGESIZE, context.SORT))
 204
 205         if get_params:
 206             base_path += "?" + get_params
 207
 208     url_joiner = "?" in base_path and "&amp;" or "?"
 209
 210
 211     def get_page():
 212         object_list = page_obj.object_list
 213
 214         #if hasattr(object_list, 'lazy'):
 215         #    return object_list.lazy()
 216         return object_list
 217     paginator.page = get_page()
 218
 219     total_pages = paginator.num_pages
 220
 221     if total_pages > 1:
 222         def page_nums():
 223             total_pages = paginator.num_pages
 224
 225             has_previous = page > 1
 226             has_next = page < total_pages
 227
 228             range_start = page - context.visible_page_range / 2
 229             range_end = page + context.visible_page_range / 2
 230
 231             if range_start < 1:
 232                 range_end = context.visible_page_range
 233                 range_start = 1
 234
 235             if range_end > total_pages:
 236                 range_start = total_pages - context.visible_page_range + 1
 237                 range_end = total_pages
 238                 if range_start < 1:
 239                     range_start = 1
 240
 241             page_numbers = []
 242
 243             if sort:
 244                 url_builder = lambda n: mark_safe("%s%s%s=%s&amp;%s=%s" % (escape(base_path), url_joiner, context.SORT, sort, context.PAGE, n))
 245             else:
 246                 url_builder = lambda n: mark_safe("%s%s%s=%s" % (escape(base_path), url_joiner, context.PAGE, n))
 247
 248             if range_start > (context.outside_page_range + 1):
 249                 page_numbers.append([(n, url_builder(n)) for n in range(1, context.outside_page_range + 1)])
 250                 page_numbers.append(None)
 251             elif range_start > 1:
 252                 page_numbers.append([(n, url_builder(n)) for n in range(1, range_start)])
 253
 254             page_numbers.append([(n, url_builder(n)) for n in range(range_start, range_end + 1)])
 255
 256             if range_end < (total_pages - context.outside_page_range):
 257                 page_numbers.append(None)
 258                 page_numbers.append([(n, url_builder(n)) for n in range(total_pages - context.outside_page_range + 1, total_pages + 1)])
 259             elif range_end < total_pages:
 260                 page_numbers.append([(n, url_builder(n)) for n in range(range_end + 1, total_pages + 1)])
 261
 262             return page_numbers_template.render(template.Context({
 263                 'has_previous': has_previous,
 264                 'previous_url': has_previous and url_builder(page - 1) or None,
 265                 'has_next': has_next,
 266                 'next_url': has_next and url_builder(page + 1) or None,
 267                 'current': page,
 268                 'page_numbers': page_numbers
 269             }))
 270         paginator.page_numbers = page_nums
 271     else:
 272         paginator.page_numbers = ''
 273
 274     if pagesize:
 275         def page_sizes():
 276             if sort:
 277                 url_builder = lambda s: mark_safe("%s%s%s=%s&amp;%s=%s" % (escape(base_path), url_joiner, context.SORT, sort, context.PAGESIZE, s))
 278             else:
 279                 url_builder = lambda s: mark_safe("%s%s%s=%s" % (escape(base_path), url_joiner, context.PAGESIZE, s))
 280
 281             sizes = [(s, url_builder(s)) for s in context.pagesizes]
 282
 283             return page_sizes_template.render(template.Context({
 284                 'current': pagesize,
 285                 'sizes': sizes
 286             }))
 287
 288         paginator.page_sizes = page_sizes
 289     else:
 290         paginator.page_sizes = ''
 291
 292     if sort:
 293         def sort_tabs():
 294             url_builder = lambda s: mark_safe("%s%s%s=%s" % (escape(base_path), url_joiner, context.SORT, s))
 295             sorts = [(n, s.label, url_builder(n), strip_tags(s.description)) for n, s in context.sort_methods.items()]
 296
 297             for name, label, url, descr in sorts:
 298                 paginator.__dict__['%s_sort_link' % name] = url
 299
 300             return sort_tabs_template.render(template.Context({
 301                 'current': sort,
 302                 'sorts': sorts,
 303                 'sticky': session_prefs.get('sticky_sort', False)
 304             }))
 305         paginator.sort_tabs = sort_tabs()
 306         paginator.sort_description = mark_safe(context.sort_methods[sort].description)
 307         paginator.current_sort = sort
 308     else:
 309         paginator.sort_tabs = paginator.sort_description = ''
 310         paginator.current_sort = ''
 311
 312     context.set_preferences(request, session_prefs)
 313     objects.paginator = paginator
 314     return objects