def get_category_event_index(self, request, category_name):
indexes = EventIndex.objects.child_of(self).live().all()
categories = Category.objects.filter(
edition=self).order_by('name').all()
category = categories.filter(slug=category_name).first()
if not category:
raise Http404
events = Event.objects.live().public().descendant_of(self).filter(
event_category=category).order_by('date')
posts = paginate(events, request, EventIndex.EVENTS_PER_PAGE)
relative_url = self.reverse_subpage('get_category_event_index',
(category_name, ))
return TemplateResponse(
request, 'agenda/event_index.html', {
'posts':
posts,
'indexes':
indexes,
'categories':
categories,
'title':
'{} - {}'.format(category.name, self.title),
'description':
'{} - {}'.format(category.name, self.title),
'canonical_url':
self.full_url + relative_url,
'featured_image':
self.get_featured_image(),
'locales': [(lang_code, lang_name, url + relative_url,
full_url + relative_url) for lang_code, lang_name,
url, full_url in self._get_locales()],
})
def pictures_view(request):
"""
show a list of picture
"""
pictures = Picture.objects.filter(is_visible=True).order_by("-creation_date")
pictures = paginate(pictures, request)
context = {"pictures": pictures, "current": "photos"}
return render_response(request, "picture/pictures_view.html", context)
def tips_view(request):
"""
show a list of picture
"""
tips = Tip.objects.filter(is_visible=True).order_by("-creation_date")
tips = paginate(tips, request, 3)
context = {'tips': tips,
'current':'tips'}
return render_response(request, 'tip/tips_view.html', context)
def public_project_list(request):
"""
return public projects list
The result list is paginated
"""
context = {}
projects = Project.objects.filter(public=True).order_by("-creation_date")
context['projects'] = paginate(projects, request)
return render_response(request, 'project/public_project_list.html', context)
def get_context_data(self, **kwargs):
ctx = super(MainPage, self).get_context_data(**kwargs)
event_list_little = Event.object_filter.live().all()[:2]
event_list = Event.object_filter.live().all()[2:]
work_list_little = Work.filters.active_list().filter(is_work=True)[:2]
work_list = Work.filters.active_list().filter(is_work=True)[2:]
service_list = Service.filters.active_list()
per_page = 3
paginator, page_obj, page = paginate(event_list, per_page, self.request)
objects = list(page_obj.object_list)
work_per_page = 3
work_paginator, work_page_obj, work_page = paginate(work_list, work_per_page, self.request, param_name='work_page')
work_objects = list(work_page_obj.object_list)
try:
contact_address = FlatContent.objects.get(slug='contact_address')
except FlatContent.DoesNotExist:
contact_address = None
try:
contact_text = FlatContent.objects.get(slug='contact_text')
except FlatContent.DoesNotExist:
contact_text = None
form = FeedbackForm()
ctx.update(
{'paginator': paginator,
'page_obj': page_obj,
'event_list': objects,
'event_list_little': event_list_little,
#'event_list': event_list,
'work_list_little':work_list_little,
'work_paginator': work_paginator,
'work_page_obj': work_page_obj,
'work_list': work_objects,
'service_list': service_list,
'contact_text': contact_text,
'contact_address': contact_address,
'form': form,
}
)
return ctx
def public_project_list(request):
"""
return public projects list
The result list is paginated
"""
context = {}
projects = Project.objects.filter(public=True).order_by("-creation_date")
context['projects'] = paginate(projects, request)
return render_response(request, 'project/public_project_list.html',
context)
def get_context(self, request, *args, **kwargs):
context = super().get_context(request, *args, **kwargs)
events = Event.objects.live().public().descendant_of(self).order_by(
'-date' if self.reversed_order else 'date')
context['posts'] = paginate(events, request,
EventIndex.EVENTS_PER_PAGE)
context['categories'] = Category.objects.filter(
edition=self.get_edition()).order_by('name').all()
context['indexes'] = EventIndex.objects.child_of(
self.get_edition()).live().all()
return context
def get_context(self, request):
context = super(BlogIndexPage, self).get_context(request)
entry_qs = self.get_posts()
paginator, entries = paginate(request,
entry_qs,
page_key=DEFAULT_PAGE_KEY,
per_page=self.per_page,
orphans=self.orphans)
context['entries_page'] = entries
context['paginator'] = paginator
return context
def get_context(self):
ctx = dict()
qs = self.model.object_filter.live()[2:]
per_page = 3
paginator, page_obj, page = paginate(qs, per_page, self.request)
objects = list(page_obj.object_list)
ctx.update(
{
'paginator': paginator,
'page_obj': page_obj,
'objects': objects,
}
)
return ctx
def render_to_response(self, context, **response_kwargs):
ctx = dict()
qs = self.model.filters.active_list().filter(is_work=True)[2:]
work_per_page = 3
work_paginator, work_page_obj, work_page = paginate(qs, work_per_page, self.request, param_name='work_page')
work_objects = list(work_page_obj.object_list)
ctx.update(
{
'work_paginator': work_paginator,
'work_page_obj': work_page_obj,
'work_list': work_objects,
}
)
template = loader.render_to_string(self.template_name, ctx)
return self.render_json_response({'template': template, })
def get_context(self, request):
context = super(CategoryPage, self).get_context(request)
entry_qs = self.get_posts()
# Use parent's settings for pagination counts
parent = self.get_parent().specific
paginator, entries = paginate(request, entry_qs,
page_key=DEFAULT_PAGE_KEY,
per_page=parent.per_page,
orphans=parent.orphans)
context['entries_page'] = entries
context['paginator'] = paginator
return context
def index(subpath='newest'):
form = LikeForm()
dic_codes = dict([(code.id,code.code_name) for code in Dic_code.query.all()])
big_cates = Dic_code.query.filter_by(parent_id=1).all()
for big_cate in big_cates:
big_cate.children = Dic_code.query.filter(Dic_code.parent_id == big_cate.type_id).order_by(Dic_code.id)
if current_user.is_authenticated():
like_tabs = [ like.like_id for like in Like.query.filter_by(uid=current_user.id)\
.filter_by(like_type=1).all() ]
else:
like_tabs = []
big_kind = request.args.get('big_kind')
if big_kind:
big_kind = int(big_kind)
little_kind = int(request.args.get('little_kind'))
if big_kind == 3:
tabs = Tab.query.filter_by(instrument=little_kind)
elif big_kind == 4:
tabs = Tab.query.filter_by(tabs_type=little_kind)
else:
tabs = Tab.query
if subpath == 'hot':
tabs = tabs.order_by(Tab.hot.desc())
else:
tabs = tabs.order_by(Tab.create_time.desc())
page = request.args.get('page')
if not page or int(page) < 1:
page = 1
#tabs = tabs.paginate(int(page), PER_PAGE, True)
tabs = paginate(tabs, page=int(page), per_page=PER_PAGE)
if request.method == 'POST' and form.validate_on_submit() and current_user.is_authenticated():
if form.op.data == 'c':
like = Like()
like.save(form, current_user.id, 1)
elif form.op.data == 'd':
like = Like.query.filter_by(like_id=form.like_id.data).filter_by(uid=current_user.id)\
.filter_by(like_type=1).first()
like.delete()
db.session.commit()
return render_template('tabs/index.html', tabs=tabs, big_cates=big_cates, dic_codes=dic_codes, \
form=form, like_tabs=like_tabs, subpath=subpath)
def project_list(request):
"""
return projects own by the current user.
The result list is paginated
"""
context = {}
projects = Project.objects.filter(owner=request.user).order_by("-creation_date")
if request.method == "POST":
form = NewProjectForm(request.POST, owner=request.user)
if form.is_valid():
new_project = form.save(commit=False)
new_project.owner = request.user
new_project.save()
else:
form = NewProjectForm(owner=request.user)
context['projects'] = paginate(projects, request)
context['new_project_form'] = form
return render_response(request, 'project/project_list.html', context)
def project_list(request):
"""
return projects own by the current user.
The result list is paginated
"""
context = {}
projects = Project.objects.filter(
owner=request.user).order_by("-creation_date")
if request.method == "POST":
form = NewProjectForm(request.POST, owner=request.user)
if form.is_valid():
new_project = form.save(commit=False)
new_project.owner = request.user
new_project.save()
else:
form = NewProjectForm(owner=request.user)
context['projects'] = paginate(projects, request)
context['new_project_form'] = form
return render_response(request, 'project/project_list.html', context)
def get_context(self, request):
context = super(DirectoryPage, self).get_context(request)
entry_filters = self.filters_from_querydict(request.GET)
entry_qs = self.get_instances(filters=entry_filters)
paginator, entries = paginate(request,
entry_qs,
page_key=DEFAULT_PAGE_KEY,
per_page=self.per_page,
orphans=self.orphans)
context['entries_page'] = entries
context['entries_filters'] = entry_filters
context['paginator'] = paginator
context['all_filters'] = {
'languages': Language.objects.all(),
'countries': Country.objects.all(),
'topics': Topic.objects.all(),
}
return context
def index():
dic_codes = dict([(code.id,code.code_name) for code in Dic_code.query.all()])
artists = Artist.query.order_by(Artist.hot.desc())
A_Z = [chr(i) for i in range(65,91)]
letters = ['ALL'] + A_Z + [u'其他']
letter = request.args.get("letter")
if letter:
if letter == 'ALL':
artists = artists
elif letter == u'其他':
artists = artists.filter(Artist.name.op('~')('^[0-9]'))
elif letter in A_Z:
artists = artists.filter_by(name_letter=letter)
page = request.args.get('page')
if not page or int(page) < 1:
page = 1
#artists = artists.paginate(int(page), PER_PAGE, True)
artists = paginate(artists, page=int(page), per_page=PER_PAGE)
return render_template('artists/index.html', letters=letters, dic_codes=dic_codes, artists=artists)
def article_archive_view(request):
articles = Article.objects.filter(is_visible=True).order_by("-modification_date")
articles = paginate(articles, request)
context = {'articles': articles,
'current':'archive'}
return render_response(request, 'article/archive.html', context)
def get_context(self, request, *args, **kwargs):
context = super().get_context(request, *args, **kwargs)
context['posts'] = paginate(
Post.objects.live().public().descendant_of(self).order_by('-date'),
request, PostIndex.POSTS_PER_PAGE)
return context
def get_context(self, request, *args, **kwargs):
context = super().get_context(request, *args, **kwargs)
context['posts'] = paginate(
Speaker.objects.live().public().descendant_of(self).order_by(
'title'), request, SpeakerIndex.SPEAKERS_PER_PAGE)
return context
