784 lines
36 KiB
Python
784 lines
36 KiB
Python
from django.conf import settings
|
|
from django import forms
|
|
from django.contrib.formtools.preview import FormPreview, AUTO_ID
|
|
from django.shortcuts import get_object_or_404, redirect
|
|
from django.utils.decorators import method_decorator
|
|
from django.shortcuts import render_to_response
|
|
from django.template.context import RequestContext
|
|
from django.core.urlresolvers import reverse
|
|
from django.utils.html import mark_safe
|
|
|
|
from ietf.dbtemplate.forms import DBTemplateForm
|
|
from ietf.group.models import Group, Role
|
|
from ietf.ietfauth.utils import role_required
|
|
from ietf.name.models import RoleName, FeedbackTypeName
|
|
from ietf.nomcom.models import ( NomCom, Nomination, Nominee, NomineePosition,
|
|
Position, Feedback, ReminderDates )
|
|
from ietf.nomcom.utils import (NOMINATION_RECEIPT_TEMPLATE, FEEDBACK_RECEIPT_TEMPLATE,
|
|
get_user_email, validate_private_key, validate_public_key,
|
|
make_nomineeposition, make_nomineeposition_for_newperson,
|
|
create_feedback_email)
|
|
from ietf.person.models import Email
|
|
from ietf.person.fields import SearchableEmailField, SearchablePersonField, SearchablePersonsField
|
|
from ietf.utils.fields import MultiEmailField
|
|
from ietf.utils.mail import send_mail
|
|
from ietf.mailtrigger.utils import gather_address_lists
|
|
|
|
import debug # pyflakes:ignore
|
|
|
|
|
|
ROLODEX_URL = getattr(settings, 'ROLODEX_URL', None)
|
|
|
|
|
|
def get_nomcom_group_or_404(year):
|
|
return get_object_or_404(Group,
|
|
acronym__icontains=year,
|
|
state__slug='active',
|
|
nomcom__isnull=False)
|
|
|
|
|
|
class PositionNomineeField(forms.ChoiceField):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.nomcom = kwargs.pop('nomcom')
|
|
positions = Position.objects.get_by_nomcom(self.nomcom).opened().order_by('name')
|
|
results = []
|
|
for position in positions:
|
|
accepted_nominees = [np.nominee for np in NomineePosition.objects.filter(position=position,state='accepted').exclude(nominee__duplicated__isnull=False)]
|
|
nominees = [('%s_%s' % (position.id, i.id), unicode(i)) for i in accepted_nominees]
|
|
if nominees:
|
|
results.append((position.name+" (Accepted)", nominees))
|
|
for position in positions:
|
|
other_nominees = [np.nominee for np in NomineePosition.objects.filter(position=position).exclude(state='accepted').exclude(nominee__duplicated__isnull=False)]
|
|
nominees = [('%s_%s' % (position.id, i.id), unicode(i)) for i in other_nominees]
|
|
if nominees:
|
|
results.append((position.name+" (Declined or Pending)", nominees))
|
|
kwargs['choices'] = results
|
|
super(PositionNomineeField, self).__init__(*args, **kwargs)
|
|
|
|
def clean(self, value):
|
|
nominee = super(PositionNomineeField, self).clean(value)
|
|
if not nominee:
|
|
return nominee
|
|
(position_id, nominee_id) = nominee.split('_')
|
|
try:
|
|
position = Position.objects.get_by_nomcom(self.nomcom).opened().get(id=position_id)
|
|
except Position.DoesNotExist:
|
|
raise forms.ValidationError('Invalid nominee')
|
|
try:
|
|
nominee = position.nominee_set.get_by_nomcom(self.nomcom).get(id=nominee_id)
|
|
except Nominee.DoesNotExist:
|
|
raise forms.ValidationError('Invalid nominee')
|
|
return (position, nominee)
|
|
|
|
|
|
class MultiplePositionNomineeField(forms.MultipleChoiceField, PositionNomineeField):
|
|
|
|
def clean(self, value):
|
|
nominees = super(PositionNomineeField, self).clean(value) # pylint: disable=bad-super-call
|
|
result = []
|
|
for nominee in nominees:
|
|
if not nominee:
|
|
return nominee
|
|
(position_id, nominee_id) = nominee.split('_')
|
|
try:
|
|
position = Position.objects.get_by_nomcom(self.nomcom).opened().get(id=position_id)
|
|
except Position.DoesNotExist:
|
|
raise forms.ValidationError('Invalid nominee')
|
|
try:
|
|
nominee = position.nominee_set.get_by_nomcom(self.nomcom).get(id=nominee_id)
|
|
except Nominee.DoesNotExist:
|
|
raise forms.ValidationError('Invalid nominee')
|
|
result.append((position, nominee))
|
|
return result
|
|
|
|
|
|
class EditMembersForm(forms.Form):
|
|
|
|
members = MultiEmailField(label="Members email", required=False, widget=forms.Textarea)
|
|
|
|
class EditMembersFormPreview(FormPreview):
|
|
form_template = 'nomcom/edit_members.html'
|
|
preview_template = 'nomcom/edit_members_preview.html'
|
|
|
|
@method_decorator(role_required("Nomcom Chair", "Nomcom Advisor"))
|
|
def __call__(self, request, *args, **kwargs):
|
|
year = kwargs['year']
|
|
group = get_nomcom_group_or_404(year)
|
|
self.state['group'] = group
|
|
self.state['rolodex_url'] = ROLODEX_URL
|
|
groups = group.nomcom_set.all()
|
|
self.nomcom = groups and groups[0] or None
|
|
self.group = group
|
|
self.year = year
|
|
|
|
return super(EditMembersFormPreview, self).__call__(request, *args, **kwargs)
|
|
|
|
def preview_get(self, request):
|
|
"Displays the form"
|
|
f = self.form(auto_id=self.get_auto_id(), initial=self.get_initial(request))
|
|
return render_to_response(self.form_template,
|
|
{'form': f,
|
|
'stage_field': self.unused_name('stage'),
|
|
'state': self.state,
|
|
'year': self.year,
|
|
'nomcom': self.nomcom,
|
|
'selected': 'edit_members'},
|
|
context_instance=RequestContext(request))
|
|
|
|
def get_initial(self, request):
|
|
members = self.group.role_set.filter(name__slug='member')
|
|
if members:
|
|
return { "members": ",\r\n".join(role.email.address for role in members) }
|
|
return {}
|
|
|
|
def process_preview(self, request, form, context):
|
|
members_email = form.cleaned_data['members']
|
|
|
|
members_info = []
|
|
emails_not_found = []
|
|
|
|
for email in members_email:
|
|
try:
|
|
email_obj = Email.objects.get(address=email)
|
|
person = email_obj.person
|
|
except Email.DoesNotExist:
|
|
person = None
|
|
if person:
|
|
members_info.append({'email': email,
|
|
'email_obj': email_obj,
|
|
'person': person})
|
|
else:
|
|
emails_not_found.append(email)
|
|
self.state.update({'members_info': members_info,
|
|
'emails_not_found': emails_not_found})
|
|
|
|
def preview_post(self, request):
|
|
"Validates the POST data. If valid, displays the preview page. Else, redisplays form."
|
|
f = self.form(request.POST, auto_id=AUTO_ID)
|
|
context = {'form': f, 'stage_field': self.unused_name('stage'), 'state': self.state,
|
|
'year': self.year}
|
|
if f.is_valid():
|
|
self.process_preview(request, f, context)
|
|
context['hash_field'] = self.unused_name('hash')
|
|
context['hash_value'] = self.security_hash(request, f)
|
|
return render_to_response(self.preview_template, context, context_instance=RequestContext(request))
|
|
else:
|
|
return render_to_response(self.form_template, context, context_instance=RequestContext(request))
|
|
|
|
def post_post(self, request):
|
|
"Validates the POST data. If valid, calls done(). Else, redisplays form."
|
|
f = self.form(request.POST, auto_id=AUTO_ID)
|
|
context = {'form': f, 'stage_field': self.unused_name('stage'), 'state': self.state,
|
|
'year': self.year}
|
|
if f.is_valid():
|
|
if self.security_hash(request, f) != request.POST.get(self.unused_name('hash')):
|
|
return self.failed_hash(request) # Security hash failed.
|
|
self.process_preview(request, f, context)
|
|
return self.done(request, f.cleaned_data)
|
|
else:
|
|
return render_to_response(self.form_template, context, context_instance=RequestContext(request))
|
|
|
|
def done(self, request, cleaned_data):
|
|
members_info = self.state['members_info']
|
|
members_email = [member['email'] for member in self.state['members_info']]
|
|
members_excluded = self.group.role_set.filter(name__slug='member').exclude(email__address__in=members_email)
|
|
members_excluded.delete()
|
|
for member in members_info:
|
|
Role.objects.get_or_create(name=RoleName.objects.get(slug="member"),
|
|
group=self.group,
|
|
person=member['person'],
|
|
email=member['email_obj'])
|
|
|
|
return redirect('nomcom_edit_members', year=self.year)
|
|
|
|
|
|
class EditNomcomForm(forms.ModelForm):
|
|
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(EditNomcomForm, self).__init__(*args, **kwargs)
|
|
|
|
if self.instance:
|
|
if self.instance.public_key:
|
|
help_text = "The nomcom already has a public key. Previous data will remain encrypted with the old key"
|
|
else:
|
|
help_text = "The nomcom has not a public key yet"
|
|
self.fields['public_key'].help_text = help_text
|
|
|
|
class Meta:
|
|
model = NomCom
|
|
fields = ('public_key', 'initial_text',
|
|
'send_questionnaire', 'reminder_interval')
|
|
|
|
def clean_public_key(self):
|
|
public_key = self.cleaned_data.get('public_key', None)
|
|
if not public_key:
|
|
return
|
|
(validation, error) = validate_public_key(public_key)
|
|
if validation:
|
|
return public_key
|
|
raise forms.ValidationError('Invalid public key. Error was: %s' % error)
|
|
|
|
|
|
class MergeForm(forms.Form):
|
|
|
|
primary_person = SearchablePersonField(help_text="Select the person you want the datatracker to keep")
|
|
duplicate_persons = SearchablePersonsField(help_text="Select all the duplicates that should be merged into the primary person record")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.nomcom = kwargs.pop('nomcom', None)
|
|
super(MergeForm, self).__init__(*args, **kwargs)
|
|
|
|
def clean(self):
|
|
primary_person = self.cleaned_data.get("primary_person")
|
|
duplicate_persons = self.cleaned_data.get("duplicate_persons")
|
|
if primary_person and duplicate_persons:
|
|
if primary_person in duplicate_persons:
|
|
msg = "The primary person must not also be listed as a duplicate person"
|
|
self._errors["primary_person"] = self.error_class([msg])
|
|
return self.cleaned_data
|
|
|
|
def save(self):
|
|
primary_person = self.cleaned_data.get("primary_person")
|
|
duplicate_persons = self.cleaned_data.get("duplicate_persons")
|
|
|
|
subject = "Request to merge Person records"
|
|
from_email = settings.NOMCOM_FROM_EMAIL
|
|
(to_email, cc) = gather_address_lists('person_merge_requested')
|
|
context = {'primary_person':primary_person, 'duplicate_persons':duplicate_persons}
|
|
send_mail(None, to_email, from_email, subject, 'nomcom/merge_request.txt', context, cc=cc)
|
|
|
|
class NominateForm(forms.ModelForm):
|
|
searched_email = SearchableEmailField(only_users=False)
|
|
qualifications = forms.CharField(label="Candidate's qualifications for the position",
|
|
widget=forms.Textarea())
|
|
confirmation = forms.BooleanField(label='Email comments back to me as confirmation.',
|
|
help_text="If you want to get a confirmation mail containing your feedback in cleartext, please check the 'email comments back to me as confirmation'.",
|
|
required=False)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.nomcom = kwargs.pop('nomcom', None)
|
|
self.user = kwargs.pop('user', None)
|
|
self.public = kwargs.pop('public', None)
|
|
|
|
super(NominateForm, self).__init__(*args, **kwargs)
|
|
|
|
new_person_url_name = 'nomcom_%s_nominate_newperson' % ('public' if self.public else 'private' )
|
|
self.fields['searched_email'].label = 'Candidate email'
|
|
self.fields['searched_email'].help_text = 'Search by name or email address. Click <a href="%s">here</a> if the search does not find the candidate you want to nominate.' % reverse(new_person_url_name,kwargs={'year':self.nomcom.year()})
|
|
self.fields['nominator_email'].label = 'Nominator email'
|
|
if self.nomcom:
|
|
self.fields['position'].queryset = Position.objects.get_by_nomcom(self.nomcom).opened()
|
|
self.fields['qualifications'].help_text = self.nomcom.initial_text
|
|
|
|
if not self.public:
|
|
self.fields.pop('confirmation')
|
|
author = get_user_email(self.user)
|
|
if author:
|
|
self.fields['nominator_email'].initial = author.address
|
|
help_text = """(Nomcom Chair/Member: please fill this in. Use your own email address if the person making the
|
|
nomination wishes to be anonymous. The confirmation email will be sent to the address given here,
|
|
and the address will also be captured as part of the registered nomination.)"""
|
|
self.fields['nominator_email'].help_text = help_text
|
|
self.fields['share_nominator'].help_text = """(Nomcom Chair/Member: Check this box if the person providing this nomination
|
|
has indicated they will allow NomCom to share their name as one of the people
|
|
nominating this candidate."""
|
|
else:
|
|
self.fields.pop('nominator_email')
|
|
|
|
|
|
def save(self, commit=True):
|
|
# Create nomination
|
|
nomination = super(NominateForm, self).save(commit=False)
|
|
nominator_email = self.cleaned_data.get('nominator_email', None)
|
|
searched_email = self.cleaned_data['searched_email']
|
|
position = self.cleaned_data['position']
|
|
qualifications = self.cleaned_data['qualifications']
|
|
confirmation = self.cleaned_data.get('confirmation', False)
|
|
share_nominator = self.cleaned_data['share_nominator']
|
|
nomcom_template_path = '/nomcom/%s/' % self.nomcom.group.acronym
|
|
|
|
nomination.candidate_name = searched_email.person.plain_name()
|
|
nomination.candidate_email = searched_email.address
|
|
|
|
author = None
|
|
if self.public:
|
|
author = get_user_email(self.user)
|
|
else:
|
|
if nominator_email:
|
|
emails = Email.objects.filter(address=nominator_email)
|
|
author = emails and emails[0] or None
|
|
nominee = make_nomineeposition(self.nomcom, searched_email.person, position, author)
|
|
|
|
# Complete nomination data
|
|
feedback = Feedback.objects.create(nomcom=self.nomcom,
|
|
comments=qualifications,
|
|
type=FeedbackTypeName.objects.get(slug='nomina'),
|
|
user=self.user)
|
|
feedback.positions.add(position)
|
|
feedback.nominees.add(nominee)
|
|
|
|
if author:
|
|
nomination.nominator_email = author.address
|
|
feedback.author = author.address
|
|
feedback.save()
|
|
|
|
nomination.nominee = nominee
|
|
nomination.comments = feedback
|
|
nomination.share_nominator = share_nominator
|
|
nomination.user = self.user
|
|
|
|
if commit:
|
|
nomination.save()
|
|
|
|
# send receipt email to nominator
|
|
if confirmation:
|
|
if author:
|
|
subject = 'Nomination receipt'
|
|
from_email = settings.NOMCOM_FROM_EMAIL
|
|
(to_email, cc) = gather_address_lists('nomination_receipt_requested',nominator=author.address)
|
|
context = {'nominee': nominee.email.person.name,
|
|
'comments': qualifications,
|
|
'position': position.name}
|
|
path = nomcom_template_path + NOMINATION_RECEIPT_TEMPLATE
|
|
send_mail(None, to_email, from_email, subject, path, context, cc=cc)
|
|
|
|
return nomination
|
|
|
|
class Meta:
|
|
model = Nomination
|
|
fields = ('share_nominator', 'position', 'nominator_email', 'searched_email',
|
|
'candidate_phone', 'qualifications', 'confirmation')
|
|
|
|
class NominateNewPersonForm(forms.ModelForm):
|
|
qualifications = forms.CharField(label="Candidate's qualifications for the position",
|
|
widget=forms.Textarea())
|
|
confirmation = forms.BooleanField(label='Email comments back to me as confirmation.',
|
|
help_text="If you want to get a confirmation mail containing your feedback in cleartext, please check the 'email comments back to me as confirmation'.",
|
|
required=False)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.nomcom = kwargs.pop('nomcom', None)
|
|
self.user = kwargs.pop('user', None)
|
|
self.public = kwargs.pop('public', None)
|
|
|
|
super(NominateNewPersonForm, self).__init__(*args, **kwargs)
|
|
|
|
self.fields['nominator_email'].label = 'Nominator email'
|
|
if self.nomcom:
|
|
self.fields['position'].queryset = Position.objects.get_by_nomcom(self.nomcom).opened()
|
|
self.fields['qualifications'].help_text = self.nomcom.initial_text
|
|
|
|
if not self.public:
|
|
self.fields.pop('confirmation')
|
|
author = get_user_email(self.user)
|
|
if author:
|
|
self.fields['nominator_email'].initial = author.address
|
|
help_text = """(Nomcom Chair/Member: please fill this in. Use your own email address if the person making the
|
|
nomination wishes to be anonymous. The confirmation email will be sent to the address given here,
|
|
and the address will also be captured as part of the registered nomination.)"""
|
|
self.fields['nominator_email'].help_text = help_text
|
|
self.fields['share_nominator'].help_text = """(Nomcom Chair/Member: Check this box if the person providing this nomination
|
|
has indicated they will allow NomCom to share their name as one of the people
|
|
nominating this candidate."""
|
|
else:
|
|
self.fields.pop('nominator_email')
|
|
|
|
|
|
def clean_candidate_email(self):
|
|
candidate_email = self.cleaned_data['candidate_email']
|
|
if Email.objects.filter(address=candidate_email).exists():
|
|
normal_url_name = 'nomcom_%s_nominate' % 'public' if self.public else 'private'
|
|
msg = '%s is already in the datatracker. \
|
|
Use the <a href="%s">normal nomination form</a> to nominate the person \
|
|
with this address.\
|
|
' % (candidate_email,reverse(normal_url_name,kwargs={'year':self.nomcom.year()}))
|
|
raise forms.ValidationError(mark_safe(msg))
|
|
return candidate_email
|
|
|
|
def save(self, commit=True):
|
|
# Create nomination
|
|
nomination = super(NominateNewPersonForm, self).save(commit=False)
|
|
nominator_email = self.cleaned_data.get('nominator_email', None)
|
|
candidate_email = self.cleaned_data['candidate_email']
|
|
candidate_name = self.cleaned_data['candidate_name']
|
|
position = self.cleaned_data['position']
|
|
qualifications = self.cleaned_data['qualifications']
|
|
confirmation = self.cleaned_data.get('confirmation', False)
|
|
share_nominator = self.cleaned_data['share_nominator']
|
|
nomcom_template_path = '/nomcom/%s/' % self.nomcom.group.acronym
|
|
|
|
|
|
author = None
|
|
if self.public:
|
|
author = get_user_email(self.user)
|
|
else:
|
|
if nominator_email:
|
|
emails = Email.objects.filter(address=nominator_email)
|
|
author = emails and emails[0] or None
|
|
## This is where it should change - validation of the email field should fail if the email exists
|
|
## The function should become make_nominee_from_newperson)
|
|
nominee = make_nomineeposition_for_newperson(self.nomcom, candidate_name, candidate_email, position, author)
|
|
|
|
# Complete nomination data
|
|
feedback = Feedback.objects.create(nomcom=self.nomcom,
|
|
comments=qualifications,
|
|
type=FeedbackTypeName.objects.get(slug='nomina'),
|
|
user=self.user)
|
|
feedback.positions.add(position)
|
|
feedback.nominees.add(nominee)
|
|
|
|
if author:
|
|
nomination.nominator_email = author.address
|
|
feedback.author = author.address
|
|
feedback.save()
|
|
|
|
nomination.nominee = nominee
|
|
nomination.comments = feedback
|
|
nomination.share_nominator = share_nominator
|
|
nomination.user = self.user
|
|
|
|
if commit:
|
|
nomination.save()
|
|
|
|
# send receipt email to nominator
|
|
if confirmation:
|
|
if author:
|
|
subject = 'Nomination receipt'
|
|
from_email = settings.NOMCOM_FROM_EMAIL
|
|
(to_email, cc) = gather_address_lists('nomination_receipt_requested',nominator=author.address)
|
|
context = {'nominee': nominee.email.person.name,
|
|
'comments': qualifications,
|
|
'position': position.name}
|
|
path = nomcom_template_path + NOMINATION_RECEIPT_TEMPLATE
|
|
send_mail(None, to_email, from_email, subject, path, context, cc=cc)
|
|
|
|
return nomination
|
|
|
|
class Meta:
|
|
model = Nomination
|
|
fields = ('share_nominator', 'position', 'nominator_email', 'candidate_name',
|
|
'candidate_email', 'candidate_phone', 'qualifications', 'confirmation')
|
|
|
|
|
|
class FeedbackForm(forms.ModelForm):
|
|
nominator_email = forms.CharField(label='Commenter email',required=False)
|
|
|
|
comments = forms.CharField(label='Comments',
|
|
widget=forms.Textarea())
|
|
confirmation = forms.BooleanField(label='Email comments back to me as confirmation (if selected, your comments will be emailed to you in cleartext when you press Save).',
|
|
required=False)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.nomcom = kwargs.pop('nomcom', None)
|
|
self.user = kwargs.pop('user', None)
|
|
self.public = kwargs.pop('public', None)
|
|
self.position = kwargs.pop('position', None)
|
|
self.nominee = kwargs.pop('nominee', None)
|
|
|
|
super(FeedbackForm, self).__init__(*args, **kwargs)
|
|
|
|
author = get_user_email(self.user)
|
|
|
|
if self.public:
|
|
self.fields.pop('nominator_email')
|
|
else:
|
|
help_text = """(Nomcom Chair/Member: please fill this in. Use your own email address if the person making the
|
|
comments wishes to be anonymous. The confirmation email will be sent to the address given here,
|
|
and the address will also be captured as part of the registered nomination.)"""
|
|
self.fields['nominator_email'].help_text = help_text
|
|
self.fields['confirmation'].label = 'Email these comments in cleartext to the provided commenter email address'
|
|
if author:
|
|
self.fields['nominator_email'].initial = author.address
|
|
|
|
|
|
def clean(self):
|
|
if not NomineePosition.objects.accepted().filter(nominee=self.nominee,
|
|
position=self.position):
|
|
msg = "There isn't a accepted nomination for %s on the %s position" % (self.nominee, self.position)
|
|
self._errors["comments"] = self.error_class([msg])
|
|
return self.cleaned_data
|
|
|
|
def save(self, commit=True):
|
|
feedback = super(FeedbackForm, self).save(commit=False)
|
|
confirmation = self.cleaned_data['confirmation']
|
|
comments = self.cleaned_data['comments']
|
|
nomcom_template_path = '/nomcom/%s/' % self.nomcom.group.acronym
|
|
|
|
author = None
|
|
if self.public:
|
|
author = get_user_email(self.user)
|
|
else:
|
|
nominator_email = self.cleaned_data['nominator_email']
|
|
if nominator_email:
|
|
emails = Email.objects.filter(address=nominator_email)
|
|
author = emails and emails[0] or None
|
|
|
|
if author:
|
|
feedback.author = author.address
|
|
|
|
feedback.nomcom = self.nomcom
|
|
feedback.user = self.user
|
|
feedback.type = FeedbackTypeName.objects.get(slug='comment')
|
|
feedback.save()
|
|
feedback.positions.add(self.position)
|
|
feedback.nominees.add(self.nominee)
|
|
|
|
# send receipt email to feedback author
|
|
if confirmation:
|
|
if author:
|
|
subject = "NomCom comment confirmation"
|
|
from_email = settings.NOMCOM_FROM_EMAIL
|
|
(to_email, cc) = gather_address_lists('nomcom_comment_receipt_requested',commenter=author.address)
|
|
context = {'nominee': self.nominee.email.person.name,
|
|
'comments': comments,
|
|
'position': self.position.name}
|
|
path = nomcom_template_path + FEEDBACK_RECEIPT_TEMPLATE
|
|
send_mail(None, to_email, from_email, subject, path, context, cc=cc)
|
|
|
|
class Meta:
|
|
model = Feedback
|
|
fields = (
|
|
'nominator_email',
|
|
'comments',
|
|
'confirmation',
|
|
)
|
|
|
|
class FeedbackEmailForm(forms.Form):
|
|
|
|
email_text = forms.CharField(label='Email text', widget=forms.Textarea())
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.nomcom = kwargs.pop('nomcom', None)
|
|
super(FeedbackEmailForm, self).__init__(*args, **kwargs)
|
|
|
|
def save(self, commit=True):
|
|
create_feedback_email(self.nomcom, self.cleaned_data['email_text'])
|
|
|
|
class QuestionnaireForm(forms.ModelForm):
|
|
|
|
comments = forms.CharField(label='Questionnaire response from this candidate',
|
|
widget=forms.Textarea())
|
|
def __init__(self, *args, **kwargs):
|
|
self.nomcom = kwargs.pop('nomcom', None)
|
|
self.user = kwargs.pop('user', None)
|
|
|
|
super(QuestionnaireForm, self).__init__(*args, **kwargs)
|
|
self.fields['nominee'] = PositionNomineeField(nomcom=self.nomcom, required=True)
|
|
|
|
def save(self, commit=True):
|
|
feedback = super(QuestionnaireForm, self).save(commit=False)
|
|
(position, nominee) = self.cleaned_data['nominee']
|
|
|
|
author = get_user_email(self.user)
|
|
|
|
if author:
|
|
feedback.author = author
|
|
|
|
feedback.nomcom = self.nomcom
|
|
feedback.user = self.user
|
|
feedback.type = FeedbackTypeName.objects.get(slug='questio')
|
|
feedback.save()
|
|
self.save_m2m()
|
|
feedback.nominees.add(nominee)
|
|
feedback.positions.add(position)
|
|
|
|
class Meta:
|
|
model = Feedback
|
|
fields = ( 'comments', )
|
|
|
|
class NomComTemplateForm(DBTemplateForm):
|
|
content = forms.CharField(label="Text", widget=forms.Textarea(attrs={'cols': '120', 'rows':'40', }))
|
|
|
|
class PositionForm(forms.ModelForm):
|
|
|
|
class Meta:
|
|
model = Position
|
|
fields = ('name', 'is_open')
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.nomcom = kwargs.pop('nomcom', None)
|
|
super(PositionForm, self).__init__(*args, **kwargs)
|
|
|
|
def save(self, *args, **kwargs):
|
|
self.instance.nomcom = self.nomcom
|
|
super(PositionForm, self).save(*args, **kwargs)
|
|
|
|
|
|
class PrivateKeyForm(forms.Form):
|
|
|
|
key = forms.CharField(label='Private key', widget=forms.Textarea(), required=False)
|
|
|
|
def clean_key(self):
|
|
key = self.cleaned_data.get('key', None)
|
|
if not key:
|
|
return
|
|
(validation, error) = validate_private_key(key)
|
|
if validation:
|
|
return key
|
|
raise forms.ValidationError('Invalid private key. Error was: %s' % error)
|
|
|
|
|
|
class PendingFeedbackForm(forms.ModelForm):
|
|
|
|
type = forms.ModelChoiceField(queryset=FeedbackTypeName.objects.all().order_by('pk'), widget=forms.RadioSelect, empty_label='Unclassified', required=False)
|
|
|
|
class Meta:
|
|
model = Feedback
|
|
fields = ('type', )
|
|
|
|
def set_nomcom(self, nomcom, user):
|
|
self.nomcom = nomcom
|
|
self.user = user
|
|
#self.fields['nominee'] = MultiplePositionNomineeField(nomcom=self.nomcom,
|
|
#required=True,
|
|
#widget=forms.SelectMultiple,
|
|
#help_text='Hold down "Control", or "Command" on a Mac, to select more than one.')
|
|
|
|
def save(self, commit=True):
|
|
feedback = super(PendingFeedbackForm, self).save(commit=False)
|
|
feedback.nomcom = self.nomcom
|
|
feedback.user = self.user
|
|
feedback.save()
|
|
return feedback
|
|
|
|
class ReminderDatesForm(forms.ModelForm):
|
|
|
|
class Meta:
|
|
model = ReminderDates
|
|
fields = ('date',)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(ReminderDatesForm, self).__init__(*args, **kwargs)
|
|
self.fields['date'].required = False
|
|
|
|
|
|
class MutableFeedbackForm(forms.ModelForm):
|
|
|
|
type = forms.ModelChoiceField(queryset=FeedbackTypeName.objects.all(), widget=forms.HiddenInput)
|
|
|
|
class Meta:
|
|
model = Feedback
|
|
fields = ('type', )
|
|
|
|
def set_nomcom(self, nomcom, user, instances=None):
|
|
self.nomcom = nomcom
|
|
self.user = user
|
|
instances = instances or []
|
|
self.feedback_type = None
|
|
for i in instances:
|
|
if i.id == self.instance.id:
|
|
self.feedback_type = i.type
|
|
break
|
|
self.feedback_type = self.feedback_type or self.fields['type'].clean(self.fields['type'].widget.value_from_datadict(self.data, self.files, self.add_prefix('type')))
|
|
|
|
self.initial['type'] = self.feedback_type
|
|
|
|
if self.feedback_type.slug != 'nomina':
|
|
self.fields['nominee'] = MultiplePositionNomineeField(nomcom=self.nomcom,
|
|
required=True,
|
|
widget=forms.SelectMultiple(attrs={'class':'nominee_multi_select','size':'12'}),
|
|
help_text='Hold down "Control", or "Command" on a Mac, to select more than one.')
|
|
else:
|
|
self.fields['position'] = forms.ModelChoiceField(queryset=Position.objects.get_by_nomcom(self.nomcom).opened(), label="Position")
|
|
self.fields['searched_email'] = SearchableEmailField(only_users=False,help_text="Try to find the candidate you are classifying with this field first. Only use the name and email fields below if this search does not find the candidate.",label="Candidate",required=False)
|
|
self.fields['candidate_name'] = forms.CharField(label="Candidate name",help_text="Only fill in this name field if the search doesn't find the person you are classifying",required=False)
|
|
self.fields['candidate_email'] = forms.EmailField(label="Candidate email",help_text="Only fill in this email field if the search doesn't find the person you are classifying",required=False)
|
|
self.fields['candidate_phone'] = forms.CharField(label="Candidate phone", required=False)
|
|
|
|
def clean(self):
|
|
cleaned_data = super(MutableFeedbackForm,self).clean()
|
|
if self.feedback_type.slug == 'nomina':
|
|
searched_email = self.cleaned_data.get('searched_email')
|
|
candidate_name = self.cleaned_data.get('candidate_name')
|
|
if candidate_name:
|
|
candidate_name = candidate_name.strip()
|
|
candidate_email = self.cleaned_data.get('candidate_email')
|
|
if candidate_email:
|
|
candidate_email = candidate_email.strip()
|
|
|
|
if not any([ searched_email and not candidate_name and not candidate_email,
|
|
not searched_email and candidate_name and candidate_email,
|
|
]):
|
|
raise forms.ValidationError("You must identify either an existing person (by searching with the candidate field) and leave the name and email fields blank, or leave the search field blank and provide both a name and email address.")
|
|
if candidate_email and Email.objects.filter(address=candidate_email).exists():
|
|
raise forms.ValidationError("%s already exists in the datatracker. Please search within the candidate field to find it and leave both the name and email fields blank." % candidate_email)
|
|
return cleaned_data
|
|
|
|
def save(self, commit=True):
|
|
feedback = super(MutableFeedbackForm, self).save(commit=False)
|
|
if self.instance.type.slug == 'nomina':
|
|
searched_email = self.cleaned_data['searched_email']
|
|
candidate_email = self.cleaned_data['candidate_email']
|
|
candidate_name = self.cleaned_data['candidate_name']
|
|
candidate_phone = self.cleaned_data['candidate_phone']
|
|
position = self.cleaned_data['position']
|
|
|
|
nominator_email = feedback.author
|
|
feedback.save()
|
|
|
|
emails = Email.objects.filter(address=nominator_email)
|
|
author = emails and emails[0] or None
|
|
|
|
if searched_email:
|
|
nominee = make_nomineeposition(self.nomcom, searched_email.person, position, author)
|
|
else:
|
|
nominee = make_nomineeposition_for_newperson(self.nomcom, candidate_name, candidate_email, position, author)
|
|
feedback.nominees.add(nominee)
|
|
feedback.positions.add(position)
|
|
Nomination.objects.create(
|
|
position=self.cleaned_data.get('position'),
|
|
candidate_name=candidate_name,
|
|
candidate_email=candidate_email,
|
|
candidate_phone=candidate_phone,
|
|
nominee=nominee,
|
|
comments=feedback,
|
|
nominator_email=nominator_email,
|
|
user=self.user)
|
|
return feedback
|
|
else:
|
|
feedback.save()
|
|
self.save_m2m()
|
|
for (position, nominee) in self.cleaned_data['nominee']:
|
|
feedback.nominees.add(nominee)
|
|
feedback.positions.add(position)
|
|
return feedback
|
|
|
|
|
|
FullFeedbackFormSet = forms.modelformset_factory(
|
|
model=Feedback,
|
|
extra=0,
|
|
max_num=0,
|
|
form=MutableFeedbackForm,
|
|
can_order=False,
|
|
can_delete=False,
|
|
fields=('type',),
|
|
)
|
|
|
|
|
|
class EditNomineeForm(forms.ModelForm):
|
|
|
|
nominee_email = forms.ModelChoiceField(queryset=Email.objects.none(),empty_label=None)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(EditNomineeForm, self).__init__(*args, **kwargs)
|
|
self.fields['nominee_email'].queryset = Email.objects.filter(person=self.instance.person,active=True)
|
|
self.fields['nominee_email'].initial = self.instance.email
|
|
self.fields['nominee_email'].help_text = "If the address you are looking for does not appear in this list, ask the nominee (or the secretariat) to add the address to their datatracker account and ensure it is marked as active."
|
|
|
|
def save(self, commit=True):
|
|
nominee = super(EditNomineeForm, self).save(commit=False)
|
|
nominee_email = self.cleaned_data.get("nominee_email")
|
|
nominee.email = nominee_email
|
|
nominee.save()
|
|
return nominee
|
|
|
|
class Meta:
|
|
model = Nominee
|
|
fields = ('nominee_email',)
|
|
|
|
class NominationResponseCommentForm(forms.Form):
|
|
comments = forms.CharField(widget=forms.Textarea,required=False,help_text="Any comments provided will be encrytped and will only be visible to the NomCom.")
|
|
|