def _list_groups(request, template, query): """Lists groups from given query.""" sort_form = SortForm(request.GET) show_pagination = False if sort_form.is_valid(): query = query.order_by(sort_form.cleaned_data['sort'], 'name') else: query = query.order_by('name') paginator = Paginator(query, settings.ITEMS_PER_PAGE) page = request.GET.get('page', 1) try: groups = paginator.page(page) except PageNotAnInteger: groups = paginator.page(1) except EmptyPage: groups = paginator.page(paginator.num_pages) if paginator.count > settings.ITEMS_PER_PAGE: show_pagination = True data = dict(groups=groups, page=page, sort_form=sort_form, show_pagination=show_pagination) return render(request, template, data)
def pagination(): class BookTable(tables.Table): name = tables.Column() # create some sample data data = [] for i in range(100): data.append({"name": "Book No. %d" % i}) books = BookTable(data) # external paginator paginator = Paginator(books.rows, 10) assert paginator.num_pages == 10 page = paginator.page(1) assert page.has_previous() is False assert page.has_next() is True # integrated paginator books.paginate(page=1) Assert(hasattr(books, "page")) is True books.paginate(page=1, per_page=10) Assert(len(list(books.page.object_list))) == 10 # new attributes Assert(books.paginator.num_pages) == 10 Assert(books.page.has_previous()) is False Assert(books.page.has_next()) is True # exceptions are converted into 404s with Assert.raises(Http404) as error: books.paginate(Paginator, page=9999, per_page=10) books.paginate(Paginator, page='abc', per_page=10)
def post(self, request, *args, **kwargs): template_name = "drinkersList.html" http_method_names = ['get', 'post'] user = self.request.user models = locateDrinkers form = forms.LocateDrinkersForm(request.POST) if form.is_valid(): # The form is valid and can be saved to the database # by calling the 'save()' method of the ModelForm instance. searchAttributes = form.save(commit=False) print "searchAttributes.boozshopaddress", searchAttributes.boozshopaddress #searchResults = boozProfiles.objects.filter(Booz_shop_location__icontains=searchAttributes.boozshopaddress) searchResults = boozProfiles.objects.all() paginator = Paginator(searchResults, 25) # Show 25 contacts per page page = request.GET.get('page') print "searchResults.query", searchResults.query print "searchResults::" ,str(searchResults) try: profilePerPages = paginator.page(page) except PageNotAnInteger: profilePerPages = paginator.page(1) except EmptyPage: profilePerPages = paginator.page(paginator.num_pages) return render_to_response("drinkersList.html", {"profilePerPages": profilePerPages}) # This means that the request is a GET request. So we need to # create an instance of the TShirtRegistrationForm class and render it in # the template else: form = forms.LocateDrinkersForm(request.POST) return render(request, "locatedrinkers.html", { 'form' : form })
def paginate_context(request, model, urlbase, object_list, page, **kwargs): ''' Helper function to make standard pagination available for the template "snapboard/page_navigation.html" ''' page = int(page) pindex = page page_next = None page_prev = None page_range = None paginator = Paginator(object_list, _userdata(request, 'tpp')) try: object_page = paginator.page(pindex) except InvalidPage: raise InvalidPage if object_page.has_next(): page_next = page + 1 if object_page.has_previous(): page_prev = page - 1 if paginator.num_pages > 2: page_range = range(1, paginator.num_pages+1) return { 'page': page, 'page_total': paginator.num_pages, 'page_next': page_next, 'page_prev': page_prev, 'page_range': page_range, model.__name__.lower() + '_page': object_page.object_list, 'page_nav_urlbase': urlbase, }
def view_groups(request): """ Django View. List all groups. @type request: C{django.http.HttpRequest} @param request: Client Request object """ groups_list = models.BookiGroup.objects.all().extra(select={'lower_name': 'lower(name)'}).order_by('lower_name') paginator = Paginator(groups_list, 50) try: page = int(request.GET.get('page', '1')) except ValueError: page = 1 try: groups = paginator.page(page) except (EmptyPage, InvalidPage): groups = paginator.page(paginator.num_pages) return render_to_response('portal/groups.html', {"request": request, "title": "Booki groups", "groups": groups })
def paginate_items(self, items, page): """ Paginate the list of items, if needed. """ paginate_by = self.get_paginate_by(items) allow_empty = self.get_allow_empty() if not paginate_by: if not allow_empty and len(items) == 0: raise Http404("Empty list and '%s.allow_empty' is False." % self.__class__.__name__) return (None, None, items) paginator = Paginator(items, paginate_by, allow_empty_first_page=allow_empty) page = page or self.request.GET.get('page', 1) try: page_number = int(page) except ValueError: if page == 'last': page_number = paginator.num_pages else: raise Http404("Page is not 'last', nor can it be converted to an int.") try: page = paginator.page(page_number) return (paginator, page, page.object_list) except InvalidPage: raise Http404('Invalid page (%s)' % page_number)
def visual_index(request, **kwargs): all_neurons, search_form = get_form_and_neurons( request, kwargs['project_id'], kwargs ) # From: http://docs.djangoproject.com/en/1.0/topics/pagination/ paginator = Paginator(all_neurons, 5) if 'page' in kwargs: page = kwargs['page'] or 1 else: try: page = int(request.GET.get('page', '1')) except ValueError: page = 1 # If page request (9999) is out of range, deliver last page of results. try: neurons = paginator.page(page) except (EmptyPage, InvalidPage): neurons = paginator.page(paginator.num_pages) return my_render_to_response(request, 'vncbrowser/visual_index.html', {'sorted_neurons': neurons.object_list, 'sorted_neurons_page' : neurons, 'project_id': kwargs['project_id'], 'catmaid_url': settings.CATMAID_URL, 'user': kwargs['logged_in_user'], 'search_form': search_form })
def get_paginator(objects, page, limit): """ Create and return a Paginator filled with the objects and paginated at the given page. Args: ``objects`` (list): A list of objects to be paginated. ``page`` (int): The current page of the pagination. If it is not a valid integer, the first page is used. If the page provided is bigger than the nuber of pages available, the last page is returned. ``limit`` (int): The number of items per page. Returns: ``django.core.paginator.Page``. The paginated data. ``django.core.paginator.Paginator``. The Paginator object. """ paginator = Paginator(objects, limit) try: paginated = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. paginated = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. paginated = paginator.page(paginator.num_pages) return paginated, paginator
def user_list(request): context = RequestContext(request) if request.method == 'POST': form = forms.FindUserForm(request.POST) if form.is_valid(): username = form.cleaned_data.get('username') try: user = models.User.objects.get(username=username) return redirect('kegadmin-edit-user', user.id) except models.User.DoesNotExist: messages.error(request, 'User "%s" does not exist.' % username) users = models.User.objects.exclude(username='******').order_by('-id') paginator = Paginator(users, 25) page = request.GET.get('page') try: users = paginator.page(page) except PageNotAnInteger: users = paginator.page(1) except EmptyPage: users = paginator.page(paginator.num_pages) context['users'] = users return render_to_response('kegadmin/user_list.html', context_instance=context)
def dashboard(request): if request.user.is_authenticated(): try: me = UserProfile.objects.get(user=request.user) except UserProfile.DoesNotExist: display_name = request.user return redirect('/register/') neos = Neo.objects.all().extra( select={ 'display_name': 'SELECT display_name FROM neo_userprofile WHERE neo_userprofile.id = neo_neo.user_id' }, ) paginator = Paginator(neos, 50) # Make sure page request is an int. If not, deliver first page. try: page = int(request.GET.get('page', '1')) except ValueError: page = 1 # If page request (9999) is out of range, deliver last page of results. try: neo_list = paginator.page(page) except (EmptyPage, InvalidPage): neo_list = paginator.page(paginator.num_pages) if request.user.is_authenticated(): return render(request, 'dashboard.html', {'neo_list': neo_list, 'page': page, 'me': me}) return render(request, 'dashboard.html', {'neo_list': neo_list, 'page': page})
def _list(request, is_active, is_formal): potential_list = Potential.objects.filter(is_active=is_active, is_formal=is_formal) paginator = Paginator(potential_list, 6) # 6 records / per page page = request.GET.get('page') # pageNo try: potentials = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. potentials = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. potentials = paginator.page(paginator.num_pages) list = [] for potential in potentials: list.append(potential.tojson()) response_data = {} response_data['potentials'] = list response_data['paginator.num_pages'] = potentials.paginator.num_pages response_data['number'] = potentials.number return response_data
def get_results(self, request): if not SEARCH_VAR in request.GET: return super(SearchChangeList, self).get_results(request) # Note that pagination is 0-based, not 1-based. sqs = SearchQuerySet().models(self.model).auto_query(request.GET[SEARCH_VAR]).load_all() paginator = Paginator(sqs, self.list_per_page) # Get the number of objects, with admin filters applied. result_count = paginator.count full_result_count = SearchQuerySet().models(self.model).all().count() can_show_all = result_count <= list_max_show_all(self) multi_page = result_count > self.list_per_page # Get the list of objects to display on this page. try: result_list = paginator.page(self.page_num+1).object_list # Grab just the Django models, since that's what everything else is # expecting. result_list = [result.object for result in result_list] except InvalidPage: result_list = () self.result_count = result_count self.full_result_count = full_result_count self.result_list = result_list self.can_show_all = can_show_all self.multi_page = multi_page self.paginator = paginator
def build_page(self): """ Paginates the results appropriately. In case someone does not want to use Django's built-in pagination, it should be a simple matter to override this method to do what they would like. """ try: page_no = int(self.request.GET.get('page', 1)) except (TypeError, ValueError): raise Http404("Not a valid number for page.") if page_no < 1: raise Http404("Pages should be 1 or greater.") start_offset = (page_no - 1) * self.results_per_page self.results[start_offset:start_offset + self.results_per_page] paginator = Paginator(self.results, self.results_per_page) try: page = paginator.page(page_no) except InvalidPage: raise Http404("No such page!") return (paginator, page)
def content_type_use(request, content_type_app_name, content_type_model_name): try: content_type = ContentType.objects.get_by_natural_key(content_type_app_name, content_type_model_name) except ContentType.DoesNotExist: raise Http404 p = request.GET.get("p", 1) page_class = content_type.model_class() # page_class must be a Page type and not some other random model if not issubclass(page_class, Page): raise Http404 pages = page_class.objects.all() paginator = Paginator(pages, 10) try: pages = paginator.page(p) except PageNotAnInteger: pages = paginator.page(1) except EmptyPage: pages = paginator.page(paginator.num_pages) return render(request, 'wagtailadmin/pages/content_type_use.html', { 'pages': pages, 'app_name': content_type_app_name, 'content_type': content_type, 'page_class': page_class, })
def adminInsumoDetail(request, insumo): insumo = get_object_or_404(Insumo, pk = insumo) entradas = Entrada.objects.filter(insumo=insumo) salidas = Salida.objects.filter(insumo=insumo) template = get_template("admininsumodetail.html") sort = request.GET.get('o') #orden del query filter if sort == None: #si no hay orden en URL se refiere a -fecha sort = '-fecha' filters = EntradasFilter(request.GET, queryset=Entrada.objects.filter(insumo=insumo)) paginator = Paginator(filters, 10) page = request.GET.get('page') try: entradas= paginator.page(page) except PageNotAnInteger: # Si la pagina no es un entero muestra la primera pagina entradas = paginator.page(1) except EmptyPage: # si la pagina esta fuera de rango, muestra la ultima pagina entradas = paginator.page(paginator.num_pages) context = { 'insumo': insumo, 'entradas': entradas,'filters': filters,'sort':sort, } return HttpResponse(template.render(context, request))
def get_context_data(self): paginator = Paginator(newest_posts(), 100) try: p = paginator.page(self.request.GET.get('page', '1')) except PageNotAnInteger: p = paginator.page('1') return dict(posts=p.object_list, paginator=p)
def index(request, parent_page_id=None): if parent_page_id: parent_page = get_object_or_404(Page, id=parent_page_id) else: parent_page = Page.get_first_root_node() pages = parent_page.get_children().prefetch_related('content_type') # Get page ordering ordering = request.GET.get('ordering', '-latest_revision_created_at') if ordering not in ['title', '-title', 'content_type', '-content_type', 'live', '-live', 'latest_revision_created_at', '-latest_revision_created_at', 'ord']: ordering = '-latest_revision_created_at' # Pagination if ordering != 'ord': ordering_no_minus = ordering if ordering_no_minus.startswith('-'): ordering_no_minus = ordering[1:] pages = pages.order_by(ordering).annotate(null_position=Count(ordering_no_minus)).order_by('-null_position', ordering) p = request.GET.get('p', 1) paginator = Paginator(pages, 50) try: pages = paginator.page(p) except PageNotAnInteger: pages = paginator.page(1) except EmptyPage: pages = paginator.page(paginator.num_pages) return render(request, 'wagtailadmin/pages/index.html', { 'parent_page': parent_page, 'ordering': ordering, 'pagination_query_params': "ordering=%s" % ordering, 'pages': pages, })
def index(self, page=1): # prepare result result = self.get_default_result("genres", page) object_list = Genre.objects.all() object_list = self.source_set_order(object_list) # get data paginator = Paginator(object_list, self.count) try: page_obj = paginator.page(page) except InvalidPage: return result result = self.result_set_order(result) result["hasNextPage"] = page_obj.has_next() for item in page_obj.object_list: dataset = { "id": item.id, "genre": item.Name, } result["itemList"].append(dataset) return result
def index(self, page=1): # prepare result result = self.get_default_result("years", page) object_list = Song.objects.values("Year").distinct() object_list = object_list.exclude(Year=None).exclude(Year=0) object_list = self.source_set_order(object_list) # get data paginator = Paginator(object_list, self.count) try: page_obj = paginator.page(page) except InvalidPage: return result result = self.result_set_order(result) result["hasNextPage"] = page_obj.has_next() for item in page_obj.object_list: dataset = { "year": item["Year"], } result["itemList"].append(dataset) return result
def make_pages(form, page): paginator = Paginator(form, 10) try: form = paginator.page(page) except PageNotAnInteger: form = paginator.page(1) except EmptyPage: form = paginator.page(paginator.num_pages) for d in form: try: docdata = MetaData.objects.get(link=d.url) reviewed = docdata.reviewed if reviewed == True: reviewed_true.append(str(docdata.link)) processed = docdata.processed if processed == True: processed_true.append(str(docdata.link)) notes[d.url] = docdata.notes except MetaData.DoesNotExist: continue for d in form: try: debug(Registrant.objects.get(reg_id=int(d.reg_id))) reg = Registrant.objects.get(reg_id=d.reg_id) names[d.reg_id] = reg.reg_name except Registrant.DoesNotExist: continue return form
def test_page_getitem(self): """ Tests proper behavior of a paginator page __getitem__ (queryset evaluation, slicing, exception raised). """ paginator = Paginator(Article.objects.order_by('id'), 5) p = paginator.page(1) # Make sure object_list queryset is not evaluated by an invalid __getitem__ call. # (this happens from the template engine when using eg: {% page_obj.has_previous %}) self.assertIsNone(p.object_list._result_cache) with self.assertRaises(TypeError): p['has_previous'] self.assertIsNone(p.object_list._result_cache) self.assertNotIsInstance(p.object_list, list) # Make sure slicing the Page object with numbers and slice objects work. self.assertEqual(p[0], Article.objects.get(headline='Article 1')) self.assertQuerysetEqual(p[slice(2)], [ "<Article: Article 1>", "<Article: Article 2>", ] ) # After __getitem__ is called, object_list is a list self.assertIsInstance(p.object_list, list)
def post(self,page=1): searchText = self.request.get('searchtext') try: page = int(page) except: page = 1 courses = Course.all() allcourses = [] for course in courses: if searchText in course.tags: course.tagstring = GetCourseTags(course.courseid) course.creatoremail = GetUserEmailFromGuser(course.createdbyuser) course.usercanreg = UserCanRegister(users.get_current_user().user_id(), course.courseid) course.regcount = GetCourseRegCount(course.courseid) allcourses.append(course) paginator = Paginator(allcourses,3) #if page>=paginator: # page = paginator self.template_values = { "courses" : paginator.page(page).object_list ,"pages" : paginator.page_range ,"page" : page } page_display(self,"templates/coursesearch.html")
def SelfPaginator(request,List,Limit): '''分页模块,用法: 1.view中引入: ex:from website.common.CommonPaginator import SelfPaginator 2.SelfPaginator需要传入三个参数 (1).request:获取请求数据 (2).List:为需要分页的数据(一般为*.objects.all()取出来数据) (3).Limit:为每页显示的条数 ex:lst = SelfPaginator(request,mList, 5) 3.view需要获取SelfPaginator return的lst,并把lst返回给前端模板 ex:kwvars = {'lPage':lst,} 4.前端需要for循环lPage也就是lst读取每页内容 ex:{% for i in lPage %} ... {% endfor %} 5.模板页引入paginator.html ex:{% include "common/paginator.html" %} ''' paginator = Paginator(List, int(Limit)) page = request.GET.get('page') try: lst = paginator.page(page) except PageNotAnInteger: lst = paginator.page(1) except EmptyPage: lst = paginator.page(paginator.num_pages) return lst
def list_projects(request): """ A list of all projects in cloud teams """ q = request.GET.get('q', '') qs = Project.objects.filter(Q(title__icontains=q) | Q(description__icontains=q) | Q(category__icontains=q)) # ordering order = request.GET.get('order', 'latest') if order == 'most-popular': qs = qs.annotate(num_followers=Count('followed')).order_by('-num_followers', '-created') else: order = 'latest' qs = qs.order_by('-created') pages = Paginator(qs, 10) context = { 'n_of_projects': Project.objects.all().count(), 'page_obj': pages.page(int(request.GET.get('page', '1'))), 'q': q, 'order': order } return render(request, 'ct_projects/project/all.html', context)
def prereg(request): """Redirects to prereg page if user has prereg access :param request: Current logged in user :return: Redirect to prereg page with username, reviewers, and user obj """ paginator = Paginator(get_prereg_drafts(user=request.user), 5) try: page_number = int(request.GET.get('page')) except (TypeError, ValueError): page_number = 1 page = paginator.page(page_number) try: drafts = [serializers.serialize_draft_registration(d, json_safe=False) for d in page] except EmptyPage: drafts = [] for draft in drafts: draft['form'] = DraftRegistrationForm(draft) context = { 'drafts': drafts, 'page': page, 'IMMEDIATE': serializers.IMMEDIATE, } return render(request, 'pre_reg/prereg.html', context)
def profile_search_id(request): queryset = profiles.objects.all().order_by('-timestamp') for object in queryset: if object.pId == "TMG": object.pId = "TMG00" + str(object.tmId) object.save() query = request.GET.get('pid') if query: instance = get_object_or_404(profiles,pId=str(query)) return HttpResponseRedirect(instance.get_absolute_url()) paginator = Paginator(queryset, 5) # Show 5 contacts per page page = request.GET.get('page') try: queryset1 = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. queryset1 = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. queryset1 = paginator.page(paginator.num_pages) content = { "objectset": queryset1, "title": "list" } return render(request, "profile_search_id.html", content)
def photo_review(request, instance): page_number = int(request.REQUEST.get('page', '1')) sort_order = request.REQUEST.get('sort', '-created_at') is_archived = request.REQUEST.get('archived', 'False') == 'True' photos = get_photos(instance, sort_order, is_archived) paginator = Paginator(photos, _PHOTO_PAGE_SIZE) try: paged_photos = paginator.page(page_number) except EmptyPage: # If the page number is out of bounds, return the last page paged_photos = paginator.page(paginator.num_pages) urlizer = UrlParams('photo_review', instance.url_name, page=page_number, sort=sort_order, archived=is_archived) return { 'photos': paged_photos, 'sort_order': sort_order, 'is_archived': is_archived, 'is_archived_text': _("Archived") if is_archived else _("Active"), 'is_archived_text_lower': (_("archived") if is_archived else _("active")), 'url_for_pagination': urlizer.url('sort', 'archived'), 'url_for_filter': urlizer.url('sort'), 'url_for_sort': urlizer.url('archived'), 'full_params': urlizer.params('page', 'sort', 'archived') }
def system_install_record(request): """ List all operating system installation records """ user = request.user if request.method == 'POST': search_fields = request.POST.get('search') else: try: search_fields = request.GET.get('search','none') except ValueError: search_fields = 'none' if search_fields == 'none': record = InstallRecord.objects.all().order_by('-id') else: record = InstallRecord.objects.filter(hostname__contains=search_fields).order_by('-id') paginator = Paginator(record,12) try: page = int(request.GET.get('page','1')) except ValueError: page = 1 try: record = paginator.page(page) except : record = paginator.page(paginator.num_pages) return render_to_response('install_record_list.html', {'record': record, 'page': page, 'paginator':paginator,'search':search_fields,'request':request},context_instance=RequestContext(request))
def audit(request): audit_log_list = tables.table_filter(request, admin.AuditLogAdmin, models.AuditLog) order_res = tables.get_orderby(request, audit_log_list, admin.AuditLogAdmin) paginator = Paginator(order_res[0], admin.AuditLogAdmin.list_per_page) page = request.GET.get('page') try: audit_log_objs = paginator.page(page) except PageNotAnInteger: audit_log_objs = paginator.page(1) except EmptyPage: audit_log_objs = paginator.page(paginator.num_pages) table_obj = tables.TableHandler(request, models.AuditLog, admin.AuditLogAdmin, audit_log_objs, order_res) return render(request, "audit.html", { 'table_obj': table_obj, 'paginator': paginator })
def AssetinfoView(request): assetinfo_list = AssetInfo.objects.all() obj_list = [] if assetinfo_list: for obj in assetinfo_list: if obj.delstatus == 0: obj_list.append(obj) allcount = len(obj_list) paginate_by = settings.PAGE_NUM paginator = Paginator(obj_list, paginate_by) page = request.GET.get('page') try: obj_list = paginator.page(page) except PageNotAnInteger: obj_list = paginator.page(1) except EmptyPage: obj_list = paginator.page(paginator.num_pages) return render(request, 'include/assetinfo/assetinfo.html', { 'obj_list': obj_list, 'allcount': allcount, 'sel_list': assetinfo_list })
def get_context_data(self, **kwargs): # Get the context of this class based view. modified_context = super().get_context_data(**kwargs) # Validate the template selected. template = self.kwargs['template'] if template not in ['search', 'summary', 'list']: from django.core.exceptions import PermissionDenied raise PermissionDenied(_('You entered wrong format.')) modified_context['template'] = template # Lookup the acitivty sheet items for this associate. jobs = WorkOrder.objects.filter( associate = modified_context['associate'] ).prefetch_related( 'associate', 'customer' ).order_by('-completion_date') # Added our job state filtering. job_state = self.request.GET.get('job_state', 'all') if job_state != "all": jobs = jobs.filter(state=job_state) # Add pagination. paginator = Paginator(jobs, 25) # Show 25 contacts per page page = self.request.GET.get('page', 1) jobs_items = paginator.get_page(page) modified_context['paginated_job_items'] = jobs_items # Added boolean to view based on whether user is in management. modified_context['user_is_management_or_executive_staff'] = self.request.user.is_management_or_executive_staff() # Return our modified context. return modified_context
def logview(request, userid): user = User.objects.filter(id__exact=userid)[0] vardict = {} logtype = request.GET.get("logtype", 'dns') deltype = request.GET.get("del") if deltype == 'dns': DNSLog.objects.filter(user=user).delete() return HttpResponseRedirect('/?logtype=dns') if deltype == 'web': WebLog.objects.filter(user=user).delete() return HttpResponseRedirect('/?logtype=web') if logtype == 'dns': vardict['logtype'] = logtype dnspage = getpage(request.GET.get("dnspage", 1)) paginator = Paginator(DNSLog.objects.filter(user=user), 10) try: dnslogs = paginator.page(dnspage) except(EmptyPage, InvalidPage, PageNotAnInteger): dnspage = paginator.num_pages dnslogs = paginator.page(paginator.num_pages) vardict['dnspage'] = dnspage vardict['pagerange'] = paginator.page_range vardict['dnslogs'] = dnslogs vardict['numpages'] = paginator.num_pages elif logtype == 'web': vardict['logtype'] = logtype webpage = getpage(request.GET.get("webpage", 1)) paginator = Paginator(WebLog.objects.filter(user=user), 10) try: weblogs = paginator.page(webpage) except(EmptyPage, InvalidPage, PageNotAnInteger): webpage = paginator.num_pages weblogs = paginator.page(paginator.num_pages) vardict['webpage'] = webpage vardict['pagerange'] = paginator.page_range vardict['weblogs'] = weblogs vardict['numpages'] = paginator.num_pages else: return HttpResponseRedirect('/') vardict['userdomain'] = user.udomain + '.' + settings.DNS_DOMAIN vardict['udomain'] = str(user.udomain) vardict['admindomain'] = str(settings.ADMIN_DOMAIN) return render_to_response('views.html', vardict)
def popular(request, *args, **kwargs): try: limit = int(request.GET.get('limit', 10)) if limit < 0 or limit > 100: limit = 10 except: limit = 10 try: page = int(request.GET.get('page', 1)) if page < 0: page = 1 except: page = 1 paginator = Paginator(Question.objects.popular(), limit) paginator.baseurl = "?page=" questions = paginator.page(page) return render(request, 'popular.html', { 'questions': questions, 'paginator': paginator, 'page': page })
def post_list(request, tag_slug=None): object_list = Post.published.all() tag=None if tag_slug: tag = get_object_or_404(Tag, slug=tag_slug) object_list = object_list.filter(tags__in=[tag]) paginator = Paginator(object_list, 3) # 3 posts in each page page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: # If page is not an integer deliver the first page posts = paginator.page(1) except EmptyPage: # If page is out of range deliver last page of results posts = paginator.page(paginator.num_pages) return render(request, 'blog/post/list.html', {'page': page, 'posts': posts, 'tag': tag})
def render(self, context): key = self.queryset_var.var value = self.queryset_var.resolve(context) if isinstance(self.paginate_by, int): paginate_by = self.paginate_by else: paginate_by = self.paginate_by.resolve(context) paginator = Paginator(value, paginate_by, self.orphans) try: page_obj = paginator.page(context['request'].page) except InvalidPage: if INVALID_PAGE_RAISES_404: raise Http404('Invalid page requested. If DEBUG were set to ' + 'False, an HTTP 404 page would have been shown instead.') context[key] = [] context['invalid_page'] = True return u'' if self.context_var is not None: context[self.context_var] = page_obj.object_list else: context[key] = page_obj.object_list context['paginator'] = paginator context['page_obj'] = page_obj return u''
def language_pages(request, language, batch, title=None, page_number=1): language_name = models.Language.objects.get(code=language).name page_title = 'Pages with %s text' % (language_name) path = 'reports/language_title_pages.html' if language != 'eng': if title: pages = models.Page.objects.filter( ocr__language_texts__language__code=language, issue__title__lccn=title ).values( 'reel__number', 'issue__date_issued', 'issue__title__lccn', 'issue__edition', 'sequence', ).order_by( 'reel__number', 'issue__date_issued', 'sequence' ) else: pages = models.Page.objects.filter( ocr__language_texts__language__code=language, issue__batch__name=batch ).values( 'reel__number', 'issue__date_issued', 'issue__title__lccn', 'issue__edition', 'sequence', ).order_by( 'reel__number', 'issue__title__lccn', 'issue__date_issued', 'sequence' ) path = 'reports/language_batch_pages.html' paginator = Paginator(pages, 25) try: page = paginator.page(page_number) except InvalidPage: page = paginator.page(1) page_range_short = list(_page_range_short(paginator, page)) return render_to_response(path, dictionary=locals(), context_instance=RequestContext(request))
def bidding(request, id=None, pg=1): if id: a = bidvar.objects.all(); bid = bidvar.objects.filter(id = id).first() if request.method == 'POST': form = BidForm(request.POST, instance=bid) for b in a: if b.buyer == request.user: messages.add_message(request, messages.INFO, 'You can\'t have highest bid on two Companies') return redirect('bidding', pg=pg) if bid.bidding_price < int(form['bidding_price'].value()): if request.user.eCoins > int(form['bidding_price'].value()): if int(form['bidding_price'].value())%100 == 0 and form.is_valid(): bid.buyer = request.user form.save() messages.add_message(request, messages.INFO, f'Your Bid has been placed sucessfully on {bid.company.company_name}' ) else: messages.add_message(request, messages.INFO, 'You need to place bid in multiple of 100\'s only.' ) else: messages.add_message(request, messages.INFO, 'You don\'t have enough E-Coins to place this bid.' ) else: messages.add_message(request, messages.INFO, 'Enter a Bid Price higher than the current Highest Bid Price') return redirect('bidding', pg=pg) form = BidForm() bid_list = bidvar.objects.filter(visible=True).order_by('-id') paginator = Paginator(bid_list, 13) context = { 'form' : form, 'Bid' : paginator.page(pg), 'page' : pg, 'paginator' : paginator, 'Companys': Company.objects.order_by('-id') } return render(request, 'home/letsbid.html', context)
def profile(request, username): try: user_profile = User.objects.get(username=username) user_following = user_profile.following.count() user_followers = user_profile.followers.count() if user_profile.followers.filter(username=request.user).exists(): bool_follow = "Unfollow" else: bool_follow = "Follow" post_list = Post.objects.filter(author=username).order_by('-timestamp') paginator = Paginator(post_list, 5) page_number = request.GET.get('page') page = paginator.get_page(page_number) return render(request, "network/profile.html", { "username": username, "page": page, "user_followers": user_followers, "user_following": user_following, "bool_follow": bool_follow }) except User.DoesNotExist: return render(request, "network/error.html", {"error": "This user does not yet exist"})
def profile(request, username): page_user = get_object_or_404(User, username=username) all_feeds = Feed.get_feeds().filter(user=page_user) paginator = Paginator(all_feeds, FEEDS_NUM_PATES) feeds = paginator.page(1) user = request.user from_feed = -1 if feeds: from_feed = feeds[0].id if Follow.objects.filter(follower=user, followed=page_user).first(): is_follow = True else: is_follow = False context = { 'page_user': page_user, 'feeds': feeds, 'from_feed': from_feed, 'page': 1, 'is_follow': is_follow } return render(request, 'core/profile.html', context)
def index(request, now_page=1): # import pdb; pdb.set_trace() if 'record_number' in request.session: record_number = request.session['record_number'] else: record_number = 10 if 'new_old' in request.session: new_old = request.session['new_old'] else: new_old = 1 record_number_form = RecordNumberForm() record_number_form.initial = {'record_number': str(record_number)} new_old_form = NewOldForm() new_old_form.initial = {'new_old': str(new_old)} if new_old == "1": memos = Memo.objects.all().order_by("update_datetime").reverse() else: memos = Memo.objects.all() # page=Paginator(memos,15) page = Paginator(memos, record_number) # print(page.page_range) # print(dir(page)) params = { # # "memos":memos, "page": page.get_page(now_page), "form": PostForm(), 'record_number_form': record_number_form, 'new_old_form': new_old_form } return render(request, "index.html", params)
def list(request, tag_slug=None): object_list = Post.objects.all() tag = None if tag_slug: tag = get_object_or_404(Tag, slug=tag_slug) object_list = object_list.filter(tags__in=[tag]) paginator = Paginator(object_list, 2) # Show 25 contacts per page page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. posts = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. posts = paginator.page(paginator.num_pages) return render(request, 'list.html', { 'page': page, 'posts': posts, 'tag': tag })
def song_list(request): page = request.GET.get('page', 1) # get list of all songs #db = MySQLdb.connect(**dbconfig) cnx = pymysql.connect(**dbconfig,cursorclass=pymysql.cursors.DictCursor) cursor = cnx.cursor() # cursor.execute("SELECT * FROM song LIMIT 100") sql_command = """ select song.*, files.APIC from song inner join files on song.file_id = files.file_id """ cursor.execute(sql_command) results = cursor.fetchall() # results[1]['APIC'] = b64encode(results[1]['APIC']) paginator = Paginator(results, 50) try: results = paginator.page(page) except PageNotAnInteger: results = paginator.page(1) except EmptyPage: results = paginator.page(paginator.num_pages) return render(request, 'song_list.html', {'results': results})
def _get_paginated_entities(locale, project, form, entities): """Return a paginated list of entities. This is used by the regular mode of the Translate page. """ paginator = Paginator(entities, form.cleaned_data['limit']) try: entities_page = paginator.page(1) except EmptyPage: return JsonResponse({ 'has_next': False, 'stats': {}, }) has_next = entities_page.has_next() entities_to_map = entities_page.object_list # If requested entity not on the first page if form.cleaned_data['entity']: entity_pk = form.cleaned_data['entity'] entities_to_map_pks = [e.pk for e in entities_to_map] # TODO: entities_to_map.values_list() doesn't return entities from selected page if entity_pk not in entities_to_map_pks: if entity_pk in entities.values_list('pk', flat=True): entities_to_map_pks.append(entity_pk) entities_to_map = entities.filter(pk__in=entities_to_map_pks) return JsonResponse({ 'entities': Entity.map_entities(locale, entities_to_map, []), 'has_next': has_next, 'stats': TranslatedResource.objects.stats( project, form.cleaned_data['paths'], locale ), }, safe=False)
def project_list(request): if request.is_ajax(): type_dict = json.loads(request.body.decode('utf-8')) if type_dict['mode'] == 'del': models.ProjectInfo.objects.filter(id=type_dict['id']).delete() return HttpResponse("OK") projectlists = models.ProjectInfo.objects.all().values( 'id', 'project_name', 'responsible_name', 'test_user', 'dev_user', 'publish_app', 'simple_desc', 'other_desc', 'create_time') paginator = Paginator(projectlists, 10) # Show 10 contacts per page # Make sure page request is an int. If not, deliver first page. try: page = int(request.GET.get('page', '1')) except ValueError: page = 1 # If page request (9999) is out of range, deliver last page of results. try: projectlist = paginator.page(page) except (EmptyPage, InvalidPage): projectlist = paginator.page(paginator.num_pages) return render(request, 'projectlist.html', {'projectlist': projectlist})
def admintable(request): if request.method == 'POST': mes = request.POST.get('mes') ano = request.POST.get('ano') print "entro al form" gasto1 = Gasto.objects.filter(fecha__year=int(ano)).filter(fecha__month=int(mes)).values_list('id', flat=True) gasto2 = Detalleg.objects.filter(gasto__in=gasto1)[:100] return render(request, 'adming.html',{'gasto':gasto2, 'posts':gasto2.all()}) elif request.method == 'GET': mes = request.GET.get('mes') ano = request.GET.get('ano') if mes == None: today = datetime.date.today() print today gasto1 = Gasto.objects.filter().values_list('id', flat=True) pagastos = Detalleg.objects.filter(gasto__in=gasto1).order_by('-fecha') paginator = Paginator(pagastos, 50) # Show 25 contacts per page page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. posts = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. posts = paginator.page(paginator.num_pages) print gasto1 gasto2 = Detalleg.objects.filter(gasto__in=gasto1) return render(request, 'adming.html',{'gasto':gasto2, 'posts':posts,'gastos':gasto2.all()}) else: return export_excelfecha(request, mes, ano)
def get_context_data(self, *args, **kwargs): context = super(SearchView, self).get_context_data(*args, **kwargs) if 'query' in self.request.GET: self.form = SearchForm(self.request.GET) if self.form.is_valid(): self.query = self.form.cleaned_data['query'] context['results_count'] = self.model.objects.select_related( 'category').filter( Q(title__icontains=self.query) | Q(content__icontains=self.query)) results = self.model.objects.select_related('category').filter( Q(title__icontains=self.query) | Q(content__icontains=self.query)) page = self.request.GET.get('page', 1) paginator = Paginator(results, 6) try: context['results'] = paginator.page(page) except PageNotAnInteger: context['results'] = paginator.page(1) except EmptyPage: context['results'] = paginator.page(paginator.num_pages) context['query'] = self.query return context
def post_list(request): categories = Category.objects.all() category_count = get_category_count() most_recent = Post.objects.order_by('-timestamp')[:8] post_list = Post.objects.order_by('-timestamp') paginator = Paginator(post_list, 8) page_request_var = 'page' page = request.GET.get(page_request_var) try: paginated_queryset = paginator.page(page) except PageNotAnInteger: paginated_queryset = paginator.page(1) except EmptyPage: paginated_queryset = paginator.page(paginator.num_pages) context = { 'queryset': paginated_queryset, 'most_recent': most_recent, 'page_request_var': page_request_var, 'categories': categories, 'category_count': category_count, # 'form': form } return render(request, 'blog.html', context)
def index(request, num=1): try: if request.method == 'POST' and request.FILES['crt'] and request.FILES['incrt'] and request.FILES['key']: certificates = { 'crt': request.FILES['crt'].read().decode().rstrip(), 'incrt': request.FILES['incrt'].read().decode().rstrip(), 'key': request.FILES['key'].read().decode().rstrip(), } test_result = certificates_test(request, certificates) if test_result: key = certificates['key'] crt = certificates['crt'] + '\n' + certificates['incrt'] upload_crts(crt, key) cn = get_cn(certificates) create_nginx_config(cn) restart_nginx_container() else: cn = "-" is_test_result = TestResult.objects.create( common_name=cn, filename_crt=request.FILES['crt'].name, filename_incrt=request.FILES['incrt'].name, filename_key=request.FILES['key'].name, is_test_result=test_result ) is_test_result.save() return HttpResponseRedirect('/') except MultiValueDictKeyError: return HttpResponseRedirect('/') event_log = TestResult.objects.all().order_by('-tested_at') page = Paginator(event_log, 10) params = { 'event_log': page.get_page(num) } return render(request, 'frontend/index.html', params)
def list(self, request, *args, **kwargs): if "api" in request.META['PATH_INFO']: return super(SetVersionViewSet, self).list(request, *args, **kwargs) else: versions = self.filter_queryset(self.get_queryset()).order_by('imagesets') current_query = request.META['QUERY_STRING'] if "page" not in request.query_params: current_query += "&page=1" page_id = 1 else: page_id = int(request.query_params.get('page', 1)) limit = int(request.query_params.get('limit', api_settings.PAGE_SIZE)) paginator = Paginator(versions, limit) page = paginator.get_page(page_id) previous_query = first_query = current_query.replace("&page="+str(page_id), "&page=1") if page.has_previous(): previous_query = current_query.replace("&page="+str(page_id), "&page={}".format(page.previous_page_number())) next_query = last_query = current_query.replace("&page="+str(page_id), "&page={}".format(paginator.num_pages)) if page.has_next(): next_query = current_query.replace("&page="+str(page_id), "&page={}".format(page.next_page_number())) return TemplateResponse(request, 'base/explore.html', { 'mode': 'versions', 'versions': page, # to separate what kind of stuff is displayed in the view 'paginator': page, # for page stuff 'first_query': first_query, 'previous_query': previous_query, 'next_query': next_query, 'last_query': last_query, #'filter': self.filterset_class })
def get_network_query_info(request): data = dict() page_size = request.GET.get("page_size") current_page = request.GET.get("current_page") search_network = request.GET.get("search_network") if search_network: all_networks = NetworkQueryList.objects.filter( network__contains=search_network) else: all_networks = NetworkQueryList.objects.all() result = [] paginator = Paginator(all_networks, page_size) total_networks = all_networks.count() network_page = paginator.page(current_page) for network in network_page: network_info = dict() network_info['key'] = network.id network_info['network'] = network.network network_info['tcp_query_ports'] = network.tcp_query_ports network_info['udp_query_ports'] = network.udp_query_ports network_info['query_status'] = network.get_query_status_display() network_info['online_ip_num'] = network.online_ip_num network_info['auto_enable'] = network.auto_enable network_info['crontab_task'] = network.crontab_task network_info['query_time'] = ( network.query_time + datetime.timedelta(hours=8)).strftime("%Y-%m-%d %H:%M:%S") result.append(network_info) data['data'] = result data['total_network'] = total_networks data["status"] = "success" return json_response(data)
def home(request): fin_rj_list = Rj.objects.all() Rjsomme = Rj.objects.aggregate(Sum('p_acide_h2so4')) Rjsomme_s = Rj.objects.aggregate(Sum('s_c')) Rjsomme_s_c = Rj.objects.aggregate(Sum('r_s_solid')) Rj_filter = RjFilter(request.GET, queryset=fin_rj_list) page = request.GET.get('page', 1) paginator = Paginator(fin_rj_list, 5) try: fin_rj_list1 = paginator.page(page) except PageNotAnInteger: fin_rj_list1 = paginator.page(1) except EmptyPage: fin_rj_list1 = paginator.page(paginator.num_pages) return render(request, 'tifert/home.html', {'Rjsomme_s': Rjsomme_s,'Rjsomme_s_c': Rjsomme_s_c,'Rjsomme': Rjsomme,'fin_rj_list': fin_rj_list,'filter': Rj_filter,'fin_rj_list1': fin_rj_list1})
def classify(request, classify_id, page_id): classify = Classification.objects.all() classify1 = classify_id books = BookName.objects.filter(cfname=classify1) # 分页显示该类图书 paginator = Paginator(books, 10) page = paginator.page(page_id) classify_name = Classification.objects.get(id=classify_id) # 创建翻页链接 pagenum = int(page_id) page_next = pagenum + 1 page_last = pagenum - 1 if page_last == 0: page_last = 1 if page_next > paginator.num_pages: page_next = paginator.num_pages return render( request, 'classify.html', { 'books': page, 'classify_name': classify_name, 'classify': classify, 'page_next': page_next, 'page_last': page_last })
def display_articles(request): """ display list of articles in article list page. """ articlelist = Articles.objects.raw( 'select o.id,title,username,views,o.created_at,g.name GNAME,c.name CNAME from (select id,title,username,views,created_at,GID,CID COMMID from ( select ba.id,ba.title , username,views,created_at ,(select group_id from Group_grouparticles where article_id=ba.id) GID , (select community_id from Community_communityarticles where article_id=ba.id) CID from (select * from BasicArticle_articles where id in (select article_id from Group_grouparticles) or id in (select article_id from Community_communityarticles)) ba join auth_user au on ba.created_by_id=au.id join workflow_states ws on ws.id=ba.state_id where ws.name="publish") t ) o left join Community_community c on c.id=COMMID left join Group_group g on g.id=GID order by views desc;' ) page = request.GET.get('page', 1) paginator = Paginator(list(articlelist), 5) try: articles = paginator.page(page) except PageNotAnInteger: articles = paginator.page(1) except EmptyPage: articles = paginator.page(paginator.num_pages) fav_articles = '' if request.user.is_authenticated: fav_articles = favourite.objects.raw( 'select ba.id as id , title from BasicArticle_articles as ba ,UserRolesPermission_favourite as uf where ba.id=resource and user_id =%s;', [request.user.id]) return render(request, 'articles.html', { 'articles': articles, 'favs': fav_articles })
def consulta_ordem_detalhe(request, **kwargs): if Ordem.objects.filter(id=kwargs.get('ordem')).exists(): menu = menu_consultas(request) ordem = Ordem.objects.get(id=kwargs.get('ordem')) if kwargs.get('tipo'): itens = MaterialSaida.objects.filter(ordem=ordem).order_by( 'material__material', 'material__codigo') else: itens = MaterialEntrada.objects.filter(ordem=ordem).order_by( 'material__material', 'material__codigo') itens = itens.values( 'material__codigo', 'material__material', 'quantidade', ) paginator = Paginator(itens, 50) page_number = request.GET.get('page') page_obj = paginator.get_page(page_number) context = { 'page_obj': page_obj, 'ordem': ordem, 'tipo': kwargs.get('tipo'), } context.update(menu) return render(request, 'almoxarifado/v2/consulta_ordem_detalhe.html', context) else: return HttpResponseRedirect('/almoxarifado/consultas/')
def bus_stations(request): with open(settings.BUS_STATION_CSV, mode='r', encoding='cp1251') as file_data: contents = csv.DictReader(file_data) stops_list = list(contents) if request.GET.get('page'): page_number = int(request.GET.get('page')) else: page_number = 1 p = Paginator(stops_list, 10) if page_number in range(1, p.num_pages): stops_page = p.page(page_number) else: stops_page = p.page(p.num_pages) current_page = stops_page.number prev_page_url = f'?page={stops_page.previous_page_number()}' \ if stops_page.has_previous() else None next_page_url = f'?page={stops_page.next_page_number()}' \ if stops_page.has_next() else None return render_to_response('index.html', context={ 'bus_stations': stops_page, 'current_page': current_page, 'prev_page_url': prev_page_url, 'next_page_url': next_page_url, })
def select_paper_all(args): """Get All Papers""" page_number = 1 if constants.PAGE_NUMBER not in args else int(args[constants.PAGE_NUMBER]) # list of tuple (id, abtract, DOI) paper_queryset = Paper.objects.all().values_list('id', 'abstract', 'DOI') papers = Paginator(paper_queryset, ALL_PAPER_PAGE_COUNT).get_page(page_number) is_finished = not papers.has_next() results = [] # list of dictionaries whose keys are ItemId, Abstract, and Keywords for paper in papers: result = {} paper_id, abstract, doi = paper keywords = paper_utils.get_keywords_paper(Q(paper_id=paper_id)) result['Keywords'] = keywords[paper_id] if paper_id in keywords else [] result['ItemId'] = paper_id if abstract: result['Abstract'] = abstract # If abstract doesn't exist, try getting abstract this time. # We can use 'alternative-id' of Crossref for getting results from Semantic Scholar, # but it is currently not saved in our DB. So use only DOI for now. else: if doi: __exploit_semanticscholar_for_abstract(paper_id, [doi]) # NOTE: This doesn't use shared_task of celery result['Abstract'] = Paper.objects.get(id=paper_id).abstract else: result['Abstract'] = abstract # save empty abstract results.append(result) return results, page_number, is_finished
def test_page_getitem(self): """ Tests proper behavior of a paginator page __getitem__ (queryset evaluation, slicing, exception raised). """ paginator = Paginator(Article.objects.order_by('id'), 5) p = paginator.page(1) # Make sure object_list queryset is not evaluated by an invalid __getitem__ call. # (this happens from the template engine when using eg: {% page_obj.has_previous %}) self.assertIsNone(p.object_list._result_cache) with self.assertRaises(TypeError): p['has_previous'] self.assertIsNone(p.object_list._result_cache) self.assertNotIsInstance(p.object_list, list) # Make sure slicing the Page object with numbers and slice objects work. self.assertEqual(p[0], Article.objects.get(headline='Article 1')) self.assertQuerysetEqual(p[slice(2)], [ "<Article: Article 1>", "<Article: Article 2>", ]) # After __getitem__ is called, object_list is a list self.assertIsInstance(p.object_list, list)
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 show_chat(request,to): from_user = request.user to_user = get_object_or_404(User,username=to) if from_user==to_user: messages.error(request,_(u'Вы не можете написать сообщение самому себе')) # messages.error(request,_(u'Can not write email to yourself')) return HttpResponseRedirect(request.META['HTTP_REFERER']) #get existed chat chat= Chat.objects.filter(from_user=from_user,to_user=to_user) or Chat.objects.filter(to_user=from_user,from_user=to_user) if chat: chat=chat[0] msgs=None if chat: if chat.from_user==from_user: chat.is_from_user_read=False else: chat.is_to_user_read=False chat.save() msgs= chat.comments.all() msgs=Paginator(msgs,10) try: page = request.GET['page'] except: page = 1 try: msgs = msgs.page(page) except (EmptyPage, InvalidPage): msgs = msgs.page(msgs.num_pages) return render_to_response('cart/message.html',{'chat':chat,'msgs':msgs,'to':to},context_instance=RequestContext(request))
def story_page(request, story_id, story_slug): """ A page or part of story. @story_id @story_slug """ user = request.user all_parts = Part.objects.filter(story = story_id).order_by('order') paginator = Paginator(all_parts, 1) page = request.GET.get('page') story = Story.objects.get(id = story_id) # If the slug is wrong, redirect to the correct url story_slug_db = story.slug if story_slug_db != story_slug: url = "/story/" + str(story.id) + "/" + str(story_slug_db) + "/" return HttpResponseRedirect(url) try: parts = paginator.page(page) except (PageNotAnInteger, TypeError): parts = paginator.page(1) except EmptyPage: parts = paginator.page(paginator.num_pages) c = {"parts": parts, "story":story, "user": user,} return render_to_response('book.html', c, context_instance = RequestContext(request))