def submit (request):
user = user_auth(request)
if request.method == 'POST':
form = JobSubmitForm(request.POST)
if form.is_valid() and 'solution' in request.FILES:
job = form.save(commit=False)
if job.contest.started() is False and user.is_staff is False:
return redirect_to_index("You can't submit, contest dind't start yet.")
if job.contest.ended() is True:
return redirect_to_index("You can't submit, contest ended.")
job.message, job.type, job.date, job.user, job.source_size, job.percent_completed, job.score = 'Waiting', 'O', datetime.datetime.now(), user, request.FILES['solution'].size, 0, 0
if job.contest.started() is False or job.contest.code == 'none':
job.private = True
job.save()
save_file(dest = os.path.join(JOBS_DIR, "job%d.%s" % (job.id, job.language)), file = request.FILES['solution'])
return HttpResponseRedirect(reverse('webEval.web_eval__core.grader__controller.status') + '?problem=%s&user=%s' % (job.problem.code, user.username))
else:
form = JobSubmitForm()
return render_to_response("grader/submit_form.html",
{'form' : form,
'compilers' : judge_settings.COMPILERS,
'problems' : Problem.objects.all(),
'navigation' : {
'main' : 'judge',
'other' : 'display-job',
}
},
context_instance=RequestContext(request))
def admin_page (request):
user = user_auth(request)
if user.is_superuser is False and user.is_staff is False:
return redirect_to_index("You don't have permission to access this page")
if request.method == 'POST':
form = TicketMilestoneForm(request.POST)
if form.is_valid():
form.save()
else:
form = TicketMilestoneForm()
last_users = UserProfile.objects.all().order_by('-id')[:20]
last_logins = UserProfile.objects.all().order_by('-last_login')[:20]
return render_to_response('grader/admin_page.html',
{
'last_users' : last_users,
'last_logins' : last_logins,
'milestones' : TicketMilestone.objects.all().order_by('due'),
'milestone_form' : form,
'navigation': {
'main' : 'admin',
'other' : 'admin_page',
}
},
context_instance = RequestContext(request)
)
def display_revision (revision, user, context_instance, widgets = {}):
# Find if user cand view or manage (edit, copy, delete, etc) this page
can_attach = revision.wiki_page.can_attach_files(user)
can_edit = revision.can_edit(user)
can_view = revision.can_view(user)
if can_view is False: # He can't view this page. Let's find why.
if user is not None: # He is an user with not enough rights
return redirect_to_index("You don't have enough rights to view this page")
else: # He is not logged in, so we don't know if he can or not view this page, we'll redirect him to login page
return redirect_with_message(page = reverse('webEval.web_eval__core.auth__controller.login'),
message = "Please login to view this page")
# Finally display the wiki revision
return render_to_response('wiki_display_revision.html',
{'revision' : revision,
'can_edit' : can_edit,
'can_attach' : can_attach,
'widgets' : widgets,
'navigation' : {
'main' : 'wiki' if widgets == {} else 'judge',
'other' : 'edit-page',
}
},
context_instance=context_instance)
def edit_entry(request, username, permalink):
user = user_auth(request)
username = get_object_or_404(UserProfile, username=username)
blog_entry = get_object_or_404(BlogEntry, author=username, permalink=permalink)
if user.has_perm("web_eval__core.edit_blogentry") is False and user != username:
return redirect_to_index("You don't have permission to edit this blog entry.")
if request.method == "POST":
form = BlogEntryEditForm(request.POST, instance=blog_entry)
if form.is_valid():
form.save()
tags = []
for tag, value in request.POST.iteritems():
if re.match("tag(?P<tag_name>\d+)input", tag):
tags.append(value)
update_tags(blog_entry, tags)
return HttpResponseRedirect(
reverse(
"webEval.web_eval__core.blog__controller.display_entry",
kwargs={"username": username.username, "permalink": permalink},
)
)
else:
form = BlogEntryEditForm(blog_entry)
return render_to_response(
"blog/edit_entry.html",
{"form": form, "blog_entry": blog_entry, "navigation": {"main": "blog", "other": "edit-entry"}},
context_instance=RequestContext(request),
)
def create_problem (request):
user = user_auth(request)
if not user.has_perm('web_eval__core.add_problem'):
return redirect_to_index("You don't have permission to add problems.")
if request.method == 'POST':
form = ProblemCreateForm(request.POST)
if form.is_valid():
contest = Contest.objects.get(code = 'none')
problem = form.save(commit = False)
problem.name = problem.code
problem.owner = user
problem.resource = contest
try:
problem.author = Author.objects.get(name = '%s %s' % (user.first_name, user.last_name))
except:
author = Author(name = '%s %s' % (user.first_name, user.last_name),
code = '%s_%s' % (user.first_name, user.last_name))
author.save()
problem.author = author
problem.time_limit = judge_settings.DEFAULT_TIME_LIMIT
problem.memory_limit = judge_settings.DEFAULT_MEMORY_LIMIT
problem.source_limit = judge_settings.DEFAULT_SOURCE_LIMIT
problem.forum_topic = None
problem.wiki_page = create_problem_wiki_page(problem, request)
problem.type = 'Normal'
problem.save()
contest.problems.add(problem)
contest.save()
os.system("mkdir %s" % os.path.join(TESTS_DIR, problem.code))
os.system("touch %s" % os.path.join(TESTS_DIR, problem.code, 'tests.txt'))
os.system("svn add %s" % os.path.join(TESTS_DIR, problem.code))
return HttpResponseRedirect(reverse('webEval.web_eval__core.grader__controller.configure_problem',
kwargs={'problem_code' : problem.code}
)
)
else:
form = ProblemCreateForm()
return render_to_response("grader/create_problem.html",
{
'form' : form,
'navigation' :
{
'main' : 'admin',
'other' : 'create-problem'
}
},
context_instance=RequestContext(request))
def create_wiki_page (request, page_url = None):
user = user_auth(request)
if user.has_perm('web_eval__core.add_wikipage') is False:
return redirect_to_index("You don't have permission to add wiki pages.")
if WikiPage.objects.filter(url = page_url):
return redirect_to_index("Page already exists...")
if request.method == 'POST':
form = WikiRevisionEditForm(request.POST)
if form.is_valid():
page_url = request.POST['url']
page = WikiPage()
page.url = page_url
page.author = user
page.save()
revision = form.save(commit = False)
revision.revision_id = 1
revision.date = datetime.datetime.now()
revision.ip = get_ip_from_request(request)
revision.wiki_page = page
revision.author = user
revision.save()
page.last_revision = revision
page.save()
return HttpResponseRedirect(reverse('webEval.web_eval__core.wiki__controller.display_page',
kwargs={'page_url' : page_url }))
else:
form = WikiRevisionEditForm()
return render_to_response('wiki_edit_revision.html',
{'revision' : 1,
'form' : form,
'edit' : False,
'page_url' : page_url,
},
context_instance = RequestContext(request)
)
def delete_entry(request, username, permalink):
user = user_auth(request)
if user.has_perm("web_eval__core.blogentry_delete") is False:
return redirect_to_index("You don't have permission to delete blog entries.")
username = get_object_or_404(UserProfile, username=username)
blog_entry = get_object_or_404(BlogEntry, author=username, permalink=permalink)
blog_entry.delete()
return HttpResponseRedirect(reverse("webEval.web_eval__core.blog__controller.index"))
def edit_page (request, page_url, widgets = {}):
user = user_auth(request)
page = get_object_or_404(WikiPage, url=page_url)
revisions_list = WikiRevision.objects.filter(wiki_page=page)
if not page.last_revision.can_edit(user):
return redirect_to_index("You don't have enough rights to edit this page, i will redirect you...")
if request.method == 'POST': # we have some POST data.
form = WikiRevisionEditForm(request.POST)
if form.is_valid():
revision = form.save(commit = False)
revision.revision_id = page.last_revision.revision_id + 1
revision.date = datetime.datetime.now()
revision.ip = get_ip_from_request(request)
revision.wiki_page = page
revision.author = user
revision.save()
page.last_revision = revision
page.save()
if 'is_problem' in widgets:
return HttpResponseRedirect(reverse('webEval.web_eval__core.grader__controller.display_problem',
kwargs = {'problem_code' : widgets['problem'].code }))
return HttpResponseRedirect(reverse('webEval.web_eval__core.wiki__controller.display_page',
kwargs = {'page_url' : page.url }))
else:
print form.errors
else:
form = WikiRevisionEditForm(page.last_revision)
can_attach = page.last_revision.wiki_page.can_attach_files(user)
can_edit = page.last_revision.can_edit(user)
can_view = page.last_revision.can_view(user)
return render_to_response('wiki_edit_revision.html',
{'revision' : page.last_revision,
'page' : page,
'form' : form,
'edit' : True,
'widgets' : widgets,
'can_view' : can_view,
'can_edit' : can_edit,
'can_attach' : can_attach,
'navigation' : {
'main' : 'wiki',
'other' : 'edit-page',
}
},
context_instance = RequestContext(request)
)
def delete_attachment (request, page_url, hash):
user = user_auth(request)
wiki_page = get_object_or_404(WikiPage, url = page_url)
attachment = get_object_or_404(WikiAttachment, wiki_page = wiki_page, hash = hash)
if attachment.can_delete(user) is False:
return redirect_to_index("You don't have enough permissions to delete this attachment.")
os.remove(os.path.join(ATTACHMENTS_DIR, "attachment%d-%s" % (attachment.id, attachment.name)))
attachment.delete()
return HttpResponseRedirect(reverse('webEval.web_eval__core.wiki__controller.attachments',
kwargs={'page_url' : wiki_page.url }))
def toogle_dashboard(request, username, permalink):
user = user_auth(request)
username = get_object_or_404(UserProfile, username=username)
blog_entry = get_object_or_404(BlogEntry, author=username, permalink=permalink)
if user.has_perm("web_eval__core_add_dashboardentry") is False:
return redirect_to_index("You don't have permission to modify dashboard.")
if DashboardEntry.objects.filter(blog_entry=blog_entry):
DashboardEntry.objects.filter(blog_entry=blog_entry).delete()
else:
DashboardEntry(blog_entry=blog_entry).save()
return HttpResponseRedirect(reverse("webEval.web_eval__core.wiki__controller.dashboard"))
def attach (request, page_url):
user = user_auth(request)
page = get_object_or_404(WikiPage, url = page_url)
if page.can_attach_files(user) is False:
return redirect_to_index("You don't have permissions to attach files to this page.")
message = None
if request.method == 'POST':
if 'file_name' in request.FILES:
attachment = WikiAttachment()
attachment.name = request.FILES['file_name'].name
attachment.wiki_page = page
attachment.ip = get_ip_from_request(request)
attachment.size = request.FILES['file_name'].size
attachment.date = datetime.datetime.now()
attachment.author = user
attachment.security = 'Public'
attachment.hash = ''
attachment.save()
attachment.hash = hashlib.md5(str(attachment.id)).hexdigest()
attachment.save()
save_file(dest = os.path.join(ATTACHMENTS_DIR, "attachment%d-%s" % (attachment.id, attachment.name)), file = request.FILES['file_name'])
message = 'File uploaded successfully.'
can_attach = page.last_revision.wiki_page.can_attach_files(user)
can_edit = page.last_revision.can_edit(user)
can_view = page.last_revision.can_view(user)
return render_to_response('wiki/attach.html',
{
'page' : page,
'message' : message if message is not None else '',
'can_view' : can_view,
'can_edit' : can_edit,
'can_attach' : can_attach,
'navigation' : {
'main' : 'wiki',
'other' : 'attach',
}
},
context_instance = RequestContext(request),
)
def display_job (request, job_id):
user = user_auth (request)
job = get_object_or_404(Job, id=job_id)
if job.can_view(user) is False:
return redirect_to_index("You don't have permission to view this job")
return render_to_response("grader/display_job.html",
{
'job' : job,
'tests' : Test.objects.filter(job=job).order_by('no'),
'navigation' : {
'main' : 'judge',
'other' : 'display-job',
}
},
context_instance = RequestContext(request))
def edit_problem_tags (request, problem_code):
user = user_auth(request)
if user is None or user.has_perm('web_eval__core.edit_problem') is False:
return redirect_to_index("You don't have permission to edit problems.")
problem = get_object_or_404(Problem, code = problem_code)
return render_to_response('grader/edit_problem_tags.html',
{
'problem' : problem,
'navigation' : {
'main' : 'judge',
'other' : 'edit-problem-tags',
}
},
context_instance = RequestContext(request)
)
def display_attachment (request, page_url, hash):
user = user_auth(request)
wiki_page = get_object_or_404(WikiPage, url = page_url)
attachment = get_object_or_404(WikiAttachment, wiki_page = wiki_page, hash = hash)
if attachment.can_view(user) is False:
return redirect_to_index("You don't have enough permissions to view this attachment.")
filename = os.path.join(ATTACHMENTS_DIR, "attachment%d-%s" % (attachment.id, attachment.name))
try:
wrapper = FileWrapper(file(filename))
except IOError:
raise Http404
response = HttpResponse(wrapper, content_type='text/plain')
response['Content-Length'] = os.path.getsize(filename)
response['Content-Disposition'] = 'attachment; filename="%s"' % attachment.name.replace('"', '')
return response
def display_job_source_code (request, job_id):
user = user_auth (request)
job = get_object_or_404(Job, id=job_id)
if job.can_view_source_code(user) is False:
return redirect_to_index("You don't have permission to view this job's source code")
lexer = get_lexer_by_name(pygments_standardize(job.language), stripall=True, tabsize=4)
formatter = HtmlFormatter(linenos=True)
source_code = highlight(''.join(open(os.path.join(JOBS_DIR, 'job%d.%s' % (job.id, job.language)), 'r').readlines()), lexer, formatter)
return render_to_response("grader/display_job_source_code.html",
{
'job' : job,
'source_code' : source_code,
'navigation' : {
'main' : 'judge',
'other' : 'display-job-source',
}
},
context_instance = RequestContext(request))
def configure_contest (request, contest_code):
user = user_auth(request)
if user.has_perm('web_eval__core.edit_contest') is False:
return redirect_to_index("You don't have permission to edit contests.")
contest = get_object_or_404(Contest, code = contest_code)
message = ""
if request.method == 'POST':
form = ContestEditForm(request.POST, instance = contest)
if form.is_valid():
form.save()
contest.problems.remove()
print request.POST
for problem_id in request.POST.getlist('selected_problems'):
problem = get_object_or_None(Problem, id = problem_id)
print problem_id
if problem is not None:
contest.problems.add(problem)
contest.save()
message = "Contest successfully saved."
form = ContestEditForm(contest)
else:
form = ContestEditForm(contest)
#print form.data['start_time']
return render_to_response('grader/configure_contest.html',
{
'contest' : contest,
'all_problems' : Problem.objects.all(),
'form' : form,
'message' : message,
'navigation' : {
'main' : 'admin',
'other': 'edit-contest',
}
},
context_instance = RequestContext(request))
def create_contest (request):
user = user_auth(request)
if not user.has_perm('web_eval__core.add_contest'):
return redirect_to_index("You don't have permission to add contests.")
if request.method == 'POST':
form = ContestCreateForm(request.POST)
if form.is_valid():
contest = form.save(commit = False)
contest.name = contest.code
contest.start_time = datetime.datetime.now()
contest.end_time = contest.start_time + datetime.timedelta(days=1)
contest.with_rating = False
contest.with_open_eval = False
contest.wiki_page = create_contest_wiki_page(contest, request)
contest.save()
return HttpResponseRedirect(reverse('webEval.web_eval__core.grader__controller.display_contest',
kwargs = {'contest_code' : contest.code }))
else:
form = ContestCreateForm()
return render_to_response("grader/create_contest.html",
{
'form': form,
'navigation' :
{
'main' : 'admin',
'other' : 'create-contest'
}
},
context_instance = RequestContext(request)
)
def history (request, page_url, widgets = {}):
user = user_auth(request)
page = get_object_or_404(WikiPage, url = page_url)
revisions = WikiRevision.objects.filter(wiki_page = page).order_by('-revision_id')
if page.last_revision.can_view(user) is False:
return redirect_to_index("You don't have enough rights to view this page's history")
problem = get_object_or_None(Problem, wiki_page=page)
if problem is not None:
widgets['is_problem'] = True
widgets['problem'] = problem
user_profile = get_object_or_None(UserProfile, wiki_page=page)
if user_profile is not None:
widgets['is_user'] = True
widgets['user'] = user_profile
can_attach = page.last_revision.wiki_page.can_attach_files(user)
can_edit = page.last_revision.can_edit(user)
can_view = page.last_revision.can_view(user)
return render_to_response('wiki_display_history.html',
{
'page' : page,
'revisions' : revisions,
'widgets' : widgets,
'can_view' : can_view,
'can_edit' : can_edit,
'can_attach' : can_attach,
'navigation' : {
'main' : 'wiki',
'other' : 'history',
}
},
context_instance = RequestContext(request))
def configure_problem (request, problem_code):
user = user_auth(request)
if user.has_perm('web_eval__core.edit_problem') is False:
return redirect_to_index("You don't have permission to edit problems.")
problem = get_object_or_404(Problem, code = problem_code)
tests = GraderTest.objects.filter(problem = problem).order_by('no')
message = ""
if request.method == 'POST':
if 'testid' in request.POST:
if request.POST['testid'] == '':
form = ProblemEditForm(problem)
else:
form = ProblemEditForm(problem)
test_id = request.POST['testid']
test = get_object_or_None(GraderTest, problem = problem, no = test_id)
if test is None:
test = GraderTest(problem = problem, no = test_id)
test.save()
if 'inputfile' in request.FILES and request.FILES['inputfile'] != '':
upload_input_file(request.FILES['inputfile'], problem, test)
if 'outputfile' in request.FILES and request.FILES['outputfile'] != '':
upload_output_file(request.FILES['outputfile'], problem, test)
message = "Tests succesfully uploaded."
for eval in Eval.objects.all():
eval.updated = True
eval.save()
tests_file = open(os.path.join(TESTS_DIR, problem.code, 'tests.txt'), 'w')
tests = GraderTest.objects.filter(problem = problem)
for test in tests:
print >> tests_file, "%s %d" % (test.no, 100 / len(tests))
tests_file.close()
os.system("svn commit %s -m \"Test %s for problem %s\"" % (TESTS_DIR, test_id, problem.code))
else:
resource = problem.resource
form = ProblemEditForm(request.POST, instance = problem)
if form.is_valid():
form.save()
if problem.resource != resource:
problem.resource.problems.add(problem)
problem.resource.save()
message = "Problem successfully saved."
form = ProblemEditForm(problem)
else:
form = ProblemEditForm(problem)
return render_to_response('grader/configure_problem.html',
{
'problem' : problem,
'contests' : Contest.objects.all(),
'tests' : tests,
'form' : form,
'message' : message,
'navigation' : {
'main' : 'admin',
'other' : 'configure-problem',
}
},
context_instance = RequestContext(request))
