class RemindResponsibleForm(forms.Form):
to = UserModelChoiceField(None, required=False, disabled=True, label=_("To"))
cc = UserModelMultipleChoiceField(None, required=False, disabled=True, label=_("CC"))
subject = forms.CharField(label=_("Subject"))
plain_content = forms.CharField(widget=forms.Textarea(), label=_("Plain Message"))
html_content = forms.CharField(widget=forms.Textarea(), label=_("HTML Message"))
def __init__(self, *args, responsible, **kwargs):
super().__init__(*args, **kwargs)
self.fields["to"].initial = responsible.pk
self.fields["to"].queryset = UserProfile.objects.filter(pk=responsible.pk)
self.fields["cc"].initial = responsible.cc_users.all() | responsible.delegates.all()
self.fields["cc"].queryset = responsible.cc_users.all() | responsible.delegates.all()
self.template = EmailTemplate.objects.get(name=EmailTemplate.EDITOR_REVIEW_REMINDER)
self.fields["subject"].initial = self.template.subject
self.fields["plain_content"].initial = self.template.plain_content
self.fields["html_content"].initial = self.template.html_content
def send(self, request, evaluations):
recipient = self.cleaned_data.get("to")
self.template.subject = self.cleaned_data.get("subject")
self.template.plain_content = self.cleaned_data.get("plain_content")
self.template.html_content = self.cleaned_data.get("html_content")
subject_params = {}
body_params = {"user": recipient, "evaluations": evaluations}
self.template.send_to_user(recipient, subject_params, body_params, use_cc=True, request=request)
class RemindResponsibleForm(forms.Form):
to = UserModelChoiceField(None, required=False, disabled=True, label=_("To"))
cc = UserModelMultipleChoiceField(None, required=False, disabled=True, label=_("CC"))
subject = forms.CharField(label=_("Subject"))
body = forms.CharField(widget=forms.Textarea(), label=_("Message"))
def __init__(self, *args, responsible, **kwargs):
super().__init__(*args, **kwargs)
self.fields['to'].initial = responsible.pk
self.fields['to'].queryset = UserProfile.objects.filter(pk=responsible.pk)
self.fields['cc'].initial = responsible.cc_users.all() | responsible.delegates.all()
self.fields['cc'].queryset = responsible.cc_users.all() | responsible.delegates.all()
self.template = EmailTemplate.objects.get(name=EmailTemplate.EDITOR_REVIEW_REMINDER)
self.fields['subject'].initial = self.template.subject
self.fields['body'].initial = self.template.body
def send(self, request, courses):
recipient = self.cleaned_data.get('to')
self.template.subject = self.cleaned_data.get('subject')
self.template.body = self.cleaned_data.get('body')
subject_params = {}
body_params = {'user': recipient, 'courses': courses}
EmailTemplate.send_to_user(recipient, self.template, subject_params, body_params, use_cc=True, request=request)
class ContributionForm(forms.ModelForm):
contributor = UserModelChoiceField(queryset=UserProfile.objects.exclude(
is_active=False))
evaluation = forms.ModelChoiceField(Evaluation.objects.all(),
disabled=True,
required=False,
widget=forms.HiddenInput())
questionnaires = forms.ModelMultipleChoiceField(
Questionnaire.objects.contributor_questionnaires().exclude(
visibility=Questionnaire.Visibility.HIDDEN),
required=False,
widget=CheckboxSelectMultiple,
label=_("Questionnaires"))
does_not_contribute = forms.BooleanField(
required=False, label=_("Add person without questions"))
class Meta:
model = Contribution
fields = ('evaluation', 'contributor', 'questionnaires', 'role',
'textanswer_visibility', 'label', 'order')
widgets = {
'order': forms.HiddenInput(),
}
def __init__(self, *args, evaluation=None, **kwargs):
self.evaluation = evaluation
# work around https://code.djangoproject.com/ticket/25880
if self.evaluation is None:
assert 'instance' in kwargs
self.evaluation = kwargs['instance'].evaluation
super().__init__(*args, **kwargs)
if self.instance.contributor:
self.fields['contributor'].queryset |= UserProfile.objects.filter(
pk=self.instance.contributor.pk)
self.fields[
'questionnaires'].queryset = Questionnaire.objects.contributor_questionnaires(
).filter(
Q(visibility=Questionnaire.Visibility.MANAGERS)
| Q(visibility=Questionnaire.Visibility.EDITORS)
| Q(contributions__evaluation=self.evaluation)).distinct()
if self.instance.pk:
self.fields[
'does_not_contribute'].initial = not self.instance.questionnaires.exists(
)
if self.evaluation.pk and not self.evaluation.can_be_edited_by_manager:
# form is used as read-only evaluation view
disable_all_fields(self)
def clean(self):
if not self.cleaned_data.get(
'does_not_contribute') and not self.cleaned_data.get(
'questionnaires'):
self.add_error(
'does_not_contribute',
_("Select either this option or at least one questionnaire!"))
class ContributionForm(forms.ModelForm):
contributor = UserModelChoiceField(queryset=UserProfile.objects.exclude_inactive_users())
responsibility = forms.ChoiceField(widget=forms.RadioSelect(), choices=Contribution.RESPONSIBILITY_CHOICES)
evaluation = forms.ModelChoiceField(Evaluation.objects.all(), disabled=True, required=False, widget=forms.HiddenInput())
questionnaires = forms.ModelMultipleChoiceField(
Questionnaire.objects.contributor_questionnaires().filter(obsolete=False),
required=False,
widget=CheckboxSelectMultiple,
label=_("Questionnaires")
)
does_not_contribute = forms.BooleanField(required=False, label=_("Does not contribute to evaluation"))
class Meta:
model = Contribution
fields = ('evaluation', 'contributor', 'questionnaires', 'order', 'responsibility', 'textanswer_visibility', 'label')
widgets = {'order': forms.HiddenInput(), 'textanswer_visibility': forms.RadioSelect(choices=Contribution.TEXTANSWER_VISIBILITY_CHOICES)}
def __init__(self, *args, evaluation=None, **kwargs):
self.evaluation = evaluation
# work around https://code.djangoproject.com/ticket/25880
if self.evaluation is None:
assert 'instance' in kwargs
self.evaluation = kwargs['instance'].evaluation
super().__init__(*args, **kwargs)
if self.instance.can_edit:
self.fields['responsibility'].initial = Contribution.IS_EDITOR
else:
self.fields['responsibility'].initial = Contribution.IS_CONTRIBUTOR
if self.instance.contributor:
self.fields['contributor'].queryset |= UserProfile.objects.filter(pk=self.instance.contributor.pk)
self.fields['questionnaires'].queryset = Questionnaire.objects.contributor_questionnaires().filter(
Q(obsolete=False) | Q(contributions__evaluation=self.evaluation)).distinct()
if self.instance.pk:
self.fields['does_not_contribute'].initial = not self.instance.questionnaires.exists()
if not self.evaluation.can_manager_edit:
# form is used as read-only evaluation view
disable_all_fields(self)
def clean(self):
if not self.cleaned_data.get('does_not_contribute') and not self.cleaned_data.get('questionnaires'):
self.add_error('does_not_contribute', _("Select either this option or at least one questionnaire!"))
def save(self, *args, **kwargs):
responsibility = self.cleaned_data['responsibility']
is_editor = responsibility == Contribution.IS_EDITOR
self.instance.can_edit = is_editor
return super().save(*args, **kwargs)
class UserMergeSelectionForm(forms.Form):
main_user = UserModelChoiceField(UserProfile.objects.all())
other_user = UserModelChoiceField(UserProfile.objects.all())
class SingleResultForm(forms.ModelForm):
semester = forms.ModelChoiceField(Semester.objects.all(), disabled=True, required=False, widget=forms.HiddenInput())
last_modified_time_2 = forms.DateTimeField(label=_("Last modified"), required=False, localize=True, disabled=True)
last_modified_user_2 = forms.CharField(label=_("Last modified by"), required=False, disabled=True)
event_date = forms.DateField(label=_("Event date"), localize=True)
responsible = UserModelChoiceField(label=_("Responsible"), queryset=UserProfile.objects.exclude_inactive_users())
answer_1 = forms.IntegerField(label=_("# very good"), initial=0)
answer_2 = forms.IntegerField(label=_("# good"), initial=0)
answer_3 = forms.IntegerField(label=_("# neutral"), initial=0)
answer_4 = forms.IntegerField(label=_("# bad"), initial=0)
answer_5 = forms.IntegerField(label=_("# very bad"), initial=0)
class Meta:
model = Course
fields = ('name_de', 'name_en', 'type', 'degrees', 'event_date', 'responsible', 'answer_1', 'answer_2', 'answer_3', 'answer_4', 'answer_5',
'last_modified_time_2', 'last_modified_user_2', 'semester')
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['last_modified_time_2'].initial = self.instance.last_modified_time
if self.instance.last_modified_user:
self.fields['last_modified_user_2'].initial = self.instance.last_modified_user.full_name
if self.instance.vote_start_datetime:
self.fields['event_date'].initial = self.instance.vote_start_datetime
if not self.instance.can_staff_edit:
disable_all_fields(self)
if self.instance.pk:
responsible = self.instance.responsible_contributors[0]
self.fields['responsible'].queryset |= UserProfile.objects.filter(pk=responsible.pk)
self.fields['responsible'].initial = responsible
answer_counts = dict()
for answer_counter in self.instance.ratinganswer_counters:
answer_counts[answer_counter.answer] = answer_counter.count
for i in range(1, 6):
self.fields['answer_' + str(i)].initial = answer_counts[i]
def save(self, *args, **kw):
user = kw.pop("user")
self.instance.last_modified_user = user
event_date = self.cleaned_data['event_date']
self.instance.vote_start_datetime = date_to_datetime(event_date)
self.instance.vote_end_date = event_date
self.instance.is_graded = False
self.instance.is_single_result = True
super().save(*args, **kw)
single_result_questionnaire = Questionnaire.single_result_questionnaire()
single_result_question = single_result_questionnaire.question_set.first()
contribution, created = Contribution.objects.get_or_create(course=self.instance, responsible=True, can_edit=True, comment_visibility=Contribution.ALL_COMMENTS)
contribution.contributor = self.cleaned_data['responsible']
if created:
contribution.questionnaires.add(single_result_questionnaire)
contribution.save()
# set answers
contribution = Contribution.objects.get(course=self.instance, responsible=True)
total_votes = 0
for i in range(1, 6):
count = self.cleaned_data['answer_' + str(i)]
total_votes += count
RatingAnswerCounter.objects.update_or_create(contribution=contribution, question=single_result_question, answer=i, defaults={'count': count})
self.instance._participant_count = total_votes
self.instance._voter_count = total_votes
# change state to "reviewed"
# works only for single_results so the course and its contribution must be saved first
self.instance.single_result_created()
self.instance.save()
class DelegateSelectionForm(forms.Form):
delegate_to = UserModelChoiceField(label=_("Delegate to"),
queryset=UserProfile.objects.exclude(is_active=False).exclude(is_proxy_user=True))
class DelegateSelectionForm(forms.Form):
delegate_to = UserModelChoiceField(
label=_("Delegate to"),
queryset=UserProfile.objects.exclude_inactive_users())
class DelegateSelectionForm(forms.Form):
delegate_to = UserModelChoiceField(
UserProfile.objects.exclude_inactive_users())
class SingleResultForm(forms.ModelForm):
last_modified_time_2 = forms.DateTimeField(label=_("Last modified"), required=False, localize=True, disabled=True)
last_modified_user_2 = forms.CharField(label=_("Last modified by"), required=False, disabled=True)
event_date = forms.DateField(label=_("Event date"), localize=True)
responsible = UserModelChoiceField(label=_("Responsible"), queryset=UserProfile.objects.exclude_inactive_users())
answer_1 = forms.IntegerField(label=_("# very good"), initial=0)
answer_2 = forms.IntegerField(label=_("# good"), initial=0)
answer_3 = forms.IntegerField(label=_("# neutral"), initial=0)
answer_4 = forms.IntegerField(label=_("# bad"), initial=0)
answer_5 = forms.IntegerField(label=_("# very bad"), initial=0)
type = forms.ModelChoiceField(CourseType.objects.all())
degrees = forms.ModelMultipleChoiceField(Degree.objects.all())
class Meta:
model = Evaluation
fields = ('name_de', 'name_en', 'type', 'degrees', 'event_date', 'responsible', 'answer_1', 'answer_2', 'answer_3', 'answer_4',
'answer_5', 'last_modified_time_2', 'last_modified_user_2')
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['last_modified_time_2'].initial = self.instance.last_modified_time
if self.instance.last_modified_user:
self.fields['last_modified_user_2'].initial = self.instance.last_modified_user.full_name
if self.instance.vote_start_datetime:
self.fields['event_date'].initial = self.instance.vote_start_datetime
if not self.instance.can_manager_edit:
disable_all_fields(self)
if self.instance.pk:
responsible = self.instance.course.responsibles.first()
self.fields['responsible'].queryset |= UserProfile.objects.filter(pk=responsible.pk)
self.fields['responsible'].initial = responsible
answer_counts = dict()
for answer_counter in self.instance.ratinganswer_counters:
answer_counts[answer_counter.answer] = answer_counter.count
for i in range(1, 6):
self.fields['answer_' + str(i)].initial = answer_counts[i]
self.fields['type'].initial = self.instance.course.type
self.fields['degrees'].initial = self.instance.course.degrees.all()
# TODO (#1047): add additional uniqueness check for Evaluation's names when a Course can have multiple Evaluations
def clean_name_de(self):
name_de = self.cleaned_data.get('name_de')
if Course.objects.filter(semester=self.instance.course.semester, name_de=name_de).exclude(id=self.instance.course.id).exists():
self.add_error("name_de", _("This name (German) was already used for a course in this semester."))
return name_de
def clean_name_en(self):
name_en = self.cleaned_data.get('name_en')
if Course.objects.filter(semester=self.instance.course.semester, name_en=name_en).exclude(id=self.instance.course.id).exists():
self.add_error("name_en", _("This name (English) was already used for a course in this semester."))
return name_en
def save(self, *args, **kw):
self.instance.course.is_graded = False
self.instance.course.name_de = self.cleaned_data['name_de']
self.instance.course.name_en = self.cleaned_data['name_en']
self.instance.course.type = self.cleaned_data['type']
self.instance.course.save()
self.instance.course.responsibles.set([self.cleaned_data['responsible']])
self.instance.course.degrees.set(self.cleaned_data['degrees'])
self.instance.course.save()
self.instance.course = Course.objects.get(id=self.instance.course.id)
user = kw.pop("user")
self.instance.last_modified_user = user
event_date = self.cleaned_data['event_date']
self.instance.vote_start_datetime = date_to_datetime(event_date)
self.instance.vote_end_date = event_date
self.instance.is_single_result = True
super().save(*args, **kw)
single_result_questionnaire = Questionnaire.single_result_questionnaire()
single_result_question = single_result_questionnaire.questions.first()
contribution, created = Contribution.objects.get_or_create(evaluation=self.instance, contributor=None)
if created:
contribution.questionnaires.add(single_result_questionnaire)
contribution.save()
# set answers
contribution = Contribution.objects.get(evaluation=self.instance)
total_votes = 0
for i in range(1, 6):
count = self.cleaned_data['answer_' + str(i)]
total_votes += count
RatingAnswerCounter.objects.update_or_create(contribution=contribution, question=single_result_question, answer=i, defaults={'count': count})
self.instance._participant_count = total_votes
self.instance._voter_count = total_votes
# change state to "reviewed"
# works only for single_results so the evaluation and its contribution must be saved first
self.instance.single_result_created()
self.instance.save()
class ContributionForm(forms.ModelForm):
contributor = UserModelChoiceField(queryset=UserProfile.objects.exclude(
is_active=False))
evaluation = forms.ModelChoiceField(Evaluation.objects.all(),
disabled=True,
required=False,
widget=forms.HiddenInput())
questionnaires = forms.ModelMultipleChoiceField(
Questionnaire.objects.contributor_questionnaires().exclude(
visibility=Questionnaire.Visibility.HIDDEN),
required=False,
widget=CheckboxSelectMultiple,
label=_("Questionnaires"),
)
does_not_contribute = forms.BooleanField(
required=False, label=_("Add person without questions"))
class Meta:
model = Contribution
fields = ("evaluation", "contributor", "questionnaires", "role",
"textanswer_visibility", "label", "order")
widgets = {
"order": forms.HiddenInput(),
}
def __init__(self, *args, evaluation=None, **kwargs):
self.evaluation = evaluation
# work around https://code.djangoproject.com/ticket/25880
if self.evaluation is None:
assert "instance" in kwargs
self.evaluation = kwargs["instance"].evaluation
super().__init__(*args, **kwargs)
if self.instance.contributor:
self.fields["contributor"].queryset |= UserProfile.objects.filter(
pk=self.instance.contributor.pk)
self.fields["questionnaires"].queryset = (
Questionnaire.objects.contributor_questionnaires().filter(
Q(visibility=Questionnaire.Visibility.MANAGERS)
| Q(visibility=Questionnaire.Visibility.EDITORS)
| Q(contributions__evaluation=self.evaluation)).distinct())
if self.instance.pk:
self.fields[
"does_not_contribute"].initial = not self.instance.questionnaires.exists(
)
if self.evaluation.pk and not self.evaluation.can_be_edited_by_manager:
# form is used as read-only evaluation view
disable_all_fields(self)
def clean(self):
if not self.cleaned_data.get(
"does_not_contribute") and not self.cleaned_data.get(
"questionnaires"):
self.add_error(
"does_not_contribute",
_("Select either this option or at least one questionnaire!"))
@property
def show_delete_button(self):
if self.instance.pk is None:
return True # not stored in the DB. Required so temporary instances in the formset can be deleted.
if not self.instance.ratinganswercounter_set.exists(
) and not self.instance.textanswer_set.exists():
return True
return False
def save(self, *args, **kwargs):
if self.instance.pk:
selected_questionnaires = self.cleaned_data.get("questionnaires")
removed_questionnaires = set(self.instance.questionnaires.all()
) - set(selected_questionnaires)
self.instance.remove_answers_to_questionnaires(
removed_questionnaires)
return super().save(*args, **kwargs)
class UserEditSelectionForm(forms.Form):
user = UserModelChoiceField(UserProfile.objects.all())
