def paginate(posts, query):
page_number = query.get('page_number')
# per_page = query.get('per_page', CatalogueConfig.get_solo().posts_per_page)
per_page = query.get('per_page', 8)
page = Paginator(posts, per_page=per_page).get_page(page_number)
page_posts = PostSerializer(page, many=True, read_only=True).data
is_paginated = page.has_other_pages()
current_page = page.number
last_page = page.paginator.num_pages
pages_list = page.paginator.page_range
has_prev = page.has_previous()
has_next = page.has_next()
next_page = page.next_page_number() if has_next else ''
prev_page = page.previous_page_number() if has_prev else ''
response = {
'page_posts': page_posts,
'is_paginated': is_paginated,
'current_page': current_page,
'last_page': last_page,
'pages_list': list(pages_list),
'has_prev': has_prev,
'has_next': has_next,
'next_page': next_page,
'prev_page': prev_page,
}
return response
def paginate(
request,
klass,
per_page=4,
page_number=1,
):
query = request.GET
page_number = query.get('page_number', page_number)
per_page = query.get('per_page', per_page)
try:
objects = klass.objects.all()
page = Paginator(objects, per_page=per_page).get_page(page_number)
except:
objects = klass
page = Paginator(objects, per_page=per_page).get_page(page_number)
is_paginated = page.has_other_pages()
current_page = page.number
last_page = page.paginator.num_pages
has_prev = page.has_previous()
has_next = page.has_next()
next_page = page.next_page_number() if has_next else ''
prev_page = page.previous_page_number() if has_prev else ''
pages_list = page.paginator.page_range
pages_list = list(pages_list)
return locals()
def get_imgs(request, page=None, pk=None):
"""
Returns some JSON corresponding to a list of image thumbnails.
These correspond to Image.objects.all() and are paginated.
"""
if page is not None:
IMGS_PER_REQ = 2
json_dict, images = {}, {}
p = Paginator(Image.objects.all(), IMGS_PER_REQ).page(page)
imgs = p.object_list
for i in imgs:
images[i.pk] = render_to_string('image_fragment.html', {'images': [i]})
json_dict['images'] = images
json_dict['next_page'] = p.next_page_number() if p.has_next() else 0
json_dict['prev_page'] = p.previous_page_number() if p.has_previous() else 0
return HttpResponse(simplejson.dumps(json_dict))
elif pk is not None:
return render_to_response(
'image_fragment.html',
{'images': [get_object_or_404(Image, pk=pk)]}
)
def pagination(posts, posts_per_page=10, page=1):
# posts per page
start_pos = (int(page)-1) * posts_per_page
end_pos = start_pos + posts_per_page
posts_of_present_page = posts[start_pos : end_pos]
paginator = Paginator(posts, posts_per_page).page(page)
has_next = paginator.has_next()
has_previous = paginator.has_previous()
nextpage = page
previous_page = page
if has_next:
nextpage = paginator.next_page_number()
if has_previous:
previous_page = paginator.previous_page_number()
custom_paginator = {
'posts' : posts_of_present_page,
'paginator' : paginator,
'has_next' : has_next,
'has_previous' : has_previous,
'nextpage' : nextpage,
'previous_page' : previous_page,
}
return custom_paginator
def get_user_detections_page(user, page, preload=False):
timeout = 48 * 3600 if preload else 10 * 60
data = cache.get("user_{}_recent_detections_{}".format(user.id, page))
if preload or not data:
p = Paginator(
Detection.objects.filter(user=user).order_by("-timestamp").filter(
visible=True),
20,
).page(page)
data = {
"has_next":
p.has_next(),
"has_previous":
p.has_previous(),
"page_number":
page,
"detections": [{
"date": format_date(d.timestamp),
"timestamp": d.timestamp,
"img": base64.encodebytes(d.frame_content).decode(),
"x": d.x,
"y": d.y,
} for d in p.object_list],
}
cache.set("user_{}_recent_detections_{}".format(user.id, page),
data,
timeout=timeout)
return data
def get_user_detections_page(user, page):
data = cache.get('user_{}_recent_detections_{}'.format(user.id, page))
if not data:
p = Paginator(Detection.objects.filter(user=user).order_by('-timestamp').filter(visible=True), 20).page(page)
data = {
'has_next': p.has_next(),
'has_previous': p.has_previous(),
'page_number': page,
'detections': [{
'date': time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(d.timestamp / 1000)),
'img': base64.encodestring(d.frame_content)
} for d in p.object_list]
}
cache.set('user_{}_recent_detections_{}'.format(user.id, page), data)
return data
def get_paginated_data(data, page=None, limit=None, url=""):
next_page, previous_page = None, None
try:
page = int(page) if page else 1
limit = int(limit) if limit else 2
data = Paginator(data, limit)
data = data.page(page)
if data.has_next():
next_page = F"{url}&page={page+1}&limit={limit}"
if data.has_previous():
previous_page = F"{url}&page={page-1}&limit={limit}"
data = list(data)
except EmptyPage or InvalidPage:
data = None
return {"data": data, "next": next_page, "previous": previous_page}
def list(request, page=1, tag=None):
page = int(page)
entries = Entry.objects.all().filter(published=True).order_by('-pub_date')
if tag:
entries = TaggedItem.objects.get_by_model(entries, tag)
p = Paginator(entries, 5).page(page)
return render_to_response('blog/base_blog.html',
{ 'entries': p.object_list,
# 'all_entries': entries,
'tag': tag,
'older_page': p.next_page_number() if p.has_next() else None,
'newer_page': p.previous_page_number() if p.has_previous() else None } )
def list(self, request):
# Sorted by -created date
editions = Edition.objects.all()
return_json = OrderedDict([('href', request.build_absolute_uri('')),
('count', len(editions)),
('next', None),
('previous', None),
('template', {}),
('results', [])])
request_page = request.GET.get('page', 1)
try:
page = Paginator(editions, 16, allow_empty_first_page=False).page(request_page)
except InvalidPage:
raise Http404("Invalid page")
except PageNotAnInteger:
raise Http404("Page not a number")
except EmptyPage:
raise Http404("Empty page")
for ed in page.object_list:
return_json['results'].append( serialize_edition(ed) )
if page.has_next():
parseResult = urlparse.urlparse(request.build_absolute_uri(''))
qd = QueryDict(parseResult.query).copy()
qd['page'] = int(request_page) + 1
query = qd.urlencode()
return_json['next'] = urlparse.urlunsplit((parseResult.scheme, parseResult.netloc, parseResult.path, query, parseResult.fragment))
else:
return_json['next'] = None
if page.has_previous():
parseResult = urlparse.urlparse(request.build_absolute_uri(''))
qd = QueryDict(parseResult.query).copy()
qd['page'] = int(request_page) - 1
query = qd.urlencode()
return_json['previous'] = urlparse.urlunsplit((parseResult.scheme, parseResult.netloc, parseResult.path, query, parseResult.fragment))
else:
return_json['previous'] = None
return Response(return_json)
def get_user_detections_page(user, page):
data = cache.get('user_{}_recent_detections_{}'.format(user.id, page))
if not data:
p = Paginator(Detection.objects.filter(user=user).order_by('-timestamp').filter(visible=True), 20).page(page)
data = {
'has_next': p.has_next(),
'has_previous': p.has_previous(),
'page_number': page,
'detections': [{
'date': format_date(d.timestamp),
'timestamp': d.timestamp,
'img': base64.encodebytes(d.frame_content).decode(),
'x': d.x,
'y': d.y
} for d in p.object_list]
}
cache.set('user_{}_recent_detections_{}'.format(user.id, page), data)
return data
def team_list(request, page=1):
page = int(page)
context = cache.get('team_list_{}'.format(page))
if not context:
p = Paginator(Team.objects.filter(detection__visible=True).annotate(detection_count=Count('detection')).exclude(
name__isnull=True).exclude(name__exact='').order_by('-detection_count'), 20).page(page)
context = {
'has_next': p.has_next(),
'has_previous': p.has_previous(),
'page_number': page,
'teams': [{
'name': t.name,
'user_count': t.user_set.count(),
'detection_count': t.detection_count,
} for t in p.object_list],
}
cache.set('team_list_{}'.format(page), context)
return render(request, 'credoweb/team_list.html', context)
def user_list(request, page=1):
page = int(page)
context = cache.get('user_list_{}'.format(page))
if not context:
p = Paginator(
User.objects.filter(detection__visible=True).annotate(detection_count=Count('detection')).order_by(
'-detection_count'), 20).page(page)
context = {
'has_next': p.has_next(),
'has_previous': p.has_previous(),
'page_number': page,
'users': [{
'name': u.username,
'display_name': u.display_name,
'detection_count': u.detection_count
} for u in p.object_list],
}
cache.set('user_list_{}'.format(page), context)
return render(request, 'credoweb/user_list.html', context)
def detection_list(request, page=1):
try:
page = int(page)
except ValueError:
raise Http404("Page index must be a number")
context = cache.get("detection_list_{}".format(page))
if not context:
try:
p = Paginator(
Detection.objects.order_by("-timestamp").filter(
visible=True).only("timestamp", "frame_content", "x", "y",
"user", "team"),
20,
).page(page)
except EmptyPage:
raise Http404("Detection list page not found")
context = {
"has_next":
p.has_next(),
"has_previous":
p.has_previous(),
"page_number":
page,
"detections": [{
"date": format_date(d.timestamp),
"timestamp": d.timestamp,
"x": d.x,
"y": d.y,
"user": {
"name": d.user.username,
"display_name": d.user.display_name,
},
"team": {
"name": d.team.name
},
"img": base64.encodebytes(d.frame_content).decode(),
} for d in p.object_list],
}
cache.set("detection_list_{}".format(page), context)
return render(request, "credoweb/detection_list.html", context)
def get_galleries(request, st_yr, st_mnth, end_yr,
end_mnth, tags, page=None):
"""
Returns some JSON corresponding to a list of image galleries and images.
"""
IMG_GALS_PER_REQ = 5
tags = [tag.strip() for tag in tags.split(',')]
st_yr, st_mnth, end_yr, end_mnth = \
int(st_yr), int(st_mnth), int(end_yr), int(end_mnth)
end_yr, end_mnth = (end_yr+1, 1) if end_mnth > 11 else (end_yr, end_mnth+1)
page = int(page or 1)
q = Q(created_on__range=(
datetime(st_yr, st_mnth, 1),
datetime(end_yr, end_mnth, 1),
))
for tag in tags:
q = q & Q(tags__text=tag)
# TODO: loading all the objects at once is REALLY inefficient; fix it
imgs = list(Image.objects.filter(q)) + list(Gallery.objects.filter(q))
p = Paginator(imgs, IMG_GALS_PER_REQ).page(page)
galleries = {}
for obj in p.object_list:
if obj.__class__ == Gallery:
galleries['gal_%d' % obj.pk] = render_to_string('image_gal_fragment.html', {
'images': obj.images.all()[:MAX_IMGS_PER_GAL],
'more': max(obj.images.count() - MAX_IMGS_PER_GAL, 0),
'gal': obj})
else:
galleries['img_%d' % obj.pk] = render_to_string('image_gal_fragment.html', {
'image': obj,
})
json_dict = {}
json_dict['galleries'] = galleries
json_dict['next_page'] = p.next_page_number() if p.has_next() else 0
json_dict['prev_page'] = p.previous_page_number() if p.has_previous() else 0
return HttpResponse(simplejson.dumps(json_dict))
def paginate(data,
page=None,
limit=None,
url='',
serializer=None,
serializer_kwargs=None):
next_page_url, previous_page_url, next_page, previous_page, count, pages = None, None, None, None, 0, 0
page = int(page) if page else 1
limit = int(limit) if limit else 10
try:
data = Paginator(data, limit)
pages = data.num_pages
count = data.count
data = data.page(page)
if data.has_next():
next_page_url = '{}&page={}&limit={}'.format(url, page + 1, limit)
next_page = page + 1
if data.has_previous():
previous_page_url = '{}&page={}&limit={}'.format(
url, page - 1, limit)
previous_page = page - 1
if serializer:
serializer_kwargs = serializer_kwargs if serializer_kwargs else {}
data = serializer(data, many=True, **serializer_kwargs).data
else:
data = list(data)
except EmptyPage or InvalidPage:
data = []
return {
'data': data,
'pagination': {
'count': count,
'pages': pages,
'page': page,
'limit': limit,
'next': next_page,
'next_url': next_page_url,
'previous': previous_page,
'previous_url': previous_page_url
}
}
def get_form(request):
search_query = request.GET.get('search', '')
if search_query:
posts = Post.objects.filter(
Q(title__icontains=search_query) | Q(body__icontains=search_query))
else:
posts = Post.objects.all()
page = Paginator(posts, 2).get_page(request.GET.get('page', 1))
is_paginated = page.has_other_pages()
prev_page_num = '?page={}'.format(
page.previous_page_number()) if page.has_previous() else ''
next_page_num = '?page={}'.format(
page.next_page_number()) if page.has_next() else ''
context = {
'page': page,
'is_paginated': is_paginated,
'next_page': next_page_num,
'prev_page': prev_page_num
}
return render(request, 'blog/index.html', context=context)
def make_pagination_ui_ctx(page: Paginator) -> Dict[str, Any]:
""" Computes the layout of the pagination UI element """
context = {}
# 1 ... p c n ... l
p = page.has_previous() and page.previous_page_number()
c = page.number
n = page.has_next() and page.next_page_number()
l = page.paginator.num_pages
# Start figuring out if we need the one and the dots
if not p or p == 1:
print1 = False
print1Dots = False
elif p == 2:
print1 = True
print1Dots = False
else:
print1 = True
print1Dots = True
context['print1'] = print1
context['print1Dots'] = print1Dots
# End by figuring out if we need the last tods etc
if not n or n == l:
printL = False
printLDots = False
elif n == l - 1:
printL = True
printLDots = False
else:
printL = True
printLDots = True
context['printL'] = printL
context['printLDots'] = printLDots
return context
def truncated_page_range(page: int, paginator: Paginator):
num_pages = paginator.paginator.num_pages
if not paginator.has_previous() or page <= 4:
for i in range(1, 7):
yield i
yield '..'
yield num_pages
return
if not paginator.has_next() or page > num_pages - 4:
yield 1
yield '..'
for i in range(num_pages - 4, num_pages):
yield i
return
yield 1
yield '..'
for i in range(page - 3, page + 4):
yield i
yield '..'
yield num_pages
def paginate(items, query):
response = {}
page_number = query.get('page', 1)
per_page = query.get('per_page', CatalogueConfig.get_solo().items_per_page)
ordering = query.get('sort', '-created')
if not item_settings.PAGINATE_AJAX:
page = items
else:
page = Paginator(items, per_page=per_page).get_page(page_number)
is_paginated = page.has_other_pages()
current_page = page.number
last_page = page.paginator.num_pages
page_range = page.paginator.page_range
has_prev = page.has_previous()
has_next = page.has_next()
next_url = f'?page={page.next_page_number()}' if has_next else ''
prev_url = f'?page={page.previous_page_number()}' if has_prev else ''
first_url = f'?page=1'
last_url = f'?page={last_page}'
response.update({
'is_paginated': is_paginated,
'current_page': current_page,
'page_range': list(page_range),
'last_page': last_page,
'first_url': first_url,
'next_url': next_url,
'prev_url': prev_url,
'last_url': last_url,
'has_prev': has_prev,
'has_next': has_next,
})
page_items = ItemDetailSerializer(page, many=True, read_only=True).data
response = {
'paginated_items': page_items,
}
return response
def detection_list(request, page=1):
page = int(page)
context = cache.get('detection_list{}'.format(page))
if not context:
p = Paginator(
Detection.objects.order_by('-timestamp').filter(visible=True).select_related('user', 'team'), 20).page(page)
context = {
'has_next': p.has_next(),
'has_previous': p.has_previous(),
'page_number': page,
'detections': [{
'date': time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(d.timestamp / 1000)),
'user': {
'name': d.user.username,
'display_name': d.user.display_name,
},
'team': {
'name': d.team.name,
},
'img': base64.encodestring(d.frame_content)
} for d in p.object_list],
}
cache.set('detection_list{}'.format(page), context)
return render(request, 'credoweb/detection_list.html', context)
class SubjectClass:
subjects = ''
keyboard = ''
clientfilter = ''
count_list = 6
COUNT_ROW = 2
def __init__(self):
self.subjects = Subject.objects.filter()
def subject_paginator(self, data, page):
self.subjects = Paginator(data, self.count_list)
self.subjects = self.subjects.page(int(page))
def generate_buttons(self,
client,
data,
subject_id,
page,
parent_id,
type_button,
back=False,
paginator=True):
if (not back):
self.subject_paginator(data, int(page))
else:
self.subjects = Paginator(data, self.count_list)
self.sub = self.subjects.page(1)
for x in self.subjects.page_range:
for y in self.subjects.page(x).object_list:
if (int(subject_id) == y.id):
self.sub = self.subjects.page(x)
page = x
break
self.subjects = self.sub
print(self.subjects)
print(self.subjects.object_list)
buttons = []
for x in self.subjects.object_list:
print(x)
self.get_filter(client)
postfix = ''
if (type_button == 'SUBJECT100'):
postfix = '✅'
buttons.append({
'text':
x.name + postfix,
'callback_data':
'{}_{}_{}_{}'.format(type_button, x.id, str(page),
str(parent_id))
})
print(buttons)
self.keyboard = types.InlineKeyboardMarkup(True)
f = lambda A, n: [A[i:i + n] for i in range(0, len(A), n)]
self.keyboard.keyboard = f(buttons, self.COUNT_ROW)
if (paginator):
buttons_paginator = []
if (self.subjects.has_previous()):
buttons_paginator.append({
'text':
'◀️',
'callback_data':
'{}PAGE_{}_{}_{}'.format(
type_button, str(subject_id),
self.subjects.previous_page_number(), parent_id)
})
buttons_paginator.append({
'text':
'Назад',
'callback_data':
'{}BACK_{}_{}_{}'.format(type_button, str(subject_id),
str(page), str(parent_id))
})
if (self.subjects.has_next()):
buttons_paginator.append({
'text':
'▶️',
'callback_data':
'{}PAGE_{}_{}_{}'.format(type_button, str(subject_id),
self.subjects.next_page_number(),
parent_id)
})
self.keyboard.keyboard.append(buttons_paginator)
class SuperPaginator:
def __init__(self,
data_list,
per_page,
show_num,
cur_page,
request_param,
get_str='page'):
"""
:param data_list: django models data list
:param per_page: every page show rows
:param show_num: how much pages link you wanna generat
:param cur_page: current page from http request param
:request_param: http request param
:get_str: http custom param, default is 'page'
:param obj: paginator object
:return:
"""
self.show_num = show_num
self.cur_page = cur_page
self.per_page = per_page
self.data_list = data_list
self.request_param = request_param
self.get_str = get_str
self.obj = Paginator(data_list, self.per_page)
try:
self.obj = self.obj.page(self.cur_page)
except Exception:
self.obj = self.obj.page(1)
@property
def start(self):
"""
:return: limit start number
"""
return (self.obj.number - 1) * self.per_page
@property
def end(self):
"""
:return: limit end number
"""
return self.obj.number * self.per_page
def request_param_get(self, p):
"""
reset param 'get_str' to p
:return: request param urlencode
"""
self.request_param[self.get_str] = p
return self.request_param.urlencode()
@property
def html(self):
"""
:start_tag: nav ul html tag str
:end_tag: nav ul html close tag str
:previous_page_str: last page html tag str
:next_page_str: next page html tag str
:show_pages_str: page html li tag str
:return: html string with bootstrap
"""
start_tag = """
<nav aria-label="Page navigation">
<ul class="pagination">
"""
end_tag = """
</ul>
</nav>
"""
show_pages_str = ''
# prev
if self.obj.has_previous(
): # if has last page then enable last page link
previous_page_str = '''
<li>
<a href="?{}" aria-label="Previous">
<span aria-hidden="true">«</span>
</a>
</li>'''.format(
self.request_param_get(self.obj.previous_page_number()))
else: # or disabled
previous_page_str = '''
<li class="disabled">
<a href="" aria-label="Previous">
<span aria-hidden="true">«</span>
</a>
</li>'''
# num
for page in self.obj.paginator.page_range: # each erver page number
# if page in show_num range then show it
if abs(self.obj.number - page) < self.show_num:
if self.obj.number == page: # if number is current page then active it
show_pages_str += '''
<li class="active">
<a href="?{}">{}</a>
</li>
'''.format(self.request_param_get(page), page)
continue
show_pages_str += '''
<li class="">
<a href="?{}">{}</a>
</li>'''.format(self.request_param_get(page),
page) # add paging link to string
# next
if self.obj.has_next(): # if has next page then enable nextpage link
next_page_str = '''
<li class="">
<a href="?{}" aria-label="Previous">
<span aria-hidden="true">»</span>
</a>
</li>'''.format(
self.request_param_get(self.obj.next_page_number()))
else: # or disabled
next_page_str = '''
<li class="disabled">
<a href="" aria-label="Previous">
<span aria-hidden="true">»</span>
</a>
</li>'''
return "{}{}{}{}{}".format(
start_tag, previous_page_str, show_pages_str, next_page_str,
end_tag) # format all string to create bootstrap html code
@property
def limit_data(self):
"""
:return: django queryset data with limit
"""
return self.data_list[self.start:self.end]
