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