def render_submission_footer(self, request, submission):
super_footer = super(ScoresRevealContestControllerMixin, self). \
render_submission_footer(request, submission)
if not has_scores_reveal(submission.problem) or \
submission.kind != 'NORMAL' or submission.user is None:
return super_footer
scores_reveals = self.get_revealed_submissions(submission.user,
submission.problem_instance).count()
scores_reveals_limit = self.get_scores_reveals_limit(
submission.problem_instance)
scores_reveals_disable_time = self.get_scores_reveals_disable_time(
submission.problem_instance)
can_reveal, reason = self.can_reveal(request, submission)
return render_to_string('scoresreveal/submission_footer.html',
context_instance=RequestContext(request,
{'submission': submission_template_context(request,
submission.programsubmission),
'scores_reveals': scores_reveals,
'scores_reveals_limit': scores_reveals_limit,
'scores_reveals_disable_time': scores_reveals_disable_time,
'can_reveal': can_reveal,
'can_reveal_reason': reason})) + super_footer
def render_submission_footer(self, request, submission):
super_footer = super(ProgrammingContestController, self). \
render_submission_footer(request, submission)
queryset = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.filter(user=submission.user) \
.filter(problem_instance=submission.problem_instance) \
.exclude(pk=submission.pk) \
.order_by('-date') \
.select_related()
if not is_contest_admin(request):
cc = request.contest.controller
queryset = cc.filter_my_visible_submissions(request, queryset)
show_scores = bool(queryset.filter(score__isnull=False))
if not queryset.exists():
return super_footer
return super_footer + render_to_string(
'programs/other_submissions.html',
context_instance=RequestContext(request, {
'submissions': [submission_template_context(request, s)
for s in queryset],
'show_scores': show_scores,
'main_submission_id': submission.id,
'submissions_on_page': getattr(settings,
'SUBMISSIONS_ON_PAGE', 15)}))
def all_submissions_view(request):
submissions = []
if request.user.is_authenticated:
queryset = Submission.objects \
.filter(user=request.user) \
.order_by('-date') \
.select_related('user', 'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem')
for s in queryset:
request.contest = s.problem_instance.contest
submissions.append(submission_template_context(request, s))
request.contest = None
show_scores = any(s['can_see_score'] for s in submissions)
navbar_links = navbar_links_registry.template_context(request)
return TemplateResponse(
request, 'contests/my_submissions_all.html', {
'submissions': submissions,
'show_scores': show_scores,
'submissions_on_page': getattr(settings, 'SUBMISSIONS_ON_PAGE',
100),
'navbar_links': navbar_links
})
def _render_disqualification_reason(self, request, submission):
prev = super(SimilarityDisqualificationMixin, self) \
._render_disqualification_reason(request, submission)
if is_contest_admin(request):
q_expression = Q(submissions__submission=submission)
else:
# Do not split this filter as it spans many-to-many relationship
q_expression = Q(submissions__submission=submission,
submissions__guilty=True)
similarities = SubmissionsSimilarityGroup.objects \
.filter(q_expression) \
.select_related('submissions')
if not similarities:
return prev
submission_contexts = {}
for group in similarities:
for entry in group.submissions.all():
submission_contexts[entry.submission] = \
submission_template_context(request, entry.submission)
template = ('similarsubmits/programming_similar_submissions_admin.html'
if is_contest_admin(request) else
'similarsubmits/programming_similar_submissions.html')
context = RequestContext(request, {
'similarities': similarities,
'main_submission_id': submission.id,
'submission_contexts': submission_contexts,
})
return prev + render_to_string(template, context_instance=context)
def render_submission_footer(self, request, submission):
super_footer = super(ScoresRevealContestControllerMixin, self). \
render_submission_footer(request, submission)
if not has_scores_reveal(submission.problem) or \
submission.kind != 'NORMAL' or submission.user is None:
return super_footer
scores_reveals = self.get_revealed_submissions(
submission.user, submission.problem_instance).count()
scores_reveals_limit = self.get_scores_reveals_limit(
submission.problem_instance)
scores_reveals_disable_time = self.get_scores_reveals_disable_time(
submission.problem_instance)
can_reveal, reason = self.can_reveal(request, submission)
return render_to_string(
'scoresreveal/submission_footer.html',
context_instance=RequestContext(
request, {
'submission':
submission_template_context(request,
submission.programsubmission),
'scores_reveals':
scores_reveals,
'scores_reveals_limit':
scores_reveals_limit,
'scores_reveals_disable_time':
scores_reveals_disable_time,
'can_reveal':
can_reveal,
'can_reveal_reason':
reason
})) + super_footer
def problem_site_submissions(request, problem):
controller = problem.main_problem_instance.controller
if request.user.is_authenticated:
qs = controller.filter_my_visible_submissions(
request,
Submission.objects.filter(problem_instance=problem.
main_problem_instance).order_by('-date'),
)
else:
qs = []
submissions = [submission_template_context(request, s) for s in qs]
show_scores = any(s['can_see_score'] for s in submissions)
return TemplateResponse(
request,
'problems/submissions.html',
{
'submissions': submissions,
'submissions_on_page': getattr(settings, 'SUBMISSIONS_ON_PAGE',
100),
'show_scores': show_scores,
'inside_problem_view': True,
},
)
def render_submission_footer(self, request, submission):
super_footer = super(ProgrammingContestController, self). \
render_submission_footer(request, submission)
queryset = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.filter(user=submission.user) \
.filter(problem_instance=submission.problem_instance) \
.exclude(pk=submission.pk) \
.order_by('-date') \
.select_related()
if not is_contest_admin(request):
cc = request.contest.controller
queryset = cc.filter_my_visible_submissions(request, queryset)
show_scores = bool(queryset.filter(score__isnull=False))
can_admin = \
can_admin_problem_instance(request, submission.problem_instance)
if not queryset.exists():
return super_footer
return super_footer + render_to_string(
'programs/other_submissions.html',
request=request,
context={
'submissions':
[submission_template_context(request, s) for s in queryset],
'show_scores':
show_scores,
'can_admin':
can_admin,
'main_submission_id':
submission.id,
'submissions_on_page':
getattr(settings, 'SUBMISSIONS_ON_PAGE', 15)
})
def _render_disqualification_reason(self, request, submission):
prev = super(SimilarityDisqualificationMixin, self) \
._render_disqualification_reason(request, submission)
if is_contest_admin(request):
q_expression = Q(submissions__submission=submission)
else:
# Do not split this filter as it spans many-to-many relationship
q_expression = Q(submissions__submission=submission,
submissions__guilty=True)
similarities = SubmissionsSimilarityGroup.objects \
.filter(q_expression) \
.prefetch_related('submissions')
if not similarities:
return prev
submission_contexts = {}
for group in similarities:
for entry in group.submissions.all():
submission_contexts[entry.submission] = \
submission_template_context(request, entry.submission)
template = ('similarsubmits/programming_similar_submissions_admin.html'
if is_contest_admin(request) else
'similarsubmits/programming_similar_submissions.html')
context = RequestContext(
request, {
'similarities': similarities,
'main_submission_id': submission.id,
'submission_contexts': submission_contexts,
})
return prev + render_to_string(template, context_instance=context)
def render_submission(self, request, submission):
problem_instance = submission.problem_instance
if submission.kind == 'USER_OUTS':
# The comment includes safe string, because it is generated
# automatically (users can not affect it).
# Note that we temporarily assign a safestring object, because
# field type in model is originally a string.
submission.programsubmission.comment = \
mark_safe(submission.programsubmission.comment)
can_admin = \
can_admin_problem_instance(request, submission.problem_instance)
return render_to_string(
'programs/submission_header.html',
request=request,
context={
'submission':
submission_template_context(request,
submission.programsubmission),
'saved_diff_id':
request.session.get('saved_diff_id'),
'supported_extra_args':
problem_instance.controller.get_supported_extra_args(
submission),
'can_admin':
can_admin
})
def contest_dashboard_view(request, round_pk=None):
messages = messages_template_context(request, visible_messages(request))[
:NUMBER_OF_RECENT_ACTIONS]
queryset = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.order_by('-date') \
.select_related('user', 'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem')
ss = [submission_template_context(request, s) for s in
queryset[:NUMBER_OF_RECENT_ACTIONS]]
rtimes = list(rounds_times(request, request.contest).items())
rtimes.sort(key=lambda r_rt: r_rt[0].start_date)
if round_pk is None and len(rtimes) > 0:
# First active round, or last one if there are no active ones
round_pk = next(
((r, rt) for r, rt in rtimes if rt.is_active(request.timestamp)),
rtimes[-1])[0].pk
context = {
'round_times': rtimes,
'selected_round': None,
'records': messages,
'submissions': ss
}
if round_pk is not None:
context.update(get_round_context(request, round_pk))
return TemplateResponse(request, 'simpleui/contest/contest.html', context)
def my_submissions_view(request):
queryset = (
Submission.objects.filter(problem_instance__contest=request.contest)
.order_by('-date')
.select_related(
'user',
'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem',
)
)
controller = request.contest.controller
queryset = controller.filter_my_visible_submissions(request, queryset)
header = controller.render_my_submissions_header(request, queryset.all())
submissions = [submission_template_context(request, s) for s in queryset]
show_scores = any(s['can_see_score'] for s in submissions)
return TemplateResponse(
request,
'contests/my_submissions.html',
{
'header': header,
'submissions': submissions,
'show_scores': show_scores,
'submissions_on_page': getattr(settings, 'SUBMISSIONS_ON_PAGE', 100),
},
)
def render_submission(self, request, submission):
return render_to_string('programs/submission_header.html',
context_instance=RequestContext(request,
{'submission': submission_template_context(request,
submission.programsubmission),
'saved_diff_id': request.session.get('saved_diff_id'),
'supported_extra_args':
self.get_supported_extra_args(submission)}))
def main_page_view(request):
navbar_links = navbar_links_registry.template_context(request)
to_show = getattr(settings, 'NUM_RECENT_CONTESTS', 7)
rcontests = recent_contests(request)
contests = list(visible_contests(request).difference(rcontests))
contests.sort(key=lambda x: x.creation_date, reverse=True)
contests = (rcontests + contests)[:to_show]
submissions = []
show_scores = False
if request.user.is_authenticated:
queryset = Submission.objects.filter(
user=request.user).order_by('-date')
# current_contest = request.contest
#
# for s in queryset:
# request.contest = "lakdnasdn"#s.problem_instance.contest
# submissions.append(submission_template_context(request, s))
#
# request.contest = current_contest
to_show = getattr(settings, 'NUM_PANEL_SUBMISSIONS', 7)
# limit queryset size, because filtering all submissions is slow
queryset = queryset[:to_show]
limit_queryset_ids = [submission.id for submission in queryset]
queryset = Submission.objects.filter(
id__in=limit_queryset_ids).select_related(
'user',
'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem',
)
submissions_list = filter_my_all_visible_submissions(request, queryset)
if django.VERSION >= (1, 11):
submissions_list = submissions_list.order_by('-date')
else:
submissions_list.sort(reverse=True, key=lambda s: s.date)
submissions = [
submission_template_context(request, s) for s in submissions_list
]
show_scores = any(s['can_see_score'] for s in submissions)
context = {
'navbar_links': navbar_links,
'contests': contests,
'submissions': submissions,
'show_scores': show_scores,
}
return TemplateResponse(request, 'main-page.html', context)
def render_submission(self, request, submission):
if submission.kind != 'TESTRUN':
return super(TestRunContestControllerMixin, self) \
.render_submission(request, submission)
return render_to_string('testrun/submission_header.html',
context_instance=RequestContext(request,
{'submission': submission_template_context(request,
submission.programsubmission.testrunprogramsubmission),
'supported_extra_args':
self.get_supported_extra_args(submission)}))
def render_submission(self, request, submission):
if submission.kind != 'TESTRUN':
return super(TestRunContestControllerMixin, self) \
.render_submission(request, submission)
return render_to_string('testrun/submission_header.html',
context_instance=RequestContext(request,
{'submission': submission_template_context(request,
submission.programsubmission.testrunprogramsubmission),
'supported_extra_args':
self.get_supported_extra_args(submission)}))
def my_submissions_view(request, contest_id):
queryset = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.order_by('-date') \
.select_related()
controller = request.contest.controller
queryset = controller.filter_visible_submissions(request, queryset)
show_scores = bool(queryset.filter(score__isnull=False))
return TemplateResponse(request, 'contests/my_submissions.html',
{'submissions': [submission_template_context(request, s)
for s in queryset], 'show_scores': show_scores})
def contest_dashboard_view(request, round_pk=None):
if request.user.is_superuser:
return redirect('default_contest_view', contest_id=request.contest.id)
messages = messages_template_context(
request, visible_messages(request))[:NUMBER_OF_RECENT_ACTIONS]
queryset = (Submission.objects.filter(
problem_instance__contest=request.contest).order_by(
'-date').select_related(
'user',
'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem',
))
ss = [
submission_template_context(request, s)
for s in queryset[:NUMBER_OF_RECENT_ACTIONS]
]
rtimes = list(rounds_times(request, request.contest).items())
rtimes.sort(key=lambda r_rt: r_rt[0].start_date)
if round_pk is None and len(rtimes) > 0:
# First active round, or last one if there are no active ones
round_pk = next(
((r, rt) for r, rt in rtimes if rt.is_active(request.timestamp)),
rtimes[-1])[0].pk
context = {
'round_times':
rtimes,
'selected_round':
None,
'records':
messages,
'submissions':
ss,
'contest_dashboard_url_name':
'simpleui_contest_dashboard',
'public_contest':
isinstance(
request.contest.controller.registration_controller(),
PublicContestRegistrationController,
),
}
if round_pk is not None:
context.update(get_round_context(request, round_pk))
return TemplateResponse(request, 'simpleui/contest/contest.html', context)
def get_last_submissions(request):
queryset = Submission.objects \
.filter(user=request.user) \
.order_by('-date') \
.select_related('problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem')[:5]
submissions = [submission_template_context(request, s) for s in queryset]
return TemplateResponse(request, "contests/my_submissions_table.html",
{'submissions': submissions, 'show_scores': True,
'hide_reports': True})
def render_submission(self, request, submission):
problem_instance = submission.problem_instance
can_admin = \
can_admin_problem_instance(request, submission.problem_instance)
context = {
'submission':
submission_template_context(request, submission.quizsubmission),
'supported_extra_args':
problem_instance.controller.get_supported_extra_args(submission),
'can_admin': can_admin
}
return render_to_string('quizzes/submission_header.html',
request=request,
context=context)
def render_submission(self, request, submission):
problem_instance = submission.problem_instance
can_admin = \
can_admin_problem_instance(request, submission.problem_instance)
context = {
'submission':
submission_template_context(request, submission.quizsubmission),
'supported_extra_args':
problem_instance.controller.get_supported_extra_args(submission),
'can_admin': can_admin
}
return render_to_string('quizzes/submission_header.html',
request=request,
context=context)
def render_submission_disqualifiaction(self, request, submission):
"""Renders the disqualification reason of the given submission to HTML.
"""
reason = self._render_disqualification_reason(request, submission)
template = 'disqualification/generic.html'
if is_contest_admin(request):
template = 'disqualification/generic_admin.html'
return render_to_string(template,
context_instance=RequestContext(request, {
'submission': submission_template_context(request,
submission.programsubmission),
'reason': reason,
}))
def render_submission(self, request, submission):
if submission.kind != 'TESTRUN' or \
not is_zeus_problem(submission.problem_instance.problem):
return super(ZeusContestControllerMixin, self) \
.render_submission(request, submission)
if not isinstance(submission, ZeusTestRunProgramSubmission):
submission = ZeusTestRunProgramSubmission.objects \
.get(id=submission.id)
return render_to_string('zeus/submission_header.html',
context_instance=RequestContext(request,
{'submission': submission_template_context(request,
submission),
'supported_extra_args':
self.get_supported_extra_args(submission)}))
def my_submissions_view(request, contest_id):
queryset = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.order_by('-date') \
.select_related()
controller = request.contest.controller
queryset = controller.filter_my_visible_submissions(request, queryset)
submissions = [submission_template_context(request, s) for s in queryset]
show_scores = any(s['can_see_score'] for s in submissions)
return TemplateResponse(
request, 'contests/my_submissions.html', {
'submissions': submissions,
'show_scores': show_scores,
'submissions_on_page': getattr(settings, 'SUBMISSIONS_ON_PAGE',
100)
})
def render_submission(self, request, submission):
if submission.kind != 'TESTRUN':
return super(TestRunContestControllerMixin, self) \
.render_submission(request, submission)
sbm_testrun = submission.programsubmission. \
testrunprogramsubmission
return render_to_string('testrun/submission-header.html',
request=request,
context={
'submission': submission_template_context(request,
sbm_testrun),
'supported_extra_args':
self.get_supported_extra_args(submission),
'input_is_zip': is_zipfile(sbm_testrun.input_file)})
def _render_disqualification_reason(self, request, submission):
"""Renders part with reason of the given submission disqualification.
This method is only used internally.
"""
reasons = Disqualification.objects.filter(submission=submission)
if not is_contest_admin(request):
reasons = reasons.filter(guilty=True)
if not reasons:
return mark_safe("")
return render_to_string('disqualification/custom.html',
context_instance=RequestContext(request, {
'submission': submission_template_context(request,
submission.programsubmission),
'reasons': reasons,
}))
def my_submissions_view(request):
queryset = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.order_by('-date') \
.select_related('user', 'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem')
controller = request.contest.controller
queryset = controller.filter_my_visible_submissions(request, queryset)
header = controller.render_my_submissions_header(request, queryset.all())
submissions = [submission_template_context(request, s) for s in queryset]
show_scores = any(s['can_see_score'] for s in submissions)
return TemplateResponse(request, 'contests/my_submissions.html',
{'header': header,
'submissions': submissions, 'show_scores': show_scores,
'submissions_on_page': getattr(settings, 'SUBMISSIONS_ON_PAGE', 100)})
def problem_site_submissions(request, problem):
controller = problem.main_problem_instance.controller
if request.user.is_authenticated:
qs = controller.filter_my_visible_submissions(request,
Submission.objects
.filter(problem_instance=problem.main_problem_instance)
.order_by('-date'))
else:
qs = []
submissions = [submission_template_context(request, s) for s in qs]
show_scores = any(s['can_see_score'] for s in submissions)
return TemplateResponse(request, 'problems/submissions.html',
{'submissions': submissions,
'submissions_on_page': getattr(settings, 'SUBMISSIONS_ON_PAGE', 100),
'show_scores': show_scores,
'inside_problem_view': True})
def contest_dashboard_view(request, contest_id):
top_links = grouper(3, top_links_registry.template_context(request))
submissions = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.order_by('-date').select_related()
controller = request.contest.controller
submissions = controller.filter_visible_submissions(request, submissions)
submissions = submissions[:getattr(settings, 'NUM_DASHBOARD_SUBMISSIONS', 8)]
submissions = [submission_template_context(request, s) for s in submissions]
show_scores = bool(s for s in submissions if s.score is not None)
messages = messages_template_context(request, visible_messages(request))
context = {
'top_links': top_links,
'submissions': submissions,
'records': messages,
'show_scores': show_scores
}
return TemplateResponse(request, 'dashboard/dashboard.html', context)
def render_submission(self, request, submission):
if submission.kind != 'TESTRUN' or \
not is_zeus_problem(submission.problem_instance.problem):
return super(ZeusContestControllerMixin, self) \
.render_submission(request, submission)
if not isinstance(submission, ZeusTestRunProgramSubmission):
submission = ZeusTestRunProgramSubmission.objects \
.get(id=submission.id)
return render_to_string(
'zeus/submission_header.html',
context_instance=RequestContext(
request, {
'submission':
submission_template_context(request, submission),
'supported_extra_args':
self.get_supported_extra_args(submission)
}))
def render_submission(self, request, submission):
problem_instance = submission.problem_instance
if submission.kind == 'USER_OUTS':
# The comment includes safe string, because it is generated
# automatically (users can not affect it).
# Note that we temporarily assign a safestring object, because
# field type in model is originally a string.
submission.programsubmission.comment = \
mark_safe(submission.programsubmission.comment)
return render_to_string('programs/submission_header.html',
context_instance=RequestContext(request,
{'submission': submission_template_context(request,
submission.programsubmission),
'saved_diff_id': request.session.get('saved_diff_id'),
'supported_extra_args':
problem_instance.controller.get_supported_extra_args(
submission)}))
def render_submission_disqualifiaction(self, request, submission):
"""Renders the disqualification reason of the given submission to HTML.
"""
reason = self._render_disqualification_reason(request, submission)
template = 'disqualification/generic.html'
if is_contest_admin(request):
template = 'disqualification/generic-admin.html'
return render_to_string(template,
request=request,
context={
'submission':
submission_template_context(
request, submission.programsubmission),
'reason':
reason,
})
def main_page_view(request):
navbar_links = navbar_links_registry.template_context(request)
to_show = getattr(settings, 'NUM_RECENT_CONTESTS', 7)
rcontests = recent_contests(request)
contests = list(visible_contests(request).difference(rcontests))
contests.sort(key=lambda x: x.creation_date, reverse=True)
contests = (rcontests + contests)[:to_show]
submissions = []
show_scores = False
if request.user.is_authenticated:
queryset = Submission.objects \
.filter(user=request.user) \
.order_by('-date') \
.select_related('user', 'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem')
# current_contest = request.contest
#
# for s in queryset:
# request.contest = "lakdnasdn"#s.problem_instance.contest
# submissions.append(submission_template_context(request, s))
#
# request.contest = current_contest
submissions = [
submission_template_context(request, s) for s in queryset
]
to_show = getattr(settings, 'NUM_PANEL_SUBMISSIONS', 7)
submissions = submissions[:to_show]
show_scores = any(s['can_see_score'] for s in submissions)
context = {
'navbar_links': navbar_links,
'contests': contests,
'submissions': submissions,
'show_scores': show_scores,
}
return TemplateResponse(request, 'main-page.html', context)
def submissions_fragment(request):
if not request.user.is_authenticated():
return None
submissions = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.order_by('-date').select_related()
cc = request.contest.controller
submissions = cc.filter_my_visible_submissions(request, submissions)
submissions = \
submissions[:getattr(settings, 'NUM_DASHBOARD_SUBMISSIONS', 8)]
if not submissions:
return None
submissions = [
submission_template_context(request, s) for s in submissions
]
show_scores = any(s['can_see_score'] for s in submissions)
context = {'submissions': submissions, 'show_scores': show_scores}
return render_to_string('dashboard/dashboard-submissions.html',
context_instance=RequestContext(request, context))
def _render_disqualification_reason(self, request, submission):
"""Renders part with reason of the given submission disqualification.
This method is only used internally.
"""
reasons = Disqualification.objects.filter(submission=submission)
if not is_contest_admin(request):
reasons = reasons.filter(guilty=True)
if not reasons:
return mark_safe("")
return render_to_string('disqualification/reason.html',
request=request,
context={
'submission':
submission_template_context(
request, submission.programsubmission),
'reasons':
reasons,
})
def submissions_fragment(request):
if not request.user.is_authenticated():
return None
submissions = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.order_by('-date').select_related()
cc = request.contest.controller
submissions = cc.filter_my_visible_submissions(request, submissions)
submissions = \
submissions[:getattr(settings, 'NUM_DASHBOARD_SUBMISSIONS', 8)]
if not submissions:
return None
submissions = [submission_template_context(request, s)
for s in submissions]
show_scores = any(s['can_see_score'] for s in submissions)
context = {
'submissions': submissions,
'show_scores': show_scores
}
return render_to_string('dashboard/submissions.html',
context_instance=RequestContext(request, context))
def render_submission_footer(self, request, submission):
super_footer = super(ProgrammingProblemController,
self).render_submission_footer(
request, submission)
queryset = (Submission.objects.filter(
problem_instance__contest=request.contest).filter(
user=submission.user).filter(
problem_instance=submission.problem_instance).exclude(
pk=submission.pk).order_by('-date').select_related())
if not submission.problem_instance.contest == request.contest:
raise SuspiciousOperation
if not is_contest_basicadmin(request) and request.contest:
cc = request.contest.controller
queryset = cc.filter_my_visible_submissions(request, queryset)
elif not request.contest and not is_contest_basicadmin(request):
pc = submission.problem_instance.controller
queryset = pc.filter_my_visible_submissions(request, queryset)
show_scores = bool(queryset.filter(score__isnull=False))
can_admin = can_admin_problem_instance(request,
submission.problem_instance)
if not queryset.exists():
return super_footer
return super_footer + render_to_string(
'programs/other_submissions.html',
request=request,
context={
'submissions':
[submission_template_context(request, s) for s in queryset],
'show_scores':
show_scores,
'can_admin':
can_admin,
'main_submission_id':
submission.id,
'submissions_on_page':
getattr(settings, 'SUBMISSIONS_ON_PAGE', 15),
},
)
def render_submission_footer(self, request, submission):
super_footer = super(QuizProblemController, self). \
render_submission_footer(request, submission)
queryset = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.filter(user=submission.user) \
.filter(problem_instance=submission.problem_instance) \
.exclude(pk=submission.pk) \
.order_by('-date') \
.select_related()
if not submission.problem_instance.contest == request.contest:
raise SuspiciousOperation
if not is_contest_basicadmin(request) and request.contest:
cc = request.contest.controller
queryset = cc.filter_my_visible_submissions(request, queryset)
elif not request.contest and not is_contest_basicadmin(request):
queryset = queryset.filter(user=request.user, date__lte=request.timestamp) \
.exclude(kind='IGNORED_HIDDEN')
show_scores = bool(queryset.filter(score__isnull=False))
can_admin = \
can_admin_problem_instance(request, submission.problem_instance)
if not queryset.exists():
return super_footer
return super_footer + render_to_string(
'quizzes/other_submissions.html',
request=request,
context={
'submissions':
[submission_template_context(request, s) for s in queryset],
'show_scores':
show_scores,
'can_admin':
can_admin,
'main_submission_id':
submission.id,
'submissions_on_page':
getattr(settings, 'SUBMISSIONS_ON_PAGE', 15)
})
def problem_site_submissions(request, problem):
controller = problem.main_problem_instance.controller
if request.user.is_authenticated():
qs = controller.filter_my_visible_submissions(
request, Submission.objects.filter(problem_instance=problem.main_problem_instance).order_by("-date")
)
else:
qs = []
submissions = [submission_template_context(request, s) for s in qs]
show_scores = any(s["can_see_score"] for s in submissions)
return TemplateResponse(
request,
"problems/submissions.html",
{
"submissions": submissions,
"submissions_on_page": getattr(settings, "SUBMISSIONS_ON_PAGE", 100),
"show_scores": show_scores,
"inside_problem_view": True,
},
)
def contest_dashboard_view(request, contest_id):
top_links = grouper(3, top_links_registry.template_context(request))
submissions = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.order_by('-date').select_related()
cc = request.contest.controller
submissions = cc.filter_my_visible_submissions(request, submissions)
submissions = \
submissions[:getattr(settings, 'NUM_DASHBOARD_SUBMISSIONS', 8)]
submissions = [
submission_template_context(request, s) for s in submissions
]
show_scores = bool(s for s in submissions if s.score is not None)
messages = messages_template_context(request, visible_messages(request))
messages = messages[:getattr(settings, 'NUM_DASHBOARD_MESSAGES', 8)]
context = {
'top_links': top_links,
'submissions': submissions,
'records': messages,
'show_scores': show_scores
}
return TemplateResponse(request, 'dashboard/dashboard.html', context)
def all_submissions_view(request):
submissions = []
if request.user.is_authenticated:
queryset = Submission.objects.filter(user=request.user).select_related(
'user',
'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem',
)
submissions_list = filter_my_all_visible_submissions(request, queryset)
if django.VERSION >= (1, 11):
submissions_list = submissions_list.order_by('-date')
else:
submissions_list.sort(reverse=True, key=lambda s: s.date)
for s in submissions_list:
request.contest = s.problem_instance.contest
submissions.append(submission_template_context(request, s))
request.contest = None
show_scores = any(s['can_see_score'] for s in submissions)
navbar_links = navbar_links_registry.template_context(request)
return TemplateResponse(
request,
'contests/my_submissions_all.html',
{
'submissions': submissions,
'show_scores': show_scores,
'submissions_on_page': getattr(settings, 'SUBMISSIONS_ON_PAGE',
100),
'navbar_links': navbar_links,
},
)
def contest_dashboard_view(request, round_pk=None):
messages = messages_template_context(
request, visible_messages(request))[:NUMBER_OF_RECENT_ACTIONS]
queryset = Submission.objects \
.filter(problem_instance__contest=request.contest) \
.order_by('-date') \
.select_related('user', 'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem')
ss = [
submission_template_context(request, s)
for s in queryset[:NUMBER_OF_RECENT_ACTIONS]
]
rtimes = rounds_times(request).items()
rtimes.sort(key=lambda (r, rt): r.start_date)
if round_pk is None and len(rtimes) > 0:
# First active round, or last one if there are no active ones
round_pk = next(
((r, rt) for r, rt in rtimes if rt.is_active(request.timestamp)),
rtimes[-1])[0].pk
context = {
'round_times': rtimes,
'selected_round': None,
'records': messages,
'submissions': ss
}
if round_pk is not None:
context.update(get_round_context(request, round_pk))
return TemplateResponse(request, 'simpleui/contest/contest.html', context)
def all_submissions_view(request):
submissions = []
if request.user.is_authenticated:
queryset = Submission.objects \
.filter(user=request.user) \
.order_by('-date') \
.select_related('user', 'problem_instance',
'problem_instance__contest',
'problem_instance__round',
'problem_instance__problem')
for s in queryset:
request.contest = s.problem_instance.contest
submissions.append(submission_template_context(request, s))
request.contest = None
show_scores = any(s['can_see_score'] for s in submissions)
navbar_links = navbar_links_registry.template_context(request)
return TemplateResponse(request, 'contests/my_submissions_all.html',
{'submissions': submissions, 'show_scores': show_scores,
'submissions_on_page': getattr(settings, 'SUBMISSIONS_ON_PAGE', 100),
'navbar_links': navbar_links})
def render_submission(self, request, submission):
return render_to_string('programs/submission_header.html',
context_instance=RequestContext(request,
{'submission': submission_template_context(request,
submission.programsubmission)}))
