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