def test_side_menus_registry(self):
admin = User.objects.get(username='******')
user = User.objects.get(username='******')
old_keys = side_pane_menus_registry.keys
old_items = side_pane_menus_registry.items
side_pane_menus_registry.keys = []
side_pane_menus_registry.items = []
try:
side_pane_menus_registry.register(menu_registry, order=200)
admin_menu_registry = MenuRegistry("Admin Menu", is_superuser)
side_pane_menus_registry.register(admin_menu_registry, order=100)
menu_registry.register('test',
'Test Menu Item',
lambda request: '/test_menu_link',
order=2)
admin_menu_registry.register('test_admin',
'Test Admin Item',
lambda request: '/spam',
order=100)
response = self._render_menu(user=user)
self.assertIn('class="contesticon"', response)
self.assertNotIn('User Menu', response)
self.assertNotIn('Admin Menu', response)
response = self._render_menu(user=admin)
self.assertNotIn('class="contesticon"', response)
self.assertIn('User Menu', response)
self.assertIn('Admin Menu', response)
self.assertLess(response.index('Test Admin Item'),
response.index('Test Menu Item'))
finally:
side_pane_menus_registry.keys = old_keys
side_pane_menus_registry.items = old_items
def test_menu_item_attrs_escape(self):
menu_registry.register('test', 'Test Menu',
lambda request: '/test_link',
attrs={'name<>\'"&': 'value<>\'"&'})
response = self._render_menu()
self.assertIn('name<>'"&='
'"value<>'"&"', response)
def test_side_menus_registry(self):
admin = User.objects.get(username='******')
user = User.objects.get(username='******')
old_keys = side_pane_menus_registry.keys
old_items = side_pane_menus_registry.items
side_pane_menus_registry.keys = []
side_pane_menus_registry.items = []
try:
side_pane_menus_registry.register(menu_registry, order=200)
admin_menu_registry = MenuRegistry("Admin Menu", is_superuser)
side_pane_menus_registry.register(admin_menu_registry, order=100)
menu_registry.register('test', 'Test Menu Item',
lambda request: '/test_menu_link', order=2)
admin_menu_registry.register('test_admin', 'Test Admin Item',
lambda request: '/spam', order=100)
response = self._render_menu(user=user)
self.assertIn('class="contesticon"', response)
self.assertNotIn('User Menu', response)
self.assertNotIn('Admin Menu', response)
response = self._render_menu(user=admin)
self.assertNotIn('class="contesticon"', response)
self.assertIn('User Menu', response)
self.assertIn('Admin Menu', response)
self.assertLess(response.index('Test Admin Item'),
response.index('Test Menu Item'))
finally:
side_pane_menus_registry.keys = old_keys
side_pane_menus_registry.items = old_items
def test_menu_item_attrs_escape(self):
menu_registry.register('test', 'Test Menu',
lambda request: '/test_link',
attrs={'name<>\'"&': 'value<>\'"&'})
response = self._render_menu()
self.assertIn('name<>'"&='
'"value<>'"&"', response)
def test_is_contest_admin(self):
admin = User.objects.get(username='******')
user = User.objects.get(username='******')
menu_registry.register('test', 'Test Admin Menu',
lambda request: '/test_admin_link',
condition=is_contest_admin)
response = self._render_menu(user=admin)
self.assertIn('test_admin_link', response)
response = self._render_menu(user=user)
self.assertNotIn('test_admin_link', response)
def test_is_contest_admin(self):
admin = User.objects.get(username='******')
user = User.objects.get(username='******')
menu_registry.register('test', 'Test Admin Menu',
lambda request: '/test_admin_link',
condition=is_contest_admin)
response = self._render_menu(user=admin)
self.assertIn('test_admin_link', response)
response = self._render_menu(user=user)
self.assertNotIn('test_admin_link', response)
def test_menu(self):
menu_registry.register('test2', 'Test Menu Item 2',
lambda request: '/test_menu_link2', order=2)
menu_registry.register('test1', 'Test Menu Item 1',
lambda request: '/test_menu_link1', order=1)
response = self._render_menu()
self.assertIn('Test Menu Item 1', response)
self.assertIn('Test Menu Item 2', response)
self.assertIn('/test_menu_link1', response)
self.assertIn('/test_menu_link2', response)
self.assertLess(response.index('Test Menu Item 1'),
response.index('Test Menu Item 2'))
def test_menu(self):
menu_registry.register('test2', 'Test Menu Item 2',
lambda request: '/test_menu_link2', order=2)
menu_registry.register('test1', 'Test Menu Item 1',
lambda request: '/test_menu_link1', order=1)
response = self._render_menu()
self.assertIn('Test Menu Item 1', response)
self.assertIn('Test Menu Item 2', response)
self.assertIn('/test_menu_link1', response)
self.assertIn('/test_menu_link2', response)
self.assertLess(response.index('Test Menu Item 1'),
response.index('Test Menu Item 2'))
lambda request: reverse('submit',
kwargs={'contest_id': request.contest.id}),
order=200)
top_links_registry.register(
'ranking',
_("Ranking"),
lambda request: reverse('default_ranking',
kwargs={'contest_id': request.contest.id}),
condition=any_ranking_visible,
order=200)
menu_registry.register(
'dashboard',
_("Dashboard"),
lambda request: reverse('contest_dashboard',
kwargs={'contest_id': request.contest.id}),
condition=not_anonymous,
order=20)
# http://stackoverflow.com/questions/1624883/alternative-way-to-split-a-list-into-groups-of-n
def grouper(n, iterable, fillvalue=None):
"grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
args = [iter(iterable)] * n
return list(itertools.izip_longest(*args, fillvalue=fillvalue))
@login_required
@enforce_condition(can_enter_contest)
def contest_dashboard_view(request, contest_id):
from django import forms
from django.core.exceptions import PermissionDenied
from django.shortcuts import get_object_or_404, redirect
from django.utils.translation import ugettext_lazy as _
from django.template.response import TemplateResponse
from django.core.urlresolvers import reverse
from oioioi.base.menu import menu_registry
from oioioi.messages.models import Message, message_kinds, MessageView
from oioioi.contests.models import ProblemInstance
from oioioi.contests.views import visible_problem_instances
from oioioi.base.permissions import enforce_condition
from oioioi.contests.utils import can_enter_contest, is_contest_admin
menu_registry.register(
'contest_messages',
_("Messages"),
lambda request: reverse('contest_messages',
kwargs={'contest_id': request.contest.id}),
order=450)
def visible_messages(request):
problem_instances = visible_problem_instances(request)
problem_ids = [pi.problem_id for pi in problem_instances]
messages = Message.objects \
.filter(Q(contest=request.contest.id)
| Q(problem_id__in=problem_ids)) \
.order_by('-date')
if not request.user.has_perm('contests.contest_admin', request.contest):
q_expression = Q(kind='PUBLIC')
if request.user.is_authenticated():
q_expression = q_expression \
from django.conf import settings
from django.core.urlresolvers import reverse
from django.utils.translation import ugettext_lazy as _
from django.template.response import TemplateResponse
from oioioi.base.permissions import enforce_condition
from oioioi.base.menu import menu_registry
from oioioi.contests.utils import has_any_submittable_problem
from oioioi.base.utils.execute import execute, ExecuteError
from oioioi.printing.forms import PrintForm
menu_registry.register('print_view', _("Print file"),
lambda request: reverse('print_view', kwargs={'contest_id':
request.contest.id}), condition=has_any_submittable_problem, order=470)
@enforce_condition(has_any_submittable_problem)
def print_view(request, contest_id):
error_message = None
success_message = None
if request.method == 'POST':
form = PrintForm(request.user, request.POST, request.FILES)
if form.is_valid():
try:
execute(settings.PRINTING_COMMAND,
stdin=form.cleaned_data['file'])
except ExecuteError as e:
error_message = unicode(e)
else:
success_message = _("File has been printed.")
else:
form = PrintForm(request.user)
from oioioi.base.permissions import enforce_condition
from oioioi.base.menu import menu_registry
from oioioi.contests.utils import can_enter_contest
# This adds the required mixin to the ContestController class
def any_ranking_visible(request):
rcontroller = request.contest.controller.ranking_controller()
return bool(rcontroller.available_rankings(request))
menu_registry.register(
'ranking',
_("Ranking"),
lambda request: reverse('default_ranking',
kwargs={'contest_id': request.contest.id}),
condition=any_ranking_visible,
order=440)
@enforce_condition(can_enter_contest)
def ranking_view(request, contest_id, key=None):
rcontroller = request.contest.controller.ranking_controller()
choices = rcontroller.available_rankings(request)
if not choices:
return TemplateResponse(request, 'rankings/no_rankings.html')
if key is None:
key = choices[0][0]
if key not in zip(*choices)[0]:
raise Http404
from oioioi.base.menu import menu_registry
from oioioi.base.permissions import not_anonymous, enforce_condition
from oioioi.contests.controllers import submission_template_context
from oioioi.contests.forms import SubmissionForm
from oioioi.contests.models import ProblemInstance, Submission, \
SubmissionReport, ContestAttachment
from oioioi.contests.utils import visible_contests, can_enter_contest, \
is_contest_admin, has_any_submittable_problem, \
visible_problem_instances
from oioioi.filetracker.utils import stream_file
from oioioi.problems.models import ProblemStatement, ProblemAttachment
from operator import itemgetter
import sys
menu_registry.register('problems_list', _("Problems"),
lambda request: reverse('problems_list', kwargs={'contest_id':
request.contest.id}), order=100)
menu_registry.register('contest_files', _("Files"),
lambda request: reverse('contest_files', kwargs={'contest_id':
request.contest.id}), condition=not_anonymous,
order=200)
menu_registry.register('submit', _("Submit"),
lambda request: reverse('submit', kwargs={'contest_id':
request.contest.id}), condition=has_any_submittable_problem,
order=300)
menu_registry.register('my_submissions', _("My submissions"),
lambda request: reverse('my_submissions', kwargs={'contest_id':
request.contest.id}), condition=not_anonymous,
from django.core.exceptions import PermissionDenied
from django.core.urlresolvers import reverse
from django.db.models import Q
from django.shortcuts import get_object_or_404, redirect
from django.template.response import TemplateResponse
from django.utils.translation import ugettext_lazy as _
from oioioi.base.menu import menu_registry
from oioioi.base.permissions import enforce_condition
from oioioi.contests.utils import can_enter_contest, is_contest_admin, visible_problem_instances
from oioioi.questions.forms import AddContestMessageForm, AddReplyForm
from oioioi.questions.models import Message, MessageView
menu_registry.register(
"contest_messages",
_("Messages"),
lambda request: reverse("contest_messages", kwargs={"contest_id": request.contest.id}),
order=450,
)
def visible_messages(request):
problem_instances = visible_problem_instances(request)
problem_ids = [pi.problem_id for pi in problem_instances]
messages = Message.objects.filter(Q(contest=request.contest.id) | Q(problem_id__in=problem_ids)).order_by("-date")
if not request.user.has_perm("contests.contest_admin", request.contest):
q_expression = Q(kind="PUBLIC")
if request.user.is_authenticated():
q_expression = (
q_expression | (Q(author=request.user) & Q(kind="QUESTION")) | Q(top_reference__author=request.user)
)
messages = messages.filter(q_expression)
from django.http import Http404
from django.template.response import TemplateResponse
from django.core.urlresolvers import reverse
from django.utils.translation import ugettext_lazy as _
from oioioi.base.permissions import enforce_condition
from oioioi.base.menu import menu_registry
from oioioi.contests.utils import can_enter_contest
# This adds the required mixin to the ContestController class
def any_ranking_visible(request):
rcontroller = request.contest.controller.ranking_controller()
return bool(rcontroller.available_rankings(request))
menu_registry.register('ranking', _("Ranking"),
lambda request: reverse('default_ranking', kwargs={'contest_id':
request.contest.id}), condition=any_ranking_visible,
order=440)
@enforce_condition(can_enter_contest)
def ranking_view(request, contest_id, key=None):
rcontroller = request.contest.controller.ranking_controller()
choices = rcontroller.available_rankings(request)
if not choices:
return TemplateResponse(request, 'rankings/no_rankings.html')
if key is None:
key = choices[0][0]
if key not in zip(*choices)[0]:
raise Http404
ranking = rcontroller.render_ranking(request, key)
return TemplateResponse(request, 'rankings/ranking_view.html',
{'choices': choices, 'ranking': ranking, 'key': key})
controller = request.contest.controller
queryset = ProblemInstance.objects.filter(contest=request.contest) \
.select_related('problem')
return [pi for pi in queryset if controller.can_see_problem(request, pi)]
def submitable_problem_instances(request):
controller = request.contest.controller
queryset = ProblemInstance.objects.filter(contest=request.contest) \
.select_related('problem')
return [pi for pi in queryset if controller.can_submit(request, pi)]
menu_registry.register(
'problems_list',
_("Problems"),
lambda request: reverse('problems_list',
kwargs={'contest_id': request.contest.id}),
order=100)
menu_registry.register(
'contest_files',
_("Files"),
lambda request: reverse('contest_files',
kwargs={'contest_id': request.contest.id}),
condition=not_anonymous,
order=200)
menu_registry.register(
'submit',
_("Submit"),
lambda request: reverse('submit',
from django.db.models import Q
from django import forms
from django.core.exceptions import PermissionDenied
from django.shortcuts import get_object_or_404, redirect
from django.utils.translation import ugettext_lazy as _
from django.template.response import TemplateResponse
from django.core.urlresolvers import reverse
from oioioi.base.menu import menu_registry
from oioioi.questions.models import Message, message_kinds, MessageView
from oioioi.contests.models import ProblemInstance
from oioioi.contests.views import visible_problem_instances
from oioioi.base.permissions import enforce_condition
from oioioi.contests.utils import can_enter_contest, is_contest_admin
menu_registry.register('contest_messages', _("Messages"),
lambda request: reverse('contest_messages', kwargs={'contest_id':
request.contest.id}), order=450)
def visible_messages(request):
problem_instances = visible_problem_instances(request)
problem_ids = [pi.problem_id for pi in problem_instances]
messages = Message.objects \
.filter(Q(contest=request.contest.id)
| Q(problem_id__in=problem_ids)) \
.order_by('-date')
if not request.user.has_perm('contests.contest_admin', request.contest):
q_expression = Q(kind='PUBLIC')
if request.user.is_authenticated():
q_expression = q_expression \
| (Q(author=request.user) & Q(kind='QUESTION')) \
| Q(top_reference__author=request.user)
top_links_registry.register('problems_list', _("Problems"),
lambda request: reverse('problems_list', kwargs={'contest_id':
request.contest.id}), order=100)
top_links_registry.register('submit', _("Submit"),
lambda request: reverse('submit', kwargs={'contest_id':
request.contest.id}), order=200)
top_links_registry.register('ranking', _("Ranking"),
lambda request: reverse('default_ranking', kwargs={'contest_id':
request.contest.id}), condition=any_ranking_visible,
order=200)
menu_registry.register('dashboard', _("Dashboard"),
lambda request: reverse('contest_dashboard', kwargs={'contest_id':
request.contest.id}), condition=not_anonymous, order=20)
# http://stackoverflow.com/questions/1624883/alternative-way-to-split-a-list-into-groups-of-n
def grouper(n, iterable, fillvalue=None):
"grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
args = [iter(iterable)] * n
return list(itertools.izip_longest(*args, fillvalue=fillvalue))
@login_required
@enforce_condition(can_enter_contest)
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()
def visible_problem_instances(request):
controller = request.contest.controller
queryset = ProblemInstance.objects.filter(contest=request.contest).select_related("problem")
return [pi for pi in queryset if controller.can_see_problem(request, pi)]
def submitable_problem_instances(request):
controller = request.contest.controller
queryset = ProblemInstance.objects.filter(contest=request.contest).select_related("problem")
return [pi for pi in queryset if controller.can_submit(request, pi)]
menu_registry.register(
"problems_list",
_("Problems"),
lambda request: reverse("problems_list", kwargs={"contest_id": request.contest.id}),
order=100,
)
menu_registry.register(
"contest_files",
_("Files"),
lambda request: reverse("contest_files", kwargs={"contest_id": request.contest.id}),
condition=not_anonymous,
order=200,
)
menu_registry.register(
"submit",
_("Submit"),
lambda request: reverse("submit", kwargs={"contest_id": request.contest.id}),
