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))
