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]