def site_rejudge_submission_list(request, contest_id):
problem_id = request.GET.get('problem_id', 0)
result = request.GET.get('result', "All")
refresh_contest_session_admin(request) # refersh the contest session
contest = Contest.objects.get(pk=contest_id)
try:
problem_id = int(problem_id)
except ValueError:
return redirect('homepage')
if not problem_id == 0:
try:
problem_title = Problem.objects.get(pk=problem_id).title
except Problem.DoesNotExist:
problem_title = None
else:
problem_title = "All problems"
all_submission = Submit.objects.filter(
contest=contest).order_by('submit_time').reverse()
all_problems = set()
for submit in all_submission:
pro = (submit.problem.id, submit.problem.title)
all_problems.add(pro)
all_problems = sorted(all_problems, key=lambda x: x[1].lower())
submission_list = all_submission
if problem_id:
submission_list = submission_list.filter(problem_id=problem_id)
if not result == "All":
submission_list = submission_list.filter(result=result)
start_time = contest.start_time
for i in submission_list:
i.contest_time = i.submit_time - start_time
all_results = [
'Correct', 'Wrong Answer', 'Judging', 'Time Limit Exceeded',
'Run Time Error', 'Compiler Error', 'Memory Limit Exceeded',
'No Output'
]
submission_list, paginator = pagination(request, submission_list)
context = {
'submission_list': submission_list,
"contest_title": contest.title,
'all_problems': all_problems,
'contest_id': contest_id,
'paginator': paginator,
'all_results': all_results,
"selected_problem": problem_id,
"problem_title": problem_title,
'selected_result': result,
'rejudge': 'hover'
}
return render(request, 'site_rejudge_submission_list.html', context)
def testcase(request, problem_id):
problem = Problem.objects.get(pk=problem_id)
test_case = TestCase.objects.filter(problem=problem)
test_case = sorted(test_case, key=lambda x: lambda_sort(x))
if test_case[-1].name[1:].isdigit():
name = 't' + str(int(test_case[-1].name[1:]) + 1)
else:
name = test_case[-1].name + '1'
if request.method == "POST":
error_list = []
for i in test_case:
in_put = request.FILES.get(i.input)
out_put = request.FILES.get(i.output)
if in_put:
try:
validate_testcase_in_file_extension(in_put)
os.system('rm ' + i.input.path)
i.input = in_put
except ValidationError:
error_list.append((i.name + ' input'))
if out_put:
try:
validate_testcase_out_file_extension(out_put)
os.system('rm ' + i.output.path)
i.output = out_put
except ValidationError:
error_list.append((i.name + ' output'))
i.save()
form = AddTestcase(request.POST, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.problem = problem
post.name = name
post.save()
messages.success(
request, "testcase " + post.name + " was added successfully.")
if error_list:
messages.warning(
request,
"Unsupported file extension in " + ', '.join(error_list))
url = request.META['HTTP_REFERER']
server_testcase_edit(problem)
return redirect('testcase', problem_id)
else:
form = AddTestcase()
test_case, paginator = pagination(request, test_case, 10)
return render(
request, 'testcase.html', {
'form': form,
'title': problem.title,
'test_case': test_case,
'paginator': paginator,
"problem_id": problem.id,
'pro': 'hover'
})
def site_rejudge_contest_select(request):
now = timezone.now()
refresh_contest_session_admin(request) # refersh the contest session
all_contest = Contest.objects.filter(
start_time__lte=now,
created_by=request.user.campus).order_by("start_time").reverse()
for contest in all_contest:
if contest.enable == False:
contest.status = "disable"
elif now < contest.active_time:
contest.status = "not active"
elif now < contest.start_time:
contest.status = "active"
elif contest.start_time <= now and now < contest.end_time:
contest.status = "on going"
elif contest.end_time <= now and now < contest.deactivate_time:
contest.status = "end"
else:
contest.status = "deactivate"
all_contest, paginator = pagination(request, all_contest)
context = {
'all_contest': all_contest,
'paginator': paginator,
'rejudge': 'hover'
}
return render(request, 'site_rejudge_select_contest.html', context)
def clarification_list(request):
refresh_contest_session_admin(request) # refersh the contest session
current_contest_id = request.session.get('active_contest_admin')
try:
current_contest = Contest.objects.get(pk=current_contest_id,
active_time__lte=timezone.now(),
enable=True)
except Contest.DoesNotExist:
current_contest = None
all_clarification = Clarification.objects.filter(
contest=current_contest, status=False).order_by('send_time').reverse()
for cla in all_clarification:
if len(cla.question) > 100:
cla.short_question = cla.question[:100] + '...'
else:
cla.short_question = cla.question
all_clarification, paginator = pagination(request, all_clarification)
page_number = all_clarification.number
context = {
'all_clarification': all_clarification,
'page_number': page_number,
'paginator': paginator,
'clar': 'hover'
}
return render(request, 'clarification_list.html', context)
def view_clarification(request):
refresh_contest_session_contestant(request) # refersh the contest session
current_contest_id = request.session.get('active_contest_contestant')
try:
current_contest = Contest.objects.get(pk=current_contest_id,
active_time__lte=timezone.now(),
enable=True)
except Contest.DoesNotExist:
current_contest = None
all_clarification = Clarification.objects.filter(contest=current_contest, user=request.user, status=True).order_by('send_time').reverse() |\
Clarification.objects.filter(
contest=current_contest, is_public=True, status=True).order_by('send_time').reverse()
for cla in all_clarification:
if len(cla.question) > 60:
cla.short_question = cla.question[:60] + ' ...'
else:
cla.short_question = cla.question
if len(cla.answer) > 60:
cla.short_answer = cla.answer[:60] + ' ...'
else:
cla.short_answer = cla.answer
all_clarification, paginator = pagination(request, all_clarification)
context = {
'all_clarification': all_clarification,
'paginator': paginator,
'clar': 'hover'
}
return render(request, 'view_clarification.html', context)
def score_values(request):
score_values = Setting.objects.all().order_by('name')
score_values, paginator = pagination(request, score_values)
return render(request, 'score_values.html', {
'score_values': score_values,
'paginator': paginator
})
def language_list(request):
language_list = Language.objects.all().order_by('name')
language_list, paginator = pagination(request, language_list)
return render(request, 'language_list.html', {
'language_list': language_list,
'paginator': paginator
})
def public_problem_list(request):
# problem_list = Problem.objects.filter(is_public=True).order_by('title')
problem_list = Statistics.objects.filter(
problem__is_public=True, is_active=True).order_by("problem__title")
for stats in problem_list:
stats.difficulty = difficulty(stats)
try:
stats.submissions_ratio = 100 * stats.accurate_submissions // stats.total_submissions
except ZeroDivisionError:
stats.submissions_ratio = 100
try:
stats.user_ratio = 100 * stats.accurate_users // stats.total_users
except ZeroDivisionError:
stats.user_ratio = 100
for stat in problem_list:
submit = Submit.objects.filter(user=request.user, problem=stat.problem)
if submit.filter(result="Correct"):
stat.status = "Solved"
elif submit:
stat.status = "Not Solved"
else:
stat.status = "Not Try"
problem_list, paginator = pagination(request, problem_list)
context = {
'problem_list': problem_list,
'paginator': paginator,
'pro': 'hover'
}
return render(request, 'problem_list.html', context)
def site_multi_rejudge(request, problem_id, contest_id, user_id):
refresh_contest_session_admin(request) # refersh the contest session
# contest_id = request.session.get('start_contest_admin') # ???
current_contest = Contest.objects.get(pk=contest_id)
submit = Submit.objects.filter(
contest_id=contest_id,
problem_id=problem_id,
user_id=user_id,
submit_time__gte=current_contest.start_time,
submit_time__lte=current_contest.end_time).order_by('submit_time')
if not submit:
return redirect('homepage')
specific_submissions = list()
for i in submit:
if i.result == 'Correct':
specific_submissions.append(i)
break
else:
specific_submissions.append(i)
start_time = current_contest.start_time
for i in specific_submissions:
i.contest_time = i.submit_time - start_time
specific_submissions, paginator = pagination(request, specific_submissions,
3)
context = {
'submit': specific_submissions,
'paginator': paginator,
'contest_id': specific_submissions[0].contest.pk,
'rejudge': 'hover'
}
return render(request, 'site_single_user_rejudge.html', context)
def site_rejudge_submission_filter(request):
try:
problem_id = int(request.GET.get('problem_id'))
contest_id = int(request.GET.get('contest_id'))
except ValueError:
return redirect('homepage')
result = request.GET.get('result')
try:
contest = Contest.objects.get(pk=contest_id)
if contest.created_by != request.user.campus:
return redirect('homepage')
except Contest.DoesNotExist:
return redirect('homepage')
if not problem_id == 0:
try:
problem_title = Problem.objects.get(pk=problem_id).title
except Problem.DoesNotExist:
problem_title = None
if problem_id == 0:
if result == "All":
submission_list = Submit.objects.filter(
contest_id=contest_id).order_by('submit_time').reverse()
else:
submission_list = Submit.objects.filter(
contest_id=contest_id,
result=result).order_by('submit_time').reverse()
problem_title = "All problems"
else:
if result == "All":
submission_list = Submit.objects.filter(
contest_id=contest_id,
problem_id=problem_id).order_by('submit_time').reverse()
else:
submission_list = Submit.objects.filter(
contest_id=contest_id, problem_id=problem_id,
result=result).order_by('submit_time').reverse()
start_time = contest.start_time
for i in submission_list:
i.contest_time = i.submit_time - start_time
submission_list, paginator = pagination(request, submission_list)
context = {
'submission_list': submission_list,
'problem_title': problem_title,
'paginator': paginator,
'contest_title': contest.title,
'selected_problem': problem_id,
'selected_result': result,
'rejudge': 'hover'
}
return render(request, 'site_rejudge_filter.html', context)
def jury_view_problem(request):
total_problems = Problem.objects.all().order_by('pk').reverse()
total_problems, paginator = pagination(request, total_problems)
return render(request, 'jury_problem_list.html', {
'problem': total_problems,
'paginator': paginator,
'pro': 'hover'
})
def site_view_problem(request):
refresh_contest_session_admin(request) # refersh the contest session
total_problems = Problem.objects.all().order_by('title')
total_problems, paginator = pagination(request, total_problems)
context = {
'problem': total_problems,
'paginator': paginator,
'pro': 'hover'
}
return render(request, 'site_problem_list.html', context)
def public_user_submission(request):
problem_id = request.GET.get('problem_id', 0)
result = request.GET.get('result', "All")
try:
problem_id = int(problem_id)
except ValueError:
return redirect('homepage')
if not problem_id == 0:
try:
problem_title = Problem.objects.get(pk=problem_id).title
except Problem.DoesNotExist:
problem_title = None
else:
problem_title = "All problems"
all_submission = Submit.objects.filter(
user__role__short_name='public').order_by('submit_time').reverse()
all_problems = set()
for submit in all_submission:
pro = (submit.problem.id, submit.problem.title)
all_problems.add(pro)
all_problems = sorted(all_problems, key=lambda x: x[1].lower())
submission_list = all_submission
if problem_id:
submission_list = submission_list.filter(problem_id=problem_id)
if not result == "All":
submission_list = submission_list.filter(result=result)
all_results = [
'Correct', 'Wrong Answer', 'Judging', 'Time Limit Exceeded',
'Run Time Error', 'Compiler Error', 'Memory Limit Exceeded',
'No Output'
]
submission_list, paginator = pagination(request, submission_list)
base_page = check_base_site(request)
context = {
'submission_list': submission_list,
'all_problems': all_problems,
'paginator': paginator,
'all_results': all_results,
"selected_problem": problem_id,
"problem_title": problem_title,
'selected_result': result,
'base_page': base_page,
'submit': 'hover'
}
return render(request, 'public_view_submission.html', context)
def public_submit(request):
problem_list = Problem.objects.filter(is_public=True).order_by('title')
if request.method == "POST":
form = SubmitAnswer(request.POST, request.FILES)
form.fields['problem'].queryset = problem_list
if form.is_valid():
post = form.save(commit=False)
post.submit_time = timezone.now()
post.user = request.user
post.submit_file = None
post.server_id = 1
post.save()
post.submit_file = request.FILES.get('submit_file')
post.result = 'Judging'
post.save()
judge_background.apply_async([post.id])
# result = judge(file_name=post.submit_file.path,
# problem=post.problem, language=post.language, submit=post)
# post.result = result
# post.save()
update_statistics(post)
return redirect('public_submit')
else:
form = SubmitAnswer()
form.fields['problem'].queryset = problem_list
all_submits = Submit.objects.filter(
user=request.user).order_by('submit_time').reverse()
for i in all_submits:
i.source_code = read_source_code(i.submit_file)
i.language_mode = i.language.editor_mode
form1 = SubmitWithEditor()
form1.fields['problem'].choices = [(None, '----------')
] + [(i.id, i) for i in problem_list]
form1.fields['language'].choices = [(None, '----------')] + [
(i.id, i) for i in Language.objects.filter(enable=True)
]
all_submits, paginator = pagination(request, all_submits)
context = {
'form': form,
'form1': form1,
'all_submits': all_submits,
"paginator": paginator,
'submit': 'hover'
}
return render(request, 'public_submit.html', context)
def submit_specific_problem(request, problem_id):
problem = Problem.objects.get(pk=problem_id)
initial_info = {'specific_problem': problem.title}
if request.method == "POST":
form = SubmitSpecificProblem(request.POST,
request.FILES,
initial=initial_info)
if form.is_valid():
post = form.save(commit=False)
post.submit_time = timezone.now()
post.user = request.user
post.problem = problem
post.submit_file = None
post.server_id = 1
post.save()
post.submit_file = request.FILES.get('submit_file')
post.result = 'Judging'
post.save()
judge_background.apply_async([post.id])
update_statistics(post)
return redirect('submit_specific_problem', problem_id)
else:
form = SubmitSpecificProblem(initial=initial_info)
all_submits = Submit.objects.filter(
user=request.user, problem=problem,
problem__is_public=True).order_by('submit_time').reverse()
for i in all_submits:
i.source_code = read_source_code(i.submit_file)
i.language_mode = i.language.editor_mode
form1 = SubmitSpecificProblemWithEditor(initial=initial_info)
form1.fields['language'].choices = [(None, '----------')] + [
(i.id, i) for i in Language.objects.filter(enable=True)
]
all_submits, paginator = pagination(request, all_submits)
context = {
'form': form,
'form1': form1,
'all_submits': all_submits,
'problem': problem,
"paginator": paginator,
'submit': 'hover'
}
return render(request, 'public_specific_problem_submit.html', context)
def public_rejudge_submission_filter(request):
try:
problem_id = int(request.GET.get('problem_id'))
except ValueError:
return redirect('homepage')
result = request.GET.get('result')
if not problem_id == 0:
try:
problem_title = Problem.objects.get(pk=problem_id).title
except Problem.DoesNotExist:
problem_title = None
if problem_id == 0:
if result == "All":
submission_list = Submit.objects.filter(
user__role__short_name='public').order_by(
'submit_time').reverse()
else:
submission_list = Submit.objects.filter(
user__role__short_name='public',
result=result).order_by('submit_time').reverse()
problem_title = "All problems"
else:
if result == "All":
submission_list = Submit.objects.filter(
user__role__short_name='public',
problem_id=problem_id).order_by('submit_time').reverse()
else:
submission_list = Submit.objects.filter(
user__role__short_name='public',
problem_id=problem_id,
result=result).order_by('submit_time').reverse()
submission_list, paginator = pagination(request, submission_list)
context = {
'submission_list': submission_list,
'problem_title': problem_title,
'paginator': paginator,
'selected_problem': problem_id,
'selected_result': result,
'rejudge': 'hover'
}
return render(request, 'public_rejudge_filter.html', context)
def request_clarification(request):
refresh_contest_session_contestant(request) # refersh the contest session
current_contest_id = request.session.get('active_contest_contestant')
problem_list = None
try:
current_contest = Contest.objects.get(pk=current_contest_id,
active_time__lte=timezone.now(),
enable=True)
except Contest.DoesNotExist:
current_contest = None
if current_contest:
problem_list = current_contest.problem.all().order_by('title')
if request.method == "POST":
form = ClarificationRequest(request.POST)
form.fields['problem'].queryset = problem_list
if form.is_valid():
post = form.save(commit=False)
post.send_time = timezone.now()
post.user = request.user
post.contest = current_contest
post.save()
return redirect('request_clarification')
else:
form = ClarificationRequest()
form.fields['problem'].queryset = problem_list
else:
form = None
all_clarification = Clarification.objects.filter(
contest=current_contest,
user=request.user).order_by('send_time').reverse()
for cla in all_clarification:
if len(cla.question) > 100:
cla.short_question = cla.question[:100] + ' ...'
else:
cla.short_question = cla.question
all_clarification, paginator = pagination(request, all_clarification)
context = {
'form': form,
'all_clarification': all_clarification,
'paginator': paginator,
'clar': 'hover'
}
return render(request, 'clarification_request.html', context)
def contest_list(request):
refresh_contest_session_admin(request) # refersh the contest session
total_contest = Contest.objects.all().order_by('start_time').reverse()
now = timezone.now()
for contest in total_contest:
if contest.enable == False:
contest.status = "disable"
elif now < contest.active_time:
contest.status = "not active"
elif now < contest.start_time:
contest.status = "active"
elif contest.start_time <= now and now < contest.end_time:
contest.status = "on going"
elif contest.end_time <= now and now < contest.deactivate_time:
contest.status = "end"
else:
contest.status = "deactivate"
total_contest, paginator = pagination(request, total_contest)
return render(request, 'contest_list.html', {'contest': total_contest, 'paginator': paginator, 'cont': 'hover'})
def public_multi_rejudge(request, problem_id, contest_id, user_id):
submit = Submit.objects.filter(user__role__short_name='public',
problem_id=problem_id,
user_id=user_id).order_by('submit_time')
if not submit:
return redirect('homepage')
specific_submissions = list()
for i in submit:
if i.result == 'Correct':
specific_submissions.append(i)
break
else:
specific_submissions.append(i)
specific_submissions, paginator = pagination(request, specific_submissions)
context = {
'submit': specific_submissions,
'contest_id': specific_submissions[0].contest.pk,
'paginator': paginator,
'rejudge': 'hover'
}
return render(request, 'public_single_user_rejudge.html', context)
def submit_specific_problem_with_editor(request, problem_id):
problem = Problem.objects.get(pk=problem_id)
initial_info = {'specific_problem': problem.title}
if request.method == "POST":
form1 = SubmitSpecificProblemWithEditor(request.POST,
initial=initial_info)
form1.fields['language'].choices = [(None, '----------')] + [
(i.id, i) for i in Language.objects.filter(enable=True)
]
if form1.is_valid():
post = Submit()
now = timezone.now()
post.submit_time = now
post.user = request.user
lang = Language.objects.get(pk=int(request.POST['language']))
post.language = lang
post.problem = problem
post.submit_file = None
post.server_id = 1
post.save()
path = problem.title + '_' + str(
request.user.id) + '_' + str(now) + '.' + lang.extension
path = path.replace(' ', '').replace('/', '')
source = request.POST['source']
if lang.name == 'Java':
path = java_class_name_find(source, path)
code = open(path, 'w')
code.write(source)
code.close()
code = open(path, 'rb')
source_code = code.read()
code.close()
submit_file = InMemoryUploadedFile(BytesIO(source_code), 'file',
path, 'file/text',
sys.getsizeof(source_code),
None)
post.submit_file = submit_file
post.result = 'Judging'
post.save()
judge_background.apply_async([post.id])
os.system(f'rm "{path}"')
update_statistics(post)
return redirect('submit_specific_problem', problem_id)
else:
form1 = SubmitSpecificProblemWithEditor(initial=initial_info)
form1.fields['language'].choices = [(None, '----------')] + [
(i.id, i) for i in Language.objects.filter(enable=True)
]
all_submits = Submit.objects.filter(
user=request.user).order_by('submit_time').reverse()
for i in all_submits:
i.source_code = read_source_code(i.submit_file)
i.language_mode = i.language.editor_mode
form = SubmitSpecificProblem(initial=initial_info)
all_submits, paginator = pagination(request, all_submits)
context = {
'form': form,
'form1': form1,
'all_submits': all_submits,
'problem': problem,
"paginator": paginator,
'submit': 'hover'
}
return render(request, 'public_specific_problem_submit.html', context)
