def index(request): """Main entry page into EvaP providing all the login options available. The username/password login is thought to be used for internal users, e.g. by connecting to a LDAP directory. The login key mechanism is meant to be used to include external participants, e.g. visiting students or visiting contributors. """ # parse the form data into the respective form submit_type = request.POST.get("submit_type", "no_submit") new_key_form = NewKeyForm(request.POST if submit_type == "new_key" else None) login_username_form = LoginUsernameForm(request, request.POST if submit_type == "login_username" else None) # process form data if request.method == 'POST': if new_key_form.is_valid(): # user wants a new login key profile = new_key_form.get_user() profile.ensure_valid_login_key() profile.save() EmailTemplate.send_login_url_to_user(new_key_form.get_user()) messages.success(request, _("We sent you an email with a one-time login URL. Please check your inbox.")) return redirect('evaluation:index') elif login_username_form.is_valid(): # user would like to login with username and password and passed password test auth.login(request, login_username_form.get_user()) # clean up our test cookie if request.session.test_cookie_worked(): request.session.delete_test_cookie() # if not logged in by now, render form if not request.user.is_authenticated: # set test cookie to verify whether they work in the next step request.session.set_test_cookie() template_data = dict(new_key_form=new_key_form, login_username_form=login_username_form) return render(request, "index.html", template_data) else: user, __ = UserProfile.objects.get_or_create(username=request.user.username) # check for redirect variable redirect_to = request.GET.get("next", None) if redirect_to is not None: return redirect(redirect_to) # redirect user to appropriate start page if request.user.is_reviewer: return redirect('staff:semester_view', Semester.active_semester().id) if request.user.is_staff: return redirect('staff:index') elif request.user.is_grade_publisher: return redirect('grades:semester_view', Semester.active_semester().id) elif user.is_student: return redirect('student:index') elif user.is_contributor_or_delegate: return redirect('contributor:index') else: return redirect('results:index')
def index(request): """Main entry page into EvaP providing all the login options available. The username/password login is thought to be used for internal users, e.g. by connecting to a LDAP directory. The login key mechanism is meant to be used to include external participants, e.g. visiting students or visiting contributors. """ # parse the form data into the respective form submit_type = request.POST.get("submit_type", "no_submit") new_key_form = NewKeyForm(request.POST if submit_type == "new_key" else None) login_username_form = LoginUsernameForm(request, request.POST if submit_type == "login_username" else None) # process form data if request.method == 'POST': if new_key_form.is_valid(): # user wants a new login key profile = new_key_form.get_user() profile.ensure_valid_login_key() profile.save() EmailTemplate.send_login_url_to_user(new_key_form.get_user()) messages.success(request, _("We sent you an email with a one-time login URL. Please check your inbox.")) return redirect('evaluation:index') elif login_username_form.is_valid(): # user would like to login with username and password and passed password test auth.login(request, login_username_form.get_user()) # clean up our test cookie if request.session.test_cookie_worked(): request.session.delete_test_cookie() # if not logged in by now, render form if not request.user.is_authenticated: # set test cookie to verify whether they work in the next step request.session.set_test_cookie() template_data = dict(new_key_form=new_key_form, login_username_form=login_username_form) return render(request, "index.html", template_data) else: user, __ = UserProfile.objects.get_or_create(username=request.user.username) # check for redirect variable redirect_to = request.GET.get("next", None) if redirect_to is not None: return redirect(redirect_to) # redirect user to appropriate start page if request.user.is_reviewer: return redirect('staff:semester_view', Semester.active_semester().id) if request.user.is_manager: return redirect('staff:index') elif request.user.is_grade_publisher: return redirect('grades:semester_view', Semester.active_semester().id) elif user.is_student: return redirect('student:index') elif user.is_contributor_or_delegate: return redirect('contributor:index') else: return redirect('results:index')
def include_navbar(user, language): return { 'user': user, 'language': language, 'published_result_semesters': Semester.get_all_with_published_unarchived_results(), 'result_semesters': Semester.get_all_with_unarchived_results(), 'grade_document_semesters': Semester.objects.filter(grade_documents_are_deleted=False), }
def include_navbar(user, language): return { "user": user, "current_language": language, "languages": LANGUAGES, "published_result_semesters": Semester.get_all_with_published_unarchived_results(), "result_semesters": Semester.get_all_with_unarchived_results(), "grade_document_semesters": Semester.objects.filter(grade_documents_are_deleted=False), "debug": DEBUG, }
def redirect_user_to_start_page(user): if user.is_reviewer: return redirect('staff:semester_view', Semester.active_semester().id) if user.is_manager: return redirect('staff:index') if user.is_grade_publisher: return redirect('grades:semester_view', Semester.active_semester().id) if user.is_student: return redirect('student:index') if user.is_responsible_or_contributor_or_delegate: return redirect('contributor:index') return redirect('results:index')
def index(request): semesters = Semester.get_all_with_published_unarchived_results() courses = Course.objects.filter(semester__in=semesters, state='published') courses = [ course for course in courses if course.can_user_see_course(request.user) ] if request.user.is_reviewer: additional_courses = Course.objects.filter( semester__in=semesters, state__in=['in_evaluation', 'evaluated', 'reviewed']) courses += get_courses_with_prefetched_data(additional_courses) course_pks = [course.pk for course in courses] degrees = Degree.objects.filter(courses__pk__in=course_pks).distinct() course_types = CourseType.objects.filter( courses__pk__in=course_pks).distinct() template_data = dict( courses=courses, degrees=degrees, course_types=course_types, semesters=semesters, ) return render(request, "results_index.html", template_data)
def index(request): semesters = Semester.get_all_with_published_unarchived_results() evaluations = Evaluation.objects.filter(course__semester__in=semesters, state='published') evaluations = [ evaluation for evaluation in evaluations if evaluation.can_user_see_evaluation(request.user) ] if request.user.is_reviewer: additional_evaluations = Evaluation.objects.filter( course__semester__in=semesters, state__in=['in_evaluation', 'evaluated', 'reviewed']) evaluations += get_evaluations_with_prefetched_data( additional_evaluations) evaluation_pks = [evaluation.pk for evaluation in evaluations] degrees = Degree.objects.filter( courses__evaluation__pk__in=evaluation_pks).distinct() course_types = CourseType.objects.filter( courses__evaluation__pk__in=evaluation_pks).distinct() template_data = dict( evaluations=evaluations, degrees=degrees, course_types=course_types, semesters=semesters, ) return render(request, "results_index.html", template_data)
def index(request): semesters = Semester.get_all_with_published_courses() return render_to_response( "results_index.html", dict(semesters=semesters), context_instance=RequestContext(request))
def include_navbar(user, language): return { 'user': user, 'language': language, 'result_semesters': Semester.get_all_with_published_courses(), 'last_five_semesters': Semester.objects.all()[:5], }
def index(request): semesters = Semester.get_all_with_published_unarchived_results() evaluations = Evaluation.objects.filter(course__semester__in=semesters, state='published') evaluations = [ evaluation for evaluation in evaluations if evaluation.can_user_see_evaluation(request.user) ] if request.user.is_reviewer: additional_evaluations = get_evaluations_with_prefetched_data( Evaluation.objects.filter( course__semester__in=semesters, state__in=['in_evaluation', 'evaluated', 'reviewed'])) additional_evaluations = get_evaluations_with_course_result_attributes( additional_evaluations) evaluations += additional_evaluations evaluations.sort( key=lambda evaluation: (evaluation.course.semester.pk, evaluation.full_name )) # evaluations must be sorted for regrouping them in the template evaluation_pks = [evaluation.pk for evaluation in evaluations] degrees = Degree.objects.filter( courses__evaluations__pk__in=evaluation_pks).distinct() course_types = CourseType.objects.filter( courses__evaluations__pk__in=evaluation_pks).distinct() template_data = dict( evaluations=evaluations, degrees=degrees, course_types=course_types, semesters=semesters, ) return render(request, "results_index.html", template_data)
def index(request): semesters = Semester.get_all_with_published_unarchived_results() evaluations = Evaluation.objects.filter(course__semester__in=semesters, state='published') evaluations = [evaluation for evaluation in evaluations if evaluation.can_be_seen_by(request.user)] if request.user.is_reviewer: additional_evaluations = get_evaluations_with_prefetched_data( Evaluation.objects.filter( course__semester__in=semesters, state__in=['in_evaluation', 'evaluated', 'reviewed'] ) ) additional_evaluations = get_evaluations_with_course_result_attributes(additional_evaluations) evaluations += additional_evaluations evaluations.sort(key=lambda evaluation: (evaluation.course.semester.pk, evaluation.full_name)) # evaluations must be sorted for regrouping them in the template evaluation_pks = [evaluation.pk for evaluation in evaluations] degrees = Degree.objects.filter(courses__evaluations__pk__in=evaluation_pks).distinct() course_types = CourseType.objects.filter(courses__evaluations__pk__in=evaluation_pks).distinct() template_data = dict( evaluations=evaluations, degrees=degrees, course_types=course_types, semesters=semesters, ) return render(request, "results_index.html", template_data)
def save(self, *args, **kw): super().save(*args, **kw) new_course_list = list( self.instance.courses_participating_in.exclude( semester=Semester.active_semester())) + list( self.cleaned_data.get('courses_participating_in')) self.instance.courses_participating_in.set(new_course_list) manager_group = Group.objects.get(name="Manager") grade_publisher_group = Group.objects.get(name="Grade publisher") reviewer_group = Group.objects.get(name="Reviewer") if self.cleaned_data.get('is_manager'): self.instance.groups.add(manager_group) else: self.instance.groups.remove(manager_group) if self.cleaned_data.get('is_grade_publisher'): self.instance.groups.add(grade_publisher_group) else: self.instance.groups.remove(grade_publisher_group) if self.cleaned_data.get( 'is_reviewer') and not self.cleaned_data.get('is_manager'): self.instance.groups.add(reviewer_group) else: self.instance.groups.remove(reviewer_group) self.instance.is_active = not self.cleaned_data.get('is_inactive') self.instance.save()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) courses_of_current_semester = Course.objects.filter(semester=Semester.active_semester()) excludes = [x.id for x in courses_of_current_semester if x.is_single_result()] courses_of_current_semester = courses_of_current_semester.exclude(id__in=excludes) self.fields['courses_participating_in'].queryset = courses_of_current_semester self.fields['courses_participating_in'].initial = courses_of_current_semester.filter(participants=self.instance) if self.instance.pk else () self.fields['courses_participating_in'].label = _("Courses participating in (active semester)") self.fields['courses_participating_in'].required = False
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) courses_in_active_semester = Course.objects.filter(semester=Semester.active_semester()) excludes = [x.id for x in courses_in_active_semester if x.is_single_result()] courses_in_active_semester = courses_in_active_semester.exclude(id__in=excludes) self.fields['courses_participating_in'].queryset = courses_in_active_semester if self.instance.pk: self.fields['courses_participating_in'].initial = courses_in_active_semester.filter(participants=self.instance) self.fields['is_staff'].initial = self.instance.is_staff self.fields['is_grade_user'].initial = self.instance.is_grade_publisher
def clean_courses_participating_in(self): courses_participating_in = self.cleaned_data.get('courses_participating_in') if self.instance.pk: courses_voted_for = self.instance.courses_voted_for.filter(semester=Semester.active_semester()) removed_courses_voted_for = set(courses_voted_for) - set(courses_participating_in) if removed_courses_voted_for: names = [str(course) for course in removed_courses_voted_for] self.add_error("courses_participating_in", _("Courses for which the user already voted can't be removed: %s") % ", ".join(names)) return courses_participating_in
def user_edit(request, user_id): user = get_object_or_404(UserProfile, id=user_id) form = UserForm(request.POST or None, request.FILES or None, instance=user) courses_contributing_to = Course.objects.filter(semester=Semester.active_semester(), contributions__contributor=user) if form.is_valid(): form.save() messages.success(request, _("Successfully updated user.")) return redirect('staff:user_index') else: return render(request, "staff_user_form.html", dict(form=form, object=user, courses_contributing_to=courses_contributing_to))
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) evaluations_in_active_semester = Evaluation.objects.filter(course__semester=Semester.active_semester()) excludes = [x.id for x in evaluations_in_active_semester if x.is_single_result] evaluations_in_active_semester = evaluations_in_active_semester.exclude(id__in=excludes) self.fields['evaluations_participating_in'].queryset = evaluations_in_active_semester if self.instance.pk: self.fields['evaluations_participating_in'].initial = evaluations_in_active_semester.filter(participants=self.instance) self.fields['is_manager'].initial = self.instance.is_manager self.fields['is_grade_publisher'].initial = self.instance.is_grade_publisher self.fields['is_reviewer'].initial = self.instance.is_reviewer self.fields['is_inactive'].initial = not self.instance.is_active
def test_grade_color_calculation(self): exporter = ExcelExporter(Semester()) self.assertEqual(exporter.STEP, 0.2) self.assertEqual(exporter.normalize_number(1.94999999999), 1.8) # self.assertEqual(exporter.normalize_number(1.95), 2.0) # floats ftw self.assertEqual(exporter.normalize_number(1.95000000001), 2.0) self.assertEqual(exporter.normalize_number(1.99999999999), 2.0) self.assertEqual(exporter.normalize_number(2.0), 2.0) self.assertEqual(exporter.normalize_number(2.00000000001), 2.0) self.assertEqual(exporter.normalize_number(2.1), 2.0) self.assertEqual(exporter.normalize_number(2.149999999999), 2.0) # self.assertEqual(exporter.normalize_number(2.15), 2.2) # floats again self.assertEqual(exporter.normalize_number(2.150000000001), 2.2) self.assertEqual(exporter.normalize_number(2.8), 2.8)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) all_users = UserProfile.objects.all() # fix generated form self.fields['delegates'].required = False self.fields['delegates'].queryset = all_users self.fields['cc_users'].required = False self.fields['cc_users'].queryset = all_users courses_of_current_semester = Course.objects.filter(semester=Semester.active_semester()) self.fields['courses_participating_in'].queryset = courses_of_current_semester self.fields['courses_participating_in'].initial = courses_of_current_semester.filter(participants=self.instance) if self.instance.pk else () self.fields['courses_participating_in'].label = _("Courses participating in (active semester)") self.fields['courses_participating_in'].required = False
def index(request): semesters = Semester.get_all_with_published_unarchived_results() evaluations = Evaluation.objects.filter(course__semester__in=semesters, state=Evaluation.State.PUBLISHED) evaluations = evaluations.select_related("course", "course__semester") evaluations = [ evaluation for evaluation in evaluations if evaluation.can_be_seen_by(request.user) ] if request.user.is_reviewer: additional_evaluations = get_evaluations_with_prefetched_data( Evaluation.objects.filter( course__semester__in=semesters, state__in=[ Evaluation.State.IN_EVALUATION, Evaluation.State.EVALUATED, Evaluation.State.REVIEWED ], )) additional_evaluations = get_evaluations_with_course_result_attributes( additional_evaluations) evaluations += additional_evaluations # put evaluations into a dict that maps from course to a list of evaluations. # this dict is sorted by course.pk (important for the zip below) # (this relies on python 3.7's guarantee that the insertion order of the dict is preserved) evaluations.sort(key=lambda evaluation: evaluation.course.pk) courses_and_evaluations = unordered_groupby( (evaluation.course, evaluation) for evaluation in evaluations) course_pks = [course.pk for course in courses_and_evaluations.keys()] # annotate each course in courses with num_evaluations annotated_courses = (Course.objects.filter(pk__in=course_pks).annotate( num_evaluations=Count("evaluations")).order_by("pk").defer()) for course, annotated_course in zip(courses_and_evaluations.keys(), annotated_courses): course.num_evaluations = annotated_course.num_evaluations degrees = Degree.objects.filter(courses__pk__in=course_pks).distinct() course_types = CourseType.objects.filter( courses__pk__in=course_pks).distinct() template_data = dict( courses_and_evaluations=courses_and_evaluations.items(), degrees=degrees, course_types=course_types, semesters=semesters, ) return render(request, "results_index.html", template_data)
def save(self, *args, **kw): super().save(*args, **kw) self.instance.course_set = list(self.instance.course_set.exclude(semester=Semester.active_semester())) + list(self.cleaned_data.get('courses_participating_in')) staff_group = Group.objects.get(name="Staff") grade_user_group = Group.objects.get(name="Grade publisher") if self.cleaned_data.get('is_staff'): self.instance.groups.add(staff_group) else: self.instance.groups.remove(staff_group) if self.cleaned_data.get('is_grade_user'): self.instance.groups.add(grade_user_group) else: self.instance.groups.remove(grade_user_group)
def clean_evaluations_participating_in(self): evaluations_participating_in = self.cleaned_data.get("evaluations_participating_in") if self.instance.pk: evaluations_voted_for = self.instance.evaluations_voted_for.filter( course__semester=Semester.active_semester() ) removed_evaluations_voted_for = set(evaluations_voted_for) - set(evaluations_participating_in) if removed_evaluations_voted_for: names = [str(evaluation) for evaluation in removed_evaluations_voted_for] self.add_error( "evaluations_participating_in", _("Evaluations for which the user already voted can't be removed: %s") % ", ".join(names), ) return evaluations_participating_in
def index(request): semesters = Semester.get_all_with_published_unarchived_results() evaluations = Evaluation.objects.filter(course__semester__in=semesters, state='published') evaluations = evaluations.select_related('course', 'course__semester') evaluations = [ evaluation for evaluation in evaluations if evaluation.can_be_seen_by(request.user) ] if request.user.is_reviewer: additional_evaluations = get_evaluations_with_prefetched_data( Evaluation.objects.filter( course__semester__in=semesters, state__in=['in_evaluation', 'evaluated', 'reviewed'])) additional_evaluations = get_evaluations_with_course_result_attributes( additional_evaluations) evaluations += additional_evaluations # put evaluations into a dict that maps from course to a list of evaluations. # this dict is sorted by course.pk (important for the zip below) # (this relies on python 3.7's guarantee that the insertion order of the dict is preserved) evaluations.sort(key=lambda evaluation: evaluation.course.pk) courses_and_evaluations = defaultdict(list) for evaluation in evaluations: courses_and_evaluations[evaluation.course].append(evaluation) course_pks = list([course.pk for course in courses_and_evaluations.keys()]) # annotate each course in courses with num_evaluations annotated_courses = Course.objects.filter(pk__in=course_pks).annotate( num_evaluations=Count('evaluations')).order_by('pk').defer() for course, annotated_course in zip(courses_and_evaluations.keys(), annotated_courses): course.num_evaluations = annotated_course.num_evaluations degrees = Degree.objects.filter(courses__pk__in=course_pks).distinct() course_types = CourseType.objects.filter( courses__pk__in=course_pks).distinct() template_data = dict( courses_and_evaluations=courses_and_evaluations.items(), degrees=degrees, course_types=course_types, semesters=semesters, ) return render(request, "results_index.html", template_data)
def user_edit(request, user_id): user = get_object_or_404(UserProfile, id=user_id) form = UserForm(request.POST or None, request.FILES or None, instance=user) courses_contributing_to = Course.objects.filter( semester=Semester.active_semester(), contributions__contributor=user) if form.is_valid(): form.save() messages.success(request, _("Successfully updated user.")) return redirect('staff:user_index') else: return render( request, "staff_user_form.html", dict(form=form, object=user, courses_contributing_to=courses_contributing_to))
def __init__(self, *args, **kwargs): super(UserForm, self).__init__(*args, **kwargs) all_users = UserProfile.objects.order_by('username') # fix generated form self.fields['delegates'].required = False self.fields['delegates'].queryset = all_users self.fields['delegates'].help_text = "" self.fields['cc_users'].required = False self.fields['cc_users'].queryset = all_users self.fields['cc_users'].help_text = "" courses_of_current_semester = Course.objects.filter(semester=Semester.active_semester()) self.fields['courses_participating_in'] = forms.ModelMultipleChoiceField(courses_of_current_semester, initial=courses_of_current_semester.filter(participants=self.instance) if self.instance.pk else (), label=_("Courses participating in (active semester)"), help_text="", required=False) self.fields['courses_participating_in'].help_text = ""
def save(self, *args, **kw): super().save(*args, **kw) new_evaluation_list = list( self.instance.evaluations_participating_in.exclude( course__semester=Semester.active_semester())) + list( self.cleaned_data.get("evaluations_participating_in")) self.instance.evaluations_participating_in.set(new_evaluation_list) manager_group = Group.objects.get(name="Manager") grade_publisher_group = Group.objects.get(name="Grade publisher") reviewer_group = Group.objects.get(name="Reviewer") if self.cleaned_data.get("is_manager"): self.instance.groups.add(manager_group) else: self.instance.groups.remove(manager_group) if self.cleaned_data.get("is_grade_publisher"): self.instance.groups.add(grade_publisher_group) else: self.instance.groups.remove(grade_publisher_group) if self.cleaned_data.get( "is_reviewer") and not self.cleaned_data.get("is_manager"): self.instance.groups.add(reviewer_group) else: self.instance.groups.remove(reviewer_group) self.instance.is_active = not self.cleaned_data.get("is_inactive") # remove instance from all other users' delegates and CC users if it is inactive self.remove_messages = ([] if self.instance.is_active else remove_user_from_represented_and_ccing_users( self.instance)) # refresh results cache if any(attribute in self.changed_data for attribute in ["first_name", "last_name", "title"]): evaluations = Evaluation.objects.filter( contributions__contributor=self.instance, state__in=STATES_WITH_RESULTS_CACHING).distinct() for evaluation in evaluations: cache_results(evaluation) self.instance.save()
def index(request): semesters = Semester.get_all_with_published_unarchived_results() courses = Course.objects.filter(semester__in=semesters, state='published') courses = [course for course in courses if course.can_user_see_course(request.user)] if request.user.is_reviewer: additional_courses = Course.objects.filter(semester__in=semesters, state__in=['in_evaluation', 'evaluated', 'reviewed']) courses += get_courses_with_prefetched_data(additional_courses) course_pks = [course.pk for course in courses] degrees = Degree.objects.filter(courses__pk__in=course_pks).distinct() course_types = CourseType.objects.filter(courses__pk__in=course_pks).distinct() template_data = dict( courses=courses, degrees=degrees, course_types=sorted(course_types, key=lambda course_type: course_type.name), semesters=semesters, ) return render(request, "results_index.html", template_data)
def redirect_user_to_start_page(user): # pylint: disable=too-many-return-statements active_semester = Semester.active_semester() if user.is_reviewer: if active_semester is not None: return redirect("staff:semester_view", active_semester.id) return redirect("staff:index") if user.is_grade_publisher: if active_semester is not None: return redirect("grades:semester_view", active_semester.id) return redirect("grades:index") if user.is_student: return redirect("student:index") if user.is_responsible_or_contributor_or_delegate: return redirect("contributor:index") return redirect("results:index")
def save(self, *args, **kw): super().save(*args, **kw) new_evaluation_list = list( self.instance.evaluations_participating_in.exclude( course__semester=Semester.active_semester())) + list( self.cleaned_data.get('evaluations_participating_in')) self.instance.evaluations_participating_in.set(new_evaluation_list) manager_group = Group.objects.get(name="Manager") grade_publisher_group = Group.objects.get(name="Grade publisher") reviewer_group = Group.objects.get(name="Reviewer") if self.cleaned_data.get('is_manager'): self.instance.groups.add(manager_group) else: self.instance.groups.remove(manager_group) if self.cleaned_data.get('is_grade_publisher'): self.instance.groups.add(grade_publisher_group) else: self.instance.groups.remove(grade_publisher_group) if self.cleaned_data.get( 'is_reviewer') and not self.cleaned_data.get('is_manager'): self.instance.groups.add(reviewer_group) else: self.instance.groups.remove(reviewer_group) self.instance.is_active = not self.cleaned_data.get('is_inactive') # refresh results cache for evaluation in Evaluation.objects.filter( contributions__contributor=self.instance).distinct(): if any(attribute in self.changed_data for attribute in ["first_name", "last_name", "title"]): collect_results(evaluation, force_recalculation=True) self.instance.save()
def include_results_semester_menu(): return dict(semesters=Semester.get_all_with_published_courses())
def save(self, *args, **kw): super().save(*args, **kw) self.instance.course_set = list(self.instance.course_set.exclude(semester=Semester.active_semester())) + list(self.cleaned_data.get('courses_participating_in'))
def all_semesters(): semesters = Semester.get_all_with_published_courses() return {'semesters': semesters}
def clean_evaluations_participating_in(self): evaluations_participating_in = self.cleaned_data.get('evaluations_participating_in') if self.instance.pk: evaluations_voted_for = self.instance.evaluations_voted_for.filter(course__semester=Semester.active_semester()) removed_evaluations_voted_for = set(evaluations_voted_for) - set(evaluations_participating_in) if removed_evaluations_voted_for: names = [str(evaluation) for evaluation in removed_evaluations_voted_for] self.add_error("evaluations_participating_in", _("Evaluations for which the user already voted can't be removed: %s") % ", ".join(names)) return evaluations_participating_in
def index(request): semesters = Semester.get_all_with_published_courses() return render(request, "results_index.html", dict(semesters=semesters))
def save(self, *args, **kw): super().save(*args, **kw) new_course_list = list(self.instance.courses_participating_in.exclude(semester=Semester.active_semester())) + list(self.cleaned_data.get('courses_participating_in')) self.instance.courses_participating_in.set(new_course_list) staff_group = Group.objects.get(name="Staff") grade_publisher_group = Group.objects.get(name="Grade publisher") reviewer_group = Group.objects.get(name="Reviewer") if self.cleaned_data.get('is_staff'): self.instance.groups.add(staff_group) else: self.instance.groups.remove(staff_group) if self.cleaned_data.get('is_grade_publisher'): self.instance.groups.add(grade_publisher_group) else: self.instance.groups.remove(grade_publisher_group) if self.cleaned_data.get('is_reviewer') and not self.cleaned_data.get('is_staff'): self.instance.groups.add(reviewer_group) else: self.instance.groups.remove(reviewer_group) self.instance.is_active = not self.cleaned_data.get('is_inactive') self.instance.save()