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 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 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_courses()
return render_to_response(
"results_index.html",
dict(semesters=semesters),
context_instance=RequestContext(request))
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 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 __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 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 __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()
def index(request):
semesters = Semester.get_all_with_published_courses()
return render(request, "results_index.html", dict(semesters=semesters))
