def get(self, request): from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator page = request.GET.get('page', 1) username = request.GET.get('username', None) versions = None lookup_user = None # Try to get the versions for the given username if not username is None: User = get_user_model() try: lookup_user = User.objects.get(username=username) versions = SystemVersion.objects.filter(creator=lookup_user) except: lookup_user = None pass if versions is None: versions = SystemVersion.objects.all() # Sort by timestamps versions = versions.order_by('-created') paginator = Paginator(versions, 25) try: versions = paginator.get_page(page) except PageNotAnInteger: versions = paginator.get_page(1) except EmptyPage: versions = paginator.get_page(paginator.num_pages) return render(request, self.template_name, context={ 'activate': 'recent', # NAV-LINKS 'versions': versions, 'lookup_user': lookup_user, })
def test_get_page_empty_object_list(self): """Paginator.get_page() with an empty object_list.""" paginator = Paginator([], 2) # An empty page returns the last page. self.assertEqual(paginator.get_page(1).number, 1) self.assertEqual(paginator.get_page(2).number, 1) # Non-integer page returns the first page. self.assertEqual(paginator.get_page(None).number, 1)
def test_get_page_empty_object_list_and_allow_empty_first_page_false(self): """ Paginator.get_page() raises EmptyPage if allow_empty_first_page=False and object_list is empty. """ paginator = Paginator([], 2, allow_empty_first_page=False) with self.assertRaises(EmptyPage): paginator.get_page(1)
def test_get_page(self): """ Paginator.get_page() returns a valid page even with invalid page arguments. """ paginator = Paginator([1, 2, 3], 2) page = paginator.get_page(1) self.assertEqual(page.number, 1) self.assertEqual(page.object_list, [1, 2]) # An empty page returns the last page. self.assertEqual(paginator.get_page(3).number, 2) # Non-integer page returns the first page. self.assertEqual(paginator.get_page(None).number, 1)
def get(self, request): """ Lists the consultants for the current page, and applies the search filter if it exists. """ # search? yes try: search_term = request.GET.get('search') consultants = Consultant.search_consultants(search_term) # no except KeyError: # get all consultants consultants = Consultant.search_consultants(None) # divide consultants by five per page paginator = Paginator(consultants, 5) page = request.GET.get('page') show_consultants = paginator.get_page(page) return render( request, 'consultant/consultants.html', {'consultants': show_consultants} )
def request_list(request): filter = RequestFilter(request.GET, queryset=Request.objects.all() ) req_data = filter.qs.order_by('-dateadded') paginator = Paginator(req_data, 100) page = request.GET.get('page') req_data = paginator.get_page(page) return render(request, 'mainapp/request_list.html', {'filter': filter , "data" : req_data })
def warehouse_orders(request): vendors, payment_method, currency = Supply.objects.all(), PaymentMethod.objects.all(), CURRENCY orders = Order.objects.all() orders = Order.filter_data(request, queryset=orders) date_start, date_end, date_range, months_list = estimate_date_start_end_and_months(request) search_name, vendor_name, balance_name, paid_name = [request.GET.get('search_name'), request.GET.getlist('vendor_name'), request.GET.get('balance_name'), request.GET.get('paid_name') ] order_count, total_value, paid_value = orders.count(), orders.aggregate(Sum('total_price'))[ 'total_price__sum'] \ if orders else 0, orders.aggregate(Sum('paid_value'))[ 'paid_value__sum'] if orders else 0 diff = total_value - paid_value warehouse_analysis = balance_sheet_chart_analysis(date_start, date_end, orders, 'total_price') warehouse_vendors = orders.values('vendor__title').annotate(value_total=Sum('total_price'), paid_val=Sum('paid_value')).order_by( '-value_total') paginator = Paginator(orders, 100) page = request.GET.get('page', 1) orders = paginator.get_page(page) context = locals() return render(request, 'report/orders.html', context)
def get(self, request): try: search_term = request.GET.get('search') # get all results from companies & consultants companies = Company.search_companies(search_term) except KeyError: # get all companies and consultants companies = Company.search_companies(None) company_filter = CompanyFilter(request.GET, queryset=companies) results = company_filter.qs paginator = Paginator(results, 8) page = request.GET.get('page') show_businesses = paginator.get_page(page) return render(request, 'companies.html', { 'company': Member.get_user_company(request.user), 'show_sidepane': True, 'companies': show_businesses, 'page': page, 'filter': company_filter, })
def buildListHTML(self, pageNumber, propertyName, parent): modelClass, modelClassName = self.modelClass, self.modelClassName modelClassDisplayName = modelClass.getPrettyClassName() if propertyName and parent: gql = "WHERE %s = :1 ORDER BY %s" % (propertyName, modelClass.NAME_PROPERTY) # logging.debug(gql + '(' + parent + ')') models = (propertyName and modelClass.gql(gql, db.get(parent))) or modelClass.get() else: models = modelClass.all() paginator = ObjectPaginator(models, 10, orphans=2) if paginator.pages < pageNumber: pageNumber = paginator.pages pageNumber0 = pageNumber - 1 models = paginator.get_page(pageNumber0) firstOnPage, lastOnPage, numModels = ( paginator.first_on_page(pageNumber0), paginator.last_on_page(pageNumber0), paginator.hits, ) hasPreviousPage, hasNextPage = paginator.has_previous_page(pageNumber0), paginator.has_next_page(pageNumber0) previousPage, nextPage = pageNumber - 1, pageNumber + 1 listItems = [] for model in models: modelToListItemHTML = lambda model, s=self, p=parent, pn=propertyName: s.modelToListItemHTML(model, p, pn) cacheKey = "listItemHTML" + parent self.modelClass.setEntityCacheFunctionForKey(modelToListItemHTML, cacheKey) listItems.append(model.getEntityCache(cacheKey)) listItems = "\n".join(listItems) return self.renderManagementTemplate(locals(), "List.html")
def chooser(request, get_results=False): # Get most popular queries queries = models.Query.get_most_popular() # If searching, filter results by query string query_string = None if 'q' in request.GET: searchform = SearchForm(request.GET) if searchform.is_valid(): query_string = searchform.cleaned_data['q'] queries = queries.filter(query_string__icontains=normalise_query_string(query_string)) else: searchform = SearchForm() paginator = Paginator(queries, per_page=10) queries = paginator.get_page(request.GET.get('p')) # Render if get_results: return render(request, "wagtailsearch/queries/chooser/results.html", { 'queries': queries, }) else: return render_modal_workflow( request, 'wagtailsearch/queries/chooser/chooser.html', None, { 'queries': queries, 'searchform': searchform, }, json_data={'step': 'chooser'} )
def get_context_data(self, number_of_publications=25, **kwargs): context = super(DashboardView, self).get_context_data(**kwargs) last_week_datetime = timezone.now() - timedelta(days=14) context['status'] = Counter() pub_count = Publication.objects.filter(is_primary=True).values('status').annotate( total=Count('status')).order_by('-total') for item in pub_count: total_count = item['total'] context['status'][item['status']] = total_count context['status']['TOTAL'] += total_count n_flagged = Publication.objects.filter(is_primary=True, flagged=True).count() context['flagged'] = n_flagged context['complete'] = Publication.objects.filter( is_primary=True, status=Publication.Status.REVIEWED) \ .annotate(n_code_archive_urls=models.Count('code_archive_urls')) \ .filter(n_code_archive_urls__gt=0).count() context['incomplete'] = context['status'][Publication.Status.REVIEWED] - context['complete'] context['unreviewed_publications_count'] = Publication.objects.filter( status=Publication.Status.UNREVIEWED, assigned_curator=self.request.user).count() context['recently_author_updated'] = Publication.objects.filter( status=Publication.Status.AUTHOR_UPDATED) recently_updated_publications = Publication.objects.exclude( status=Publication.Status.AUTHOR_UPDATED) recently_updated_list = recently_updated_publications.filter( date_modified__gte=last_week_datetime, is_primary=True).order_by('-date_modified') paginator = Paginator(recently_updated_list, number_of_publications) page = self.request.GET.get('page') recently_updated = paginator.get_page(page) context['recently_updated'] = recently_updated return context
def user_profile(request): posts_list = request.user.post_set.all() paginator = Paginator(posts_list, 10) # Show 25 contacts per page page = request.GET.get('page') posts = paginator.get_page(page) context = {"author":request.user,"userposts":posts} return render(request,"user/user-profile-posts.html",context)
def __init__(self, searchResults, handler, title, user): self.user, self.handler = user, handler self.rootNode = rootNode = ElementTree.Element('SearchResults') ElementTree.ElementTree.__init__(self, rootNode) rootNode.set('title', title) rootNode.set('pagelessUrl', self.getPagelessUrlFromHandler(handler)) # Don't limit the number of results if viewing the characters in a campaign. hitsPerPage = handler.request.get('campaign', None) and 100 or self.HITS_PER_PAGE paginator = ObjectPaginator(searchResults, hitsPerPage, orphans=self.ORPHANS_PER_PAGE) pageNumber = int(handler.request.get('p', '1')) numPages = paginator.pages pageNumber = min(numPages, pageNumber) pageNumber0 = pageNumber - 1 firstOnPage, lastOnPage, numResults = \ paginator.first_on_page(pageNumber0), paginator.last_on_page(pageNumber0), paginator.hits firstOnPage = lastOnPage and firstOnPage or 0 # so firstOnPage isn't 1 when there are 0 results localVars = locals() for thisVar in ('numResults', 'numPages', 'pageNumber', 'firstOnPage', 'lastOnPage'): rootNode.set(thisVar, str(localVars[thisVar])) try: [ self.addResult(thisResult, user) for thisResult in paginator.get_page(pageNumber0) ] except AttributeError: raise raise RuntimeError, 'expecting searchResults, got %(searchResults)r' % locals()
def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) all_links = self.request.user.links.all() paginator = Paginator(all_links, 50) page = self.request.GET.get('page') context['links'] = paginator.get_page(page) return context
def move_choose_destination(request, page_to_move_id, viewed_page_id=None): page_to_move = get_object_or_404(Page, id=page_to_move_id) page_perms = page_to_move.permissions_for_user(request.user) if not page_perms.can_move(): raise PermissionDenied if viewed_page_id: viewed_page = get_object_or_404(Page, id=viewed_page_id) else: viewed_page = Page.get_first_root_node() viewed_page.can_choose = page_perms.can_move_to(viewed_page) child_pages = [] for target in viewed_page.get_children(): # can't move the page into itself or its descendants target.can_choose = page_perms.can_move_to(target) target.can_descend = ( not(target == page_to_move or target.is_child_of(page_to_move)) and target.get_children_count() ) child_pages.append(target) # Pagination paginator = Paginator(child_pages, per_page=50) child_pages = paginator.get_page(request.GET.get('p')) return render(request, 'wagtailadmin/pages/move_choose_destination.html', { 'page_to_move': page_to_move, 'viewed_page': viewed_page, 'child_pages': child_pages, })
def posts_list(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() paginator = Paginator(posts, posts_on_page) page_number = request.GET.get('page', 1) page = paginator.get_page(page_number) is_paginated = page.has_other_pages() if page.has_previous(): prev_url = '?page={}'.format(page.previous_page_number()) else: prev_url = '' if page.has_next(): next_url = '?page={}'.format(page.next_page_number()) else: next_url = '' context = { 'page_object':page, 'is_paginated':is_paginated, 'next_url':next_url, 'prev_url':prev_url } return render(request, 'blog/index.html', context=context)
def chooser_upload(request): Image = get_image_model() ImageForm = get_image_form(Image) if request.method == 'POST': image = Image(uploaded_by_user=request.user) form = ImageForm( request.POST, request.FILES, instance=image, user=request.user, prefix='image-chooser-upload' ) if form.is_valid(): # Set image file size image.file_size = image.file.size # Set image file hash image.file.seek(0) image._set_file_hash(image.file.read()) image.file.seek(0) form.save() # Reindex the image to make sure all tags are indexed search_index.insert_or_update_object(image) if request.GET.get('select_format'): form = ImageInsertionForm( initial={'alt_text': image.default_alt_text}, prefix='image-chooser-insertion' ) return render_modal_workflow( request, 'wagtailimages/chooser/select_format.html', None, {'image': image, 'form': form}, json_data={'step': 'select_format'} ) else: # not specifying a format; return the image details now return render_modal_workflow( request, None, None, None, json_data={'step': 'image_chosen', 'result': get_image_result_data(image)} ) else: form = ImageForm(user=request.user, prefix='image-chooser-upload') images = Image.objects.order_by('-created_at') # allow hooks to modify the queryset for hook in hooks.get_hooks('construct_image_chooser_queryset'): images = hook(images, request) paginator = Paginator(images, per_page=12) images = paginator.get_page(request.GET.get('p')) context = get_chooser_context(request) context.update({ 'images': images, 'uploadform': form, }) return render_modal_workflow( request, 'wagtailimages/chooser/chooser.html', None, context, json_data=get_chooser_js_data() )
def index(request): Image = get_image_model() # Get images (filtered by user permission) images = permission_policy.instances_user_has_any_permission_for( request.user, ['change', 'delete'] ).order_by('-created_at') # Search query_string = None if 'q' in request.GET: form = SearchForm(request.GET, placeholder=_("Search images")) if form.is_valid(): query_string = form.cleaned_data['q'] images = images.search(query_string) else: form = SearchForm(placeholder=_("Search images")) # Filter by collection current_collection = None collection_id = request.GET.get('collection_id') if collection_id: try: current_collection = Collection.objects.get(id=collection_id) images = images.filter(collection=current_collection) except (ValueError, Collection.DoesNotExist): pass paginator = Paginator(images, per_page=20) images = paginator.get_page(request.GET.get('p')) collections = permission_policy.collections_user_has_any_permission_for( request.user, ['add', 'change'] ) if len(collections) < 2: collections = None else: collections = Collection.order_for_display(collections) # Create response if request.is_ajax(): return render(request, 'wagtailimages/images/results.html', { 'images': images, 'query_string': query_string, 'is_searching': bool(query_string), }) else: return render(request, 'wagtailimages/images/index.html', { 'images': images, 'query_string': query_string, 'is_searching': bool(query_string), 'search_form': form, 'popular_tags': popular_tags_for_model(Image), 'collections': collections, 'current_collection': current_collection, 'user_can_add': permission_policy.user_has_permission(request.user, 'add'), })
def user_posts_detail(request,id): author = get_object_or_404(User,pk=id) posts_list = author.post_set.all() paginator = Paginator(posts_list, 25) # Show 25 contacts per page page = request.GET.get('page') posts = paginator.get_page(page) context = {"author":author,"userposts":posts} return render(request,"user/user-posts-all.html",context)
def user_posts_gallery(request,id): author = get_object_or_404(User,pk=id) gallery_list = author.picture_set.all() paginator = Paginator(gallery_list, 15) # Show 25 contacts per page page = request.GET.get('page') gallerys = paginator.get_page(page) context = {"author":author,"gallerys":gallerys} return render(request,"user/user-posts-gallery.html",context)
def getModelPageNumber(self, model): modelKey = model.key() allModels = self.modelClass.get() paginator = ObjectPaginator(allModels, 10, orphans=2) for pageNumber in range(paginator.pages): for thisModel in paginator.get_page(pageNumber): if thisModel.key() == modelKey: return pageNumber
def _paged_offers(page_queryset, page_num, page_size): if page_num <= 0: return [] paged_products = Paginator(page_queryset, page_size) if page_num > paged_products.num_pages: return [] page = paged_products.get_page(page_num) return page.object_list
def list(request, app_label, model_name): model = get_snippet_model_from_url_params(app_label, model_name) permissions = [ get_permission_name(action, model) for action in ['add', 'change', 'delete'] ] if not any([request.user.has_perm(perm) for perm in permissions]): return permission_denied(request) items = model.objects.all() # Preserve the snippet's model-level ordering if specified, but fall back on PK if not # (to ensure pagination is consistent) if not items.ordered: items = items.order_by('pk') # Search is_searchable = class_is_indexed(model) is_searching = False search_query = None if is_searchable and 'q' in request.GET: search_form = SearchForm(request.GET, placeholder=_("Search %(snippet_type_name)s") % { 'snippet_type_name': model._meta.verbose_name_plural }) if search_form.is_valid(): search_query = search_form.cleaned_data['q'] search_backend = get_search_backend() items = search_backend.search(search_query, items) is_searching = True else: search_form = SearchForm(placeholder=_("Search %(snippet_type_name)s") % { 'snippet_type_name': model._meta.verbose_name_plural }) paginator = Paginator(items, per_page=20) paginated_items = paginator.get_page(request.GET.get('p')) # Template if request.is_ajax(): template = 'wagtailsnippets/snippets/results.html' else: template = 'wagtailsnippets/snippets/type_index.html' return render(request, template, { 'model_opts': model._meta, 'items': paginated_items, 'can_add_snippet': request.user.has_perm(get_permission_name('add', model)), 'can_delete_snippets': request.user.has_perm(get_permission_name('delete', model)), 'is_searchable': is_searchable, 'search_form': search_form, 'is_searching': is_searching, 'query_string': search_query, })
def choose(request, app_label, model_name): model = get_snippet_model_from_url_params(app_label, model_name) items = model.objects.all() # Preserve the snippet's model-level ordering if specified, but fall back on PK if not # (to ensure pagination is consistent) if not items.ordered: items = items.order_by('pk') # Search is_searchable = class_is_indexed(model) is_searching = False search_query = None if is_searchable and 'q' in request.GET: search_form = SearchForm(request.GET, placeholder=_("Search %(snippet_type_name)s") % { 'snippet_type_name': model._meta.verbose_name }) if search_form.is_valid(): search_query = search_form.cleaned_data['q'] search_backend = get_search_backend() items = search_backend.search(search_query, items) is_searching = True else: search_form = SearchForm(placeholder=_("Search %(snippet_type_name)s") % { 'snippet_type_name': model._meta.verbose_name }) # Pagination paginator = Paginator(items, per_page=25) paginated_items = paginator.get_page(request.GET.get('p')) # If paginating or searching, render "results.html" if request.GET.get('results', None) == 'true': return render(request, "wagtailsnippets/chooser/results.html", { 'model_opts': model._meta, 'items': paginated_items, 'query_string': search_query, 'is_searching': is_searching, }) return render_modal_workflow( request, 'wagtailsnippets/chooser/choose.html', None, { 'model_opts': model._meta, 'items': paginated_items, 'is_searchable': is_searchable, 'search_form': search_form, 'query_string': search_query, 'is_searching': is_searching, }, json_data={'step': 'choose'} )
def forum_list(request): all_questions = Question.objects.all() paginator = Paginator(all_questions, 5) # Show 5 contacts per page page = request.GET.get('page') questions = paginator.get_page(page) if request.method == 'GET': question_form = QuestionModelForm() return render(request, 'dashboard/list_ajax.html', {'questions': questions, 'question_form': question_form})
def usage(request, image_id): image = get_object_or_404(get_image_model(), id=image_id) paginator = Paginator(image.get_usage(), per_page=20) used_by = paginator.get_page(request.GET.get('p')) return render(request, "wagtailimages/images/usage.html", { 'image': image, 'used_by': used_by })
def usage(request, document_id): Document = get_document_model() doc = get_object_or_404(Document, id=document_id) paginator = Paginator(doc.get_usage(), per_page=20) used_by = paginator.get_page(request.GET.get('p')) return render(request, "wagtaildocs/documents/usage.html", { 'document': doc, 'used_by': used_by })
def usage(request, app_label, model_name, pk): model = get_snippet_model_from_url_params(app_label, model_name) instance = get_object_or_404(model, pk=unquote(pk)) paginator = Paginator(instance.get_usage(), per_page=20) used_by = paginator.get_page(request.GET.get('p')) return render(request, "wagtailsnippets/snippets/usage.html", { 'instance': instance, 'used_by': used_by })
def front_page(request): jobs = Job.objects.all().filter(filled=False).filter(approved=True).order_by("-id") paginator = Paginator(jobs, 15) page = request.GET.get("page") return render( request, "main_page.html", { "jobs": paginator.get_page(page) } )
def new_dashboard(request): statistics = Statistics(request.user) # type: Statistics goals = Goals(request.user) paginator = Paginator(Workout.objects.filter(user=request.user), 20) page = request.GET.get("page") workouts = paginator.get_page(page) return render(request, 'training/new_dashboard.html', {'statistics': statistics, 'goals': goals, 'days_left_in_this_month': dates.days_left_in_this_month(), 'workouts': workouts})
def transactions(request): dvds = DVD.objects.all() #imports dvds from database trans = Transaction.objects.all() #imports dvds from database users = User.objects.all() #imports dvds from database customer = Customer.objects.all() #imports dvds from database query = request.GET.get("query") if query: trans = Transaction.objects.filter( Q(TransactionNumber__icontains=query) ) #Search Function according to name paginator = Paginator(dvds, 6) # Show 3 dvds per page page = request.GET.get('page') dvds = paginator.get_page(page) form = DocumentForm() context_dict = { 'dvds': dvds, 'form': form, 'trans': trans, 'users': users, 'customer': customer } return render(request, 'transactions.html', context_dict)
def index(request): if request.method == 'POST': #salva os dados e a foto product_form = ProductForm(data=request.POST,files=request.FILES,) # Verifica se o formulario é valido if product_form.is_valid(): # Salva o produto product_form.save() # Confirma com mensagem na tela messages.success(request, 'Produto Salvo com Sucesso') #Vai para pagina principal return HttpResponseRedirect(reverse('index')) else: # Avisa o motivo do erro no shell. print(product_form.errors) else: # Renderiza um formulario para cadastro . product_form = ProductForm() # Cria uma lista por ordem decrescente por data product_list = Product.objects.all().order_by('-date') #Paginação page_number = request.GET.get('page') paginator = Paginator(product_list,3) # Mostra nemero de itens por pagina, no caso 3. try: pages = paginator.page(page_number) except PageNotAnInteger: pages = paginator.page(1) except EmptyPage: pages = paginator.get_page(page_number) context = { 'product_form': product_form, 'pages':pages } return render(request, 'base/index.html' , context)
def get(self, request): model = CommentsModel.objects.order_by('-timedate') paginator = Paginator(model, 3) page_number = request.GET.get('page', 1) page = paginator.get_page(page_number) is_paginated = page.has_other_pages() if page.has_previous(): prev_url = '?page={}'.format(page.previous_page_number()) else: prev_url = '' if page.has_next(): next_url = '?page={}'.format(page.next_page_number()) else: next_url = '' if request.user.is_authenticated: initial = { 'surname': request.user.first_name, 'name': request.user.last_name, } form = CommentsForm(initial=initial) else: form = CommentsForm() context = { 'form': form, 'model': page, 'prev_url': prev_url, 'next_url': next_url, 'is_paginated': is_paginated, } return render(request, 'comments/comments.html', context=context)
def index(request, sort=None): if sort == 'rank': movies = Movie.objects.order_by('-vote_average').filter( release_date__lte=datetime.datetime.now()) elif sort == 'release': movies = Movie.objects.order_by('-release_date').filter( release_date__lte=datetime.datetime.now()) else: movies = Movie.objects.order_by('-pk').filter( release_date__lte=datetime.datetime.now()) paginator = Paginator(movies, 12) nowDate = datetime.datetime.now().strftime('%Y-%m-%d') page_number = request.GET.get('page') page_obj = paginator.get_page(page_number) context = { 'page_obj': page_obj, 'nowDate': nowDate, } if not page_number or int(page_number) == 1: return render(request, 'movies/index.html', context) else: return render(request, 'movies/index_scroll.html', context)
def profile(request, username): username = get_object_or_404(User, username=username) tag = request.GET.getlist('filters') recipes = Recipe.objects.filter(author=username).\ select_related('author').all() if tag: recipes = recipes.filter(tags__slug__in=tag) paginator = Paginator(recipes, 6) page_number = request.GET.get('page') page = paginator.get_page(page_number) if request.user.is_authenticated: following = FollowUser.objects.filter(user=request.user).\ filter(author=username).select_related('author') if not following: following = None else: following = True return render(request, "authorRecipe.html", {'username': username, 'page': page, 'paginator': paginator, 'following': following}) return render(request, "authorRecipe.html", {'username': username, 'page': page, 'paginator': paginator, })
def search(request): show_tags = False search_string = request.GET.get('search') page = request.GET.get('page') param_search = search_string try: items = Item.objects.filter(name_lower__contains=search_string.lower(), is_active=True) except: return render(request, '404.html', locals()) if not items: items = Item.objects.filter( name_lower__contains=search_string.lower()[:-1], is_active=True) if not items: items = Item.objects.filter(article__contains=search_string) items_paginator = Paginator(items, 12) try: items = items_paginator.get_page(page) except PageNotAnInteger: items = items_paginator.page(1) except EmptyPage: items = items_paginator.page(items_paginator.num_pages) return render(request, 'page/search.html', locals())
def user_profile(request, username): user = get_object_or_404(User, username=username) if request.user.username != username: post_list = Blog.objects.filter( user=user, published=True, created_at__lte=timezone.now()).order_by('-created_at') is_self = False else: post_list = Blog.objects.filter( user=user, created_at__lte=timezone.now()).order_by('-created_at') is_self = True paginator = Paginator(post_list, 3) page_number = request.GET.get('page') page_obj = paginator.get_page(page_number) return render(request, "Blog/user_profile.html", context={ "author": user, "page_obj": page_obj, "is_self": is_self })
def index(request): postsdata = Post.objects.all().order_by('-timestamp') loggedUser = '' if (request.user.is_authenticated): loggedUser = User.objects.get(username=request.user.username) p = Paginator(postsdata, 10) pagenumber = request.GET.get('page') if pagenumber == None: pagenumber = 1 elif int(pagenumber) > int(p.num_pages): pagenumber = 1 else: pagenumber = int(pagenumber) maindata = p.get_page(pagenumber) return render(request, "network/index.html", { 'data': maindata, 'loggedUser': loggedUser, 'page_obj': maindata, })
def index(request): # return HttpResponse('Hello There~') issues = Issue.objects.order_by('-pub_at') paginator = Paginator(issues, 6) # 实例化paginator,每页X条数据 page_number = request.GET.get('page') # 获取当前页码 page_obj = paginator.get_page(page_number) # 根据当前页码获取实例对象 # 这部分是为了再有大量数据时,仍然保证所显示的页码数量不超过10, page_num = request.GET.get('page', default='1') page_num = int(page_num) if page_num < 6: if paginator.num_pages <= 10: dis_range = range(1, paginator.num_pages + 1) else: dis_range = range(1, 11) elif (page_num >= 6) and (page_num <= paginator.num_pages - 5): dis_range = range(page_num - 5, page_num + 5) else: dis_range = range(paginator.num_pages - 9, paginator.num_pages + 1) return render(request, 'issues/index.html', { 'page_obj': page_obj, 'dis_range ': dis_range })
def index(request): if 'search_filter' in request.GET: search_filter = request.GET['search_filter'] consoles = [{ 'id': x.id, 'name': x.console_name, 'description': x.console_short_description, 'firstImage': x.consoleimage_set.first().console_image_image } for x in Console.objects.filter( console_name__icontains=search_filter)] return JsonResponse({'data': consoles}) consoles = Console.objects.all().order_by('console_name') paginator = Paginator(consoles, 6) page = request.GET.get('page') paged_consoles = paginator.get_page(page) context = {'console': paged_consoles} return render(request, 'consoles/index.html', context=context)
def search(request): query = request.GET.get('q') if not query: return redirect("home-page") requests = None time_deltas = [] if query: requests = FeedbackRequestDocument.search().query( "multi_match", query=query, fields=['title', 'maintext']) requests = requests.to_queryset() requests = requests.filter(feedbackee=F('feedbacker')).exclude( feedbackee=request.user) page_number = request.GET.get('page', 1) # defaults to 1 if not found paginator = Paginator(requests, 5) # each page contains 5 feedback requests requests = paginator.get_page(page_number) page_obj = requests curr_time = datetime.now(timezone.utc) for feedback_request in requests: time_posted = feedback_request.date_posted time_deltas.append(get_time_delta(time_posted, curr_time)) else: page_obj = None context = { 'requests': requests, 'search': query, 'areas': Area.objects.all(), 'page_obj': page_obj, 'time_deltas': time_deltas, 'title': '| Search' } return render(request, 'main/search-requests.html', context)
def products(request): """ View for showing all ads that are not sold, ordering them by date created and paginating them over multiple pages :param request: A django HttpRequest object. The session of the user. :return: render: A render with the product_listEXT.html file """ products = Advertisement.objects.all().filter( sold=False).order_by('-created_date') paginator = Paginator(products, 6) # Show X products per page page_number = request.GET.get('page') page_obj = paginator.get_page(page_number) categories = Category.objects.all() context = { 'products': page_obj.object_list, 'page_obj': page_obj, 'categories': categories } return render(request, 'sellyoshit/product_listEXT.html', context)
def by_rubric(request, pk): """ вывод объявлений """ rubric = get_object_or_404(SubRubric, pk=pk) bbs = Bb.objects.filter(is_active=True, rubric=pk) if 'keyword' in request.GET: keyword = request.GET['keyword'] q = Q(title__icontains=keyword) | Q(content__icontains=keyword) bbs = bbs.filter(q) else: keyword = '' form = SearchForm(initial={'keyword': keyword}) paginator = Paginator(bbs, 2) if 'page' in request.GET: page_num = request.GET['page'] else: page_num = 1 page = paginator.get_page(page_num) context = { 'rubric': rubric, 'page': page, 'bbs': page.object_list, 'form': form } return render(request, 'main/by_rubric.html', context)
def result_table(request): check = False result = Result.objects.all().order_by('-id') paginator = Paginator(result, 1) # Show 10 obj per page page = request.GET.get('page') result = paginator.get_page(page) if request.method == 'POST' and 'btn-search' in request.POST: q = request.POST.get('search').strip() result = Result.objects.filter(Q(studentId__icontains = q)).order_by('-id') check = True context = { 'result': result, 'check' : check, } return render(request, 'result/result_table.html', context)
def generate_result_from_paginator_for_admin_portal(model_cls, serializer_cls, search_options=None, sort_options=(), page_number=1, page_size=20): qs = model_cls.objects.order_by('-id') if sort_options: for option in sort_options: qs = qs.order_by(option) if search_options: qs = qs.filter(**search_options) paginator = Paginator(qs, page_size, allow_empty_first_page=True) page = paginator.get_page(page_number) data = serializer_cls(instance=page.object_list, many=True).data return { 'data': data, 'total': paginator.count, }
def my_page(request): """ Renders a page displaying the logged in user's ads :param request: A django HttpRequest object. The session of the user. :return: redirect: Redirects to home if the user if not logged in render: Renders the logged in user's ad in the file mypage.html """ user = request.user if not user.is_authenticated: return redirect('home') products = Advertisement.objects.all().filter(seller=user.userid) paginator = Paginator(products, 6) # Show X products per page page_number = request.GET.get('page') page_obj = paginator.get_page(page_number) context = {'products': page_obj.object_list, 'page_obj': page_obj, 'categories': Category.objects.all() } return render(request, 'sellyoshit/mypage.html', context)
def index(request): """ pybo 목록 출력 """ # 입력 파라미터 page = request.GET.get('page', '1') # 페이지 kw = request.GET.get('kw', '') # 검색어 so = request.GET.get('so', 'recent') # 정렬 if so == 'recommend': question_list = Question.objects.annotate( num_voter=Count('voter')).order_by('-num_voter', '-create_date') elif so == 'popular': question_list = Question.objects.annotate( num_answer=Count('answer')).order_by('-num_answer', '-create_date') else: question_list = Question.objects.order_by('-create_date') # 검색 if kw: question_list = question_list.filter( Q(subject__icontains=kw) | # 제목검색 Q(content__icontains=kw) | # 내용검색 Q(author__username__icontains=kw) | #질문 글쓴이검색 Q(answer__author__username__icontains=kw) # 답변 글쓴이검색 ).distinct() # 페이징처리 paginator = Paginator(question_list, 10) # 페이지당 10개씩 보여주기 page_obj = paginator.get_page(page) context = {'question_list': page_obj, 'page': page, 'kw': kw, 'so': so} return render(request, 'pybo/question_list.html', context)
def blog_get_paginator(request, blogs_all_list): context = {} paginator = Paginator(blogs_all_list, 5) page_num = request.GET.get('page', 1) page_of_blogs = paginator.get_page(page_num) curentr_page_num = page_of_blogs.number page_range = list(range(max(curentr_page_num-2, 1), curentr_page_num)) + \ list(range(curentr_page_num, min(curentr_page_num + 2, paginator.num_pages) + 1)) if page_range[0] - 1 >= 2: page_range.insert(0, '...') if paginator.num_pages - page_range[-1] >= 2: page_range.append('...') if page_range[0] != 1: page_range.insert(0, 1) if page_range[-1] != paginator.num_pages: page_range.append(paginator.num_pages) blog_dates = Blog.objects.dates("create_time", "month", order="DESC") blog_types = BlogType.objects.all() blog_type_list = [] for blog_type in blog_types: blog_type.blog_count = Blog.objects.filter(blog_type=blog_type, is_delete=False).count() blog_type_list.append(blog_type) blog_date_list = {} for blog_date in blog_dates: blog_count = Blog.objects.filter(create_time__year=blog_date.year, create_time__month = blog_date.month, is_delete=False).count() blog_date_list[blog_date] = blog_count print(blog_date.month) #缓存数据 context["page_of_blogs"] = page_of_blogs context["blog_types"] = blog_types context["blogs"] = page_of_blogs.object_list context["page_range"] = page_range context["blog_dates"] = blog_date_list return context
def user_visit_list(request): # Medical Center med_center = MedicalCenter.objects.all()[:1].get() # Get doctor first user_id = request.user.id user = User.objects.get(id=user_id) # Visits visits = [] if user.role == 0: visits = Visit.objects.filter(doctor__profile_id=user_id) elif user.role == 1: visits = Visit.objects.filter( patient__profile_id=user_id).order_by('-start_time') paginator = Paginator(visits, 10) page_number = request.GET.get('page') page_obj = paginator.get_page(page_number) context = {"page_obj": page_obj, "med_center": med_center} if user.role == 0: return render(request, "visit/visits-list.html", context=context) elif user.role == 1: return render(request, "visit/patient-visit-list.html", context=context)
def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse: """ pybo 목록 출력 """ logger.info("pybo 목록을 출력합니다.") # 입력 파라미터 page = request.GET.get('page', '1') # 페이지 kw = request.GET.get('kw', '') # 검색어 so = request.GET.get('so', 'recent') # 정렬기준 # 정렬 if so == 'recommend': question_list = Question.objects.annotate( num_voter=Count('voter')).order_by('-num_voter', '-created_on') elif so == 'popular': question_list = Question.objects.annotate( num_answer=Count('answer')).order_by('-num_answer', '-created_on') else: # recent question_list = Question.objects.order_by('-created_on') # 검색 if kw: question_list = question_list.filter( Q(subject__icontains=kw) | # 제목검색 Q(content__icontains=kw) | # 내용검색 Q(created_by__username__icontains=kw) | # 질문 글쓴이검색 Q(answer__created_by__username__icontains=kw) # 답변 글쓴이검색 ).distinct() # 페이징처리 paginator = Paginator(question_list, 10) # 페이지당 10개씩 보여주기 page_obj = paginator.get_page(page) context = {'question_list': page_obj, 'page': page, 'kw': kw, 'so': so} # <------ so 추가 return self.render_to_response(context)
def listwithrawquerywithpaginator(request): data = request.GET.copy() # data = dict() # connection.row_factory = sqlite3.Row # cursor = connection.cursor() with sqlite3.connect("db.sqlite3") as con: con.row_factory = sqlite3.Row cur = con.cursor() cur.execute("select * from economic") contact_list = cur.fetchall() paginator = Paginator(contact_list, 5) # Show 15 contacts per page. page_number = request.GET.get('page') page_number = page_number if page_number else 1 data['page_obj'] = paginator.get_page(page_number) page_obj = data['page_obj'] for row in page_obj: print(f"{row['title']}, {row['link']}") return render(request, 'board/listwithrawquerywithpaginator.html', context=data)
def details(request, slug, title): keyword = request.GET.get("keyword") if keyword: articles = Article.objects.filter(title__contains=keyword) paginator = Paginator(articles, 10) page = request.GET.get('page') contacts = paginator.get_page(page) return render(request, "articles.html", { "contacts": contacts, "keyword": keyword }) list = (Category.objects.all()) for i in list: k = i.slug if slug == str(k): article = get_object_or_404(Article, seo=title, category=i) comments = article.comments.all() context = {"article": article, "comments": comments} article.views = article.views + 1 article.save() return render(request, "detail.html", context) article.views = article.views + 1 article.save() return render(request, "detail.html", context)
def index(request): given_types = get_filter_type(request) no_chosen_types = False if given_types is None: recipe_list = Recipe.objects.all() else: types = RecipeType.objects.filter(id__in=given_types) if not types: no_chosen_types = True recipe_list = Recipe.objects.get_index_in_types(types) url_type_line = get_url_with_types(request) all_types = RecipeType.objects.all() paginator = Paginator(recipe_list, OBJECT_PER_PAGE) page_number = request.GET.get('page') page = paginator.get_page(page_number) data = { 'paginator': paginator, 'page': page, 'types': all_types, 'given_types': given_types, 'url_type_line': url_type_line, 'no_chosen_types': no_chosen_types } return render(request, 'index.html', data)
def get(self, request, pk): if not User.objects.filter(id=pk): page_title = "Пользователь не найден" message = 'Пользователь не найден' return render(request, 'mathhack/errors/Not_founded_user.html', {'page_title': page_title, 'message': message, }, ) else: this_user = User.objects.get(id=pk) page_title = str(this_user.username) statistics = this_user.customer.solved_variants.all()[::-1] paginator = Paginator(statistics, 10) page_number = request.GET.get('page') page_obj = paginator.get_page(page_number) if this_user.customer.points_num != 0: average_point = this_user.customer.points_sum / this_user.customer.points_num average_point = '{0:0.2f}'.format(average_point) else: average_point = 'No information' return render(request, 'mathhack/auth/user_page.html', {'this_user': this_user, 'page_title': page_title, 'pk': pk, 'average_point': average_point, 'statistics': statistics, 'page_obj': page_obj})
def badge_view(request, uid): badge = Badge.objects.filter(uid=uid).annotate( count=Count("award")).first() target = request.GET.get('user') page = request.GET.get('page', 1) user = User.objects.filter(profile__uid=target).first() if not badge: messages.error(request, f"Badge with id={uid} does not exist.") return redirect(reverse("badge_list")) awards = badge.award_set.all().order_by("-date") if user: awards = awards.filter(user=user) awards = awards.prefetch_related("user", "user__profile", "post", "post__root") paginator = Paginator(object_list=awards, per_page=settings.POSTS_PER_PAGE) awards = paginator.get_page(page) context = dict(awards=awards, badge=badge) return render(request, "badge_view.html", context=context)
def news_list(request): news_lists = News.objects.all() paginator = Paginator(news_lists, 3) page_num = request.GET.get('page', 1) page_of_news = paginator.get_page(page_num) current_page_num = page_of_news.number page_range = list(range(max(1, current_page_num - 2), current_page_num)) + \ list(range(current_page_num, min(paginator.num_pages, current_page_num + 2) + 1)) if page_range[0] -1 >= 2: page_range.insert(0, '...') if page_range[-1] + 2 <= paginator.num_pages: page_range.append('...') #加上首頁與尾頁 if page_range[0] != 1: page_range.insert(0, 1) if page_range[-1] != paginator.num_pages: page_range.append(paginator.num_pages) context={} context['news_lists'] = page_of_news.object_list context['page_of_news'] = page_of_news context['page_range'] = page_range return render(request, 'news_list.html',context)
def delete_before_match_info(request,match_pk) : try : pk=request.session.get('pk') player_name = request.GET.get('player_name') if pk is None : return redirect('/') match=Match.objects.get(pk=match_pk) match.delete() matches = Match.objects.all().filter(accept=False).order_by('-pk') count = matches.count() paginator = Paginator(matches, 10) pages = request.GET.get('page',1) matches = paginator.get_page(pages) except PageNotAnInteger : matches = paginator.page(1) except EmptyPage : matches = paginator.page(paginator.num_pages) return HttpResponse("end") except Exception as e : return HttpResponse("게시물이 존재하지 않습니다.") return render(request, 'hzm/match_before.html',{'matches' : matches, 'count':count, 'pk':pk, 'player_name':player_name})
def get_all_common_data(request, articles_all_list): paginator = Paginator(articles_all_list, settings.ARTICLE_NUMBER_EACH_PAGE) # 8篇一页 # 获取页码参数(GET请求) .GET 字典 使用get方法判断是否有page值,没有返回1 page_num = request.GET.get("page", 1) # 输入许可字符范围外的字符会返回1 page_of_articles = paginator.get_page(page_num) # 获取当前页 current_page = page_of_articles.number # 页码显示范围 page_range = [ i for i in range(current_page - 2, current_page + 3) if 0 < i <= paginator.num_pages ] # 第一页 if page_range[0] >= 2: page_range.insert(0, 1) # 第一位插入1页码 if page_range[1] != 2: page_range.insert(1, '...') # 加上... # 最后一页 if page_range[-1] <= paginator.num_pages - 1: if page_range[-1] != paginator.num_pages - 1: page_range.append('...') # 加上... page_range.append(paginator.num_pages) context = {} # context['articles'] = page_of_articles.object_list # 前端页面 context['page_of_articles'] = page_of_articles # 当前页码 # context['article_types'] = artcile_types_list # 所有分类 context['article_types'] = ArticleType.objects.annotate( article_count=Count('art_art')) # 所有分类 # context['article_dates'] = Articles.objects.dates('created_time', 'month', order='DESC') context['article_dates'] = get_categories_count() # 日期分类与数量 context['page_range'] = page_range return context
def proposedClubList(request): voter=request.user totalstudent=Profile.objects.all().count() clubs = Onpollclub.objects.all() for i in clubs: start=i.date milistart=int(time.mktime(start.timetuple())) * 1000 #print(milistart) #print('nf') currtime=timezone.now() milicurr=(int(time.mktime(currtime.timetuple())) * 1000) + 330*60*1000 #print(milicurr) endtime=int(milistart) + 7*24*60*60*1000 timeleft=int(endtime - milicurr) #print(timeleft) i.pollend=timeleft i.save() for a in clubs: if a.pollend<0: vote=a.num_vote_up # print(vote) threshhold=(vote/totalstudent)*100 if threshhold >10: instance=ExistingClub.objects.create(club_name=a.club_name, club_info=a.club_info,club_logo=a.club_logo) instance.admin.add(a.name) instance.club_members.add(a.name) a.delete() clubs = Onpollclub.objects.all() paginator = Paginator(clubs,10) page = request.GET.get('page') posts = paginator.get_page(page) context = { 'clubs': clubs, } return render(request,'propose_join/prlist.html', context)
def store_beers(request, store_id): ''' Returns all beers in stock at given Vinmonopolet store Paginated in order to use infinite scroll ''' queryset = BeerStock.objects.filter(product_stock__gt=0, store_id=store_id).order_by(F('beer_id__untappd__rating').desc(nulls_last=True)) if request.user.is_authenticated: # This subquery returns the rating of any beers the User has checked in to Untappd check_in_subquery = UserCheckIn.objects.filter(beer_id = OuterRef('beer_id'), user_id=request.user) queryset = queryset.annotate(untappd_rating=Subquery(check_in_subquery.values('rating')[:1])) # This subquery returns a value if User has the Beer in Wish List on Untappd wishlist_subquery = UserWishList.objects.filter(beer_id = OuterRef('beer_id'), user_id=request.user) queryset = queryset.annotate(untappd_wishlist=Subquery(wishlist_subquery.values('user')[:1])) paginator = Paginator(queryset, 50, 0) page_number = request.GET.get('page') beerstock = paginator.get_page(page_number) return render(request, 'stubs/store_inventory.html', {'beerstock': beerstock, 'store_id': store_id, 'full_store_stock':True})