def edit_attestation(request, attestation_id):
if not (request.user.is_tutor or request.user.is_trainer or request.user.is_superuser):
return access_denied(request)
attest = get_object_or_404(Attestation, pk=attestation_id)
if not (attest.author == request.user or request.user.is_trainer):
return access_denied(request)
if attest.published:
# If if this attestation is already final or not by this user redirect to view_attestation
return HttpResponseRedirect(reverse('view_attestation', args=[attestation_id]))
solution = attest.solution
model_solution = solution.task.model_solution
if request.method == "POST":
with transaction.atomic():
attestForm = AttestationForm(request.POST, instance=attest, prefix='attest')
attestFileFormSet = AnnotatedFileFormSet(request.POST, instance=attest, prefix='attestfiles')
ratingResultFormSet = RatingResultFormSet(request.POST, instance=attest, prefix='ratingresult')
if attestForm.is_valid() and attestFileFormSet.is_valid() and ratingResultFormSet.is_valid():
attestForm.save()
attest.final = False
attest.save()
attestFileFormSet.save()
ratingResultFormSet.save()
return HttpResponseRedirect(reverse('view_attestation', args=[attestation_id]))
else:
attestForm = AttestationForm(instance=attest, prefix='attest')
attestFileFormSet = AnnotatedFileFormSet(instance=attest, prefix='attestfiles')
ratingResultFormSet = RatingResultFormSet(instance=attest, prefix='ratingresult')
show_author = not get_settings().anonymous_attestation
show_run_checkers = get_settings().attestation_allow_run_checkers
return render_to_response("attestation/attestation_edit.html", {"attestForm": attestForm, "attestFileFormSet": attestFileFormSet, "ratingResultFormSet":ratingResultFormSet, "solution": solution, "model_solution":model_solution, "show_author":show_author, "show_run_checkers":show_run_checkers}, context_instance=RequestContext(request))
def publish(self, request, by):
""" Set attestation to published and send email to user """
self.published = True
self.published_on = datetime.now()
self.save()
email = self.solution.author.email
if not email:
return
# Send confirmation email
t = loader.get_template('attestation/attestation_email.html')
c = {
'attest': self,
'protocol': request.is_secure() and "https" or "http",
'domain': RequestSite(request).domain,
'site_name': settings.SITE_NAME,
'by': by,
'invisible_attestor' : get_settings().invisible_attestor,
}
subject = _("New attestation for your solution of the task '%s'") % self.solution.task
body = t.render(c)
reply_to = ([self.author.email] if self.author.email and (not get_settings().invisible_attestor) else []) \
+ ([get_settings().attestation_reply_to] if get_settings().attestation_reply_to else [])
headers = {'Reply-To': ', '.join(reply_to)} if reply_to else None
email = EmailMessage(subject, body, None, (email,), headers = headers)
email.send()
def rating_overview(request):
if not (request.user.is_trainer or request.user.is_superuser):
return access_denied(request)
tasks = Task.objects.filter(submission_date__lt = datetime.datetime.now).order_by('publication_date','submission_date')
users = User.objects.filter(groups__name='User').filter(is_active=True).order_by('last_name','first_name')
rating_list = user_task_attestation_map(users, tasks)
FinalGradeFormSet = modelformset_factory(User, fields=('final_grade',), extra=0)
# corresponding user to user_id_list in reverse order! important for easy displaying in template
user = User.objects.filter(groups__name='User').filter(is_active=True).order_by('-last_name','-first_name')
script = Script.objects.get_or_create(id=1)[0]
if request.method == "POST":
final_grade_formset = FinalGradeFormSet(request.POST, request.FILES, queryset = user)
script_form = ScriptForm(request.POST, instance=script)
publish_final_grade_form = PublishFinalGradeForm(request.POST, instance=get_settings())
if final_grade_formset.is_valid() and script_form.is_valid() and publish_final_grade_form.is_valid():
final_grade_formset.save()
script_form.save()
publish_final_grade_form.save()
else:
final_grade_formset = FinalGradeFormSet(queryset = user)
script_form = ScriptForm(instance=script)
publish_final_grade_form = PublishFinalGradeForm(instance=get_settings())
return render_to_response("attestation/rating_overview.html", {'rating_list':rating_list, 'tasks':tasks, 'final_grade_formset':final_grade_formset, 'script_form':script_form, 'publish_final_grade_form':publish_final_grade_form}, context_instance=RequestContext(request))
def rating_overview(request):
full_form = request.user.is_trainer or request.user.is_superuser
if not (full_form or
(request.user.is_coordinator and request.method != "POST")):
return access_denied(request)
tasks = Task.objects.filter(submission_date__lt=datetime.datetime.now())
users = User.objects.filter(groups__name='User').filter(
is_active=True).order_by('last_name', 'first_name', 'id')
# corresponding user to user_id_list in reverse order! important for easy displaying in template
rev_users = users.reverse()
users = users.select_related("user_ptr", "user_ptr__groups__name",
"user_ptr__is_active", "user_ptr__user_id")
FinalGradeFormSet = modelformset_factory(User,
fields=('final_grade', ),
extra=0)
if request.method == "POST":
final_grade_option_form = FinalGradeOptionForm(request.POST,
instance=get_settings())
if final_grade_option_form.is_valid():
final_grade_option_form.save()
if 'save' in request.POST:
# also save final grades
final_grade_formset = FinalGradeFormSet(request.POST,
request.FILES,
queryset=rev_users)
publish_final_grade_form = PublishFinalGradeForm(
request.POST, instance=get_settings())
if final_grade_formset.is_valid(
) and publish_final_grade_form.is_valid():
final_grade_formset.save()
publish_final_grade_form.save()
else:
final_grade_formset = FinalGradeFormSet(queryset=rev_users)
publish_final_grade_form = PublishFinalGradeForm(
instance=get_settings())
else:
# all 3 forms are created without request input
final_grade_option_form = FinalGradeOptionForm(instance=get_settings())
final_grade_formset = FinalGradeFormSet(queryset=rev_users)
publish_final_grade_form = PublishFinalGradeForm(
instance=get_settings())
rating_list = user_task_attestation_map(users, tasks)
return render(
request, "attestation/rating_overview.html", {
'rating_list': rating_list,
'tasks': tasks,
'final_grade_formset': final_grade_formset,
'final_grade_option_form': final_grade_option_form,
'publish_final_grade_form': publish_final_grade_form,
'full_form': full_form
})
def edit_attestation(request, attestation_id):
if not (request.user.is_tutor or request.user.is_trainer
or request.user.is_superuser):
return access_denied(request)
attest = get_object_or_404(Attestation, pk=attestation_id)
if not (attest.author == request.user or request.user.is_trainer):
return access_denied(request)
if attest.published:
# If if this attestation is already final or not by this user redirect to view_attestation
return HttpResponseRedirect(
reverse('view_attestation', args=[attestation_id]))
solution = attest.solution
model_solution = solution.task.model_solution
if request.method == "POST":
with transaction.atomic():
attestForm = AttestationForm(request.POST,
instance=attest,
prefix='attest')
attestFileFormSet = AnnotatedFileFormSet(request.POST,
instance=attest,
prefix='attestfiles')
ratingResultFormSet = RatingResultFormSet(request.POST,
instance=attest,
prefix='ratingresult')
if attestForm.is_valid() and attestFileFormSet.is_valid(
) and ratingResultFormSet.is_valid():
attestForm.save()
attest.final = False
attest.save()
attestFileFormSet.save()
ratingResultFormSet.save()
return HttpResponseRedirect(
reverse('view_attestation', args=[attestation_id]))
else:
attestForm = AttestationForm(instance=attest, prefix='attest')
attestFileFormSet = AnnotatedFileFormSet(instance=attest,
prefix='attestfiles')
ratingResultFormSet = RatingResultFormSet(instance=attest,
prefix='ratingresult')
show_author = not get_settings().anonymous_attestation
show_run_checkers = get_settings().attestation_allow_run_checkers
return render_to_response("attestation/attestation_edit.html", {
"attestForm": attestForm,
"attestFileFormSet": attestFileFormSet,
"ratingResultFormSet": ratingResultFormSet,
"solution": solution,
"model_solution": model_solution,
"show_author": show_author,
"show_run_checkers": show_run_checkers
},
context_instance=RequestContext(request))
def save(self):
user = super(MyRegistrationForm, self).save()
# default group: user
user.groups = Group.objects.filter(name='User')
# disable user until activated via email
user.is_active = False
user.set_new_activation_key()
user.mat_number = self.cleaned_data.get("mat_number")
user.save()
# Send activation email
c = {
'email': user.email,
'domain': self.domain,
'site_name': settings.SITE_NAME,
'uid': int_to_base36(user.id),
'user': user,
'protocol': self.use_https and 'https' or 'http',
'activation_key': user.activation_key,
'expiration_days': get_settings().acount_activation_days,
}
if get_settings().account_manual_validation:
t = loader.get_template(
'registration/registration_email_manual_to_staff.html')
send_mail(
_("Account activation on %s for %s (%s) ") %
(settings.SITE_NAME, user.username, unicode(user)),
t.render(Context(c)), None, [
staff.email
for staff in User.objects.all().filter(is_staff=True)
])
t = loader.get_template(
'registration/registration_email_manual_to_user.html')
send_mail(
_("Account activation on %s") % settings.SITE_NAME,
t.render(Context(c)), None, [user.email])
else:
t = loader.get_template('registration/registration_email.html')
send_mail(
_("Account activation on %s") % settings.SITE_NAME,
t.render(Context(c)), None, [user.email])
return user
def register(request):
extra_context = {}
if get_settings().deny_registration_from < datetime.now():
extra_context['deny_registration_from'] = get_settings().deny_registration_from
extra_context['admins'] = User.objects.filter(is_superuser=True)
extra_context['trainers'] = Group.objects.get(name="Trainer").user_set.all()
else:
if request.method == 'POST':
form = MyRegistrationForm(request.POST, domain=RequestSite(request).domain, use_https=request.is_secure())
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('registration_complete'))
else:
form = MyRegistrationForm()
extra_context['form'] = form
return render_to_response('registration/registration_form.html', extra_context, context_instance=RequestContext(request))
def solution_detail(request, solution_id, full):
solution = get_object_or_404(Solution, pk=solution_id)
if (not (solution.author == request.user
or in_group(request.user, 'Trainer') or
(solution.author.tutorial and
solution.author.tutorial.tutors.filter(id=request.user.id)))):
return access_denied(request)
if (request.method == "POST"):
solution.copy()
return HttpResponseRedirect(
reverse('solution_list', args=[solution.task.id]))
else:
attestations = Attestation.objects.filter(
solution__task=solution.task,
author__tutored_tutorials=request.user.tutorial)
attestationsPublished = attestations[
0].published if attestations else False
return object_detail(request,
Solution.objects.all(),
solution_id,
extra_context={
"attestationsPublished":
attestationsPublished,
"accept_all_solutions":
get_settings().accept_all_solutions,
"full": full
},
template_object_name='solution')
def taskList(request):
now = django.utils.timezone.now()
tasks = Task.objects.filter(
publication_date__lte=now).order_by('submission_date')
expired_Tasks = Task.objects.filter(submission_date__lt=now).order_by(
'publication_date', 'submission_date')
try:
tutors = request.user.tutorial.tutors.all()
except:
tutors = None
trainers = User.objects.filter(groups__name="Trainer")
# we only have a single user here, so the rating_list only contains a single row;
# this row belongs to the given user
(_, attestations, threshold,
calculated_grade) = user_task_attestation_map([request.user], tasks)[0]
attestations = list(map(lambda a, b: (a, ) + b, tasks, attestations))
def tasksWithSolutions(tasks):
return [(t, t.final_solution(request.user)) for t in tasks]
return render(
request, 'tasks/task_list.html', {
'tasks': tasksWithSolutions(tasks),
'expired_tasks': tasksWithSolutions(expired_Tasks),
'attestations': attestations,
'show_final_grade': get_settings().final_grades_published,
'tutors': tutors,
'trainers': trainers,
'threshold': threshold,
'calculated_grade': calculated_grade,
})
def view_attestation(request, attestation_id):
attest = get_object_or_404(Attestation, pk=attestation_id)
if not (attest.solution.author == request.user or in_group(
request.user, 'Tutor,Trainer') or request.user.is_superuser):
return access_denied(request)
if request.method == "POST":
form = AttestationPreviewForm(request.POST, instance=attest)
if form.is_valid():
form.save()
if 'publish' in request.POST:
attest.publish(request)
return HttpResponseRedirect(
reverse('attestation_list', args=[attest.solution.task.id]))
else:
form = AttestationPreviewForm(instance=attest)
submitable = attest.author == request.user and not attest.published
return render_to_response(
"attestation/attestation_view.html", {
"attest": attest,
'submitable': submitable,
'form': form,
'show_author': not get_settings().anonymous_attestation
},
context_instance=RequestContext(request))
def activate(request, activation_key):
account = User.activate_user(activation_key)
return render(
request, 'registration/registration_activated.html', {
'account': account,
'expiration_days': get_settings().acount_activation_days
})
def shib_login(request):
attr, error = parse_attributes(request.META)
was_redirected = False
if "next" in request.REQUEST:
was_redirected = True
redirect_url = request.REQUEST.get('next', resolve_url(settings.LOGIN_REDIRECT_URL))
context = {'shib_attrs': attr,
'was_redirected': was_redirected}
if error:
return render_forbidden('registration/shib_error.html',
context,
context_instance=RequestContext(request))
try:
username = attr[settings.SHIB_USERNAME]
# TODO this should log a misconfiguration.
except:
return render_forbidden('registration/shib_error.html',
context,
context_instance=RequestContext(request))
if not attr[settings.SHIB_USERNAME] or attr[settings.SHIB_USERNAME] == '':
return render_forbidden('registration/shib_error.html',
context,
context_instance=RequestContext(request))
try:
user = User.objects.get(username=attr[settings.SHIB_USERNAME])
except User.DoesNotExist:
try:
if attr['matriculationNumber'] is not None:
user = User.objects.get(mat_number=attr['matriculationNumber'])
else:
raise User.DoesNotExist
except:
if get_settings().new_users_via_sso:
user = User.objects.create_user(attr[settings.SHIB_USERNAME],'')
user_group = Group.objects.get(name='User')
user.groups.add(user_group)
else:
return render_forbidden('registration/shib_not_allowed.html',
context,
context_instance=RequestContext(request))
# This needs to be made more general smarter
user.first_name = attr['first_name'] if attr['first_name'] is not None else user.first_name
user.last_name = attr['last_name'] if attr['last_name'] is not None else user.last_name
user.email = attr['email'] if attr['email'] is not None else user.email
user.mat_number = attr['matriculationNumber'] if attr['matriculationNumber'] is not None else user.mat_number
user.programme = attr['programme'] if attr['programme'] is not None else user.programme
user.save()
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
if not redirect_url or '//' in redirect_url or ' ' in redirect_url:
redirect_url = settings.LOGIN_REDIRECT_URL
return HttpResponseRedirect(redirect_url)
def get_solutions_zip(solutions):
zip_file = tempfile.SpooledTemporaryFile()
zip = zipfile.ZipFile(zip_file, 'w')
for solution in solutions:
# TODO: make this work for anonymous attesration, too
if get_settings().anonymous_attestation:
project_path = 'User' + index
project_name = 'User ' + index
else:
project_path = path_for_user(solution.author)
project_name = solution.author.get_full_name()
base_name = path_for_task(solution.task) + '/' + project_path + '/'
zip.writestr((base_name + '.project').encode('cp437'),
render_to_string('solutions/eclipse/project.xml', {
'name': project_name
}).encode("utf-8"))
zip.writestr((base_name + '.classpath').encode('cp437'),
render_to_string('solutions/eclipse/classpath.xml', {}))
for index, solutionfile in enumerate(solution.solutionfile_set.all()):
file = solutionfile.file
name = (base_name + solutionfile.path()).encode('cp437', 'ignore')
zip.write(file.path, name)
zip.close()
zip_file.seek(0)
return zip_file
def process_request(self, request):
if not request.user.is_authenticated:
return
if get_settings().requires_disclaimer_acceptance and not request.user.accepted_disclaimer:
# prevent infinite redirects or catching logout requests
if request.path not in {reverse('accept_disclaimer'), reverse('logout')}:
return HttpResponseRedirect(reverse('accept_disclaimer'))
def taskList(request):
now = django.utils.timezone.now()
tasks = Task.objects.filter(publication_date__lte = now).order_by('submission_date')
expired_Tasks = Task.objects.filter(submission_date__lt = now).order_by('publication_date','submission_date')
try:
tutors = request.user.tutorial.tutors.all()
except:
tutors = None
trainers = User.objects.filter(groups__name="Trainer")
# we only have a single user here, so the rating_list only contains a single row;
# this row belongs to that user
(_,attestations,threshold,calculated_grade) = user_task_attestation_map([request.user], tasks)[0]
attestations = map(lambda a, b: (a,)+b, tasks, attestations)
def tasksWithSolutions(tasks):
return map(lambda t: (t, t.final_solution(request.user)), tasks)
return render(request,
'tasks/task_list.html',
{
'tasks':tasksWithSolutions(tasks),
'expired_tasks': tasksWithSolutions(expired_Tasks),
'attestations':attestations,
'show_final_grade': get_settings().final_grades_published,
'tutors':tutors,
'trainers':trainers,
'threshold':threshold,
'calculated_grade':calculated_grade,
})
def clean_email(self):
# cleaning the email in the form doesn't validate it in the admin (good for tutors etc.)
data = self.cleaned_data['email']
email_validation_regex = get_settings().email_validation_regex
if email_validation_regex and not re.match(email_validation_regex, data):
raise forms.ValidationError("The email you have provided is not valid. It has to be in: " + email_validation_regex)
return data
def new_attestation_for_solution(request, solution_id, force_create=False):
if not (request.user.is_tutor or request.user.is_trainer
or request.user.is_superuser):
return access_denied(request)
solution = get_object_or_404(Solution, pk=solution_id)
attestations = Attestation.objects.filter(solution=solution)
if ((not force_create) and attestations):
return render_to_response(
"attestation/attestation_already_exists_for_solution.html", {
'task': solution.task,
'attestations': attestations,
'solution': solution,
'show_author': not get_settings().anonymous_attestation
},
context_instance=RequestContext(request))
attest = Attestation(solution=solution, author=request.user)
attest.save()
for solutionFile in solution.solutionfile_set.filter(
mime_type__startswith='text'):
annotatedFile = AnnotatedSolutionFile(attestation=attest,
solution_file=solutionFile,
content=solutionFile.content())
annotatedFile.save()
for rating in solution.task.rating_set.all():
ratingResult = RatingResult(attestation=attest, rating=rating)
ratingResult.save()
return HttpResponseRedirect(reverse('edit_attestation', args=[attest.id]))
def solution_detail(request,solution_id,full):
solution = get_object_or_404(Solution, pk=solution_id)
if not (solution.author == request.user or request.user.is_trainer or request.user.is_superuser or (solution.author.tutorial and solution.author.tutorial.tutors.filter(id=request.user.id))):
return access_denied(request)
if full and not (request.user.is_trainer or request.user.is_tutor or request.user.is_superuser):
return access_denied(request)
accept_all_solutions = get_settings().accept_all_solutions
if (request.method == "POST"):
if solution.final or solution.testupload or solution.task.expired():
return access_denied(request)
if not (solution.accepted or accept_all_solutions):
return access_denied(request)
solution.copy()
return HttpResponseRedirect(reverse('solution_list', args=[solution.task.id]))
else:
attestations = Attestation.objects.filter(solution__task=solution.task, author__tutored_tutorials=request.user.tutorial)
attestationsPublished = attestations[0].published if attestations else False
return render_to_response(
"solutions/solution_detail.html",
{
"solution": solution,
"attestationsPublished": attestationsPublished,
"accept_all_solutions": accept_all_solutions,
"full":full
},
context_instance=RequestContext(request))
def clean_email(self):
# cleaning the email in the form doesn't validate it in the admin (good for tutors etc.)
data = self.cleaned_data['email']
email_validation_regex = get_settings().email_validation_regex
if email_validation_regex and not re.match(email_validation_regex, data):
raise forms.ValidationError("The email you have provided is not valid. It has to be in: " + email_validation_regex)
return data
def taskList(request):
now = django.utils.timezone.now()
tasks = Task.objects.filter(publication_date__lte = now).order_by('submission_date')
try:
tutors = request.user.tutorial.tutors.all()
except:
tutors = None
trainers = User.objects.filter(groups__name="Trainer")
attestations = []
expired_Tasks = Task.objects.filter(submission_date__lt = now).order_by('publication_date','submission_date')
for task in expired_Tasks:
attestation_qs = Attestation.objects.filter(solution__task = task, published=True, solution__author=request.user)
attestations.append((task, attestation_qs.first()))
script = Script.objects.get_or_create(id=1)[0].script
def tasksWithSolutions(tasks):
return map(lambda t: (t, t.final_solution(request.user)), tasks)
return render_to_response(
'tasks/task_list.html',
{
'tasks':tasksWithSolutions(tasks),
'expired_tasks': tasksWithSolutions(expired_Tasks),
'attestations':attestations,
'show_final_grade': get_settings().final_grades_published,
'tutors':tutors,
'trainers':trainers,
'script':script
},
context_instance=RequestContext(request))
def taskList(Request):
now = datetime.now()
tasks = Task.objects.filter(
publication_date__lte=now).order_by('submission_date')
try:
tutors = Request.user.tutorial.tutors.all()
except:
tutors = None
trainers = User.objects.filter(groups__name="Trainer")
attestations = []
expired_Tasks = Task.objects.filter(
submission_date__lt=datetime.now).order_by('publication_date',
'submission_date')
for task in expired_Tasks:
attestation_qs = Attestation.objects.filter(
solution__task=task, published=True, solution__author=Request.user)
attestations.append(
(task, attestation_qs[0] if attestation_qs.exists() else None))
script = Script.objects.get_or_create(id=1)[0].script
return render_to_response('tasks/task_list.html', {
'tasks': tasks,
'expired_tasks': expired_Tasks,
'attestations': attestations,
'show_final_grade': get_settings().final_grades_published,
'tutors': tutors,
'trainers': trainers,
'script': script
},
context_instance=RequestContext(Request))
def activation_key_expired(self): """ Determine whether the activation key has expired, returning a boolean -- ``True`` if the key has expired. The date the user signed up is incremented by the number of days specified in the setting ''get_settings().acount_activation_days`` (which should be the number of days after signup during which a user is allowed to activate their account); if the result is less than or equal to the current date, the key has expired and this method returns ``True``. """ expiration_date = datetime.timedelta(days=get_settings().acount_activation_days) return (self.user.date_joined + expiration_date <= datetime.datetime.now())
def activate(request, activation_key):
account = User.activate_user(activation_key)
return render_to_response(
'registration/registration_activated.html', {
'account': account,
'expiration_days': get_settings().acount_activation_days
},
context_instance=RequestContext(request))
def activation_key_expired(self):
"""
Determine whether the activation key has expired, returning a boolean -- ``True`` if the key has expired.
The date the user signed up is incremented by the number of days specified in the setting ''get_settings().acount_activation_days`` (which should be the number of days after signup during which a user is allowed to activate their account); if the result is less than or equal to the current date, the key has expired and this method returns ``True``.
"""
expiration_date = datetime.timedelta(days=get_settings().acount_activation_days)
return (self.user.date_joined + expiration_date <= datetime.datetime.now())
def view_attestation(request, attestation_id):
attest = get_object_or_404(Attestation, pk=attestation_id)
may_modify = attest.author == request.user or request.user.is_trainer
may_view = attest.solution.author == request.user or request.user.is_tutor or may_modify
if not may_view:
return access_denied(request)
if request.method == "POST":
if not may_modify:
return access_denied(request)
with transaction.atomic():
form = AttestationPreviewForm(request.POST, instance=attest)
if form.is_valid():
form.save()
if 'publish' in request.POST:
if attest.solution.task.only_trainers_publish and not request.user.is_trainer:
return access_denied(request)
attest.publish(request, by=request.user)
return HttpResponseRedirect(
reverse('attestation_list',
args=[attest.solution.task.id]))
else:
form = AttestationPreviewForm(instance=attest)
submitable = may_modify and not attest.published
withdrawable = may_modify and attest.published
htmlinjectors = HtmlInjector.objects.filter(
task=attest.solution.task, inject_in_attestation_view=True)
htmlinjector_snippets = [
injector.html_file.read() for injector in htmlinjectors
]
return render_to_response(
"attestation/attestation_view.html", {
"attest": attest,
"submitable": submitable,
"withdrawable": withdrawable,
"form": form,
"show_author": not get_settings().anonymous_attestation,
"show_attestor": not get_settings().invisible_attestor,
"htmlinjector_snippets": htmlinjector_snippets,
},
context_instance=RequestContext(request))
def import_user(request):
""" View in the admin """
if request.method == 'POST':
form = ImportForm(request.POST, request.FILES)
if form.is_valid():
try:
imported_user = User.import_user(form.files['file'])
request.user.message_set.create(
message="The import was successfull. %i users imported." %
imported_user.count())
if form.cleaned_data['require_reactivation']:
for user in [
user for user in imported_user if user.is_active
]:
user.is_active = False
user.set_new_activation_key()
user.save()
if form.cleaned_data['send_reactivation_email']:
# Send activation email
t = Template(form.cleaned_data['meassagetext'])
c = {
'email':
user.email,
'domain':
RequestSite(request).domain,
'site_name':
settings.SITE_NAME,
'uid':
int_to_base36(user.id),
'user':
user,
'protocol':
request.is_secure() and 'https' or 'http',
'activation_key':
user.activation_key,
'expiration_days':
get_settings().acount_activation_days,
}
send_mail(
_("Account activation on %s") %
settings.SITE_NAME, t.render(Context(c)), None,
[user.email])
return HttpResponseRedirect(
urlresolvers.reverse('admin:accounts_user_changelist'))
except:
raise
from django.forms.util import ErrorList
msg = "An Error occured. The import file was propably malformed."
form._errors["file"] = ErrorList([msg])
else:
form = ImportForm()
return render_to_response('admin/accounts/user/import.html', {
'form': form,
'title': "Import User"
}, RequestContext(request))
def solution_list(request, task_id, user_id=None):
if (user_id and not request.user.is_trainer and not request.user.is_superuser):
return access_denied(request)
task = get_object_or_404(Task, pk=task_id)
author = get_object_or_404(User, pk=user_id) if user_id else request.user
solutions = task.solution_set.filter(author = author).order_by('-id')
final_solution = task.final_solution(author)
if task.publication_date >= datetime.now() and not request.user.is_trainer:
raise Http404
if request.method == "POST":
if task.expired() and not request.user.is_trainer:
return access_denied(request)
solution = Solution(task = task, author=author)
formset = SolutionFormSet(request.POST, request.FILES, instance=solution)
if formset.is_valid():
solution.save()
formset.save()
run_all_checker = bool(User.objects.filter(id=user_id, tutorial__tutors__pk=request.user.id) or request.user.is_trainer)
solution.check_solution(run_all_checker)
if solution.accepted:
# Send submission confirmation email
t = loader.get_template('solutions/submission_confirmation_email.html')
c = {
'protocol': request.is_secure() and "https" or "http",
'domain': RequestSite(request).domain,
'site_name': settings.SITE_NAME,
'solution': solution,
}
with tempfile.NamedTemporaryFile(mode='w+') as tmp:
tmp.write(t.render(c))
tmp.seek(0)
[signed_mail, __, __, __, __] = execute_arglist(["openssl", "smime", "-sign", "-signer", settings.CERTIFICATE, "-inkey", settings.PRIVATE_KEY, "-in", tmp.name], ".", unsafe=True)
connection = get_connection()
message = ConfirmationMessage(_("%s submission confirmation") % settings.SITE_NAME, signed_mail, None, [solution.author.email], connection=connection)
if solution.author.email:
message.send()
if solution.accepted or get_settings().accept_all_solutions:
solution.final = True
solution.save()
return HttpResponseRedirect(reverse('solution_detail', args=[solution.id]))
else:
formset = SolutionFormSet()
attestations = Attestation.objects.filter(solution__task=task, author__tutored_tutorials=request.user.tutorial)
attestationsPublished = attestations[0].published if attestations else False
return render(request, "solutions/solution_list.html",
{"formset": formset, "task":task, "solutions": solutions, "final_solution":final_solution, "attestationsPublished":attestationsPublished, "author":author, "invisible_attestor":get_settings().invisible_attestor})
def jplag(request, task_id):
if not (request.user.is_staff):
return access_denied(request)
task = get_object_or_404(Task, pk=task_id)
if request.method == 'POST':
task.run_jplag(request.POST['lang'])
return HttpResponseRedirect(reverse('solution_jplag', args=[task_id]))
jplag_lang = get_settings().jplag_setting
return render(request, "solutions/jplag.html", {"task":task, "jplag_lang": jplag_lang})
def run_jplag(self, lang):
# sanity check
if not hasattr(settings, 'JPLAGJAR'):
raise RuntimeError("Setting JPLAGJAR not set")
if not os.path.exists(settings.JPLAGJAR):
raise RuntimeError("Setting JPLAGJAR points to non-existing file %s" % settings.JPLAGJAR)
if not lang in self.jplag_languages():
raise RuntimeError("Unknown jplag settings %s" % lang)
# Remember jplag setting
configuration = get_settings()
configuration.jplag_setting = lang
configuration.save()
jplag_settings = self.jplag_languages()[lang]
path = self.jplag_dir_path()
tmp = os.path.join(path, "tmp")
# clean out previous run
if self.did_jplag_run():
shutil.rmtree(path)
# create output directory
os.makedirs(path)
# extract all final solutions
os.mkdir(tmp)
final_solutions = self.solution_set.filter(final=True)
from solutions.models import path_for_user
for solution in final_solutions:
subpath = os.path.join(tmp, path_for_user(solution.author))
os.mkdir(subpath)
solution.copySolutionFiles(subpath)
# run jplag
args = [settings.JVM,
"-jar", settings.JPLAGJAR,
"-s",
"-l", jplag_settings['param'],
"-p", jplag_settings['files'],
"-r", path,
tmp]
[output, error, exitcode, timed_out, oom_ed] = \
execute_arglist(args, path, unsafe=True)
# remove solution copies
shutil.rmtree(tmp)
# write log file
with open(os.path.join(path, "jplag.txt"), 'w') as fd:
fd.write(output)
# mark jplag as up-to-date
self.jplag_up_to_date = True
self.save()
def view_attestation(request, attestation_id):
attest = get_object_or_404(Attestation, pk=attestation_id)
may_modify = attest.author == request.user or request.user.is_trainer
may_view = attest.solution.author == request.user or request.user.is_tutor or may_modify
if not may_view:
return access_denied(request)
if request.method == "POST":
if not may_modify:
return access_denied(request)
with transaction.atomic():
form = AttestationPreviewForm(request.POST, instance=attest)
if form.is_valid():
form.save()
if 'publish' in request.POST:
if attest.solution.task.only_trainers_publish and not request.user.is_trainer:
return access_denied(request)
attest.publish(request, by = request.user)
return HttpResponseRedirect(reverse('attestation_list', args=[attest.solution.task.id]))
else:
form = AttestationPreviewForm(instance=attest)
submitable = may_modify and not attest.published
withdrawable = may_modify and attest.published
htmlinjectors = HtmlInjector.objects.filter(task = attest.solution.task, inject_in_attestation_view = True)
htmlinjector_snippets = [ injector.html_file.read() for injector in htmlinjectors ]
return render(request,
"attestation/attestation_view.html",
{
"attest": attest,
"submitable": submitable,
"withdrawable": withdrawable,
"form": form,
"show_author": not get_settings().anonymous_attestation,
"show_attestor": not get_settings().invisible_attestor,
"htmlinjector_snippets": htmlinjector_snippets,
}
)
def register(request):
extra_context = {}
if (not settings.REGISTRATION_POSSIBLE
) or get_settings().deny_registration_from < datetime.now():
extra_context['deny_registration_from'] = get_settings(
).deny_registration_from
extra_context['admins'] = User.objects.filter(is_superuser=True)
extra_context['trainers'] = Group.objects.get(
name="Trainer").user_set.all()
else:
if request.method == 'POST':
form = MyRegistrationForm(request.POST,
domain=RequestSite(request).domain,
use_https=request.is_secure())
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('registration_complete'))
else:
form = MyRegistrationForm()
extra_context['form'] = form
return render(request, 'registration/registration_form.html',
extra_context)
def rating_overview(request):
full_form = request.user.is_trainer or request.user.is_superuser
if not (full_form or (request.user.is_coordinator and request.method != "POST")):
return access_denied(request)
tasks = Task.objects.filter(submission_date__lt = datetime.datetime.now())
users = User.objects.filter(groups__name='User').filter(is_active=True).order_by('last_name', 'first_name', 'id')
# corresponding user to user_id_list in reverse order! important for easy displaying in template
rev_users = users.reverse()
users = users.select_related("user_ptr", "user_ptr__groups__name", "user_ptr__is_active", "user_ptr__user_id")
FinalGradeFormSet = modelformset_factory(User, fields=('final_grade',), extra=0)
if request.method == "POST":
final_grade_option_form = FinalGradeOptionForm(request.POST, instance=get_settings())
if final_grade_option_form.is_valid():
final_grade_option_form.save()
if 'save' in request.POST:
# also save final grades
final_grade_formset = FinalGradeFormSet(request.POST, request.FILES, queryset=rev_users)
publish_final_grade_form = PublishFinalGradeForm(request.POST, instance=get_settings())
if final_grade_formset.is_valid() and publish_final_grade_form.is_valid():
final_grade_formset.save()
publish_final_grade_form.save()
else:
final_grade_formset = FinalGradeFormSet(queryset=rev_users)
publish_final_grade_form = PublishFinalGradeForm(instance=get_settings())
else:
# all 3 forms are created without request input
final_grade_option_form = FinalGradeOptionForm(instance=get_settings())
final_grade_formset = FinalGradeFormSet(queryset=rev_users)
publish_final_grade_form = PublishFinalGradeForm(instance=get_settings())
rating_list = user_task_attestation_map(users, tasks)
return render(request, "attestation/rating_overview.html", {'rating_list': rating_list, 'tasks': tasks, 'final_grade_formset': final_grade_formset, 'final_grade_option_form': final_grade_option_form, 'publish_final_grade_form': publish_final_grade_form, 'full_form': full_form})
def run_jplag(self, lang):
# sanity check
if not hasattr(settings,'JPLAGJAR'):
raise RuntimeError("Setting JPLAGJAR not set")
if not os.path.exists(settings.JPLAGJAR):
raise RuntimeError("Setting JPLAGJAR points to non-existing file %s" % settings.JPLAGJAR)
if not lang in self.jplag_languages():
raise RuntimeError("Unknown jplag settings %s" % lang)
# Remember jplag setting
configuration = get_settings()
configuration.jplag_setting = lang
configuration.save()
jplag_settings = self.jplag_languages()[lang]
path = self.jplag_dir_path()
tmp = os.path.join(path,"tmp")
# clean out previous run
if self.did_jplag_run():
shutil.rmtree(path)
# create output directory
os.makedirs(path)
# extract all final solutions
os.mkdir(tmp)
final_solutions = self.solution_set.filter(final=True)
from solutions.models import path_for_user
for solution in final_solutions:
subpath = os.path.join(tmp, path_for_user(solution.author))
os.mkdir(subpath)
solution.copySolutionFiles(subpath)
# run jplag
args = [settings.JVM,
"-jar", settings.JPLAGJAR,
"-l", jplag_settings['param'],
"-p", jplag_settings['files'],
"-r", path,
tmp]
[output, error, exitcode,timed_out, oom_ed] = \
execute_arglist(args, path, unsafe=True)
# remove solution copies
shutil.rmtree(tmp)
# write log file
file(os.path.join(path,"jplag.txt"),'w').write(output)
# mark jplag as up-to-date
self.jplag_up_to_date = True
self.save()
def save(self):
user = super(MyRegistrationForm, self).save()
# default group: user
user.groups = Group.objects.filter(name='User')
# disable user until activated via email
user.is_active=False
user.set_new_activation_key()
user.mat_number=self.cleaned_data.get("mat_number")
user.save()
# Send activation email
c = {
'email': user.email,
'domain': self.domain,
'site_name': settings.SITE_NAME,
'uid': int_to_base36(user.id),
'user': user,
'protocol': self.use_https and 'https' or 'http',
'activation_key': user.activation_key,
'expiration_days': get_settings().acount_activation_days,
}
if get_settings().account_manual_validation:
t = loader.get_template('registration/registration_email_manual_to_staff.html')
send_mail(_("Account activation on %s for %s (%s) ") % (settings.SITE_NAME,user.username,unicode(user)), t.render(Context(c)), None, [staff.email for staff in User.objects.all().filter(is_staff=True)])
t = loader.get_template('registration/registration_email_manual_to_user.html')
send_mail(_("Account activation on %s") % settings.SITE_NAME, t.render(Context(c)), None, [user.email])
else:
t = loader.get_template('registration/registration_email.html')
send_mail(_("Account activation on %s") % settings.SITE_NAME, t.render(Context(c)), None, [user.email])
return user
def solution_list(request, task_id, user_id=None):
if (user_id and not request.user.is_trainer and not request.user.is_superuser):
return access_denied(request)
task = get_object_or_404(Task,pk=task_id)
author = get_object_or_404(User,pk=user_id) if user_id else request.user
solutions = task.solution_set.filter(author = author).order_by('-id')
final_solution = task.final_solution(author)
if task.publication_date >= datetime.now() and not request.user.is_trainer:
raise Http404
if request.method == "POST":
if task.expired() and not request.user.is_trainer:
return access_denied(request)
solution = Solution(task = task, author=author)
formset = SolutionFormSet(request.POST, request.FILES, instance=solution)
if formset.is_valid():
solution.save()
formset.save()
run_all_checker = bool(User.objects.filter(id=user_id, tutorial__tutors__pk=request.user.id) or request.user.is_trainer)
solution.check(run_all_checker)
if solution.accepted:
# Send submission confirmation email
t = loader.get_template('solutions/submission_confirmation_email.html')
c = {
'protocol': request.is_secure() and "https" or "http",
'domain': RequestSite(request).domain,
'site_name': settings.SITE_NAME,
'solution': solution,
}
if solution.author.email:
send_mail(_("%s submission confirmation") % settings.SITE_NAME, t.render(Context(c)), None, [solution.author.email])
if solution.accepted or get_settings().accept_all_solutions:
solution.final = True
solution.save()
return HttpResponseRedirect(reverse('solution_detail', args=[solution.id]))
else:
formset = SolutionFormSet()
attestations = Attestation.objects.filter(solution__task=task, author__tutored_tutorials=request.user.tutorial)
attestationsPublished = attestations[0].published if attestations else False
return render_to_response("solutions/solution_list.html",
{"formset": formset, "task":task, "solutions": solutions, "final_solution":final_solution, "attestationsPublished":attestationsPublished, "author":author, "invisible_attestor":get_settings().invisible_attestor},
context_instance=RequestContext(request))
def solution_list(request, task_id, user_id=None):
if (user_id and not request.user.is_trainer and not request.user.is_superuser):
return access_denied(request)
task = get_object_or_404(Task,pk=task_id)
author = get_object_or_404(User,pk=user_id) if user_id else request.user
solutions = task.solution_set.filter(author = author).order_by('-id')
final_solution = task.final_solution(author)
if task.publication_date >= datetime.now() and not request.user.is_trainer:
raise Http404
if request.method == "POST":
if task.expired() and not request.user.is_trainer:
return access_denied(request)
solution = Solution(task = task, author=author)
formset = SolutionFormSet(request.POST, request.FILES, instance=solution)
if formset.is_valid():
solution.save()
formset.save()
run_all_checker = bool(User.objects.filter(id=user_id, tutorial__tutors__pk=request.user.id) or request.user.is_trainer)
solution.check_solution(run_all_checker)
if solution.accepted:
# Send submission confirmation email
t = loader.get_template('solutions/submission_confirmation_email.html')
c = {
'protocol': request.is_secure() and "https" or "http",
'domain': RequestSite(request).domain,
'site_name': settings.SITE_NAME,
'solution': solution,
}
if solution.author.email:
send_mail(_("%s submission confirmation") % settings.SITE_NAME, t.render(c), None, [solution.author.email])
if solution.accepted or get_settings().accept_all_solutions:
solution.final = True
solution.save()
return HttpResponseRedirect(reverse('solution_detail', args=[solution.id]))
else:
formset = SolutionFormSet()
attestations = Attestation.objects.filter(solution__task=task, author__tutored_tutorials=request.user.tutorial)
attestationsPublished = attestations[0].published if attestations else False
return render(request, "solutions/solution_list.html",
{"formset": formset, "task":task, "solutions": solutions, "final_solution":final_solution, "attestationsPublished":attestationsPublished, "author":author, "invisible_attestor":get_settings().invisible_attestor})
def view_attestation(request, attestation_id):
attest = get_object_or_404(Attestation, pk=attestation_id)
may_modify = attest.author == request.user or request.user.is_trainer
may_view = attest.solution.author == request.user or request.user.is_tutor or may_modify
if not may_view:
return access_denied(request)
if request.method == "POST":
if not may_modify:
return access_denied(request)
with transaction.atomic():
form = AttestationPreviewForm(request.POST, instance=attest)
if form.is_valid():
form.save()
if 'publish' in request.POST:
if attest.solution.task.only_trainers_publish and not request.user.is_trainer:
return access_denied(request)
attest.publish(request, by=request.user)
return HttpResponseRedirect(
reverse('attestation_list',
args=[attest.solution.task.id]))
else:
form = AttestationPreviewForm(instance=attest)
submitable = may_modify and not attest.published
withdrawable = may_modify and attest.published
return render_to_response(
"attestation/attestation_view.html", {
"attest": attest,
'submitable': submitable,
'withdrawable': withdrawable,
'form': form,
'show_author': not get_settings().anonymous_attestation,
'show_attestor': not get_settings().invisible_attestor
},
context_instance=RequestContext(request))
def attestation_list(request, task_id):
if not (in_group(request.user,'Tutor,Trainer') or request.user.is_superuser):
return access_denied(request)
task = Task.objects.get(pk=task_id)
attestation_stats = []
if (in_group(request.user,'Trainer')):
attestation_stats = [ {'tutor': tutor,
'unattested' : Solution.objects.filter(task = task, final=True, plagiarism = False, attestation = None,author__tutorial__tutors=tutor).count(),
'final': Attestation.objects.filter(solution__task = task,final=True,author=tutor).count(),
'nonfinal': Attestation.objects.filter(solution__task = task,final=False,author=tutor).count() }
for tutor in User.objects.filter(groups__name="Tutor")]
for entry in attestation_stats:
entry['attested'] = entry['final']+entry['nonfinal']
entry['total'] = entry['final']+entry['nonfinal']+entry['unattested']
tutored_users = User.objects.filter(groups__name="User", is_active=True).order_by('last_name') if in_group(request.user,'Trainer') or request.user.is_superuser else None
unattested_solutions = Solution.objects.filter(task = task, final=True, plagiarism = False, attestation = None)
if in_group(request.user,'Tutor'): # the trainer sees them all
unattested_solutions = unattested_solutions.filter(author__tutorial__in = request.user.tutored_tutorials.all())
my_attestations = Attestation.objects.filter(solution__task = task, author = request.user).order_by('-created')
all_attestations_for_my_tutorials = Attestation.objects.filter(solution__task = task, solution__author__tutorial__in = request.user.tutored_tutorials.all()).order_by('-created')
if (in_group(request.user,'Trainer')):
# show all to trainer
attestations_by_others = Attestation.objects.filter(solution__task = task).order_by('-created')
solutions_with_plagiarism = Solution.objects.filter(task = task, plagiarism = True)
else:
# show from my toturials
attestations_by_others = all_attestations_for_my_tutorials.exclude(author = request.user)
solutions_with_plagiarism = Solution.objects.filter(task = task, plagiarism = True, author__tutorial__in = request.user.tutored_tutorials.all())
if request.method == "POST":
for attestation in all_attestations_for_my_tutorials.filter(final = True, published = False):
attestation.publish(request)
all_attestations_published = all_attestations_for_my_tutorials.filter(published = False).count() == 0
all_attestations_final = all_attestations_for_my_tutorials.filter(final = False).count() == 0
show_author = not get_settings().anonymous_attestation or in_group(request.user,'Trainer') or published
data = {'task':task, 'tutored_users':tutored_users, 'solutions_with_plagiarism':solutions_with_plagiarism, 'my_attestations':my_attestations, 'attestations_by_others':attestations_by_others, 'unattested_solutions':unattested_solutions, 'published': all_attestations_published, 'show_author': show_author, 'attestation_stats' : attestation_stats}
return render_to_response("attestation/attestation_list.html", data, context_instance=RequestContext(request))
def solution_detail(request, solution_id, full):
solution = get_object_or_404(Solution, pk=solution_id)
if not (solution.author == request.user or request.user.is_trainer
or request.user.is_superuser or
(solution.author.tutorial
and solution.author.tutorial.tutors.filter(id=request.user.id))):
return access_denied(request)
if full and not (request.user.is_trainer or request.user.is_tutor
or request.user.is_superuser):
return access_denied(request)
accept_all_solutions = get_settings().accept_all_solutions
if (request.method == "POST"):
if solution.final or solution.testupload or solution.task.expired():
return access_denied(request)
if not (solution.accepted or accept_all_solutions):
return access_denied(request)
solution.copy()
return HttpResponseRedirect(
reverse('solution_list', args=[solution.task.id]))
else:
attestations = Attestation.objects.filter(
solution__task=solution.task,
author__tutored_tutorials=request.user.tutorial)
attestationsPublished = attestations[
0].published if attestations else False
htmlinjectors = []
if full:
htmlinjectors = HtmlInjector.objects.filter(
task=solution.task, inject_in_solution_full_view=True)
else:
htmlinjectors = HtmlInjector.objects.filter(
task=solution.task, inject_in_solution_view=True)
htmlinjector_snippets = [
injector.html_file.read().decode("utf-8")
for injector in htmlinjectors
]
return render(
request, "solutions/solution_detail.html", {
"solution": solution,
"attestationsPublished": attestationsPublished,
"accept_all_solutions": accept_all_solutions,
"htmlinjector_snippets": htmlinjector_snippets,
"full": full
})
def activation_allow(request,user_id):
user = get_object_or_404(User,pk=user_id)
# Send activation email
t = loader.get_template('registration/registration_email.html')
c = {
'email': user.email,
'domain': RequestSite(request).domain,
'site_name': settings.SITE_NAME,
'uid': int_to_base36(user.id),
'user': user,
'protocol': request.is_secure() and 'https' or 'http',
'activation_key': user.activation_key,
'expiration_days': get_settings().acount_activation_days,
}
send_mail(_("Account activation on %s") % settings.SITE_NAME, t.render(Context(c)), None, [user.email])
return render_to_response('registration/registration_activation_allowed.html', { 'new_user': user, }, context_instance=RequestContext(request))
def attestation_run_checker(request, attestation_id):
if not (request.user.is_tutor or request.user.is_trainer or request.user.is_superuser):
return access_denied(request)
attestation = get_object_or_404(Attestation, pk=attestation_id)
if not (attestation.author == request.user or request.user.is_trainer or request.user.is_superuser):
return access_denied(request)
if attestation.published:
return access_denied(request)
if not get_settings().attestation_allow_run_checkers:
return access_denied(request)
solution = attestation.solution
check_solution(solution, True)
return HttpResponseRedirect(reverse('edit_attestation', args=[attestation_id]))
def attestation_run_checker(request, attestation_id):
if not (request.user.is_tutor or request.user.is_trainer or request.user.is_superuser):
return access_denied(request)
attestation = get_object_or_404(Attestation, pk=attestation_id)
if not (attestation.author == request.user or request.user.is_trainer or request.user.is_superuser):
return access_denied(request)
if attestation.published:
return access_denied(request)
if not get_settings().attestation_allow_run_checkers:
return access_denied(request)
solution = attestation.solution
check_solution(solution, True)
return HttpResponseRedirect(reverse('edit_attestation', args=[attestation_id]))
def activation_allow(request, user_id):
user = get_object_or_404(User, pk=user_id)
# Send activation email
t = loader.get_template('registration/registration_email.html')
c = {
'email': user.email,
'domain': RequestSite(request).domain,
'site_name': settings.SITE_NAME,
'uid': int_to_base36(user.id),
'user': user,
'protocol': request.is_secure() and 'https' or 'http',
'activation_key': user.activation_key,
'expiration_days': get_settings().acount_activation_days,
}
send_mail(
_("Account activation on %s") % settings.SITE_NAME, t.render(c), None,
[user.email])
return render(request, 'registration/registration_activation_allowed.html',
{
'new_user': user,
})
def solution_detail(request, solution_id, full):
solution = get_object_or_404(Solution, pk=solution_id)
if not (solution.author == request.user or request.user.is_trainer or request.user.is_superuser or (solution.author.tutorial and solution.author.tutorial.tutors.filter(id=request.user.id))):
return access_denied(request)
if full and not (request.user.is_trainer or request.user.is_tutor or request.user.is_superuser):
return access_denied(request)
accept_all_solutions = get_settings().accept_all_solutions
if (request.method == "POST"):
if solution.final or solution.testupload or solution.task.expired():
return access_denied(request)
if not (solution.accepted or accept_all_solutions):
return access_denied(request)
solution.copy()
return HttpResponseRedirect(reverse('solution_list', args=[solution.task.id]))
else:
attestations = Attestation.objects.filter(solution__task=solution.task, author__tutored_tutorials=request.user.tutorial)
attestationsPublished = attestations[0].published if attestations else False
htmlinjectors = []
if full:
htmlinjectors = HtmlInjector.objects.filter(task = solution.task, inject_in_solution_full_view = True)
else:
htmlinjectors = HtmlInjector.objects.filter(task = solution.task, inject_in_solution_view = True)
htmlinjector_snippets = [ injector.html_file.read() for injector in htmlinjectors ]
return render(request,
"solutions/solution_detail.html",
{
"solution": solution,
"attestationsPublished": attestationsPublished,
"accept_all_solutions": accept_all_solutions,
"htmlinjector_snippets": htmlinjector_snippets,
"full":full
}
)
def get_solutions_zip(solutions):
zip_file = tempfile.SpooledTemporaryFile()
zip = zipfile.ZipFile(zip_file,'w')
for solution in solutions:
# TODO: make this work for anonymous attesration, too
if get_settings().anonymous_attestation:
project_path = 'User' + index
project_name = 'User ' + index
else:
project_path = path_for_user(solution.author)
project_name = solution.author.get_full_name()
base_name = path_for_task(solution.task) + '/' + project_path + '/'
zip.writestr((base_name+'.project').encode('cp437'), render_to_string('solutions/eclipse/project.xml', { 'name': project_name }).encode("utf-8"))
zip.writestr((base_name+'.classpath').encode('cp437'), render_to_string('solutions/eclipse/classpath.xml', { }))
for index, solutionfile in enumerate(solution.solutionfile_set.all()):
file = solutionfile.file
name = (base_name + solutionfile.path()).encode('cp437','ignore')
zip.write(file.path, name)
zip.close()
zip_file.seek(0)
return zip_file
def solution_detail(request, solution_id, full):
solution = get_object_or_404(Solution, pk=solution_id)
if not (solution.author == request.user or request.user.is_trainer
or request.user.is_superuser or
(solution.author.tutorial
and solution.author.tutorial.tutors.filter(id=request.user.id))):
return access_denied(request)
if full and not (request.user.is_trainer or request.user.is_tutor
or request.user.is_superuser):
return access_denied(request)
accept_all_solutions = get_settings().accept_all_solutions
if (request.method == "POST"):
if solution.final or solution.testupload or solution.task.expired():
return access_denied(request)
if not (solution.accepted or accept_all_solutions):
return access_denied(request)
solution.copy()
return HttpResponseRedirect(
reverse('solution_list', args=[solution.task.id]))
else:
attestations = Attestation.objects.filter(
solution__task=solution.task,
author__tutored_tutorials=request.user.tutorial)
attestationsPublished = attestations[
0].published if attestations else False
return render_to_response("solutions/solution_detail.html", {
"solution": solution,
"attestationsPublished": attestationsPublished,
"accept_all_solutions": accept_all_solutions,
"full": full
},
context_instance=RequestContext(request))
def import_user(request):
""" View in the admin """
if request.method == 'POST':
form = ImportForm(request.POST, request.FILES)
if form.is_valid():
try:
imported_user = User.import_user(form.files['file'])
request.user.message_set.create(message="The import was successfull. %i users imported." % imported_user.count())
if form.cleaned_data['require_reactivation']:
for user in [user for user in imported_user if user.is_active]:
user.is_active = False
user.set_new_activation_key()
user.save()
if form.cleaned_data['send_reactivation_email']:
# Send activation email
t = Template(form.cleaned_data['meassagetext'])
c = {
'email': user.email,
'domain': RequestSite(request).domain,
'site_name': settings.SITE_NAME,
'uid': int_to_base36(user.id),
'user': user,
'protocol': request.is_secure() and 'https' or 'http',
'activation_key': user.activation_key,
'expiration_days': get_settings().acount_activation_days,
}
send_mail(_("Account activation on %s") % settings.SITE_NAME, t.render(Context(c)), None, [user.email])
return HttpResponseRedirect(urlresolvers.reverse('admin:accounts_user_changelist'))
except:
raise
from django.forms.util import ErrorList
msg = "An Error occured. The import file was propably malformed."
form._errors["file"] = ErrorList([msg])
else:
form = ImportForm()
return render_to_response('admin/accounts/user/import.html', {'form': form, 'title':"Import User" }, RequestContext(request))
def validate_mat_number(value):
regex = get_settings().mat_number_validation_regex
if regex:
RegexValidator("^"+regex+"$", message="This is not a valid student number.", code="")(value)
def tutorial_overview(request, tutorial_id=None):
if not (request.user.is_tutor or request.user.is_trainer or request.user.is_superuser):
return access_denied(request)
if (tutorial_id):
tutorial = get_object_or_404(Tutorial, pk=tutorial_id)
if request.user.is_tutor and not tutorial.tutors.filter(id=request.user.id):
return access_denied(request)
else:
tutorials = request.user.tutored_tutorials.all()
if (not tutorials):
return render(request, "attestation/tutorial_none.html")
tutorial = request.user.tutored_tutorials.all()[0]
if request.user.is_tutor:
other_tutorials = request.user.tutored_tutorials.all()
else:
other_tutorials = Tutorial.objects.all()
other_tutorials = other_tutorials.exclude(id=tutorial.id)
tasks = Task.objects.filter(submission_date__lt = datetime.datetime.now()).order_by('publication_date', 'submission_date')
users = User.objects.filter(groups__name='User').filter(is_active=True, tutorial=tutorial).order_by('last_name', 'first_name')
rating_list = user_task_attestation_map(users, tasks, False)
def to_float(a, default, const):
try:
return (float(str(a.final_grade)), const)
except (ValueError, TypeError, AttributeError):
return (default, default)
averages = [0.0 for i in range(len(tasks))]
nr_of_grades = [0 for i in range(len(tasks))]
for (user, attestations, _, _) in rating_list:
averages = [avg+to_float(att, 0.0, None)[0] for (avg, (att, _)) in zip(averages, attestations)]
nr_of_grades = [n+to_float(att, 0, 1)[1] for (n, (att, _)) in zip(nr_of_grades, attestations)]
nr_of_grades = [ (n if n>0 else 1) for n in nr_of_grades]
averages = [a/n for (a, n) in zip(averages, nr_of_grades)]
return render(request, "attestation/tutorial_overview.html", {'other_tutorials':other_tutorials, 'tutorial':tutorial, 'rating_list':rating_list, 'tasks':tasks, 'final_grades_published': get_settings().final_grades_published, 'averages':averages})
def user_task_attestation_map(users,tasks,only_published=True):
if only_published:
attestations = Attestation.objects.filter( published=True )
else:
attestations = Attestation.objects.all()
attestations = attestations.select_related("solution", "final_grade")
attestations = attestations.prefetch_related("ratingresult_set")
attestation_dict = {} #{(task_id,user_id):attestation}
for attestation in attestations:
attestation_dict[attestation.solution.task_id, attestation.solution.author_id] = attestation
solutions = Solution.objects.filter( final=True )
final_solutions_dict = {}
for solution in solutions:
final_solutions_dict[solution.task_id, solution.author_id] = solution
settings = get_settings()
arithmetic_option = settings.final_grades_arithmetic_option
plagiarism_option = settings.final_grades_plagiarism_option
rating_list = []
for user in users:
rating_for_user_list = []
grade_sum = 0
threshold = 0
for task in tasks:
solution = final_solutions_dict.get((task.id, user.id), None)
try:
rating = attestation_dict[task.id, user.id]
if rating.final_grade is None:
# rating has no grade, so it is shown as if there was no rating
# should only be relevant for unfinished attestations
rating = None
except KeyError:
rating = None
if rating or (task.expired() and not solution):
threshold += task.warning_threshold
if rating is not None:
if plagiarism_option == 'WP' or (plagiarism_option == 'NP' and not rating.solution.plagiarism):
try:
grade_sum += float(rating.final_grade.name)
except:
pass #non-numeric grade, ignore
rating_for_user_list.append((rating, solution))
if arithmetic_option == 'SUM':
calculated_grade = grade_sum
else:
# in this case: arithmetic_option == 'AVG'
if len(rating_for_user_list) == 0:
calculated_grade = 0
else:
calculated_grade = grade_sum / len(rating_for_user_list)
rating_list.append((user, rating_for_user_list, threshold, calculated_grade))
return rating_list
def new_attestation_for_solution(request, solution_id, force_create = False):
if not (request.user.is_tutor or request.user.is_trainer or request.user.is_superuser):
return access_denied(request)
solution = get_object_or_404(Solution, pk=solution_id)
attestations = Attestation.objects.filter(solution = solution)
if ((not force_create) and attestations):
return render(request, "attestation/attestation_already_exists_for_solution.html", { 'task' : solution.task, 'attestations' : attestations, 'solution' : solution, 'show_author': not get_settings().anonymous_attestation })
attest = Attestation(solution = solution, author = request.user)
attest.save()
for solutionFile in solution.solutionfile_set.filter(mime_type__startswith='text'):
annotatedFile = AnnotatedSolutionFile(attestation = attest, solution_file=solutionFile, content=solutionFile.content())
annotatedFile.save()
for rating in solution.task.rating_set.all():
ratingResult = RatingResult(attestation = attest, rating=rating)
ratingResult.save()
return HttpResponseRedirect(reverse('edit_attestation', args=[attest.id]))
def attestation_list(request, task_id):
if not (request.user.is_tutor or request.user.is_trainer or request.user.is_superuser):
return access_denied(request)
task = Task.objects.get(pk=task_id)
attestation_stats = []
no_tutorial_stats = {}
if request.user.is_trainer:
attestation_stats = [ tutor_attestation_stats(task, tutor)
for tutor in User.objects.filter(groups__name="Tutor")]
no_tutorial_stats = tutor_attestation_stats(task, None)
tutored_users = User.objects.filter(groups__name="User", is_active=True).order_by('last_name') if request.user.is_trainer or request.user.is_superuser else None
unattested_solutions = Solution.objects.filter(task = task, final=True, attestation = None)
if request.user.is_tutor: # the trainer sees them all
unattested_solutions = unattested_solutions.filter(author__tutorial__in = request.user.tutored_tutorials.all())
all_attestations = Attestation.objects \
.filter(solution__task = task) \
.order_by('-created') \
.select_related('solution', 'solution__author', 'author')
my_attestations = all_attestations \
.filter(author = request.user) \
all_attestations_for_my_tutorials = all_attestations \
.filter(solution__author__tutorial__in = request.user.tutored_tutorials.all()) \
attestations_by_others = all_attestations_for_my_tutorials \
.exclude(author = request.user)
# for the warning about solutions marked as plagiarism
if request.user.is_trainer:
# show all to trainer
solutions_with_plagiarism = Solution.objects.filter(task = task, plagiarism = True)
else:
# show from my turials to tutors
solutions_with_plagiarism = Solution.objects.filter(task = task, plagiarism = True, author__tutorial__in = request.user.tutored_tutorials.all())
# the trainer sees all
if not request.user.is_trainer:
all_attestations = None
publishable_tutorial = all_attestations_for_my_tutorials.filter(final = True, published = False)
publishable_all = None
if request.user.is_trainer:
publishable_all = all_attestations.filter(final = True, published = False)
if request.method == "POST":
if request.POST['what'] == 'tutorial':
if not request.user.is_tutor:
return access_denied(request)
if task.only_trainers_publish:
return access_denied(request)
for attestation in publishable_tutorial:
attestation.publish(request, request.user)
return HttpResponseRedirect(reverse('attestation_list', args=[task_id]))
if request.POST['what'] == 'all':
if not request.user.is_trainer:
return access_denied(request)
for attestation in publishable_all:
attestation.publish(request, request.user)
return HttpResponseRedirect(reverse('attestation_list', args=[task_id]))
show_author = not get_settings().anonymous_attestation or request.user.is_tutor or request.user.is_trainer or published
data = {'task': task,
'tutored_users': tutored_users,
'solutions_with_plagiarism': solutions_with_plagiarism,
'my_attestations': my_attestations,
'attestations_by_others': attestations_by_others,
'all_attestations': all_attestations,
'unattested_solutions': unattested_solutions,
'publishable_tutorial': publishable_tutorial,
'publishable_all': publishable_all,
'show_author': show_author,
'attestation_stats': attestation_stats,
'no_tutorial_stats': no_tutorial_stats,}
return render(request, "attestation/attestation_list.html", data)
def view_attestation(request, attestation_id):
attest = get_object_or_404(Attestation, pk=attestation_id)
may_modify = attest.author == request.user or request.user.is_trainer
may_view = attest.solution.author == request.user or request.user.is_tutor or may_modify
if not may_view:
return access_denied(request)
if request.method == "POST":
if not may_modify:
return access_denied(request)
with transaction.atomic():
form = AttestationPreviewForm(request.POST, instance=attest)
if form.is_valid():
form.save()
if 'publish' in request.POST:
if attest.solution.task.only_trainers_publish and not request.user.is_trainer:
return access_denied(request)
attest.publish(request, by = request.user)
return HttpResponseRedirect(reverse('attestation_list', args=[attest.solution.task.id]))
else:
form = AttestationPreviewForm(instance=attest)
submitable = may_modify and not attest.published
withdrawable = may_modify and attest.published
return render_to_response("attestation/attestation_view.html", {"attest": attest, 'submitable':submitable, 'withdrawable': withdrawable, 'form':form, 'show_author': not get_settings().anonymous_attestation, 'show_attestor': not get_settings().invisible_attestor}, context_instance=RequestContext(request))
def get_solutions_zip(solutions,include_file_copy_checker_files=False):
zip_file = tempfile.SpooledTemporaryFile()
zip = zipfile.ZipFile(zip_file,'w')
praktomat_files_destination = "praktomat-files/"
testsuite_destination = praktomat_files_destination + "testsuite/"
createfile_checker_files_destination = praktomat_files_destination + "other/"
checkstyle_checker_files_destination = praktomat_files_destination + "checkstyle/"
solution_files_destination = "solution/"
for solution in solutions:
# TODO: make this work for anonymous attesration, too
if get_settings().anonymous_attestation:
project_path = 'User' + index
project_name = unicode(solution.task) + u"-" + 'User ' + index
else:
project_path = path_for_user(solution.author)
project_name = unicode(solution.task) + u"-" + solution.author.get_full_name()
base_name = path_for_task(solution.task) + '/' + project_path + '/'
# We need to pass unicode strings to ZipInfo to ensure that it sets bit
# 11 appropriately if the filename contains non-ascii characters.
assert isinstance(base_name, unicode)
createfile_checker_files = []
checkstyle_checker_files = []
junit3 = False
junit4 = False
checkstyle = False
if include_file_copy_checker_files:
createfile_checker = solution.task.createfilechecker_set.all()
checkstyle_checker = solution.task.checkstylechecker_set.all()
junit_checker = solution.task.junitchecker_set.all()
junit3 = bool([ 0 for j in junit_checker if j.junit_version == 'junit3' ])
junit4 = bool([ 0 for j in junit_checker if j.junit_version == 'junit4' ])
checkstyle = bool(checkstyle_checker)
createfile_checker_files = [(createfile_checker_files_destination + checker.path + '/' + checker.filename, checker.file) for checker in createfile_checker]
checkstyle_checker_files = [(checkstyle_checker_files_destination + os.path.basename(checker.configuration.name), checker.configuration) for checker in checkstyle_checker]
zip.writestr(base_name+'.project', render_to_string('solutions/eclipse/project.xml', { 'name': project_name, 'checkstyle' : checkstyle }).encode("utf-8"))
zip.writestr(base_name+'.settings/org.eclipse.jdt.core.prefs', render_to_string('solutions/eclipse/settings/org.eclipse.jdt.core.prefs', { }).encode("utf-8"))
zip.writestr(base_name+'.classpath', render_to_string('solutions/eclipse/classpath.xml', {'junit3' : junit3, 'junit4': junit4, 'createfile_checker_files' : include_file_copy_checker_files, 'createfile_checker_files_destination' : createfile_checker_files_destination, 'testsuite_destination' : testsuite_destination }).encode("utf-8"))
if checkstyle:
zip.writestr(base_name+'.checkstyle', render_to_string('solutions/eclipse/checkstyle.xml', {'checkstyle_files' : [filename for (filename,_) in checkstyle_checker_files], 'createfile_checker_files_destination' : createfile_checker_files_destination, 'testsuite_destination' : testsuite_destination }).encode("utf-8"))
if junit4:
zip.writestr(base_name+testsuite_destination+'AllJUnitTests.java', render_to_string('solutions/eclipse/AllJUnitTests.java', { 'testclasses' : [ j.class_name for j in junit_checker if j.junit_version == 'junit4' ]}).encode("utf-8"))
zip.writestr(base_name+praktomat_files_destination+'AllJUnitTests.launch', render_to_string('solutions/eclipse/AllJUnitTests.launch', { 'project_name' : project_name, 'praktomat_files_destination' : praktomat_files_destination}).encode("utf-8"))
zip.write(os.path.dirname(__file__)+"/../checker/scripts/eclipse-junit.policy", (base_name+praktomat_files_destination+'eclipse-junit.policy'))
solution_files = [ (solution_files_destination+solutionfile.path(), solutionfile.file) for solutionfile in solution.solutionfile_set.all()]
for (name,file) in solution_files + createfile_checker_files + checkstyle_checker_files:
zippath = os.path.normpath(base_name + name)
assert isinstance(zippath, unicode)
try: # Do not overwrite files from the solution by checker files
zip.getinfo(zippath)
except KeyError:
zip.write(file.path, zippath)
assert zip.getinfo(zippath) # file was really added under name "zippath" (not only some normalization thereof)
zip.close()
zip_file.seek(0)
return zip_file
