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 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 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 list_identifiers(self, page_number=1, from_date=None, until_date=None, set=None, microsite=None): headers = [] items = Paginator(self.get_items(from_date, until_date, set, microsite), self.BATCH_SIZE).page(page_number) for item in items.object_list: header = self.repository.build_header(item) headers.append(header) next_page_number = None if items.has_next(): next_page_number = items.next_page_number() return headers, next_page_number, items.paginator.count
def list_records(self, page_number=1, from_date=None, until_date=None, set=None, microsite=None): records = [] items = Paginator(self.get_items(from_date, until_date, set, microsite), self.BATCH_SIZE).page(page_number) site = Site.objects.get_current() for item in items.object_list: header = self.repository.build_header(item) metadata = self.build_metadata(item, site) records.append(Record(header, metadata)) next_page_number = None if items.has_next(): next_page_number = items.next_page_number() return records, next_page_number, items.paginator.count
def create_pagination_info(request, objects_paginator: Paginator, page, size, filter_): uri = request.build_absolute_uri() info = dict() if page > 1 and objects_paginator.page(page).has_previous(): prev = "{}?page={}&size={}&filter=".format( uri, objects_paginator.previous_page_number(), size, filter_) info["previous"] = prev if objects_paginator.page(page).has_next(): next = "{}?page={}&size={}&filter=".format( uri, objects_paginator.next_page_number(), size, filter_) info["next"] = next return info
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 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 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
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]
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)
def attempt_question(request, quiz_id, attempt_id, question_id): """ opens the selected question in the quiz-attempt mode. """ quiz = get_object_or_404(Quiz, id=quiz_id, published=True) questions = quiz.quiz_questions.order_by('number') questions_prev_next = Paginator(questions, 1).page(question_id) """ @todo, this is buggy and needs to be fixed. """ question = get_object_or_404(Question, quiz=quiz_id, number=question_id) answers = Answer.objects.filter(question=question) attempt_question_form = AttemptQuestionForm(instance=question) if request.method == "POST": attempt = Attempt.objects.get(owner=request.user, quiz=quiz_id, attempt=attempt_id) attempt_question, created = AttemptQuestion.objects.get_or_create(attempt=attempt, question=question) attempt_question_form = AttemptQuestionForm(request.POST, instance=attempt_question) if attempt_question_form.is_valid(): answer_form = attempt_question_form.save(commit=False) answer_form.save() if questions_prev_next.has_next(): return HttpResponseRedirect(reverse("quizattempt.views.attempt_question", args=[quiz_id, attempt.attempt, questions_prev_next.next_page_number()])) else: attempt.status = "complete" attempt.save() return HttpResponseRedirect(reverse("reports.views.report_attempt", args=[quiz_id, attempt.attempt])) return render_to_response("quizattempt/attempt_question.html", { "quiz_id" : quiz_id, "attempt_id" : attempt_id, "selected_question": question, "questions_prev_next" : questions_prev_next, "questions" : questions, "answers": answers, "attemptanswer_form" : attempt_question_form, "pagetitle" : "Attempt Question", }, context_instance=RequestContext(request))