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 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 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 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 __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 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 __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 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 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 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 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 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 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 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()
