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 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 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 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