def get_context(self, request, category, slug, year, month, day, id):
try:
cat = Category.objects.get_by_tree_path(category)
except Category.DoesNotExist:
raise Http404("Category with tree_path '%s' doesn't exist." % category)
if year:
publishable = get_cached_object_or_404(Publishable,
publish_from__year=year,
publish_from__month=month,
publish_from__day=day,
category=cat,
slug=slug,
static=False
)
else:
publishable = get_cached_object_or_404(Publishable, pk=id)
if not publishable.static:
raise Http404()
if not (publishable.is_published() or request.user.is_staff):
# future publish, render if accessed by logged in staff member
raise Http404
obj = publishable.target
context = {
'object' : obj,
'category' : cat,
'content_type_name' : slugify(obj.content_type.model_class()._meta.verbose_name_plural),
'content_type' : obj.content_type
}
return context
def _category_detail(tree_path=False):
"""
Helper function that does all the data fetching for `home` and `category_detail` views. Returns
a dictionary containing:
- `category`: the root `Category` of the site
- `is_homepage`: boolean whether the category is the root category
- `archive_entry_year`: year of last `Listing`
:Parameters:
- `tree_path`: `Category.tree_path` (empty if home category)
:Exceptions:
- `Http404`: if there is no base category
"""
if tree_path:
cat = get_cached_object_or_404(Category, tree_path=tree_path, site__id=settings.SITE_ID)
else:
cat = get_cached_object_or_404(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
context = {
'category' : cat,
'is_homepage': not bool(tree_path),
'archive_entry_year' : __archive_entry_year(cat),
}
return context
def get_context(self, request, **kwargs):
category = kwargs.get("category", None)
slug = kwargs.get("slug", None)
export = None
cat = None
title = u""
link = ""
items = tuple()
context = dict()
if slug:
items = Export.objects.get_items_for_slug(slug=slug)
try:
export_object = Export.objects.get(slug=slug)
title = export_object.title
link = export_object.url
except Export.DoesNotExist:
raise Http404
else:
if category:
cat = get_cached_object_or_404(Category, tree_path=category, site__id=settings.SITE_ID)
else:
cat = get_cached_object_or_404(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
items = Export.objects.get_items_for_category(category=cat)
export_object = Export.objects.get(category=cat)
title = export_object.title
link = export_object.url
context.update(
{"exported_items": items, "category": cat, "is_homepage": not bool(category), "title": title, "link": link}
)
return context
def _object_detail(user, category, content_type, slug, year=None, month=None, day=None):
"""
Helper function that does all the data fetching for `object_detail` view. It
returns a dictionary containing:
- `placement`: `Placement` instance representing the URL accessed
- `object`: `Publishable` instance bound to the `placement`
- `category`: `Category` of the `placement`
- `content_type_name`: slugified plural verbose name of the publishable's content type
- `content_type`: `ContentType` of the publishable
:Parameters:
- `user`: django `User` instance
- `category`: `Category.tree_path` (empty if home category)
- `year`, `month`, `day`: date matching the `publish_from` field of the `Placement` object
- `content_type`: slugified `verbose_name_plural` of the target model
- `slug`: slug of the `Placement`
:Exceptions:
- `Http404`: if object or placement doesn't exist or dates don't match
"""
ct = get_content_type(content_type)
if category:
cat = get_cached_object_or_404(Category, tree_path=category, site__id=settings.SITE_ID)
else:
cat = get_cached_object_or_404(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
if year:
placement = get_cached_object_or_404(Placement,
publish_from__year=year,
publish_from__month=month,
publish_from__day=day,
publishable__content_type=ct,
category=cat,
slug=slug,
static=False
)
else:
placement = get_cached_object_or_404(Placement, category=cat, publishable__content_type=ct, slug=slug, static=True)
if not (placement.is_active() or user.is_staff):
# future placement, render if accessed by logged in staff member
raise Http404
obj = placement.publishable.target
context = {
'placement' : placement,
'object' : obj,
'category' : cat,
'content_type_name' : content_type,
'content_type' : ct,
}
return context
def get_context(self, request, category, slug, year, month, day, id):
try:
cat = Category.objects.get_by_tree_path(category)
except Category.DoesNotExist:
# non-static url, no way to recover
if year:
raise Http404("Category with tree_path '%s' doesn't exist." %
category)
else:
cat = None
if year:
publishable = get_cached_object_or_404(Publishable,
publish_from__year=year,
publish_from__month=month,
publish_from__day=day,
category=cat,
slug=slug,
static=False)
else:
publishable = get_cached_object_or_404(Publishable, pk=id)
if cat is None:
raise self.WrongUrl(
'Category with tree_path %r does not exist.' % category,
publishable)
elif not publishable.static:
raise self.WrongUrl('%s is not static.' % publishable,
publishable)
elif slug != publishable.slug:
raise self.WrongUrl('Wrong slug in URL (%r).' % slug,
publishable)
elif publishable.category_id != cat.pk:
raise self.WrongUrl('Wrong category for %s.' % publishable,
publishable)
if not (publishable.is_published() or request.user.is_staff):
# future publish, render if accessed by logged in staff member
raise Http404
# save existing object to preserve memory and SQL
publishable.category = cat
context = {
'object':
publishable,
'category':
cat,
'content_type_name':
slugify(publishable.content_type.model_class()._meta.
verbose_name_plural),
'content_type':
publishable.content_type
}
return context
def get_context(self, request, category=None):
if category:
cat = get_cached_object_or_404(Category, tree_path=category, site__id=settings.SITE_ID)
else:
cat = get_cached_object_or_404(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
context = {
'category' : cat,
'is_homepage': not bool(category),
'archive_entry_year' : self._archive_entry_year(cat),
}
return context
def get_context(self, request, category, slug, year, month, day, id):
try:
cat = Category.objects.get_by_tree_path(category)
except Category.DoesNotExist:
# non-static url, no way to recover
if year:
raise Http404("Category with tree_path '%s' doesn't exist." % category)
else:
cat = None
if year:
publishable = get_cached_object_or_404(Publishable,
publish_from__year=year,
publish_from__month=month,
publish_from__day=day,
category=cat,
slug=slug,
static=False
)
else:
publishable = get_cached_object_or_404(Publishable, pk=id)
if not (publishable.is_published() or request.user.is_staff):
# future publish, render if accessed by logged in staff member
raise Http404
if not year:
if cat is None:
raise self.WrongUrl('Category with tree_path %r does not exist.' % category, publishable)
elif not publishable.static:
raise self.WrongUrl('%s is not static.' % publishable, publishable)
elif slug != publishable.slug:
raise self.WrongUrl('Wrong slug in URL (%r).' % slug, publishable)
elif publishable.category_id != cat.pk:
raise self.WrongUrl('Wrong category for %s.' % publishable, publishable)
# save existing object to preserve memory and SQL
publishable.category = cat
context = {
'object' : publishable,
'category' : cat,
'content_type_name' : slugify(publishable.content_type.model_class()._meta.verbose_name_plural),
'content_type' : publishable.content_type
}
return context
def get_context(self, request, category, slug, year, month, day, id):
try:
cat = Category.objects.get_by_tree_path(category)
except Category.DoesNotExist:
# non-static url, no way to recover
if year:
raise Http404("Category with tree_path '%s' doesn't exist." % category)
else:
cat = None
if year:
lookup = {
'publish_from__year': year,
'publish_from__month': month,
'publish_from__day': day,
'category': cat,
'slug': slug,
'static': False
}
try:
publishable = get_cached_object(Publishable, published=True, **lookup)
except Publishable.DoesNotExist:
# Fallback for staff members in case there are multiple
# objects with same URL.
if request.user.is_staff:
try:
publishable = Publishable.objects.filter(published=False, **lookup)[0]
except IndexError:
raise Http404
else:
raise Http404
else:
publishable = get_cached_object_or_404(Publishable, pk=id)
if not (publishable.is_published() or request.user.is_staff):
# future publish, render if accessed by logged in staff member
raise Http404
if not year:
if cat is None:
raise self.WrongUrl('Category with tree_path %r does not exist.' % category, publishable)
elif not publishable.static:
raise self.WrongUrl('%s is not static.' % publishable, publishable)
elif slug != publishable.slug:
raise self.WrongUrl('Wrong slug in URL (%r).' % slug, publishable)
elif publishable.category_id != cat.pk:
raise self.WrongUrl('Wrong category for %s.' % publishable, publishable)
# save existing object to preserve memory and SQL
publishable.category = cat
context = {
'object' : publishable,
'category' : cat,
'content_type_name' : slugify(publishable.content_type.model_class()._meta.verbose_name_plural),
'content_type' : publishable.content_type
}
return context
def correct_answer_view(self, request, contest_pk, extra_context=None):
contest = get_cached_object_or_404(Contest, pk=contest_pk)
contestants = contest.get_correct_answers()
title = u"%s '%s': %s" % (Contest._meta.verbose_name, contest.title, _('Correct Answers'))
module_name = Contestant._meta.module_name
return render_to_response('newman/polls/correct-answers.html',
{'contestants' : contestants, 'title' : title, 'module_name' : module_name})
def done(self, request, cleaned_data):
ip = request.META['REMOTE_ADDR']
CommentForm(request.POST).save(
other_values={'ip_address': ip}
)
ct = get_cached_object_or_404(ContentType, pk=cleaned_data['target_ct'].id)
target = get_cached_object_or_404(ct, pk=cleaned_data['target_id'])
if 'redir' in request.POST:
url = request.POST['redir']
elif hasattr(target, 'get_absolute_url'):
url = target.get_absolute_url()
else:
url = '/'
return HttpResponseRedirect(url)
def get_context(self, request, **kwargs):
slug = kwargs.get('slug', None)
export_object = get_cached_object_or_404(AggregatedExport, slug=slug)
context = {
'export_slug': slug,
'export_object': export_object,
'category': None
}
return context
def __call__(self, request, url):
if url and url.endswith('correct_answers'):
pk = url.split('/')[-2]
contest = get_cached_object_or_404(Contest, pk=pk)
contestants = contest.get_correct_answers()
title = u"%s '%s': %s" % (Contest._meta.verbose_name, contest.title, _('Correct Answers'))
module_name = Contestant._meta.module_name
return render_to_response('admin/polls/answer/correct.html',
{'contestants' : contestants, 'title' : title, 'module_name' : module_name})
return super(ContestOptions, self).__call__(request, url)
def get_context(self, request, category, content_type, slug, year, month,
day):
ct = get_content_type(content_type)
cat = get_cached_object_or_404(Category,
tree_path=category,
site__id=settings.SITE_ID)
if year:
placement = get_cached_object_or_404(Placement,
publish_from__year=year,
publish_from__month=month,
publish_from__day=day,
publishable__content_type=ct,
category=cat,
slug=slug,
static=False)
else:
placement = get_cached_object_or_404(Placement,
category=cat,
publishable__content_type=ct,
slug=slug,
static=True)
# save existing object to preserve memory and SQL
placement.category = cat
placement.publishable.content_type = ct
if not (placement.is_active() or request.user.is_staff):
# future placement, render if accessed by logged in staff member
raise Http404
obj = placement.publishable.target
context = {
'placement': placement,
'object': obj,
'category': cat,
'content_type_name': content_type,
'content_type': ct,
}
return context
def get_context(self, request, **kwargs):
slug = kwargs.get('slug', None)
export_object = get_cached_object_or_404(AggregatedExport, slug=slug)
context = {
'export_slug': slug,
'export_object': export_object,
'category': None
}
return context
def __call__(self, request, url):
if url and url.endswith('correct_answers'):
pk = url.split('/')[-2]
contest = get_cached_object_or_404(Contest, pk=pk)
contestants = contest.get_correct_answers()
title = u"%s '%s': %s" % (Contest._meta.verbose_name, contest.title, _('Correct Answers'))
module_name = Contestant._meta.module_name
return render_to_response('admin/polls/answer/correct.html',
{'contestants' : contestants, 'title' : title, 'module_name' : module_name})
return super(ContestAdmin, self).__call__(request, url)
def correct_answer_view(self, request, contest_pk, extra_context=None):
contest = get_cached_object_or_404(Contest, pk=contest_pk)
contestants = contest.get_correct_answers()
title = u"%s '%s': %s" % (Contest._meta.verbose_name, contest.title, _("Correct Answers"))
module_name = Contestant._meta.module_name
return render_to_response(
"newman/polls/correct-answers.html",
{"contestants": contestants, "title": title, "module_name": module_name},
)
def correct_answer_view(self, request, contest_pk, extra_context=None):
contest = get_cached_object_or_404(Contest, pk=contest_pk)
contestants = contest.get_correct_answers()
title = u"%s '%s': %s" % (Contest._meta.verbose_name, contest.title, _('Correct Answers'))
module_name = get_model_name_from_class(Contestant)
context = {
'contest': contest,
'contestants': contestants,
'title': title,
'module_name': module_name
}
if (request.GET.get('type') == 'excel'):
response = render_to_response(
'admin/polls/correct-answers-excel.html',
context,
RequestContext(request)
)
response['Content-Disposition'] = 'attachment; filename=contest_%s.xls' % contest.pk
response['Content-Type'] = 'application/vnd.ms-excel;charset=utf-8'
return response
elif (request.GET.get('type') == 'csv'):
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename=contest_%s.csv' % contest.pk
writer = csv.writer(response)
head = [
encode_item(_('Count Guess Difference')),
encode_item(_('Name')),
encode_item(_('Surname')),
encode_item(_('User')),
encode_item(_('Email')),
encode_item(_('Phone number')),
encode_item(_('Address')),
encode_item(_('Winner')),
]
writer.writerow(list(head))
for contestant in contestants:
row = [
encode_item(contestant.count_guess_difference),
encode_item(contestant.name),
encode_item(contestant.surname),
encode_item(contestant.user),
encode_item(contestant.email),
encode_item(contestant.phonenumber),
encode_item(contestant.address),
encode_item(contestant.winner and _('Yes') or _('No')),
]
writer.writerow(list(row))
return response
else:
return render_to_response(
'admin/polls/correct-answers.html',
context,
RequestContext(request)
)
def get_context(self, request, category, content_type, slug, year, month, day, id):
ct = get_content_type(content_type)
try:
cat = Category.objects.get_by_tree_path(category)
except Category.DoesNotExist:
raise Http404('Category with given tree_path doesn\'t exist.')
if year:
publishable = get_cached_object_or_404(Publishable,
publish_from__year=year,
publish_from__month=month,
publish_from__day=day,
content_type=ct,
category=cat,
slug=slug,
static=False
)
else:
publishable = get_cached_object_or_404(Publishable, pk=id)
if publishable.category_id != cat.pk or publishable.content_type_id != ct.id or not publishable.static:
raise Http404()
# save existing object to preserve memory and SQL
publishable.category = cat
publishable.content_type = ct
if not (publishable.is_published() or request.user.is_staff):
# future publish, render if accessed by logged in staff member
raise Http404
obj = publishable.target
context = {
'object' : obj,
'category' : cat,
'content_type_name' : content_type,
'content_type' : ct,
}
return context
def get_context(self, request, **kwargs):
now = datetime.now()
category = kwargs.get('category', None)
slug = kwargs.get('slug', None)
export = None
export_object = None
cat = None
title = u''
link = ''
items = tuple()
context = dict()
if slug:
items = Export.objects.get_items_for_slug(slug=slug)
try:
export_object = Export.objects.get(slug=slug)
except Export.DoesNotExist:
raise Http404(_('Export with given slug does not exist.'))
else:
if category:
cat = get_cached_object_or_404(Category, tree_path=category, site__id=settings.SITE_ID)
else:
cat = get_cached_object_or_404(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
items = Export.objects.get_items_for_category(category=cat)
export_object = Export.objects.get(category=cat)
title = export_object.title
link = export_object.url
description = export_object.description
context.update({
'updated': now.strftime('%Y-%m-%dT%H:%M:%S+02:00'),
'exported_items': items,
'export_slug': slug,
'export_object': export_object,
'description': description,
'category': cat,
'is_homepage': not bool(category),
'title': title,
'link': link
})
return context
def correct_answer_view(self, request, contest_pk, extra_context=None):
contest = get_cached_object_or_404(Contest, pk=contest_pk)
contestants = contest.get_correct_answers()
title = u"%s '%s': %s" % (Contest._meta.verbose_name, contest.title,
_('Correct Answers'))
module_name = Contestant._meta.module_name
return render_to_response('newman/polls/correct-answers.html', {
'contestants': contestants,
'title': title,
'module_name': module_name
})
def __call__(self, request, url):
if url and url.endswith("correct_answers"):
pk = url.split("/")[-2]
contest = get_cached_object_or_404(Contest, pk=pk)
contestants = contest.get_correct_answers()
title = u"%s '%s': %s" % (Contest._meta.verbose_name, contest.title, _("Correct Answers"))
module_name = Contestant._meta.module_name
return render_to_response(
"admin/polls/answer/correct.html",
{"contestants": contestants, "title": title, "module_name": module_name},
)
return super(ContestOptions, self).__call__(request, url)
def get_context(self, request, category, content_type, slug, year, month, day):
ct = get_content_type(content_type)
cat = get_cached_object_or_404(Category, tree_path=category, site__id=settings.SITE_ID)
if year:
placement = get_cached_object_or_404(Placement,
publish_from__year=year,
publish_from__month=month,
publish_from__day=day,
publishable__content_type=ct,
category=cat,
slug=slug,
static=False
)
else:
placement = get_cached_object_or_404(Placement, category=cat, publishable__content_type=ct, slug=slug, static=True)
# save existing object to preserve memory and SQL
placement.category = cat
placement.publishable.content_type = ct
if not (placement.is_active() or request.user.is_staff):
# future placement, render if accessed by logged in staff member
raise Http404
obj = placement.publishable.target
context = {
'placement' : placement,
'object' : obj,
'category' : cat,
'content_type_name' : content_type,
'content_type' : ct,
}
return context
def get(self, request, *args, **kwargs):
if 'slug' not in kwargs:
raise Http404
# Compatibility with `paginator` tag.
if 'p' in request.GET:
self.kwargs.update({'page': request.GET['p']})
self.author = get_cached_object_or_404(Author, slug=kwargs['slug'])
response = render_as_api(request, self.author)
if response:
return response
return super(AuthorView, self).get(request, *args, **kwargs)
def root_ella(self, request, url):
url = url.lstrip('ella/')
url = url.rstrip('/')
if url.startswith('cache/status'):
from ella.ellaadmin.memcached import cache_status
return cache_status(request)
if url.split('/')[0].isdigit():
url_parts = url.split('/')
contenttype = get_cached_object_or_404(ContentType, pk=url_parts[0])
url_parts.pop(0)
return self.root_contenttype(request, contenttype, *url_parts)
raise http.Http404
def get(self, request, *args, **kwargs):
if 'slug' not in kwargs:
raise Http404
# Compatibility with `paginator` tag.
if 'p' in request.GET:
self.kwargs.update({'page': request.GET['p']})
self.author = get_cached_object_or_404(Author, slug=kwargs['slug'])
response = render_as_api(request, self.author)
if response:
return response
return super(AuthorView, self).get(request, *args, **kwargs)
def root_ella(self, request, url):
url = url.lstrip('ella/')
url = url.rstrip('/')
if url.startswith('cache/status'):
from ella.ellaadmin.memcached import cache_status
return cache_status(request)
if url.split('/')[0].isdigit():
url_parts = url.split('/')
contenttype = get_cached_object_or_404(ContentType,
pk=url_parts[0])
url_parts.pop(0)
return self.root_contenttype(request, contenttype, *url_parts)
raise http.Http404
def new_comment(request, context, reply=None):
"""new comment for specified object"""
init_props = {
'target': '%d:%d' % (context['content_type'].id, context['object']._get_pk_val()),
'options' : FORM_OPTIONS['UNAUTHORIZED_ONLY'],
}
if reply:
init_props['parent'] = reply
context.update({
'reply' : True,
'parent' : get_cached_object_or_404(Comment, pk=reply, target_ct=context['content_type'], target_id=context['object']._get_pk_val()),
})
form = CommentForm(init_props=init_props)
context['form'] = form
templates = get_templates_from_placement('comments/form.html', context['placement'])
return render_to_response(templates, context, context_instance=RequestContext(request))
def root_contenttype(self, request, contenttype, *url_parts):
"""
prepare redirect to admin_list view, objects change_view,
other special views (delete, history, ..) and hook our own views
"""
get_params = request.GET and '?%s' % request.GET.urlencode() or ''
changelist_view = '../../%s/%s' % (
contenttype.app_label,
contenttype.model,
)
if not len(url_parts):
# redirect to admin changelist list for this contet type
redir = '%s/%s' % (changelist_view, get_params)
return http.HttpResponseRedirect(redir)
if not url_parts[0].isdigit:
# we don't handle actions on content type itself
raise http.Http404
if len(url_parts) == 1:
# redirect to admin change view for specific object
redir = '../%s/%s/%s' % (changelist_view, url_parts[0], get_params)
return http.HttpResponseRedirect(redir)
if len(url_parts) == 2 and url_parts[1] == 'info':
# object_detail for some ajax raw_id widget
mimetype = 'text/html' or 'application/json' # ?:)
obj = get_cached_object_or_404(contenttype, pk=url_parts[0])
response = {
'name': str(obj),
'content_type_name': contenttype.name,
'content_type': contenttype.model,
'url': getattr(obj, 'get_absolute_url', lambda: None)(),
'admin_url': admin_url(obj),
}
return http.HttpResponse(simplejson.dumps(response, indent=2),
mimetype=mimetype)
if len(url_parts) == 2:
# some action on specific object (delete, history, ..)
redir = '../../%s/%s/%s/%s' % (changelist_view, url_parts[0],
url_parts[1], get_params)
return http.HttpResponseRedirect(redir)
raise http.Http404
def get_context(self, request, **kwargs):
now = datetime.now()
category = kwargs.get("category", None)
slug = kwargs.get("slug", None)
export = None
export_object = None
cat = None
title = u""
link = ""
items = tuple()
context = dict()
photo_format = request.GET.get("photo_format", None)
if photo_format:
try:
photo_format = get_cached_object_or_404(Format, name=photo_format, sites=settings.SITE_ID)
except ValueError, Format.DoesNotExist:
raise Http404
def get_context(self, request, **kwargs):
now = datetime.now()
category = kwargs.get('category', None)
slug = kwargs.get('slug', None)
export = None
export_object = None
cat = None
title = u''
link = ''
items = tuple()
context = dict()
photo_format = request.GET.get('photo_format', None)
if photo_format:
try:
photo_format = get_cached_object_or_404(Format, name=photo_format, sites=settings.SITE_ID)
except ValueError, Format.DoesNotExist:
raise Http404
def root_contenttype(self, request, contenttype, *url_parts):
"""
prepare redirect to admin_list view, objects change_view,
other special views (delete, history, ..) and hook our own views
"""
get_params = request.GET and '?%s' % request.GET.urlencode() or ''
changelist_view = '../../%s/%s' % (contenttype.app_label, contenttype.model,)
if not len(url_parts):
# redirect to admin changelist list for this contet type
redir = '%s/%s' % (changelist_view, get_params)
return http.HttpResponseRedirect(redir)
if not url_parts[0].isdigit:
# we don't handle actions on content type itself
raise http.Http404
if len(url_parts) == 1:
# redirect to admin change view for specific object
redir = '../%s/%s/%s' % (changelist_view, url_parts[0], get_params)
return http.HttpResponseRedirect(redir)
if len(url_parts) == 2 and url_parts[1] == 'info':
# object_detail for some ajax raw_id widget
mimetype = 'text/html' or 'application/json' # ?:)
obj = get_cached_object_or_404(contenttype, pk=url_parts[0])
response = {
'name': str(obj),
'content_type_name': contenttype.name,
'content_type': contenttype.model,
'url': getattr(obj, 'get_absolute_url', lambda:None)(),
'admin_url': admin_url(obj),
}
return http.HttpResponse(simplejson.dumps(response, indent=2), mimetype=mimetype)
if len(url_parts) == 2:
# some action on specific object (delete, history, ..)
redir = '../../%s/%s/%s/%s' % (changelist_view, url_parts[0], url_parts[1], get_params)
return http.HttpResponseRedirect(redir)
raise http.Http404
def new_comment(request, context, reply=None):
"""new comment for specified object"""
init_props = {
'target': '%d:%d' % (context['content_type'].id, context['object']._get_pk_val()),
'options' : FORM_OPTIONS['UNAUTHORIZED_ONLY'],
}
if reply:
init_props['parent'] = reply
context.update({
'reply' : True,
'parent' : get_cached_object_or_404(
Comment,
pk=reply,
target_ct=context['content_type'],
target_id=context['object']._get_pk_val()
),
})
form = CommentForm(init_props=init_props)
context['form'] = form
templates = get_templates_from_placement('comments/form.html', context['placement'])
return render_to_response(templates, context, context_instance=RequestContext(request))
def export(request, count, name='', content_type=None):
"""
Export banners.
:Parameters:
- `count`: number of objects to pass into the template
- `name`: name of the template ( page/export/banner.html is default )
- `models`: list of Model classes to include
"""
t_list = []
if name:
t_list.append('page/export/%s.html' % name)
t_list.append('page/export/banner.html')
cat = get_cached_object_or_404(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
listing = Listing.objects.get_listing(count=count, category=cat)
return render_to_response(
t_list,
{ 'category' : cat, 'listing' : listing },
context_instance=RequestContext(request),
content_type=content_type
)
def export(request, count, name='', content_type=None):
"""
Export banners.
:Parameters:
- `count`: number of objects to pass into the template
- `name`: name of the template ( page/export/banner.html is default )
- `models`: list of Model classes to include
"""
t_list = []
if name:
t_list.append('page/export/%s.html' % name)
t_list.append('page/export/banner.html')
cat = get_cached_object_or_404(Category,
tree_path='',
site__id=settings.SITE_ID)
listing = Listing.objects.get_listing(count=count, category=cat)
return render(request,
t_list, {
'category': cat,
'listing': listing
},
content_type=content_type)
def get_context(self, request, category, slug, year, month, day, id):
try:
cat = Category.objects.get_by_tree_path(category)
except Category.DoesNotExist:
# non-static url, no way to recover
if year:
raise Http404("Category with tree_path '%s' doesn't exist." % category)
else:
cat = None
if year:
start_date = localize(datetime(int(year), int(month), int(day)))
end_date = start_date + timedelta(days=1)
lookup = {
'publish_from__gte': start_date,
'publish_from__lt': end_date,
'category': cat,
'slug': slug,
'static': False
}
try:
publishable = get_cached_object(Publishable, published=True, **lookup)
except Publishable.DoesNotExist:
# Fallback for staff members in case there are multiple
# objects with same URL.
if request.user.is_staff:
try:
# Make sure we return specific publishable subclass
# like when using `get_cached_object` if possible.
p = Publishable.objects.filter(published=False, **lookup)[0]
publishable = p.content_type.model_class()._default_manager.get(pk=p.pk)
except IndexError:
raise Http404
else:
raise Http404
else:
publishable = get_cached_object_or_404(Publishable, pk=id)
if not (publishable.is_published() or request.user.is_staff):
# future publish, render if accessed by logged in staff member
raise Http404
if not year:
if cat is None:
raise self.WrongUrl('Category with tree_path %r does not exist.' % category, publishable)
elif not publishable.static:
raise self.WrongUrl('%s is not static.' % publishable, publishable)
elif slug != publishable.slug:
raise self.WrongUrl('Wrong slug in URL (%r).' % slug, publishable)
elif publishable.category_id != cat.pk:
raise self.WrongUrl('Wrong category for %s.' % publishable, publishable)
# save existing object to preserve memory and SQL
publishable.category = cat
context = {
'object': publishable,
'category': cat,
'content_type_name': slugify(publishable.content_type.model_class()._meta.verbose_name_plural),
'content_type': publishable.content_type
}
return context
try:
photo_format = get_cached_object_or_404(Format, name=photo_format, sites=settings.SITE_ID)
except ValueError, Format.DoesNotExist:
raise Http404
else:
photo_format = None
if slug:
items = Export.objects.get_items_for_slug(slug=slug, photo_format=photo_format)
try:
export_object = Export.objects.get(slug=slug)
except Export.DoesNotExist:
raise Http404(_('Export with given slug does not exist.'))
else:
if category:
cat = get_cached_object_or_404(Category, tree_path=category, site__id=settings.SITE_ID)
else:
cat = get_cached_object_or_404(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
items = Export.objects.get_items_for_category(category=cat, photo_format=photo_format)
export_object = Export.objects.get(category=cat)
# Ugly hack how to force photo format passed in GET params
if photo_format:
export_object.photo_format = photo_format
title = export_object.title
link = export_object.url
description = export_object.description
context.update({
'updated': now.strftime('%Y-%m-%dT%H:%M:%S+02:00'),
month = int(month)
date(year, month, 1)
except ValueError, e:
raise Http404()
kwa['publish_from__month'] = month
if day:
try:
day = int(day)
date(year, month, day)
except ValueError, e:
raise Http404()
kwa['publish_from__day'] = day
if category:
cat = get_cached_object_or_404(Category, tree_path=category, site__id=settings.SITE_ID)
kwa['category'] = cat
kwa['children'] = Listing.objects.ALL
else:
cat = get_cached_object_or_404(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
kwa['category'] = cat
if content_type:
ct = get_content_type(content_type)
kwa['content_types'] = [ ct ]
else:
ct = False
qset = Listing.objects.get_queryset_wrapper(kwa)
paginator = Paginator(qset, paginate_by)
try:
month = int(month)
date(year, month, 1)
except ValueError, e:
raise Http404()
kwa['publish_from__month'] = month
if day:
try:
day = int(day)
date(year, month, day)
except ValueError, e:
raise Http404()
kwa['publish_from__day'] = day
cat = get_cached_object_or_404(Category, tree_path=category, site__id=settings.SITE_ID)
kwa['category'] = cat
if category:
kwa['children'] = Listing.objects.ALL
if content_type:
ct = get_content_type(content_type)
kwa['content_types'] = [ ct ]
else:
ct = False
qset = Listing.objects.get_queryset_wrapper(kwa)
paginator = Paginator(qset, paginate_by)
if page_no > paginator.num_pages or page_no < 1:
raise Http404()
def poll_vote(request, poll_id):
"""
Add vote for a poll
Redirect to object's get_absolute_url() on success.
Params:
poll_id: Poll object identifier
Raises:
Http404 if no content_type or model is associated with the given IDs
"""
poll_ct = ContentType.objects.get_for_model(Poll)
poll = get_cached_object_or_404(poll_ct, pk=poll_id)
url = get_next_url(request)
# activity check
if not poll.is_active():
return HttpResponseRedirect(url)
# vote check
if poll_check_vote(request, poll) != POLL_USER_NOT_YET_VOTED:
return HttpResponseRedirect(url)
form = QuestionForm(poll.question)(request.POST)
# invalid input
if not form.is_valid():
# no choice selected error - via session
sess_nv = request.session.get(POLLS_NO_CHOICE_COOKIE_NAME, [])
sess_nv.append(poll.id)
request.session[POLLS_NO_CHOICE_COOKIE_NAME] = sess_nv
return HttpResponseRedirect(url)
# vote save
kwa = {}
if request.user.is_authenticated():
kwa['user'] = request.user
if request.META.has_key('HTTP_X_FORWARDED_FOR'):
kwa['ip_address'] = request.META['HTTP_X_FORWARDED_FOR']
else:
kwa['ip_address'] = request.META['REMOTE_ADDR']
poll.vote(form.cleaned_data['choice'], **kwa)
# just voted info session update
sess_jv = request.session.get(POLLS_JUST_VOTED_COOKIE_NAME, [])
sess_jv.append(poll.id)
request.session[POLLS_JUST_VOTED_COOKIE_NAME] = sess_jv
response = HttpResponseRedirect(url)
# authenticated user vote - session update
if request.user.is_authenticated():
sess = request.session.get(POLLS_COOKIE_NAME, [])
sess.append(poll.id)
request.session[POLLS_COOKIE_NAME] = sess
# annonymous user vote - cookies update
else:
cook = request.COOKIES.get(POLLS_COOKIE_NAME, '').split(',')
if len(cook) > POLLS_MAX_COOKIE_LENGTH:
cook = cook[1:]
cook.append(str(poll.id))
expires = datetime.strftime(datetime.utcnow() + timedelta(seconds=POLLS_MAX_COOKIE_AGE), "%a, %d-%b-%Y %H:%M:%S GMT")
response.set_cookie(
POLLS_COOKIE_NAME,
value=','.join(cook),
max_age=POLLS_MAX_COOKIE_AGE,
expires=expires,
path='/',
domain=Site.objects.get_current().domain,
secure=None
)
return response
def get_context(self, request, **kwargs):
slug = kwargs.get("slug", None)
export_object = get_cached_object_or_404(AggregatedExport, slug=slug)
context = {"export_slug": slug, "export_object": export_object, "category": None}
return context
month = int(month)
date(year, month, 1)
except ValueError, e:
raise Http404()
kwa['publish_from__month'] = month
if day:
try:
day = int(day)
date(year, month, day)
except ValueError, e:
raise Http404()
kwa['publish_from__day'] = day
cat = get_cached_object_or_404(Category,
tree_path=category,
site__id=settings.SITE_ID)
kwa['category'] = cat
if category:
kwa['children'] = Listing.objects.ALL
if content_type:
ct = get_content_type(content_type)
kwa['content_types'] = [ct]
else:
ct = False
qset = Listing.objects.get_queryset_wrapper(kwa)
paginator = Paginator(qset, paginate_by)
if page_no > paginator.num_pages or page_no < 1:
def get_context(self, request, category='', year=None, month=None, \
day=None, content_type=None,
paginate_by=listingex_settings.PAGINATE_BY):
# pagination
if 'p' in request.GET and request.GET['p'].isdigit():
page_no = int(request.GET['p'])
else:
page_no = 1
# if we are not on the first page, display a different template
category_title_page = page_no == 1
kwa = {}
if year:
category_title_page = False
year = int(year)
kwa['publish_from__year'] = year
if month:
try:
month = int(month)
date(year, month, 1)
except ValueError:
raise Http404()
kwa['publish_from__month'] = month
if day:
try:
day = int(day)
date(year, month, day)
except ValueError:
raise Http404()
kwa['publish_from__day'] = day
cat = get_cached_object_or_404(Category, tree_path=category,
site__id=settings.SITE_ID)
kwa['category'] = cat
if category:
kwa['children'] = Listing.objects.ALL
if content_type:
ct = get_content_type(content_type)
kwa['content_types'] = [ct]
else:
ct = False
qset = Listing.objects.get_queryset_wrapper(kwa)
if self.is_ex_applied(cat):
per_first_page = (listingex_settings.FIRST_PAGE_COUNT or
paginate_by)
else:
per_first_page = paginate_by
paginator = PaginatorEx(qset, per_first_page, paginate_by)
if page_no > paginator.num_pages or page_no < 1:
raise Http404()
page = paginator.page(page_no)
listings = page.object_list
context = {
'page': page,
'is_paginated': paginator.num_pages > 1,
'results_per_page': paginate_by,
'content_type': ct,
'content_type_name': content_type,
'listings': listings,
'category': cat,
'is_homepage': (not bool(category) and page_no == 1
and year is None),
'is_title_page': category_title_page,
'archive_entry_year': lambda: self._archive_entry_year(cat),
}
return context
def survey_vote(request, survey_id):
survey_ct = ContentType.objects.get_for_model(Survey)
survey = get_cached_object_or_404(survey_ct, pk=survey_id)
url = get_next_url(request)
# activity check
if not survey.current_activity_state == polls_settings.ACTIVITY_ACTIVE:
return HttpResponseRedirect(url)
# vote check
if survey_check_vote(request, survey) != polls_settings.USER_NOT_YET_VOTED:
return HttpResponseRedirect(url)
form = QuestionForm(survey)(request.POST)
# invalid input
if not form.is_valid():
# no choice selected error - via session
sess_nv = request.session.get(
polls_settings.SURVEY_NO_CHOICE_COOKIE_NAME, [])
sess_nv.append(survey.id)
request.session[polls_settings.SURVEY_NO_CHOICE_COOKIE_NAME] = sess_nv
return HttpResponseRedirect(url)
# vote save
kwa = {}
if request.user.is_authenticated():
kwa['user'] = request.user
kwa['ip_address'] = request.META['REMOTE_ADDR']
survey.vote(form.cleaned_data['choice'], **kwa)
# just voted info session update
sess_jv = request.session.get(polls_settings.SURVEY_JUST_VOTED_COOKIE_NAME,
[])
sess_jv.append(survey.id)
request.session[polls_settings.SURVEY_JUST_VOTED_COOKIE_NAME] = sess_jv
response = HttpResponseRedirect(url)
# authenticated user vote - session update
if request.user.is_authenticated():
sess = request.session.get(polls_settings.SURVEY_COOKIE_NAME, [])
sess.append(survey.id)
request.session[polls_settings.SURVEY_COOKIE_NAME] = sess
# annonymous user vote - cookies update
else:
cook = request.COOKIES.get(polls_settings.SURVEY_COOKIE_NAME,
'').split(',')
if len(cook) > polls_settings.SURVEY_MAX_COOKIE_LENGTH:
cook = cook[1:]
cook.append(str(survey.id))
expires = datetime.strftime(
datetime.utcnow() +
timedelta(seconds=polls_settings.SURVEY_MAX_COOKIE_AGE),
"%a, %d-%b-%Y %H:%M:%S GMT")
response.set_cookie(polls_settings.SURVEY_COOKIE_NAME,
value=','.join(cook),
max_age=polls_settings.SURVEY_MAX_COOKIE_AGE,
expires=expires,
path='/',
domain=Site.objects.get_current().domain,
secure=None)
return response
def survey_vote(request, survey_id):
survey_ct = ContentType.objects.get_for_model(Survey)
survey = get_cached_object_or_404(survey_ct, pk=survey_id)
url = get_next_url(request)
# activity check
if not survey.current_activity_state == polls_settings.ACTIVITY_ACTIVE:
return HttpResponseRedirect(url)
# vote check
if survey_check_vote(request, survey) != polls_settings.USER_NOT_YET_VOTED:
return HttpResponseRedirect(url)
form = QuestionForm(survey)(request.POST)
# invalid input
if not form.is_valid():
# no choice selected error - via session
sess_nv = request.session.get(polls_settings.SURVEY_NO_CHOICE_COOKIE_NAME, [])
sess_nv.append(survey.id)
request.session[polls_settings.SURVEY_NO_CHOICE_COOKIE_NAME] = sess_nv
return HttpResponseRedirect(url)
# vote save
kwa = {}
if request.user.is_authenticated():
kwa['user'] = request.user
kwa['ip_address'] = request.META['REMOTE_ADDR']
survey.vote(form.cleaned_data['choice'], **kwa)
# just voted info session update
sess_jv = request.session.get(polls_settings.SURVEY_JUST_VOTED_COOKIE_NAME, [])
sess_jv.append(survey.id)
request.session[polls_settings.SURVEY_JUST_VOTED_COOKIE_NAME] = sess_jv
response = HttpResponseRedirect(url)
# authenticated user vote - session update
if request.user.is_authenticated():
sess = request.session.get(polls_settings.SURVEY_COOKIE_NAME, [])
sess.append(survey.id)
request.session[polls_settings.SURVEY_COOKIE_NAME] = sess
# annonymous user vote - cookies update
else:
cook = request.COOKIES.get(polls_settings.SURVEY_COOKIE_NAME, '').split(',')
if len(cook) > polls_settings.SURVEY_MAX_COOKIE_LENGTH:
cook = cook[1:]
cook.append(str(survey.id))
expires = datetime.strftime(datetime.utcnow() + timedelta(seconds=polls_settings.SURVEY_MAX_COOKIE_AGE), "%a, %d-%b-%Y %H:%M:%S GMT")
response.set_cookie(
polls_settings.SURVEY_COOKIE_NAME,
value=','.join(cook),
max_age=polls_settings.SURVEY_MAX_COOKIE_AGE,
expires=expires,
path='/',
domain=Site.objects.get_current().domain,
secure=None
)
return response
def results_export_view(self, request, contest_pk, extra_context=None, all_correct=False):
contest = get_cached_object_or_404(Contest, pk=contest_pk)
return self.results_export_response(request, contest, all_correct=all_correct)
