def result_details(request, context):
quiz = context['object']
if not quiz.has_correct_answers:
raise Http404
results = request.GET.get(RESULT_FIELD, '').split('|')
if len(results) != len(quiz.questions):
raise Http404
questions = []
for question, q_res in zip(quiz.questions, results):
q_id, id_list = q_res.split(':')
choices = question.choices
if question.allow_multiple:
cl = set(id_list.split(','))
for ch in choices:
if str(ch.id) in cl:
ch.chosen = True
else:
for ch in choices:
if str(ch.id) == id_list:
ch.chosen = True
break
questions.append((question, choices))
context['questions'] = questions
return render_to_response(get_templates_from_publishable(
'result_detail.html', context['object']),
context,
context_instance=RequestContext(request))
def done(self, request, form_list):
points = 0
results = []
for question, f in zip(self.quiz.questions, form_list):
if not question.allow_no_choice:
if question.allow_multiple:
points += sum(c.points for c in f.cleaned_data['choice'])
results.append('%d:%s' % (question.id, ','.join(
str(c.id) for c in f.cleaned_data['choice'])))
else:
points += f.cleaned_data['choice'].points
results.append('%d:%s' %
(question.id, f.cleaned_data['choice'].id))
results = '|'.join(results)
result = self.quiz.get_result(points)
result.count += 1
result.save()
self.extra_context.update({
'result':
result,
'points':
points,
'results':
results,
'result_field':
RESULT_FIELD,
'result_action':
self.quiz.get_absolute_url() + slugify(_('results')) + '/'
})
return render_to_response(get_templates_from_publishable(
'result.html', self.extra_context['object']),
self.extra_context,
context_instance=RequestContext(request))
def contest_finish(request, context, qforms, contestant_form):
contest = context['object']
email = contestant_form.cleaned_data['email']
if Contestant.objects.filter(email=email, contest=contest).count() > 0:
context.update({
'duplicate' : True,
'forms' : qforms,
'contestant_form' : contestant_form,
})
return render_to_response(
get_templates_from_publishable('form.html', context['object']),
context,
context_instance=RequestContext(request)
)
choices = '|'.join(
'%d:%s' % (
question.id,
question.allow_multiple and ','.join(str(c.id) for c in sorted(f.cleaned_data['choice'], key=lambda ch: ch.id)) or f.cleaned_data['choice'].id)
for question, f in sorted(qforms, key=lambda q: q[0].id)
)
c = Contestant(
contest=contest,
choices=choices,
**contestant_form.cleaned_data
)
if request.user.is_authenticated():
c.user = request.user
c.save()
return HttpResponseRedirect(contest.get_absolute_url() + slugify(ugettext('result')) + u'/')
def done(self, request, form_list):
points = 0
results = []
for question, f in zip(self.quiz.questions, form_list):
if not question.allow_no_choice:
if question.allow_multiple:
points += sum(c.points for c in f.cleaned_data['choice'])
results.append('%d:%s' % (question.id, ','.join(str(c.id) for c in f.cleaned_data['choice'])))
else:
points += f.cleaned_data['choice'].points
results.append('%d:%s' % (question.id, f.cleaned_data['choice'].id))
results = '|'.join(results)
result = self.quiz.get_result(points)
result.count += 1
result.save()
self.extra_context.update(
{
'result' : result,
'points' : points,
'results' : results,
'result_field': RESULT_FIELD,
'result_action' : self.quiz.get_absolute_url() + slugify(_('results')) + '/'
}
)
return render_to_response(
get_templates_from_publishable('result.html', self.extra_context['object']),
self.extra_context,
context_instance=RequestContext(request)
)
def result_details(request, context):
quiz = context['object']
if not quiz.has_correct_answers:
raise Http404
results = request.GET.get(RESULT_FIELD, '').split('|')
if len(results) != len(quiz.questions):
raise Http404
questions = []
for question, q_res in zip(quiz.questions, results):
q_id, id_list = q_res.split(':')
choices = question.choices
if question.allow_multiple:
cl = set(id_list.split(','))
for ch in choices:
if str(ch.id) in cl:
ch.chosen = True
else:
for ch in choices:
if str(ch.id) == id_list:
ch.chosen = True
break
questions.append((question, choices))
context['questions'] = questions
return render_to_response(
get_templates_from_publishable('result_detail.html', context['object']),
context,
context_instance=RequestContext(request)
)
def add_child(request, context):
data = None
if request.method == 'POST':
data = request.POST
wiki = None
wform = WikiForm(context['object'], data)
if wform.is_valid():
wiki = wform.save(commit=False)
sform = SubmissionForm(wiki, request.user, data)
if sform.is_valid() and wform.is_valid():
wiki.save()
submission = sform.save()
# pre-approve moderator submissions
if wiki_settings.IS_MODERATOR_FUNC(request.user):
submission.approve(request.user)
return redirect(wiki)
return redirect(context['object'])
context['wiki_form'] = wform
context['submission_form'] = sform
return TemplateResponse(
request,
get_templates_from_publishable('child_form.html', context['object']),
context
)
def contest_finish(request, context, qforms, contestant_form):
contest = context['object']
email = contestant_form.cleaned_data['email']
if Contestant.objects.filter(email=email, contest=contest).count() > 0:
context.update({
'duplicate': True,
'forms': qforms,
'contestant_form': contestant_form,
})
return render_to_response(get_templates_from_publishable(
'form.html', context['object']),
context,
context_instance=RequestContext(request))
choices = '|'.join(
'%d:%s' % (question.id, question.allow_multiple and ','.join(
str(c.id)
for c in sorted(f.cleaned_data['choice'], key=lambda ch: ch.id))
or f.cleaned_data['choice'].id)
for question, f in sorted(qforms, key=lambda q: q[0].id))
c = Contestant(contest=contest,
choices=choices,
**contestant_form.cleaned_data)
if request.user.is_authenticated():
c.user = request.user
c.save()
return HttpResponseRedirect(contest.get_absolute_url() +
slugify(ugettext('result')) + u'/')
def get_result(request, context, choice):
quiz = context['object']
try:
context['result'] = quiz.results[int(choice)]
except KeyError:
raise Http404()
template_name = 'quiz_result.html'
if request.is_ajax():
template_name = 'quiz_result_async.html'
return TemplateResponse(request, get_templates_from_publishable(template_name, quiz), context)
def get_result(request, context, choice):
quiz = context['object']
try:
context['result'] = quiz.results[int(choice)]
except KeyError:
raise Http404()
template_name = 'quiz_result.html'
if request.is_ajax():
template_name = 'quiz_result_async.html'
return TemplateResponse(
request, get_templates_from_publishable(template_name, quiz), context)
def submission_detail(request, context, submission_id):
try:
submission = context['object'].history.get(pk=submission_id)
except Submission.DoesNotExist:
raise Http404()
context['submission'] = submission
return TemplateResponse(
request,
get_templates_from_publishable('submission.html', context['object']),
context
)
def detail(request, category, url_remainder=''):
path = category.split('/')
# construct all possible tree_paths and get their IDs from redis
part = []
pipe = redis.pipeline()
for p in path:
part.append(p)
pipe.get(REDIS_KEY % '/'.join(part))
ids = pipe.execute()
# no IDs -> 404
if not any(ids):
raise Http404()
# get the last ID == the most specific wiki object
id = filter(None, ids)[-1]
wiki = get_cached_object(Wiki, pk=id)
if not (wiki.is_published() or wiki_settings.IS_MODERATOR_FUNC(request.user)):
# future publish, render if accessed by moderator
raise Http404()
# treat the rest as part of custom_urls part
leftover = category[len(wiki.tree_path):]
object_rendering.send(sender=Wiki, request=request, category=wiki.category, publishable=wiki)
context = {
'category': wiki.category,
'object': wiki,
'content_type': wiki.content_type,
}
# custom urls
if leftover or url_remainder:
url_remainder = ('%s/%s' % (leftover, url_remainder)). strip('/') + '/'
return custom_urls.resolver.call_custom_view(request, wiki, url_remainder, context)
# ella API
response = render_as_api(request, wiki)
if response:
return response
# custom detail
if custom_urls.resolver.has_custom_detail(wiki):
return custom_urls.resolver.call_custom_detail(request, context)
object_rendered.send(sender=Wiki, request=request, category=wiki.category, publishable=wiki)
return TemplateResponse(request, get_templates_from_publishable('object.html', wiki), context)
def paginated_view(request, context):
qset = getattr(context['object'], attr_name)()
paginator = Paginator(qset, paginate_by)
try:
page = paginator.page(request.GET.get('p', 1))
except InvalidPage:
raise Http404()
context.update({
'page': page,
'object_list': page.object_list,
})
return TemplateResponse(
request,
get_templates_from_publishable(template_name, context['object']),
context
)
def edit(request, context):
data = None
if request.method == 'POST':
data = request.POST
form = SubmissionForm(context['object'], request.user, data)
if form.is_valid():
submission = form.save()
# pre-approve moderator submissions
if wiki_settings.IS_MODERATOR_FUNC(request.user):
submission.approve(request.user)
return redirect(context['object'])
context['form'] = form
return TemplateResponse(
request,
get_templates_from_publishable('submission_form.html', context['object']),
context
)
def contest_vote(request, context):
contest = context['object']
forms = []
forms_are_valid = True
# question forms
for question in contest.questions:
form = QuestionForm(question)(request.POST or None, prefix=str(question.id))
if not form.is_valid():
forms_are_valid = False
forms.append((question, form))
# contestant form
initial = {}
if request.user.is_authenticated():
initial['name'] = request.user.first_name
initial['surname'] = request.user.last_name
initial['email'] = request.user.email
contestant_form = ContestantForm(request.POST or None, initial=initial)
if not contestant_form.is_valid():
forms_are_valid = False
# saving contestant
if forms_are_valid and contest.is_active():
return contest_finish(request, context, forms, contestant_form)
context.update({
'forms' : forms,
'contestant_form' : contestant_form,
'activity_not_yet_active' : polls_settings.ACTIVITY_NOT_YET_ACTIVE,
'activity_active' : polls_settings.ACTIVITY_ACTIVE,
'activity_closed' : polls_settings.ACTIVITY_CLOSED
})
return render_to_response(
get_templates_from_publishable('form.html', context['object']),
context,
context_instance=RequestContext(request)
)
def contest_vote(request, context):
contest = context['object']
forms = []
forms_are_valid = True
# question forms
for question in contest.questions:
form = QuestionForm(question)(request.POST or None,
prefix=str(question.id))
if not form.is_valid():
forms_are_valid = False
forms.append((question, form))
# contestant form
initial = {}
if request.user.is_authenticated():
initial['name'] = request.user.first_name
initial['surname'] = request.user.last_name
initial['email'] = request.user.email
contestant_form = ContestantForm(request.POST or None, initial=initial)
if not contestant_form.is_valid():
forms_are_valid = False
# saving contestant
if forms_are_valid and contest.is_active():
return contest_finish(request, context, forms, contestant_form)
context.update({
'forms': forms,
'contestant_form': contestant_form,
'activity_not_yet_active': polls_settings.ACTIVITY_NOT_YET_ACTIVE,
'activity_active': polls_settings.ACTIVITY_ACTIVE,
'activity_closed': polls_settings.ACTIVITY_CLOSED
})
return render_to_response(get_templates_from_publishable(
'form.html', context['object']),
context,
context_instance=RequestContext(request))
def get_template_names(self):
template_name = self.template_name
if self.request.is_ajax():
template_name = self.ajax_template_name
return get_templates_from_publishable(template_name, self.contest)
def get_template(self, step):
return get_templates_from_publishable('step.html', self.extra_context['object'])
def contest_conditions(request, context):
return render_to_response(
get_templates_from_publishable('conditions.html', context['object']),
context,
context_instance=RequestContext(request)
)
def get_template(self, name, context):
return get_templates_from_publishable(name, context['object'])
def get_template(self, step):
return get_templates_from_publishable('step.html',
self.extra_context['object'])
def get_template(self, name, context):
obj = context['object']
if hasattr(obj, 'get_templates'):
return obj.get_templates(name)
return get_templates_from_publishable(name, obj)
def gallery_item_detail(request, context, item_slug=None, url_remainder=None):
'''
Returns ``GalleryItem`` object by its slug or first one (given by
``GalleryItem``.``order``) from ``Gallery``.
'''
gallery = context['object']
item_sorted_dict = gallery.items
item_sorted_dict_values = list(item_sorted_dict.values())
count = len(item_sorted_dict)
count_str = ungettext('%(count)d object total', '%(count)d objects total',
count) % {'count': count}
next = None
previous = None
if count == 0:
# TODO: log empty gallery
raise Http404()
if item_slug is None:
item = item_sorted_dict_values[0]
if count > 1:
next = item_sorted_dict_values[1]
position = 1
else:
try:
item = item_sorted_dict[item_slug]
except KeyError:
raise Http404()
item_index = item_sorted_dict_values.index(item)
if item_index > 0:
previous = item_sorted_dict_values[item_index - 1]
if (item_index + 1) < count:
next = item_sorted_dict_values[item_index + 1]
position = item_index + 1
context.update({
'gallery': gallery,
'item': item,
'item_list': item_sorted_dict_values,
'next': next,
'previous': previous,
'count': count,
'count_str': count_str,
'position': position,
'on_item_page': item_slug is not None,
})
if url_remainder:
context['object'] = context['item']
return custom_urls.resolver.call_custom_view(request, gallery, url_remainder, context)
if request.is_ajax():
template_name = "item-ajax.html"
else:
template_name = "item.html"
response = TemplateResponse(
request,
get_templates_from_publishable(template_name, context['object']),
context,
)
object_rendered.send(sender=context['object'].__class__, request=request, category=context['category'], publishable=context['object'])
patch_vary_headers(response, ('X-Requested-With',))
return response
def gallery_item_detail(request, context, item_slug=None, url_remainder=None):
'''
Returns ``GalleryItem`` object by its slug or first one (given by
``GalleryItem``.``order``) from ``Gallery``.
'''
gallery = context['object']
item_sorted_dict = gallery.items
count = len(item_sorted_dict)
count_str = ungettext('%(count)d object total', '%(count)d objects total',
count) % {'count': count}
next = None
previous = None
if count == 0:
# TODO: log empty gallery
raise Http404()
if item_slug is None:
item = item_sorted_dict.value_for_index(0)
if count > 1:
next = item_sorted_dict.value_for_index(1)
position = 1
else:
try:
item = item_sorted_dict[item_slug]
except KeyError:
# check if flag is set then 301 to the main gallery url else 404 since slug was not found
GALLERY_REDIRECT_ENABLED = getattr(settings, 'GALLERY_REDIRECT_ENABLED', False)
if GALLERY_REDIRECT_ENABLED:
return redirect(gallery.get_absolute_url(), permanent=True)
raise Http404()
item_index = item_sorted_dict.keyOrder.index(item_slug)
if item_index > 0:
previous = item_sorted_dict.value_for_index(item_index - 1)
if (item_index + 1) < count:
next = item_sorted_dict.value_for_index(item_index + 1)
position = item_index + 1
context.update({
'gallery': gallery,
'item': item,
'item_list': item_sorted_dict.values(),
'next': next,
'previous': previous,
'count': count,
'count_str': count_str,
'position': position,
'on_item_page': item_slug is not None,
})
if url_remainder:
context['object'] = context['item']
return custom_urls.resolver.call_custom_view(request, gallery, url_remainder, context)
if request.is_ajax():
template_name = "item-ajax.html"
else:
template_name = "item.html"
response = TemplateResponse(
request,
get_templates_from_publishable(template_name, context['object']),
context,
)
object_rendered.send(sender=context['object'].__class__, request=request, category=context['category'], publishable=context['object'])
patch_vary_headers(response, ('X-Requested-With',))
return response
def get_templates(self, name):
return get_templates_from_publishable(name, self.gallery)
from ella.utils.timezone import now
from ella_flatcomments.models import CommentList, FlatComment
from ella_flatcomments.conf import comments_settings
from ella_flatcomments.forms import FlatCommentMultiForm
from ella_flatcomments.utils import show_reversed
from ella_flatcomments.signals import comment_updated
mod_required = user_passes_test(comments_settings.IS_MODERATOR_FUNC)
def get_template(name, obj=None, async=False):
if async:
name = '%s_async.%s' % tuple(name.rsplit('.', 1))
if hasattr(obj, 'get_templates'):
return obj.get_templates(name)
return get_templates_from_publishable(name, obj)
def list_comments(request, context, reverse=None):
if reverse is None:
reverse = show_reversed(request)
clist = CommentList.for_object(context['object'], reverse)
paginator = Paginator(clist, comments_settings.PAGINATE_BY)
try:
p = request.GET.get('p', 1)
if p == 'last':
context['page'] = paginator.page(paginator.num_pages)
else:
context['page'] = paginator.page(p)
except (PageNotAnInteger, EmptyPage):
raise Http404()
def contest_conditions(request, context):
return render_to_response(get_templates_from_publishable(
'conditions.html', context['object']),
context,
context_instance=RequestContext(request))
