def problem_site_view(request, site_key): problem = get_object_or_404(Problem, problemsite__url_key=site_key) package = ProblemPackage.objects.filter(problem=problem).first() show_add_button, administered_recent_contests = \ _generate_add_to_contest_metadata(request) extra_actions = problem.controller.get_extra_problem_site_actions(problem) navbar_links = navbar_links_registry.template_context(request) context = {'problem': problem, 'package': package if package and package.package_file else None, 'extra_actions': extra_actions, 'can_admin_problem': can_admin_problem(request, problem), 'select_problem_src': request.GET.get('select_problem_src'), 'show_add_button': show_add_button, 'administered_recent_contests': administered_recent_contests, 'navbar_links': navbar_links} tab_kwargs = {'problem': problem} tab_link_params = request.GET.dict() if 'page' in tab_link_params: del tab_link_params['page'] def build_link(tab): tab_link_params['key'] = tab.key return request.path + '?' + six.moves.urllib.parse.urlencode( tab_link_params) return tabbed_view(request, 'problems/problemset/problem-site.html', context, problem_site_tab_registry, tab_kwargs, build_link)
def add_or_update_problem(request, contest, template): if 'problem' in request.GET: existing_problem = \ get_object_or_404(Problem, id=request.GET['problem']) if contest and not existing_problem.probleminstance_set.filter( contest=contest).exists(): raise Http404 if not can_admin_problem(request, existing_problem): raise PermissionDenied else: existing_problem = None if not request.user.has_perm('problems.problems_db_admin'): if contest and (not is_contest_admin(request)): raise PermissionDenied navbar_links = navbar_links_registry.template_context(request) context = {'existing_problem': existing_problem, 'navbar_links': navbar_links} tab_kwargs = { 'contest': contest, 'existing_problem': existing_problem } tab_link_params = request.GET.dict() def build_link(tab): tab_link_params['key'] = tab.key return request.path + '?' + six.moves.urllib.parse.urlencode( tab_link_params) return tabbed_view(request, template, context, problem_sources(request), tab_kwargs, build_link)
def problem_site_view(request, site_key): problem = get_object_or_404(Problem, problemsite__url_key=site_key) package = ProblemPackage.objects.filter(problem=problem).first() show_add_button, administered_recent_contests = _generate_add_to_contest_metadata(request) context = { "problem": problem, "package": package if package and package.package_file else None, "can_admin_problem": can_admin_problem(request, problem), "select_problem_src": request.GET.get("select_problem_src"), "show_add_button": show_add_button, "administered_recent_contests": administered_recent_contests, } tab_kwargs = {"problem": problem} tab_link_params = request.GET.dict() if "page" in tab_link_params: del tab_link_params["page"] def build_link(tab): tab_link_params["key"] = tab.key return request.path + "?" + urllib.urlencode(tab_link_params) return tabbed_view( request, "problems/problemset/problem_site.html", context, problem_site_tab_registry, tab_kwargs, build_link )
def problem_site_external_statement_view(request, site_key): problem = get_object_or_404(Problem, problemsite__url_key=site_key) statement = query_statement(problem.id) if statement.extension == '.zip' \ and not can_admin_problem(request, problem): raise PermissionDenied return stream_file(statement.content, statement.download_name)
def has_change_permission(self, request, obj=None): if obj is None: return False problem = obj.problem if problem.main_problem_instance != obj: return False return can_admin_problem(request, problem)
def can_generate_user_out(self, request, submission_report): """Determines if the current user is allowed to generate outs from ``submission_report``. Default implementations allow only problem admins. """ problem = submission_report.submission.problem_instance.problem return can_admin_problem(request, problem)
def get_default_submission_kind(self, request, problem_instance): """Returns default kind of newly created submission by the current user. The default implementation returns ``'IGNORED'`` for problem admins. In other cases it returns ``'NORMAL'``. """ if can_admin_problem(request, problem_instance.problem): return 'IGNORED' return 'NORMAL'
def _get_package(request, package_id): package = get_object_or_404(ProblemPackage, id=package_id) has_perm = False if package.contest: has_perm = request.user.has_perm("contests.contest_admin", package.contest) elif package.problem: has_perm = can_admin_problem(request, package.problem) else: has_perm = request.user.is_superuser if not has_perm: raise PermissionDenied return package
def get_submissions_limit(self, request, problem_instance, kind='NORMAL'): if kind != 'TESTRUN': return super(TestRunProblemControllerMixin, self) \ .get_submissions_limit(request, problem_instance, kind) if can_admin_problem(request, problem_instance.problem): return None if (hasattr(problem_instance.problem, 'test_run_config') and hasattr(problem_instance, 'test_run_config')): test_runs_limit = problem_instance.test_run_config.test_runs_limit else: test_runs_limit = settings.DEFAULT_TEST_RUNS_LIMIT return test_runs_limit
def _out_generate_status(self, request, testreport): problem = testreport.test.problem_instance.problem try: if can_admin_problem(request, problem) or \ testreport.userout_status.visible_for_user: # making sure, that output really exists or is processing if bool(testreport.output_file) or \ testreport.userout_status.status == '?': return testreport.userout_status.status except UserOutGenStatus.DoesNotExist: if testreport.output_file: return 'OK' return None
def problem_site_view(request, site_key): problem = get_object_or_404(Problem, problemsite__url_key=site_key) context = {'problem': problem, 'can_admin_problem': can_admin_problem(request, problem), 'select_problem_src': request.GET.get('select_problem_src')} tab_kwargs = {'problem': problem} tab_link_params = request.GET.dict() if 'page' in tab_link_params: del tab_link_params['page'] def build_link(tab): tab_link_params['key'] = tab.key return request.path + '?' + urllib.urlencode(tab_link_params) return tabbed_view(request, 'problems/problemset/problem_site.html', context, problem_site_tab_registry, tab_kwargs, build_link)
def filter_visible_reports(self, request, submission, queryset): """Determines which reports the user should be able to see. It needs to check whether the submission is visible to the user and submission is submitted without contest. :param request: Django request :param submission: instance of :class:`~oioioi.contests.models.Submission` :param queryset: a queryset, initially filtered at least to select only given submission's reports :returns: updated queryset """ assert not submission.problem_instance.contest problem = submission.problem_instance.problem if can_admin_problem(request, problem): return queryset return queryset.filter(status='ACTIVE', kind='NORMAL')
def inline_actions(self, instance): result = [] assert ProblemSite.objects.filter(problem=instance.problem).exists() move_href = self._move_href(instance) result.append((move_href, _("Edit"))) is_quiz = hasattr(instance.problem, 'quiz') and instance.problem.quiz if is_quiz: edit_quiz_href = self._edit_quiz_href(instance) result.append((edit_quiz_href, _("Quiz questions"))) else: models_href = self._model_solutions_href(instance) limits_href = self._reset_limits_href(instance) result.extend([ (models_href, _("Model solutions")), (limits_href, _("Reset tests limits")), ]) reattach_href = self._reattach_problem_href(instance) result.append((reattach_href, _("Attach to another contest"))) problem_count = len( ProblemInstance.objects.filter(problem=instance.problem_id)) # Problem package can only be reuploaded if the problem instance # is only in one contest and in the problem base # Package reupload does not apply to quizzes. if problem_count <= 2 and not is_quiz: add_or_update_href = self._add_or_update_href(instance) result.append((add_or_update_href, _("Reupload package"))) if instance.needs_rejudge: rejudge_all_href = self._rejudge_all_submissions_for_problem_href( instance) result.append( (rejudge_all_href, _("Rejudge all submissions for problem"))) rejudge_not_needed_href = self._set_needs_rejudge_to_false_href( instance) result.append((rejudge_not_needed_href, _("Rejudge not needed"))) problem_change_href = self._problem_change_href(instance) replace_statement_href = self._replace_statement_href(instance) package_manage_href = self._package_manage_href(instance) request = self._request_local.request if can_admin_problem(request, instance.problem): result.append((problem_change_href, _("Advanced settings"))) result.append((replace_statement_href, _("Replace statement"))) result.append((package_manage_href, _("Edit package"))) return result
def _out_generate_status(self, request, testreport): problem = testreport.test.problem_instance.problem try: if ( can_admin_problem(request, problem) or testreport.userout_status.visible_for_user ): # making sure, that output really exists or is processing if ( bool(testreport.output_file) or testreport.userout_status.status == '?' ): return testreport.userout_status.status except UserOutGenStatus.DoesNotExist: if testreport.output_file: return 'OK' return None
def filter_my_visible_submissions(self, request, queryset): """Returns the submissions which the user should see in the problemset in "My submissions" view. The default implementation returns all submissions belonging to the user for current problem except for author, who gets all his submissions. Should return the updated queryset. """ if not request.user.is_authenticated: return queryset.none() qs = queryset \ .filter(problem_instance=self.problem.main_problem_instance) if can_admin_problem(request, self.problem): return qs.filter(Q(user=request.user) | Q(user__isnull=True)) else: return qs.filter(user=request.user, date__lte=request.timestamp) \ .exclude(kind='IGNORED_HIDDEN')
def filter_my_visible_submissions(self, request, queryset): """Returns the submissions which the user should see in the problemset in "My submissions" view. The default implementation returns all submissions belonging to the user for current problem except for author, who gets all his submissions. Should return the updated queryset. """ if not request.user.is_authenticated(): return queryset.none() qs = queryset \ .filter(problem_instance=self.problem.main_problem_instance) if can_admin_problem(request, self.problem): return qs.filter(Q(user=request.user) | Q(user__isnull=True)) else: return qs.filter(user=request.user, date__lte=request.timestamp) \ .exclude(kind='IGNORED_HIDDEN')
def problem_site_settings(request, problem): show_add_button, administered_recent_contests = generate_add_to_contest_metadata( request) package = ProblemPackage.objects.filter(problem=problem).first() model_solutions = generate_model_solutions_context( request, problem.main_problem_instance_id) extra_actions = problem.controller.get_extra_problem_site_actions(problem) algorithm_tag_proposals = AlgorithmTagProposal.objects.all().filter( problem=problem).order_by('-pk')[:25] return TemplateResponse( request, 'problems/settings.html', { 'site_key': problem.problemsite.url_key, 'problem': problem, 'administered_recent_contests': administered_recent_contests, 'package': package if package and package.package_file else None, 'model_solutions': model_solutions, 'algorithm_tag_proposals': algorithm_tag_proposals, 'can_admin_problem': can_admin_problem(request, problem), 'extra_actions': extra_actions })
def problem_site_view(request, site_key): problem = get_object_or_404(Problem, problemsite__url_key=site_key) package = ProblemPackage.objects.filter(problem=problem).first() show_add_button, administered_recent_contests = \ generate_add_to_contest_metadata(request) extra_actions = problem.controller.get_extra_problem_site_actions(problem) navbar_links = navbar_links_registry.template_context(request) problemset_tabs = generate_problemset_tabs(request) problemset_tabs.append({ 'name': _('Problem view'), 'url': reverse('problem_site', kwargs={'site_key': site_key}) }) context = { 'problem': problem, 'problemsite_key': site_key, 'package': package if package and package.package_file else None, 'extra_actions': extra_actions, 'can_admin_problem': can_admin_problem(request, problem), 'select_problem_src': request.GET.get('select_problem_src'), 'show_add_button': show_add_button, 'show_proposal_form': show_proposal_form(problem, request.user), 'administered_recent_contests': administered_recent_contests, 'navbar_links': navbar_links, 'problemset_tabs': problemset_tabs } tab_kwargs = {'problem': problem} tab_link_params = request.GET.dict() if 'page' in tab_link_params: del tab_link_params['page'] def build_link(tab): tab_link_params['key'] = tab.key return request.path + '?' + six.moves.urllib.parse.urlencode( tab_link_params) return tabbed_view(request, 'problems/problemset/problem-site.html', context, problem_site_tab_registry, tab_kwargs, build_link)
def add_or_update_problem(request, contest, template): if 'problem' in request.GET: existing_problem = get_object_or_404(Problem, id=request.GET['problem']) if (contest and not existing_problem.probleminstance_set.filter( contest=contest).exists()): raise Http404 if not can_admin_problem(request, existing_problem): raise PermissionDenied else: existing_problem = None if not request.user.has_perm('problems.problems_db_admin'): if contest and (not is_contest_basicadmin(request)): raise PermissionDenied navbar_links = navbar_links_registry.template_context(request) problemset_tabs = generate_problemset_tabs(request) context = { 'existing_problem': existing_problem, 'navbar_links': navbar_links, 'problemset_tabs': problemset_tabs, } tab_kwargs = {'contest': contest, 'existing_problem': existing_problem} tab_link_params = request.GET.dict() def build_link(tab): tab_link_params['key'] = tab.key return request.path + '?' + six.moves.urllib.parse.urlencode( tab_link_params) return tabbed_view( request, template, context, problem_sources(request, existing_problem=existing_problem is not None), tab_kwargs, build_link, )
def add_or_update_problem(request, contest, template): if "problem" in request.GET: existing_problem = get_object_or_404(Problem, id=request.GET["problem"]) if contest and not existing_problem.probleminstance_set.filter(contest=contest).exists(): raise Http404 if not can_admin_problem(request, existing_problem): raise PermissionDenied else: existing_problem = None if not request.user.has_perm("problems.problems_db_admin"): if contest and (not is_contest_admin(request)): raise PermissionDenied context = {"existing_problem": existing_problem} tab_kwargs = {"contest": contest, "existing_problem": existing_problem} tab_link_params = request.GET.dict() def build_link(tab): tab_link_params["key"] = tab.key return request.path + "?" + urllib.urlencode(tab_link_params) return tabbed_view(request, template, context, problem_sources(request), tab_kwargs, build_link)
def problem_site_view(request, site_key): problem = get_object_or_404(Problem, problemsite__url_key=site_key) package = ProblemPackage.objects.filter(problem=problem).first() show_add_button, administered_recent_contests = \ _generate_add_to_contest_metadata(request) context = {'problem': problem, 'package': package if package and package.package_file else None, 'can_admin_problem': can_admin_problem(request, problem), 'select_problem_src': request.GET.get('select_problem_src'), 'show_add_button': show_add_button, 'administered_recent_contests': administered_recent_contests} tab_kwargs = {'problem': problem} tab_link_params = request.GET.dict() if 'page' in tab_link_params: del tab_link_params['page'] def build_link(tab): tab_link_params['key'] = tab.key return request.path + '?' + urllib.urlencode(tab_link_params) return tabbed_view(request, 'problems/problemset/problem_site.html', context, problem_site_tab_registry, tab_kwargs, build_link)
def has_change_permission(self, request, obj=None): if obj is None: return self.get_queryset(request).exists() return can_admin_problem(request, obj)
def has_change_permission(self, request, obj=None): if obj is None: return self.get_queryset(request).exists() else: return can_admin_problem(request, obj)
def get_submissions_limit(self, request, problem_instance): problem = problem_instance.problem if can_admin_problem(request, problem): return None return problem_instance.submissions_limit
def download_extra_file_view(request, file_id): file = get_object_or_404(ExtraFile, id=file_id) if not can_admin_problem(request, file.problem): raise PermissionDenied return stream_file(file.file)
def check_repeated_submission(self, request, problem_instance, form): return not can_admin_problem(request, problem_instance.problem) \ and form.kind == 'NORMAL' and \ getattr(settings, 'WARN_ABOUT_REPEATED_SUBMISSION', False)
def model_solutions_view(request, problem_instance_id): problem_instance = \ get_object_or_404(ProblemInstance, id=problem_instance_id) problem = problem_instance.problem contest = problem_instance.contest if (contest is None and not can_admin_problem(request, problem)) or \ (contest and not request.user.has_perm('contests.contest_admin', contest)): raise PermissionDenied filter_kwargs = { 'test__isnull': False, 'submission_report__submission__problem_instance': problem_instance, 'submission_report__submission__programsubmission' '__modelprogramsubmission__isnull': False, 'submission_report__status': 'ACTIVE', } test_reports = TestReport.objects.filter(**filter_kwargs) \ .select_related() filter_kwargs = { 'submission_report__submission__problem_instance': problem_instance, 'submission_report__submission__programsubmission' '__modelprogramsubmission__isnull': False, 'submission_report__status': 'ACTIVE', } group_reports = GroupReport.objects.filter(**filter_kwargs) \ .select_related() submissions = ModelProgramSubmission.objects \ .filter(problem_instance=problem_instance) \ .order_by('model_solution__order_key') \ .select_related('model_solution') \ .all() tests = problem_instance.test_set \ .order_by('order', 'group', 'name').all() group_results = defaultdict(lambda: defaultdict(lambda: None)) for gr in group_reports: group_results[gr.group][gr.submission_report.submission_id] = gr test_results = defaultdict(lambda: defaultdict(lambda: None)) for tr in test_reports: test_results[tr.test_id][tr.submission_report.submission_id] = tr submissions_percentage_statuses = {s.id: '25' for s in submissions} rows = [] submissions_row = [] for t in tests: row_test_results = test_results[t.id] row_group_results = group_results[t.group] percentage_statuses = {s.id: '100' for s in submissions} for s in submissions: if row_test_results[s.id] is not None: time_ratio = float(row_test_results[s.id].time_used) / \ row_test_results[s.id].test_time_limit if time_ratio <= 0.25: percentage_statuses[s.id] = '25' elif time_ratio <= 0.50: percentage_statuses[s.id] = '50' if submissions_percentage_statuses[s.id] is not '100': submissions_percentage_statuses[s.id] = '50' else: percentage_statuses[s.id] = '100' submissions_percentage_statuses[s.id] = '100' rows.append({ 'test': t, 'results': [{ 'test_report': row_test_results[s.id], 'group_report': row_group_results[s.id], 'is_partial_score': s.problem_instance.controller ._is_partial_score(row_test_results[s.id]), 'percentage_status': percentage_statuses[s.id] } for s in submissions ] }) for s in submissions: status = s.status if s.status == 'OK' or s.status == 'INI_OK': status = 'OK' + submissions_percentage_statuses[s.id] submissions_row.append({ 'submission': s, 'status': status }) context = { 'problem_instance': problem_instance, 'submissions_row': submissions_row, 'submissions': submissions, 'rows': rows } return TemplateResponse(request, 'programs/admin/model_solutions.html', context)
def can_see_test(self, request, test): return can_admin_problem(request, self.problem)
def is_admin(self, request, report): return can_admin_problem(request, self.problem)
def test_view_for_problem(request, package_id): tp = get_object_or_404(TestsPackage, id=package_id) if not can_admin_problem(request, tp.problem): raise PermissionDenied return get_tests_package_file(tp)
def can_see_checker_exe(self, request, checker): return can_admin_problem(request, self.problem)