def get_language_hints_view(request):
pi_ids = request.GET.getlist(u'pi_ids[]')
filename = request.GET.get(u'filename', u'')
pis = ProblemInstance.objects.filter(id__in=pi_ids)
extension = get_extension(filename)
lang_dict = {pi: get_language_by_extension(pi, extension) for pi in pis}
if contest_exists(request):
submittable_pis = submittable_problem_instances(request)
lang_dict = {
pi: lang
for (pi, lang) in lang_dict.items() if pi in submittable_pis
}
else:
problemsite_key = request.GET.get(u'problemsite_key', u'')
lang_dict = {
pi: lang
for (pi, lang) in lang_dict.items()
if pi.problem.problemsite.url_key == problemsite_key
}
langs = getattr(settings, 'SUBMITTABLE_LANGUAGES', {})
lang_display_dict = {
pi.id: langs.get(lang, {'display_name': ''})['display_name']
for (pi, lang) in lang_dict.items()
}
return lang_display_dict
def get_compiler_for_submission(self, submission):
problem_instance = submission.problem_instance
extension = get_extension(submission.source_file.name)
language = get_language_by_extension(problem_instance, extension)
assert language
compiler = problem_instance.controller.get_compiler_for_language(
problem_instance, language)
if compiler is not None:
return compiler
else:
logger.warning("No default compiler for language %s", language)
return 'default-' + extension
def collect_list(self):
ccontroller = self.contest.controller
q_expressions = Q(user__isnull=False)
if self.round:
q_expressions = q_expressions & Q(
problem_instance__round=self.round)
else:
q_expressions = q_expressions & Q(
problem_instance__contest=self.contest)
if self.only_final:
q_expressions = q_expressions & Q(
submissionreport__userresultforproblem__isnull=False)
submissions_list = []
psubmissions = ProgramSubmission.objects.filter(
q_expressions).select_related()
for s in psubmissions:
data = SubmissionData()
data.submission_id = s.id
data.user_id = s.user_id
data.username = s.user.username
data.first_name = s.user.first_name
data.last_name = s.user.last_name
data.problem_short_name = s.problem_instance.short_name
data.score = s.score
data.solution_language = get_extension(s.source_file.name)
data.source_file = s.source_file
# here we try to get some optional data, it just may not be there
# and it's ok
try:
registration = (Participant.objects.select_related().get(
contest_id=self.contest.id,
user=s.user).registration_model)
try:
data.city = registration.city
except AttributeError:
pass
try:
data.school = registration.school.name
data.school_city = registration.school.city
except AttributeError:
pass
except (Participant.DoesNotExist, ObjectDoesNotExist):
pass
submissions_list.append(data)
return submissions_list
def generate_initial_evaluation_environ(self, environ, submission, **kwargs):
problem_instance = submission.problem_instance
problem = problem_instance.problem
contest = problem_instance.contest
if contest is not None:
round = problem_instance.round
submission = submission.programsubmission
environ['source_file'] = django_to_filetracker_path(submission.source_file)
environ['language'] = get_extension(submission.source_file.name)
environ[
'compilation_result_size_limit'
] = problem_instance.controller.get_compilation_result_size_limit(submission)
environ['submission_id'] = submission.id
environ['submission_kind'] = submission.kind
environ['problem_instance_id'] = problem_instance.id
environ['problem_id'] = problem.id
environ['problem_short_name'] = problem.short_name
if contest is not None:
environ['round_id'] = round.id
environ['contest_id'] = contest.id
environ['submission_owner'] = (
submission.user.username if submission.user else None
)
environ['oioioi_instance'] = settings.SITE_NAME
environ['contest_priority'] = (
contest.judging_priority
if contest is not None
else settings.NON_CONTEST_PRIORITY
)
environ['contest_priority'] += settings.OIOIOI_INSTANCE_PRIORITY_BONUS
environ['contest_weight'] = (
contest.judging_weight
if contest is not None
else settings.NON_CONTEST_WEIGHT
)
environ['contest_weight'] += settings.OIOIOI_INSTANCE_WEIGHT_BONUS
environ.setdefault('report_kinds', ['INITIAL', 'NORMAL'])
if 'hidden_judge' in environ['extra_args']:
environ['report_kinds'] = ['HIDDEN']
environ['compiler'] = problem_instance.controller.get_compiler_for_submission(
submission
)
def validate_language(file):
ext = get_extension(file.name)
if ext not in get_allowed_languages_extensions(problem_instance):
raise ValidationError(
_("Unknown or not supported file extension."))
def validate_submission_form(self, request, problem_instance, form,
cleaned_data):
if any(field in form.errors.as_data() for field in ('file', 'code')):
return # already have a ValidationError
is_file_chosen = 'file' in cleaned_data and cleaned_data[
'file'] is not None
is_code_pasted = 'code' in cleaned_data and cleaned_data['code']
if (not is_file_chosen and not is_code_pasted) or (is_file_chosen
and is_code_pasted):
raise ValidationError(
_("You have to either choose file or paste "
"code."))
langs_field_name = form_field_id_for_langs(problem_instance)
if langs_field_name not in cleaned_data:
cleaned_data[langs_field_name] = None
if not cleaned_data[langs_field_name] and is_file_chosen:
ext = get_extension(cleaned_data['file'].name)
cleaned_data[langs_field_name] = get_language_by_extension(
problem_instance, ext)
if not cleaned_data[langs_field_name]:
if is_code_pasted:
raise ValidationError(
_("You have to choose programming language."))
else:
raise ValidationError(_("Unrecognized file extension."))
langs = get_allowed_languages_dict(problem_instance)
if cleaned_data[langs_field_name] not in langs.keys():
raise ValidationError(
_("This language is not allowed for selected"
" problem."))
if is_file_chosen:
code = cleaned_data['file'].read()
else:
code = cleaned_data['code'].encode('utf-8')
if problem_instance.controller.check_repeated_submission(
request, problem_instance, form):
lines = iter(code.splitlines())
md5 = hashlib.md5()
for line in lines:
md5.update(line)
md5 = md5.hexdigest()
session_md5_key = 'programs_%d_md5' % cleaned_data[
'problem_instance'].id
if (session_md5_key in request.session
and md5 == request.session[session_md5_key]):
del request.session[session_md5_key]
raise ValidationError(
_("You have submitted the same file for this problem "
"again. Please resubmit if you really want "
"to submit the same file"))
else:
request.session[session_md5_key] = md5
request.session.save()
return cleaned_data
