def page_lists(request, page):
page_posts = RichTextPage.objects.published(for_user=request.user).filter(parent=page).order_by("-publish_date")
paginate(page_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
return {'page_posts': page_posts}
def person_list(request,
category=None,
template="mezzanine_people/person_list.html"):
"""
Display a list of people that are filtered by category.
Custom templates are checked for using the name
``people/person_list_XXX.html`` where ``XXX`` is the category's slug.
"""
settings.use_editable()
templates = []
people = Person.objects.published()
if category is not None:
category = get_object_or_404(PersonCategory, slug=category)
people = people.filter(categories=category)
templates.append(u"mezzanine_people/person_list_%s.html" %
unicode(category.slug))
# requires Django VERSION >= (1, 4):
people = people.prefetch_related("categories")
people = paginate(people, request.GET.get("page", 1),
settings.PEOPLE_PER_PAGE, settings.MAX_PAGING_LINKS)
context = {"people": people, "category": category}
templates.append(template)
return render(request, templates, context)
def get_context_data(self, **kwargs):
context = super(DocumentDuplicatesView,
self).get_context_data(**kwargs)
context['sha_document_list'] = paginate(
self.get_sha_document_list(context['document_list']),
self.request.GET.get("page", 1), self.mezz_paginate_by, 7)
return context
def blog_post_list(request, tag=None, year=None, month=None, username=None,
category=None, template="blog/blog_post_list.html"):
"""
Display a list of blog posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
settings.use_editable()
templates = []
blog_posts = BlogPost.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
blog_posts = blog_posts.filter(keywords__in=tag.assignments.all())
if year is not None:
blog_posts = blog_posts.filter(publish_date__year=year)
if month is not None:
blog_posts = blog_posts.filter(publish_date__month=month)
month = month_name[int(month)]
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
blog_posts = blog_posts.filter(categories=category)
templates.append(u"blog/blog_post_list_%s.html" %
unicode(category.slug))
author = None
if username is not None:
author = get_object_or_404(User, username=username)
blog_posts = blog_posts.filter(user=author)
templates.append(u"blog/blog_post_list_%s.html" % username)
# Create dicts mapping blog post IDs to lists of categories and
# keywords, and assign these to each blog post, to avoid querying
# the database inside the template loop for posts.
blog_posts = list(blog_posts.select_related("user"))
categories = defaultdict(list)
if blog_posts:
ids = ",".join([str(p.id) for p in blog_posts])
for cat in BlogCategory.objects.raw(
"SELECT * FROM blog_blogcategory "
"JOIN blog_blogpost_categories "
"ON blog_blogcategory.id = blogcategory_id "
"WHERE blogpost_id IN (%s)" % ids):
categories[cat.blogpost_id].append(cat)
keywords = defaultdict(list)
blogpost_type = ContentType.objects.get(app_label="blog", model="blogpost")
assigned = AssignedKeyword.objects.filter(blogpost__in=blog_posts,
content_type=blogpost_type).select_related("keyword")
for a in assigned:
keywords[a.object_pk].append(a.keyword)
for i, post in enumerate(blog_posts):
setattr(blog_posts[i], "category_list", categories[post.id])
setattr(blog_posts[i], "keyword_list", keywords[post.id])
blog_posts = paginate(blog_posts,
request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {"blog_page": blog_page(), "blog_posts": blog_posts,
"year": year, "month": month, "tag": tag,
"category": category, "author": author}
templates.append(template)
return render(request, templates, context)
def blog_detail(request,
slug,
year=None,
month=None,
day=None,
template="pages/blog_detail.html",
extra_context=None):
""". Custom templates are checked for using the name
``blog/blog_post_detail_XXX.html`` where ``XXX`` is the blog
posts's slug.
"""
# blog_posts = MyBlog.objects.get(slug=slug)
blog_post = get_object_or_404(MyBlog, slug=slug)
par_blog_posts = BlogPostNew.objects.filter(blog=blog_post)
blog_posts = paginate(par_blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
# related_posts = blog_post.related_posts.published(for_user=request.user)
context = {
"blog_post": blog_post,
"editable_obj": blog_post,
"blog_posts": blog_posts
}
context.update(extra_context or {})
templates = [u"pages/blog_detail.html", template]
# return TemplateResponse(request, templates, context)
return render(request, 'pages/blog_detail.html', context)
def author_list(request,
tag=None,
year=None,
month=None,
username=None,
category=None,
template="pages/blogs_list.html",
extra_context=None):
"""
Display a list of blog posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
templates = []
blog_posts = MyProfile.objects.all()
author = None
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {
"blog_posts": blog_posts,
"year": year,
"month": month,
"tag": tag,
"category": category,
"author": author,
}
context.update(extra_context or {})
templates.append(template)
return render(request, 'pages/author_list.html', context)
def search(request, template="search_results.html"):
"""
Display search results. Takes an optional "contenttype" GET parameter
in the form "app-name.ModelName" to limit search results to a single model.
"""
settings.use_editable()
query = request.GET.get("q", "")
page = request.GET.get("page", 1)
per_page = settings.SEARCH_PER_PAGE
max_paging_links = settings.MAX_PAGING_LINKS
try:
parts = request.GET.get("type", "").split(".", 1)
search_model = apps.get_model(*parts)
search_model.objects.search # Attribute check
except (ValueError, TypeError, LookupError, AttributeError):
search_model = Displayable
search_type = _("Everything")
else:
search_type = search_model._meta.verbose_name_plural.capitalize()
results = search_model.objects.search(query, for_user=request.user)
paginated = paginate(results, page, per_page, max_paging_links)
context = {
"query": query,
"results": paginated,
"search_type": search_type
}
return render(request, template, context)
def search(request, template="search_results.html"):
"""
Display search results. Takes an optional "contenttype" GET parameter
in the form "app-name.ModelName" to limit search results to a single model.
"""
settings.use_editable()
query = request.GET.get("q", "")
page = request.GET.get("page", 1)
per_page = settings.SEARCH_PER_PAGE
max_paging_links = settings.MAX_PAGING_LINKS
try:
search_model = get_model(*request.GET.get("type", "").split(".", 1))
if not issubclass(search_model, Displayable):
raise TypeError
except TypeError:
search_model = Displayable
search_type = _("Everything")
else:
search_type = search_model._meta.verbose_name_plural.capitalize()
results = search_model.objects.search(query, for_user=request.user)
if 'location' and 'age' in request.session:
if 'cart loaded' in request.session:
stores = request.session['stores']
else:
avail_store_ids = request.session['store ids']
if avail_store_ids:
stores = Store.objects.filter(id__in=avail_store_ids)
else:
return HttpResponseRedirect('/shop/no-stores-yet')
avail_prod_ids = []
for p in stores:
for k in results:
if p == k.store:
avail_prod_ids.append(k.id)
results = Product.objects.filter(id__in=avail_prod_ids)
sort_options = [(slugify(option[0]), option[1])
for option in settings.SHOP_PRODUCT_SORT_OPTIONS]
sort_by = request.GET.get("sort", sort_options[0][1])
results = paginate(results.order_by(sort_by),
request.GET.get("page", 1),
settings.SHOP_PER_PAGE_CATEGORY,
settings.MAX_PAGING_LINKS)
results.sort_by = sort_by
else:
# return render(request, template, {"have_loc": False})
info(request, _("Enter your location to use the search"))
return HttpResponseRedirect('/')
# paginated = paginate(results, page, per_page, max_paging_links)
paginated = results
context = {"query": query, "results": paginated,
"search_type": search_type, "have_loc": True}
return render(request, template, context)
def homepage(request,
tag=None,
year=None,
month=None,
username=None,
category=None,
template="index.html"):
settings.use_editable()
templates = []
blog_posts = BlogPost.objects.published(for_user=request.user)
author = None
prefetch = ("categories", "keywords__keyword")
blog_posts = blog_posts.select_related(
"user", "user__profile").prefetch_related(*prefetch)[:5]
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {
"blog_posts": blog_posts,
"year": year,
"month": month,
"tag": tag,
"category": category,
"author": author
}
templates.append(template)
return render(request, templates, context)
def show_forum(request, forum_id, full=True):
forum = get_object_or_404(Forum, pk=forum_id)
if not forum.category.has_access(request.user):
raise PermissionDenied
topics = forum.topics.order_by('-sticky', '-updated').select_related()
topics = paginate(topics, request.GET.get("page", 1),
forum_settings.FORUM_PAGE_SIZE, 20)
moderator = request.user.is_superuser or\
request.user in forum.moderators.all()
categories = []
for category in Category.objects.all():
if category.has_access(request.user):
categories.append(category)
to_return = {'categories': categories,
'forum': forum,
'posts': forum.post_count,
'topics': topics,
'moderator': moderator,
}
if full:
return render(request, 'djangobb_forum/forum.html', to_return)
else:
return render(request, 'djangobb_forum/lofi/forum.html', to_return)
def blog_post_home(request, template="blog/blog_post_list.html"):
settings.use_editable()
templates = []
category = BlogCategory.objects.get(slug='ads')
blog_posts = BlogPost.objects.published(for_user=request.user)
ads_posts = None
if category:
blog_posts = blog_posts.exclude(categories=category)
ads_posts = BlogPost.objects.published(for_user=request.user)
ads_posts = ads_posts.filter(categories=category)
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {
"blog_posts": blog_posts,
"ads_posts": ads_posts,
"year": None,
"month": None,
"tag": None,
"category": None,
"author": None
}
templates.append(template)
return render(request, templates, context)
def search(request, template="search_results.html", extra_context=None):
"""
Display search results. Takes an optional "contenttype" GET parameter
in the form "app-name.ModelName" to limit search results to a single model.
"""
settings.use_editable()
query = request.GET.get("q", "")
page = request.GET.get("page", 1)
per_page = settings.SEARCH_PER_PAGE
max_paging_links = settings.MAX_PAGING_LINKS
try:
parts = request.GET.get("type", "").split(".", 1)
search_model = apps.get_model(*parts)
search_model.objects.search # Attribute check
except (ValueError, TypeError, LookupError, AttributeError):
search_model = Displayable
search_type = _("Everything")
else:
search_type = search_model._meta.verbose_name_plural.capitalize()
results = search_model.objects.search(query, for_user=request.user)
paginated = paginate(results, page, per_page, max_paging_links)
context = {"query": query, "results": paginated,
"search_type": search_type}
context.update(extra_context or {})
return render(request, template, context)
def fashion_list(request, sub=None, template="fashion.j2"):
"""
Display a list of blog posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
category = get_object_or_404(BlogCategory, slug="fashion")
blog_posts = BlogPost.objects.published(for_user=request.user).filter(
categories=category)
if sub is not None:
sub = get_object_or_404(BlogCategory, slug=sub)
blog_posts = blog_posts.filter(categories=sub)
author = None
prefetch = ("categories", "keywords__keyword")
blog_posts = blog_posts.select_related("user").prefetch_related(*prefetch)
blog_posts = paginate(blog_posts, request.GET.get("page", 1), 12,
settings.MAX_PAGING_LINKS)
context = {
"blog_posts": blog_posts,
"year": None,
"month": None,
"tag": None,
"category": sub,
"author": author
}
#context.update(extra_context or {})
#templates.append(template)
return TemplateResponse(request, template, context)
def have_location_get_categories_products(request, page, published_products, avail_stores, avail_store_names, avail_liquor_types):
avail_prod_ids = []
for p in avail_stores:
for k in published_products:
if p == k.store:
avail_prod_ids.append(k.id)
products = Product.objects.filter(id__in=avail_prod_ids)
sort_options = [(slugify(option[0]), option[1])
for option in settings.SHOP_PRODUCT_SORT_OPTIONS]
sort_by = request.GET.get("sort", sort_options[0][1])
products = paginate(products.order_by(sort_by),
request.GET.get("page", 1),
settings.SHOP_PER_PAGE_CATEGORY,
settings.MAX_PAGING_LINKS)
products.sort_by = sort_by
sub_categories = [p.titles for p in page.category.children.published()]
avail_stores = list(set(sub_categories) & set(avail_store_names))
avail_liquors = list(set(sub_categories) & set(avail_liquor_types))
avail_categories = avail_liquors + avail_stores
child_categories = Category.objects.filter(titles__in=avail_categories)
return products, child_categories
def frontpage(request):
# @TODO: Use weight and featured fields, which need to be implemented.
articles = Article.objects.filter(public=True).order_by('-updated_at')[:5]
articles = paginate(articles, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
return render(request, ['frontpage.html'], {'articles': articles})
def bookmarks(request, slug=None, username=None):
bookmarks = Bookmark.objects.all().order_by("-publish_date")
keyword = None
user = None
if slug:
try:
keyword = Keyword.objects.get(slug=slug)
except Keyword.DoesNotExist:
raise Http404
bookmarks = bookmarks.filter(keywords__keyword_id=keyword.pk)
if username:
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise Http404
bookmarks = bookmarks.filter(user__username=username)
bookmarks = paginate(
bookmarks,
request.GET.get("page", 1),
15,
settings.MAX_PAGING_LINKS,
)
return render(request, ["bookmarks/bookmarks.html"], {
"bookmarks": bookmarks,
"tag": keyword,
"username": user,
})
def article_list(request, tag=None, category=None, template="article/article_list.html"):
"""
Display a list of blog posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
settings.use_editable()
templates = []
articles = Article.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
articles = articles.filter(keywords__in=tag.assignments.all())
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
articles = articles.filter(categories=category)
# templates.append(u"article/blog_post_list_%s.html" %
# str(category.slug))
author = None
prefetch = ("categories", "keywords__keyword")
articles = articles.select_related("user").prefetch_related(*prefetch)
articles = paginate(articles, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {"articles": articles,
"tag": tag, "category": category, "author": author}
templates.append(template)
return render(request, templates, context)
def agents(request, agent_state_slug, agent_city_slug):
agents = queryset_iterator(
Agent.objects.filter(
slugged_state=abbreviate_slugged_state(agent_state_slug),
slugged_city=agent_city_slug))
# agents = get_list_or_404(Agent, slugged_state=abbreviate_slugged_state(agent_state_slug),
# slugged_city=agent_city_slug)
agent_list = []
for ag in agents:
agent_list.append(ag)
agents = paginate(agent_list, request.GET.get("page", 1), 100, 10)
profile_claimed = is_profile_claimed(request.user)
if request.GET.get("page") == '1':
return HttpResponsePermanentRedirect(
reverse('agent.views.agents',
args=[agent_state_slug, agent_city_slug]))
return render_to_response('pages/agents.html', {
'agents': agents,
'agent_state_slug': agent_state_slug,
'agent_city_slug': agent_city_slug,
'profile_claimed': profile_claimed
},
context_instance=RequestContext(request))
def bookmarks(request, slug=None):
if not slug:
bookmarks = Bookmark.objects.all().order_by("-publish_date")
keyword = None
else:
try:
keyword = Keyword.objects.get(slug=slug)
except Keyword.DoesNotExist:
raise Http404
bookmarks = Bookmark.objects.filter(
keywords__keyword_id=keyword.pk).order_by("-publish_date")
if len(bookmarks) == 0:
raise Http404
bookmarks = paginate(
bookmarks,
request.GET.get("page", 1),
15,
settings.MAX_PAGING_LINKS,
)
return render(request, ["bookmarks/bookmarks.html"], {
"bookmarks": bookmarks,
"tag": keyword,
})
def lco_blog_post_list(request, tag=None, year=None, month=None, username=None,
category=None, template="blog/blog_post_list.html",
extra_context=None):
"""
Display a list of blog posts that are filtered by tag, year, month,
author or category.
"""
templates = []
blog_posts = BlogPost.objects.published(for_user=request.user)
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
blog_posts = blog_posts.filter(categories=category)
templates.append(u"blog/blog_post_list_%s.html" %
str(category.slug))
if category == None:
blog_posts = blog_posts.filter(categories=None)
author = None
if username is not None:
author = get_object_or_404(User, username=username)
blog_posts = blog_posts.filter(user=author)
templates.append(u"blog/blog_post_list_%s.html" % username)
prefetch = ("categories", "keywords__keyword")
blog_posts = blog_posts.select_related("user").prefetch_related(*prefetch)
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {"blog_posts": blog_posts, "year": year, "month": month,
"tag": tag, "category": category, "author": author}
context.update(extra_context or {})
templates.append(template)
return TemplateResponse(request, templates, context)
def paginate_queryset(self, queryset, page_size):
page_kwarg = self.page_kwarg
page_num = self.kwargs.get(page_kwarg) or self.request.GET.get(
page_kwarg) or 1
page = paginate(queryset, page_num, page_size,
self.get_max_paging_links())
return (page.paginator, page, page.object_list, page.has_other_pages())
def get_context_data(self, **kwargs):
context = super(ArticleEventView, self).get_context_data(**kwargs)
context['objects'] = paginate(self.qs, self.request.GET.get("page", 1),
settings.MEDIA_PER_PAGE,
settings.MAX_PAGING_LINKS)
context['title'] = _('Laboratory News')
return context
def blog_post_list(request, tag=None, year=None, month=None, username=None,
category=None, template="blog/blog_post_list.html"):
"""
Display a list of blog posts.
"""
settings.use_editable()
blog_posts = BlogPost.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
blog_posts = blog_posts.filter(keywords=tag)
if year is not None:
blog_posts = blog_posts.filter(publish_date__year=year)
if month is not None:
blog_posts = blog_posts.filter(publish_date__month=month)
month = month_name[int(month)]
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
blog_posts = blog_posts.filter(categories=category)
author = None
if username is not None:
author = get_object_or_404(User, username=username)
blog_posts = blog_posts.filter(user=author)
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.BLOG_POST_MAX_PAGING_LINKS)
context = {"blog_posts": blog_posts, "year": year, "month": month,
"tag": tag, "category": category, "author": author,
"use_disqus": bool(settings.COMMENTS_DISQUS_SHORTNAME),
"blog_page": blog_page()}
return render_to_response(template, context, RequestContext(request))
def render_blog(self, request, year=None, month=None, author=None, category=None):
posts = self.posts.published(for_user=request.user)
#if tag is not None:
# tag = get_object_or_404(Keyword, slug=tag)
# blog_posts = blog_posts.filter(keywords=tag)
if year is not None:
if not year.isdigit():
raise Http404
posts = posts.filter(publish_date__year=year)
if month is not None:
if not month.isdigit():
raise Http404
posts = posts.filter(publish_date__month=month)
month = month_name[int(month)]
if category is not None:
try:
category = self.categories.get(slug=category)
except Category.DoesNotExist:
raise Http404
posts = posts.filter(category=category)
if author is not None:
author = get_object_or_404(User, username=author)
posts = posts.filter(user=author)
posts = paginate(posts,
request,
self.posts_per_page,
self.max_paging_links)
context = {"displayable": self,
"posts": posts,
"year": year,
"month": month,
"category": category,
"author": author,
}
return HttpResponse(self.get_template().render(RequestContext(request, context)))
def search(request, template="search_results.html", extra_context=None):
"""
Display search results. Takes an optional "contenttype" GET parameter
in the form "app-name.ModelName" to limit search results to a single model.
"""
query = request.GET.get("q", "")
page = request.GET.get("page", 1)
per_page = settings.SEARCH_PER_PAGE
max_paging_links = settings.MAX_PAGING_LINKS
try:
parts = request.GET.get("type", "").split(".", 1)
search_model = apps.get_model(*parts)
search_model.objects.search # Attribute check
except (ValueError, TypeError, LookupError, AttributeError):
search_model = Displayable
search_type = _("Everything")
else:
search_type = search_model._meta.verbose_name_plural.capitalize()
results = search_model.objects.search(query, for_user=request.user)
queryTitle = query.split("‧", 1);
results_title = list(Book.objects.filter(Q(title__contains=query) | Q(chinese_title__contains=queryTitle[0])))
author = Author.objects.filter(Q(chinese_name__contains=query) | Q(english_name__contains=query)).first()
results_author = []
if author:
results_author = list(Book.objects.filter(author_id=author.id))
results = list(set(results + results_author+ results_title))
paginated = paginate(results, page, per_page, max_paging_links)
context = {"query": query, "results": paginated,
"search_type": search_type}
context.update(extra_context or {})
return TemplateResponse(request, template, context)
def comment_thread(context, parent):
"""
Return a list of child comments for the given parent, storing all
comments in a dict in the context when first called, using parents
as keys for retrieval on subsequent recursive calls from the
comments template.
"""
if "all_comments" not in context:
comments = defaultdict(list)
if "request" in context and context["request"].user.is_staff:
comments_queryset = parent.comments.all()
else:
comments_queryset = parent.comments.visible()
for comment in comments_queryset.select_related("user"):
comments[comment.replied_to_id].append(comment)
context["all_comments"] = comments
parent_id = parent.id if isinstance(parent, Review) else None
try:
replied_to = int(context["request"].POST["replied_to"])
except KeyError:
replied_to = 0
page = context['request'].GET.get("page", 1)
per_page = django_settings.REVIEWS_PER_PAGE
max_paging_links = django_settings.MAX_PAGING_LINKS
comments_queryset = context["all_comments"].get(parent_id, [])
paginated = paginate(comments_queryset, page, per_page, max_paging_links)
context.update({
"comments_for_thread": paginated,
"no_comments": parent_id is None and not context["all_comments"],
"replied_to": replied_to,
})
return context
def agents(request, agent_state_slug, agent_city_slug):
agents = queryset_iterator(Agent.objects.filter(slugged_state=abbreviate_slugged_state(agent_state_slug),
slugged_city=agent_city_slug))
# agents = get_list_or_404(Agent, slugged_state=abbreviate_slugged_state(agent_state_slug),
# slugged_city=agent_city_slug)
agent_list = []
for ag in agents:
agent_list.append(ag)
agents = paginate(agent_list,
request.GET.get("page", 1),
100, 10)
profile_claimed = is_profile_claimed(request.user)
if request.GET.get("page") == '1':
return HttpResponsePermanentRedirect(reverse('agent.views.agents',
args=[agent_state_slug, agent_city_slug]))
return render_to_response('pages/agents.html',
{'agents': agents,
'agent_state_slug': agent_state_slug,
'agent_city_slug': agent_city_slug,
'profile_claimed': profile_claimed}, context_instance=RequestContext(request))
def bookmarks(request, slug=None, username=None):
bookmarks = Bookmark.objects.all().order_by("-publish_date")
keyword = None
user = None
if slug:
try:
keyword = Keyword.objects.get(slug=slug)
except Keyword.DoesNotExist:
raise Http404
bookmarks = bookmarks.filter(keywords__keyword_id=keyword.pk)
if username:
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise Http404
bookmarks = bookmarks.filter(user__username=username)
bookmarks = paginate(
bookmarks,
request.GET.get("page", 1),
15,
settings.MAX_PAGING_LINKS,
)
return render(request, ["bookmarks/bookmarks.html"], {
"bookmarks": bookmarks,
"tag": keyword,
"username": user,
})
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['testimonials'] = paginate(context['testimonials'],
self.request.GET.get("page", 1),
5,
settings.MAX_PAGING_LINKS)
return context
def list_infos(request, template="/pages/info_list.html"):
listado_infos = InfoInteres.objects.published()
filtrar_like = False
if request.method == "POST":
content = request.POST['content']
if content != '':
listado_infos = listado_infos.filter(Q(title__icontains=content) | Q(descripcion__icontains=content))
# todo sacar el resto de parametros
tipo_info = request.POST['tipo_info']
if tipo_info != '':
listado_infos = listado_infos.filter(tipo_info=tipo_info)
try:
like = request.POST['like']
if like:
filtrar_like = True
except:
pass
templates = []
templates.append(u'pages/info_list.html')
# context = {"lista": lista, "most_viewed_talks":most_viewed_talks, "most_rated_talks":most_rated_talks}
listado_infos = utils.getLikeCommentInfos(request.user, listado_infos, filtrar_like)
listado_infos = paginate(listado_infos, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {"lista": listado_infos}
templates.append(template)
return TemplateResponse(request, templates, context)
def get_context_data(self, **kwargs):
context = super(ArticleListView, self).get_context_data(**kwargs)
context['keywords'] = settings.ARTICLE_KEYWORDS
# keywords
assigned_keyword = AssignedKeyword()
self.keywords = assigned_keyword.get_keywords_of_content_type(
self.model._meta.app_label, self.model.__name__.lower())
if self.keywords:
context['keywords'] = self.keywords
# pagination
context['objects'] = paginate(self.qs, self.request.GET.get("page", 1),
settings.ARTICLE_PER_PAGE,
settings.MAX_PAGING_LINKS)
# keyword by AssignKeyword
if 'keyword' in self.kwargs:
context['current_keyword_slug'] = self.kwargs['keyword']
# keyword by MediaType: video, audio.....
if 'type' in self.kwargs:
context['current_keyword'] = self.kwargs['type']
return context
def blog_post_list(request,
tag=None,
year=None,
month=None,
username=None,
blog_name=None,
category=None,
template="blog/blog_post_list.html",
extra_context=None):
"""
Display a list of blog posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
templates = []
if blog_name is not None:
blog = get_object_or_404(Blog, slug=blog_name)
blog_posts = BlogPost.objects.published(for_user=request.user).filter(
blog=blog)
else:
blog_posts = BlogPost.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
blog_posts = blog_posts.filter(keywords__keyword=tag)
if year is not None:
blog_posts = blog_posts.filter(publish_date__year=year)
if month is not None:
blog_posts = blog_posts.filter(publish_date__month=month)
try:
month = month_name[int(month)]
except IndexError:
raise Http404()
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
blog_posts = blog_posts.filter(categories=category)
templates.append(u"blog/blog_post_list_%s.html" % str(category.slug))
author = None
if username is not None:
author = get_object_or_404(User, username=username)
blog_posts = blog_posts.filter(user=author)
templates.append(u"blog/blog_post_list_%s.html" % username)
prefetch = ("categories", "keywords__keyword")
blog_posts = blog_posts.select_related("user").prefetch_related(*prefetch)
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {
"blog_posts": blog_posts,
"year": year,
"month": month,
"tag": tag,
"category": category,
"author": author
}
context.update(extra_context or {})
templates.append(template)
return TemplateResponse(request, templates, context)
def comment_thread_social_level2(context, parent):
"""
Return a list of child comments for the given parent, storing all
comments in a dict in the context when first called, using parents
as keys for retrieval on subsequent recursive calls from the
comments template.
"""
comments = None
if "request" in context and context["request"].user.is_staff:
comments_queryset = parent.comments.all()
else:
comments_queryset = parent.comments.visible()
#user_social_auth_list = context["request"].user.social_auth.filter(provider="facebook")
#if not user_social_auth_list:
# user_social_auth_list = context["request"].user.social_auth.filter(provider="twitter")
#if user_social_auth_list:
# user_social_auth = user_social_auth_list[0]
# if user_social_auth:
# friends_of_friends = cache.get(user_social_auth.user.username+"SocialFriendListLevel2")
# if not friends_of_friends:
# friends = SocialFriendList.objects.existing_social_friends(context["request"].user.social_auth.filter(provider="facebook")[0])
# friends_of_friends = list(friends)
# for friend in friends:
# friends_level2 = SocialFriendList.objects.existing_social_friends(friend.social_auth.filter(provider="facebook")[0])
# friends_of_friends = list(chain(friends_of_friends, friends_level2))
# cache.set(user_social_auth.user.username+"SocialFriendListLevel2", friends_of_friends)
friends_of_friends = set()
friends = context["request"].user.relationships.following()
for friend in friends:
friends_of_friends.add(friend)
friends_level2 = friend.relationships.following()
for friend_level2 in friends_level2:
friends_of_friends.add(friend_level2)
comments_queryset = comments_queryset.order_by('-submit_date')
comments = comments_queryset.select_related("user").filter(user__in=friends_of_friends)
parent_id = parent.id if isinstance(parent, Review) else None
try:
replied_to = int(context["request"].POST["replied_to"])
except KeyError:
replied_to = 0
page = context['request'].GET.get("page", 1)
per_page = django_settings.REVIEWS_PER_PAGE
max_paging_links = django_settings.MAX_PAGING_LINKS
paginated = paginate(comments, page, per_page, max_paging_links)
context.update({
"comments_for_thread": paginated,
"no_comments": parent_id is None and not comments,
"replied_to": replied_to,
})
return context
def search(request, template="search_results.html"):
"""
Display search results. Takes an optional "contenttype" GET parameter
in the form "app-name.ModelName" to limit search results to a single model.
"""
settings.use_editable()
query = request.GET.get("q", "")
page = request.GET.get("page", 1)
per_page = settings.SEARCH_PER_PAGE
max_paging_links = settings.MAX_PAGING_LINKS
table_name = BlogPost._meta.db_table
try:
search_model = get_model(*request.GET.get("type", "").split(".", 1))
if not issubclass(search_model, Displayable):
raise TypeError
except TypeError:
search_model = BlogPost#Displayable
search_type = _("blog.BlogPost")#_("Everything")
else:
search_type = search_model._meta.verbose_name_plural.capitalize()
queryWithQuotes = '"%s"' % query
results = search_model.objects.search(queryWithQuotes, for_user=request.user)
filters = request.GET.get("filter", '')
filter_arr = []
if filters != '':
filter_arr = filters.split('-')
filter_sum = ''
if len(filter_arr) > 0:
for i in range(len(filter_arr)):
if is_valid_search_filter(filter_arr[i]):
if i == 0:
filter_sum += filter_arr[i].lower()+'_average'
else:
filter_sum += '+' + filter_arr[i].lower()+'_average'
if filter_sum != '':
'''
If filters are apllied, order vendors by sum of the filter parameter values.
In case filter values are equal, order them as per their overall average.
For now tie between equal overall_average is not broken. To break add more parameters ahead in order of priority.
'''
results = results.extra(select={'filtersum': filter_sum,
'fieldsum':'price_average + website_ex_average + quality_average + service_average',
'followers': 'SELECT COUNT(*) FROM %s WHERE target_blogpost_id=%s.id' % (Follow._meta.db_table, table_name)},
order_by=('-filtersum', '-overall_average', '-fieldsum', '-comments_count', '-followers',)).distinct()
else:
'''
In absence of any filters, order vendors by overall_average by default.
'''
results = results.extra(select={'fieldsum':'price_average + website_ex_average + quality_average + service_average',
'followers': 'SELECT COUNT(*) FROM %s WHERE target_blogpost_id=%s.id' % (Follow._meta.db_table, table_name)},
order_by=('-overall_average', '-fieldsum', '-comments_count', '-followers',)).distinct()
#results.sort(searchComparator, reverse=True)
paginated = paginate(results, page, per_page, max_paging_links)
context = {"query": query, "results": paginated,
"search_type": search_type}
return render(request, template, context)
def index(request):
results = CommunityModel.objects.published(for_user=request.user)
result_list = paginate(results, request.GET.get("page", 1), settings.ITEMS_PER_PAGE, settings.MAX_PAGE_LINKS)
return render(request, 'community/index.html', {
'result_list': result_list,
'title': "Community",
})
def list_to_paginate(list_object, request):
"""
Transforma uma lista recebida em objeto para paginação
"""
object_paginate = paginate(list_object, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
return object_paginate
def community(request, page):
results = CommunityModel.objects.all()
result_list = paginate(results, request.GET.get("page", 1), settings.ITEMS_PER_PAGE, settings.MAX_PAGE_LINKS)
return {
'result_list': result_list,
}
def get_context_data(self, **kwargs):
context = super(DocumentDuplicatesView, self).get_context_data(**kwargs)
context['sha_document_list'] = paginate(
self.get_sha_document_list(context['document_list']),
self.request.GET.get("page", 1),
self.mezz_paginate_by,
7)
return context
def list_to_paginate(list_object, request):
"""
Transforma uma lista recebida em objeto para paginação
"""
object_paginate = paginate(list_object, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
return object_paginate
def event_list(request):
"""
List view of all events.
The filter form determines the start and end date interval.
"""
start = None
end = None
form = ListFilterForm(request.GET)
occurrences = Occurrence.objects.published().select_related("event")
if form.is_valid():
occurrences = form.filter(occurrences)
start = form.cleaned_data["start_day"]
end = form.cleaned_data["end_day"]
# Adjust to include the current time if start is set to today
if start == today():
start = now()
featured_occurrences = paginate(
list(
occurrences.filter(event__featured=True).all_occurrences(
start, end)),
page_num=request.GET.get("featured-page", 1),
per_page=settings.EVENTS_FEATURED_PER_PAGE,
max_paging_links=settings.MAX_PAGING_LINKS,
)
regular_occurrences = paginate(
list(
occurrences.filter(event__featured=False).all_occurrences(
start, end)),
page_num=request.GET.get("page", 1),
per_page=settings.EVENTS_PER_PAGE,
max_paging_links=settings.MAX_PAGING_LINKS,
)
context = {
"today": today(),
"start_day": start,
"end_day": end,
"filter_form": form,
"filter_form_url": request.path,
"featured_occurrences": featured_occurrences,
"occurrences": regular_occurrences,
}
return render(request, "mezzanine_events/event_list.html", context)
def event_list(request,
tag=None,
year=None,
month=None,
username=None,
location=None,
template="agenda/event_list.html"):
"""
Display a list of events that are filtered by tag, year, month,
author or location. Custom templates are checked for using the name
``agenda/event_list_XXX.html`` where ``XXX`` is either the
location slug or author's username if given.
"""
settings.use_editable()
templates = []
events = Event.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
events = events.filter(keywords__keyword=tag)
if year is not None:
events = events.filter(start__year=year)
if month is not None:
events = events.filter(start__month=month)
try:
month = month_name[int(month)]
except IndexError:
raise Http404()
if location is not None:
location = get_object_or_404(EventLocation, slug=location)
events = events.filter(location=location)
templates.append(u"agenda/event_list_%s.html" % str(location.slug))
author = None
if username is not None:
author = get_object_or_404(User, username=username)
events = events.filter(user=author)
templates.append(u"agenda/event_list_%s.html" % username)
if not tag and not year and not location and not username:
#Get upcoming events/ongoing events
events = events.filter(
Q(start__gt=datetime.now())
| Q(end__gt=datetime.now())).order_by("start")
prefetch = ("keywords__keyword", )
events = events.select_related("user").prefetch_related(*prefetch)
events = paginate(events, request.GET.get("page", 1),
settings.EVENT_PER_PAGE, settings.MAX_PAGING_LINKS)
context = {
"events": events,
"year": year,
"month": month,
"tag": tag,
"location": location,
"author": author
}
templates.append(template)
return TemplateResponse(request, templates, context)
def get_all_events(request, page=1):
events = Event.objects.filter(visible=True).annotate(startdate = models.Max('eventschedule__start'), enddate = models.Max('eventschedule__end')).order_by('startdate')
if request.GET.get('page'):
page = request.GET.get('page')
events = paginate(events, page,
settings.EVENTS_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {'events':events}
return render(request, 'events/event_list.html', context)
def get_all_announcements(request, page=1):
announcements = Announcement.objects.get_latest_announcements()
if request.GET.get('page'):
page = request.GET.get('page')
announcements = paginate(announcements, page,
settings.ANNOUNCEMENT_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {'announcements':announcements}
return render(request, 'announcements/announcement_list.html', context)
def get_context_data(self, **kwargs):
context = super(TopicDetailView, self).get_context_data(**kwargs)
# paginate "manually" articles because we are not in a ListView
articles = paginate(self.object.articles.published(),
self.request.GET.get("page",
1), settings.ARTICLE_PER_PAGE,
settings.MAX_PAGING_LINKS)
context['articles'] = articles
return context
def get_context_data(self, **kwargs):
context = super(ScoreOrderingView, self).get_context_data(**kwargs)
qs = context["object_list"]
context["by_score"] = self.kwargs.get("by_score", True)
context["by_canteen"] = self.kwargs.get("by_canteen", False)
context["canteen"] = self.kwargs.get("canteen", 'other')
context["num"] = self.kwargs.get('num',0) #0其实是用来作为false用
context["solved"] = self.kwargs.get('solved',False) #0其实是用来作为false用
if context["by_score"]:
'''全部按分数'''
#默认所有数量
qs = order_by_score(qs, self.score_fields, self.date_field) #qs是queryset传递过去，返回queryset
if context["num"]:
#控制数量，通过url或者查询关键字 get
num=int(context["num"])
qs=qs[0:num]
else:
#按时间，默认所有
qs = qs.order_by("-" + self.date_field)
#时间,控制数量
if context["num"]:
#控制数量，通过url或者查询关键字 get
num=int(context["num"])
qs=qs[0:num]
#按餐厅
if context["by_canteen"] :
'''硬编码了，习惯不好，为了速度 dirty and quickly 核心逻辑：把if 当作开关'''
qs = Link.objects.filter(canteen=context["canteen"]) #queryset
if context["by_score"]:
'''餐厅内部按分数'''
qs = order_by_score(qs, self.score_fields, self.date_field)
#餐厅，热度，数量
if context["num"]:
num=int(context["num"])
qs=qs[0:num]
else:
qs = qs.order_by("-" + self.date_field)
#餐厅，时间，数量
if context["num"]:
num=int(context["num"])
qs=qs[0:num]
if context["solved"]: #最后一步过滤,queryset是list,当作list来过滤
#qs=qs.objects.filter(solved=True)
qs = [item for item in qs if item.solved == False]
context["object_list"] = paginate(qs, self.request.GET.get("page", 1),
settings.ITEMS_PER_PAGE, settings.MAX_PAGING_LINKS)
context["title"] = self.get_title(context)
return context
def get_context_data(self, **kwargs):
context = super(BlogPostList, self).get_context_data(**kwargs)
context["drafts"] = context["object_list"].filter(status=1)
context["object_list"] = paginate(
context["object_list"].filter(status=2),
self.request.GET.get("page", 1),
settings.ITEMS_PER_PAGE, settings.MAX_PAGING_LINKS
)
return context
def calls_post_list(request,
tag=None,
year=None,
month=None,
username=None,
category=None,
template="calls/calls_post_list.html"):
"""
Display a list of calls posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``calls/calls_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
settings.use_editable()
templates = []
calls_posts = CallsPost.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
calls_posts = calls_posts.filter(keywords__in=tag.assignments.all())
if year is not None:
calls_posts = calls_posts.filter(publish_date__year=year)
if month is not None:
calls_posts = calls_posts.filter(publish_date__month=month)
month = month_name[int(month)]
if category is not None:
category = get_object_or_404(CallsCategory, slug=category)
calls_posts = calls_posts.filter(categories=category)
templates.append(u"calls/calls_post_list_%s.html" % str(category.slug))
author = None
if username is not None:
author = get_object_or_404(User, username=username)
calls_posts = calls_posts.filter(user=author)
templates.append(u"calls/calls_post_list_%s.html" % username)
prefetch = ("categories", "keywords__keyword")
calls_posts = calls_posts.select_related("user").prefetch_related(
*prefetch)
calls_posts = paginate(calls_posts, request.GET.get("page", 1),
settings.CALLS_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
subscribed = 0
subscribed = request.user.groups.filter(
name='Calls Notification group').exists()
context = {
"calls_posts": calls_posts,
"year": year,
"month": month,
"tag": tag,
"category": category,
"author": author,
"subscribed": subscribed
}
templates.append(template)
#return render(request, templates, context)
return TemplateResponse(request, templates, context)
def posts_change(request):
try:
page = request.GET.get("page", 1)
per_page = settings.SEARCH_PER_PAGE
max_paging_links = settings.MAX_PAGING_LINKS
mod_posts = ModifiedPost.objects.all().order_by('publish_date')
except ModifiedPost.DoesNotExist:
mod_posts = []
paginated = paginate(mod_posts, page, per_page, max_paging_links)
return render(request, 'myadmin/myadminpage.html', {'modif_posts': paginated})
def search(request, template="search_results.html"):
"""
Display search results.
"""
query = request.GET.get("q", "")
results = Displayable.objects.search(request.settings, query)
results = paginate(results, request.GET.get("page", 1),
request.settings.SEARCH_PER_PAGE, request.settings.SEARCH_MAX_PAGING_LINKS)
context = {"query": query, "results": results}
return render_to_response(template, context, RequestContext(request))
def get(self, request, *args, **kwargs):
try:
page = request.GET.get("page", 1)
per_page = settings.SEARCH_PER_PAGE
max_paging_links = settings.MAX_PAGING_LINKS
notifications = Blog_Post_Comment.objects.filter(post_to__user=request.user.pk).exclude(user = request.user.pk).order_by('-date')
except Blog_Post_Comment.DoesNotExist:
notifications = []
paginated = paginate(notifications, page, per_page, max_paging_links)
return render(request, 'pages/notifications.html', {'notifications': paginated})
def users(request):
users = User.objects.filter(forum_profile__post_count__gte=forum_settings.POST_USER_SEARCH).order_by('username')
users = paginate(users, request.GET.get("page", 1),
forum_settings.USERS_PAGE_SIZE, 20)
form = UserSearchForm(request.GET)
users = form.filter(users)
return render(request, 'djangobb_forum/users.html', {'users': users,
'form': form,
})
def search(request, template="search_results.html"):
"""
Display search results.
"""
settings.use_editable()
query = request.GET.get("q", "")
page = request.GET.get("page", 1)
results = paginate(Displayable.objects.search(query), page, settings.SEARCH_PER_PAGE, settings.MAX_PAGING_LINKS)
context = {"query": query, "results": results}
return render(request, template, context)
def get_context_data(self, **kwargs):
context = super(PlaylistListView, self).get_context_data(**kwargs)
context['playlists'] = paginate(self.qs,
self.request.GET.get("page", 1),
settings.MEDIA_PER_PAGE,
settings.MAX_PAGING_LINKS)
context['current_type'] = self.current_type
return context
def blog_post_list(
request,
tag=None,
year=None,
month=None,
username=None,
category=None,
template="blog/blog_post_list.html",
extra_context=None,
):
"""
Display a list of blog posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
templates = []
blog_posts = BlogPost.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
blog_posts = blog_posts.filter(keywords__keyword=tag)
if year is not None:
blog_posts = blog_posts.filter(publish_date__year=year)
if month is not None:
blog_posts = blog_posts.filter(publish_date__month=month)
try:
month = _(month_name[int(month)])
except IndexError:
raise Http404()
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
blog_posts = blog_posts.filter(categories=category)
templates.append("blog/blog_post_list_%s.html" % str(category.slug))
author = None
if username is not None:
author = get_object_or_404(User, username=username)
blog_posts = blog_posts.filter(user=author)
templates.append("blog/blog_post_list_%s.html" % username)
prefetch = ("categories", "keywords__keyword")
blog_posts = blog_posts.select_related("user").prefetch_related(*prefetch)
blog_posts = paginate(
blog_posts, request.GET.get("page", 1), settings.BLOG_POST_PER_PAGE, settings.MAX_PAGING_LINKS
)
context = {
"blog_posts": blog_posts,
"year": year,
"month": month,
"tag": tag,
"category": category,
"author": author,
}
context.update(extra_context or {})
templates.append(template)
return TemplateResponse(request, templates, context)
def order_history(request, template="shop/order_history.html"):
"""
Display a list of the currently logged-in user's past orders.
"""
all_orders = (Order.objects.filter(user_id=request.user.id).annotate(
quantity_total=Sum('items__quantity')))
orders = paginate(all_orders.order_by('-time'), request.GET.get("page", 1),
settings.SHOP_PER_PAGE_CATEGORY,
settings.MAX_PAGING_LINKS)
context = {"orders": orders}
return render(request, template, context)
def paginated_comment_thread(context, parent):
"""
Override Mezzanine's comment_thread inclusion_tag.
The aim is to paginate all parent comments, but otherwise
the behaviour is the same. N.B. context persists between the
recursive calls to this tag. Remember this gets called with BlogPost
as parent first.
Return a list of child comments for the given parent, storing all
comments in a dict in the context when first called, using parents
as keys for retrieval on subsequent recursive calls from the
comments template.
"""
if "all_comments" not in context:
comments = defaultdict(list)
if "request" in context and context["request"].user.is_staff:
comments_queryset = parent.comments.all()
else:
comments_queryset = parent.comments.visible()
for comment in comments_queryset.select_related("user"):
comments[comment.replied_to_id].append(comment)
context["all_comments"] = comments
parent_id = parent.id if isinstance(parent, ThreadedComment) else None
try:
replied_to = int(context["request"].POST["replied_to"])
except KeyError:
replied_to = 0
# Pagination for zeroth level comments
comments_for_thread = context["all_comments"].get(parent_id, [])
context.update({"comments_for_thread": comments_for_thread})
if parent_id is None:
# Zeroth level comment
comments_for_thread_paginator = paginate(comments_for_thread,
context["request"].GET.get("page", 1),
settings.COMMENTS_PER_PAGE,
settings.MAX_PAGING_LINKS)
# For ease, tell the context we are at zeroth level in tree too
# context.update({"zeroth_level": True})
context.update({"comments_for_thread":
comments_for_thread_paginator.object_list})
context.update({"comments_for_thread_paginator":
comments_for_thread_paginator})
# If any comment id in all_comments keys, it means that it has children
# comment_ids = [comment.id for comment in comments_for_thread]
# more_children = any(map(lambda x: x in context["all_comments"].keys(),
# comment_ids))
context.update({
"no_comments": parent_id is None and not context["all_comments"],
"replied_to": replied_to,
})
return context
def search(request, template="search_results.html"):
"""
Display search results.
"""
settings.use_editable()
query = request.GET.get("q", "")
page = request.GET.get("page", 1)
results = paginate(Displayable.objects.search(query), page,
settings.SEARCH_PER_PAGE, settings.MAX_PAGING_LINKS)
context = {"query": query, "results": results}
return render(request, template, context)
def especialistas_list(request, extra_context=None):
"""Display a list of blog posts that are filtered by tag, year, month,
author or categoria. Custom templates are checked for using the name
``carceropolis/publicacao/publicacao_list_XXX.html`` where ``XXX`` is
either the categoria slug or author's username if given.
"""
areas_de_atuacao = AreaDeAtuacao.objects.all()
areas_de_atuacao = areas_de_atuacao.order_by('ordem')
especialistas = Especialista.objects.all()
especialistas = especialistas.order_by('nome')
context = {
'area_atuacao': '',
'nome': '',
'especialidade': '',
'areas_de_atuacao': areas_de_atuacao,
'especialistas': None
}
if 'nome' in request.GET.keys():
nome = request.GET.get('nome'),
nome = nome[0]
especialistas = especialistas.filter(nome__icontains=nome)
context['nome'] = nome
if 'area_atuacao' in request.GET.keys():
area_atuacao = request.GET.get('area_atuacao'),
area_atuacao = area_atuacao[0]
especialistas = especialistas.filter(
area_de_atuacao__nome__in=[area_atuacao])
context['area_atuacao'] = area_atuacao
if 'especialidade' in request.GET.keys():
especialidade = request.GET.get('especialidade'),
especialidade = especialidade[0]
especialistas = especialistas.filter(
especialidades__nome__in=[especialidade])
context['especialidade'] = especialidade
prefetch = ("area_de_atuacao", 'especialidades')
especialistas = especialistas.prefetch_related(*prefetch)
especialistas = paginate(especialistas, request.GET.get("page", 1),
settings.PUBLICACAO_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {
'areas_de_atuacao': areas_de_atuacao,
'especialistas': especialistas
}
context.update(extra_context or {})
templates = ['carceropolis/especialistas/especialistas.html']
return TemplateResponse(request, templates, context)
def search(request, template="search_results.html"):
"""
Display search results.
"""
settings.use_editable()
query = request.GET.get("q", "")
results = Displayable.objects.search(query)
results = paginate(results, request.GET.get("page", 1),
settings.SEARCH_PER_PAGE, settings.SEARCH_MAX_PAGING_LINKS)
context = {"query": query, "results": results}
return render_to_response(template, context, RequestContext(request))
