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