def private_questionnaire(request, year):
nomcom = get_nomcom_by_year(year)
has_publickey = nomcom.public_key and True or False
message = None
questionnaire_response = None
template = 'nomcom/private_questionnaire.html'
if not has_publickey:
message = ('warning', "This Nomcom is not yet accepting questionnaires")
return render_to_response(template,
{'message': message,
'nomcom': nomcom,
'year': year,
'selected': 'questionnaire'}, RequestContext(request))
if request.method == 'POST':
form = QuestionnaireForm(data=request.POST,
nomcom=nomcom, user=request.user)
if form.is_valid():
form.save()
message = ('success', 'The questionnaire response has been registered.')
questionnaire_response = form.cleaned_data['comments']
form = QuestionnaireForm(nomcom=nomcom, user=request.user)
else:
form = QuestionnaireForm(nomcom=nomcom, user=request.user)
return render_to_response(template,
{'form': form,
'questionnaire_response': questionnaire_response,
'message': message,
'nomcom': nomcom,
'year': year,
'selected': 'questionnaire'}, RequestContext(request))
def test_edit_nomcom_view(self):
r = self.access_chair_url(self.edit_nomcom_url)
q = PyQuery(r.content)
f = open(self.cert_file.name)
response = self.client.post(self.edit_nomcom_url, {
'public_key': f,
'reminderdates_set-TOTAL_FORMS': q('input[name="reminderdates_set-TOTAL_FORMS"]').val(),
'reminderdates_set-INITIAL_FORMS': q('input[name="reminderdates_set-INITIAL_FORMS"]').val(),
'reminderdates_set-MAX_NUM_FORMS': q('input[name="reminderdates_set-MAX_NUM_FORMS"]').val(),
})
f.close()
self.assertEqual(response.status_code, 200)
nominee = Nominee.objects.get(email__person__user__username=COMMUNITY_USER)
position = Position.objects.get(name='OAM')
comments = u'Plain text. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'
nomcom = get_nomcom_by_year(self.year)
feedback = Feedback.objects.create(nomcom=nomcom,
comments=comments,
type=FeedbackType.objects.get(slug='nomina'))
feedback.positions.add(position)
feedback.nominees.add(nominee)
# to check feedback comments are saved like enrypted data
self.assertNotEqual(feedback.comments, comments)
self.assertEqual(check_comments(feedback.comments, comments, self.privatekey_file), True)
self.client.logout()
def private_feedback_email(request, year):
nomcom = get_nomcom_by_year(year)
has_publickey = nomcom.public_key and True or False
message = None
template = 'nomcom/private_feedback_email.html'
if not has_publickey:
message = ('warning', "This Nomcom is not yet accepting feedback email")
return render_to_response(template,
{'message': message,
'nomcom': nomcom,
'year': year,
'selected': 'feedback_email'}, RequestContext(request))
form = FeedbackEmailForm(nomcom=nomcom)
if request.method == 'POST':
form = FeedbackEmailForm(data=request.POST,
nomcom=nomcom)
if form.is_valid():
form.save()
form = FeedbackEmailForm(nomcom=nomcom)
message = ('success', 'The feedback email has been registered.')
return render_to_response(template,
{'form': form,
'message': message,
'nomcom': nomcom,
'year': year,
'selected': 'feedback_email'}, RequestContext(request))
def feedback(request, year, public):
nomcom = get_nomcom_by_year(year)
has_publickey = nomcom.public_key and True or False
nominee = None
position = None
if nomcom.group.state_id != 'conclude':
selected_nominee = request.GET.get('nominee')
selected_position = request.GET.get('position')
if selected_nominee and selected_position:
nominee = get_object_or_404(Nominee, id=selected_nominee)
position = get_object_or_404(Position, id=selected_position)
positions = Position.objects.get_by_nomcom(nomcom=nomcom).opened()
user_comments = Feedback.objects.filter(nomcom=nomcom,
type='comment',
author__in=request.user.person.email_set.filter(active='True'))
counter = Counter(user_comments.values_list('positions','nominees'))
counts = dict()
for pos,nom in counter:
counts.setdefault(pos,dict())[nom] = counter[(pos,nom)]
if public:
base_template = "nomcom/nomcom_public_base.html"
else:
base_template = "nomcom/nomcom_private_base.html"
if not has_publickey:
messages.warning(request, "This Nomcom is not yet accepting comments")
return render(request, 'nomcom/feedback.html', {
'nomcom': nomcom,
'year': year,
'selected': 'feedback',
'counts' : counts,
'base_template': base_template
})
if nominee and position and request.method == 'POST':
form = FeedbackForm(data=request.POST,
nomcom=nomcom, user=request.user,
public=public, position=position, nominee=nominee)
if form.is_valid():
form.save()
messages.success(request, 'Your feedback has been registered.')
form = None
else:
if nominee and position:
form = FeedbackForm(nomcom=nomcom, user=request.user, public=public,
position=position, nominee=nominee)
else:
form = None
return render(request, 'nomcom/feedback.html', {
'form': form,
'nomcom': nomcom,
'year': year,
'positions': positions,
'selected': 'feedback',
'counts': counts,
'base_template': base_template
})
def edit_position(request, year, position_id=None):
nomcom = get_nomcom_by_year(year)
if nomcom.group.state_id=='conclude':
return HttpResponseForbidden('This nomcom is closed.')
if position_id:
try:
position = nomcom.position_set.get(id=position_id)
except Position.DoesNotExist:
raise Http404
else:
position = None
if request.method == 'POST':
form = PositionForm(request.POST, instance=position, nomcom=nomcom)
if form.is_valid():
form.save()
return redirect('nomcom_list_positions', year=year)
else:
form = PositionForm(instance=position, nomcom=nomcom)
return render_to_response('nomcom/edit_position.html',
{'form': form,
'position': position,
'year': year,
'nomcom': nomcom,
'is_chair_task' : True,
}, RequestContext(request))
def is_chair(user, year):
if not user or not year:
return False
nomcom = get_nomcom_by_year(year=year)
if has_role(user, "Secretariat"):
return True
return nomcom.group.has_role(user, "chair")
def test_edit_nomcom_view(self):
"""Verify edit nomcom view"""
self.access_chair_url(self.edit_nomcom_url)
f = open(self.cert_file.name)
response = self.client.post(self.edit_nomcom_url, {'public_key': f})
f.close()
self.assertEqual(response.status_code, 200)
nominee = Nominee.objects.get(email__person__name=COMMUNITY_USER)
position = Position.objects.get(name='OAM')
comments = u'Plain text. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'
nomcom = get_nomcom_by_year(self.year)
feedback = Feedback.objects.create(
nomcom=nomcom,
comments=comments,
type=FeedbackType.objects.get(slug='nomina'))
feedback.positions.add(position)
feedback.nominees.add(nominee)
# to check feedback comments are saved like enrypted data
self.assertNotEqual(feedback.comments, comments)
self.assertEqual(
check_comments(feedback.comments, comments, self.privatekey_file),
True)
self.client.logout()
def nominate(request, year, public):
nomcom = get_nomcom_by_year(year)
has_publickey = nomcom.public_key and True or False
if public:
template = 'nomcom/public_nominate.html'
else:
template = 'nomcom/private_nominate.html'
if not has_publickey:
message = ('warning', "This Nomcom is not yet accepting nominations")
return render_to_response(template,
{'message': message,
'nomcom': nomcom,
'year': year,
'selected': 'nominate'}, RequestContext(request))
message = None
if request.method == 'POST':
form = NominateForm(data=request.POST, nomcom=nomcom, user=request.user, public=public)
if form.is_valid():
form.save()
message = ('success', 'Your nomination has been registered. Thank you for the nomination.')
else:
form = NominateForm(nomcom=nomcom, user=request.user, public=public)
return render_to_response(template,
{'form': form,
'message': message,
'nomcom': nomcom,
'year': year,
'selected': 'nominate'}, RequestContext(request))
def view_feedback(request, year):
nomcom = get_nomcom_by_year(year)
nominees = Nominee.objects.get_by_nomcom(nomcom).not_duplicated().distinct()
independent_feedback_types = []
feedback_types = []
for ft in FeedbackType.objects.all():
if ft.slug in settings.NOMINEE_FEEDBACK_TYPES:
feedback_types.append(ft)
else:
independent_feedback_types.append(ft)
nominees_feedback = {}
for nominee in nominees:
nominee_feedback = [(ft.name, nominee.feedback_set.by_type(ft.slug).count()) for ft in feedback_types]
nominees_feedback.update({nominee: nominee_feedback})
independent_feedback = [ft.feedback_set.get_by_nomcom(nomcom).count() for ft in independent_feedback_types]
return render_to_response('nomcom/view_feedback.html',
{'year': year,
'selected': 'view_feedback',
'nominees': nominees,
'feedback_types': feedback_types,
'independent_feedback_types': independent_feedback_types,
'independent_feedback': independent_feedback,
'nominees_feedback': nominees_feedback,
'nomcom': nomcom}, RequestContext(request))
def test_edit_nomcom_view(self):
"""Verify edit nomcom view"""
self.access_chair_url(self.edit_nomcom_url)
f = open(self.cert_file.name)
response = self.client.post(self.edit_nomcom_url, {'public_key': f})
f.close()
self.assertEqual(response.status_code, 200)
nominee = Nominee.objects.get(email__person__name=COMMUNITY_USER)
position = Position.objects.get(name='OAM')
comments = u'Plain text. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'
nomcom = get_nomcom_by_year(self.year)
feedback = Feedback.objects.create(nomcom=nomcom,
comments=comments,
type=FeedbackType.objects.get(slug='nomina'))
feedback.positions.add(position)
feedback.nominees.add(nominee)
# to check feedback comments are saved like enrypted data
self.assertNotEqual(feedback.comments, comments)
self.assertEqual(check_comments(feedback.comments, comments, self.privatekey_file), True)
self.client.logout()
def is_chair(user, year):
if not user or not year:
return False
nomcom = get_nomcom_by_year(year=year)
if has_role(user, "Secretariat"):
return True
return nomcom.group.is_chair(user)
def process_nomination_status(request, year, nominee_position_id, state, date, hash):
valid = get_hash_nominee_position(date, nominee_position_id) == hash
if not valid:
return HttpResponseForbidden("Bad hash!")
expiration_days = getattr(settings, 'DAYS_TO_EXPIRE_NOMINATION_LINK', None)
if expiration_days:
request_date = datetime.date(int(date[:4]), int(date[4:6]), int(date[6:]))
if datetime.date.today() > (request_date + datetime.timedelta(days=settings.DAYS_TO_EXPIRE_REGISTRATION_LINK)):
return HttpResponseForbidden("Link expired")
need_confirmation = True
nomcom = get_nomcom_by_year(year)
nominee_position = get_object_or_404(NomineePosition, id=nominee_position_id)
if nominee_position.state.slug != "pending":
return HttpResponseForbidden("The nomination already was %s" % nominee_position.state)
state = get_object_or_404(NomineePositionState, slug=state)
message = ('warning', "Are you sure to change the nomination on %s as %s?" % (nominee_position.position.name,
state.name))
if request.method == 'POST':
nominee_position.state = state
nominee_position.save()
need_confirmation = False
message = message = ('success', 'Your nomination on %s has been set as %s' % (nominee_position.position.name,
state.name))
return render_to_response('nomcom/process_nomination_status.html',
{'message': message,
'nomcom': nomcom,
'year': year,
'nominee_position': nominee_position,
'state': state,
'need_confirmation': need_confirmation,
'selected': 'feedback'}, RequestContext(request))
def edit_nomcom(request, year):
nomcom = get_nomcom_by_year(year)
has_publickey = nomcom.public_key and True or False
if has_publickey:
message = ('warning', 'Previous data will remain encrypted with the old key')
else:
message = ('warning', 'The nomcom has not a public key yet')
ReminderDateInlineFormSet = inlineformset_factory(parent_model=NomCom,
model=ReminderDates,
form=ReminderDatesForm)
if request.method == 'POST':
formset = ReminderDateInlineFormSet(request.POST, instance=nomcom)
form = EditNomcomForm(request.POST,
request.FILES,
instance=nomcom)
if form.is_valid() and formset.is_valid():
form.save()
formset.save()
formset = ReminderDateInlineFormSet(instance=nomcom)
message = ('success', 'The nomcom has been changed')
else:
formset = ReminderDateInlineFormSet(instance=nomcom)
form = EditNomcomForm(instance=nomcom)
return render_to_response('nomcom/edit_nomcom.html',
{'form': form,
'formset': formset,
'nomcom': nomcom,
'message': message,
'year': year,
'selected': 'edit_nomcom'}, RequestContext(request))
def questionnaires(request, year):
nomcom = get_nomcom_by_year(year)
positions = nomcom.position_set.all()
return render_to_response('nomcom/questionnaires.html',
{'nomcom': nomcom,
'positions': positions,
'year': year,
'selected': 'questionnaires'}, RequestContext(request))
def _is_nomcom_member(user, *args, **kwargs):
year = kwargs.get('year', None)
if year:
nomcom = get_nomcom_by_year(year=year)
if role == 'chair':
return nomcom.group.is_chair(user)
else:
return nomcom.group.is_member(user)
return False
def list_positions(request, year):
nomcom = get_nomcom_by_year(year)
positions = nomcom.position_set.all()
return render_to_response('nomcom/list_positions.html',
{'positions': positions,
'year': year,
'selected': 'edit_positions',
'nomcom': nomcom}, RequestContext(request))
def _is_nomcom_member(user, *args, **kwargs):
year = kwargs.get('year', None)
if year:
nomcom = get_nomcom_by_year(year=year)
if role == 'chair':
return nomcom.group.is_chair(user)
else:
return nomcom.group.is_member(user)
return False
def year_index(request, year):
nomcom = get_nomcom_by_year(year)
home_template = '/nomcom/%s/%s' % (nomcom.group.acronym, HOME_TEMPLATE)
template = render_to_string(home_template, {})
return render_to_response('nomcom/year_index.html',
{'nomcom': nomcom,
'year': year,
'selected': 'index',
'template': template}, RequestContext(request))
def edit_template(request, year, template_id):
nomcom = get_nomcom_by_year(year)
return_url = request.META.get('HTTP_REFERER', None)
return template_edit(request, nomcom.group.acronym, template_id,
base_template='nomcom/edit_template.html',
formclass=NomComTemplateForm,
extra_context={'year': year,
'return_url': return_url,
'nomcom': nomcom})
def list_positions(request, year):
nomcom = get_nomcom_by_year(year)
positions = nomcom.position_set.order_by('-is_open')
return render_to_response('nomcom/list_positions.html',
{'positions': positions,
'year': year,
'selected': 'edit_positions',
'nomcom': nomcom,
'is_chair_task' : True,
}, RequestContext(request))
def list_templates(request, year):
nomcom = get_nomcom_by_year(year)
positions = nomcom.position_set.all()
template_list = DBTemplate.objects.filter(group=nomcom.group).exclude(path__contains='/position/')
return render_to_response('nomcom/list_templates.html',
{'template_list': template_list,
'positions': positions,
'year': year,
'selected': 'edit_templates',
'nomcom': nomcom}, RequestContext(request))
def view_feedback_nominee(request, year, nominee_id):
nomcom = get_nomcom_by_year(year)
nominee = get_object_or_404(Nominee, id=nominee_id)
feedback_types = FeedbackType.objects.filter(slug__in=settings.NOMINEE_FEEDBACK_TYPES)
return render_to_response('nomcom/view_feedback_nominee.html',
{'year': year,
'selected': 'view_feedback',
'nominee': nominee,
'feedback_types': feedback_types,
'nomcom': nomcom}, RequestContext(request))
def add_questionnaire(self, *args, **kwargs):
public = kwargs.pop('public', False)
nominee_email = kwargs.pop('nominee_email', u'*****@*****.**')
nominator_email = kwargs.pop('nominator_email',
"%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))
position_name = kwargs.pop('position', 'IAOC')
self.nominate_view(public=public,
nominee_email=nominee_email,
position=position_name,
nominator_email=nominator_email)
response = self.client.get(self.add_questionnaire_url)
self.assertEqual(response.status_code, 200)
nomcom = get_nomcom_by_year(self.year)
if not nomcom.public_key:
self.assertNotContains(response, "questionnnaireform")
# save the cert file in tmp
nomcom.public_key.storage.location = tempfile.gettempdir()
nomcom.public_key.save('cert', File(open(self.cert_file.name, 'r')))
response = self.client.get(self.add_questionnaire_url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "questionnnaireform")
position = Position.objects.get(name=position_name)
nominee = Nominee.objects.get(email__address=nominee_email)
comments = u'Test add questionnaire view. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'
test_data = {
'comments': comments,
'nominee': '%s_%s' % (position.id, nominee.id)
}
response = self.client.post(self.add_questionnaire_url, test_data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "info-message-success")
## check objects
feedback = Feedback.objects.filter(
positions__in=[position],
nominees__in=[nominee],
type=FeedbackType.objects.get(slug='questio')).latest('id')
## to check feedback comments are saved like enrypted data
self.assertNotEqual(feedback.comments, comments)
self.assertEqual(
check_comments(feedback.comments, comments, self.privatekey_file),
True)
def process_nomination_status(request, year, nominee_position_id, state, date, hash):
valid = get_hash_nominee_position(date, nominee_position_id) == hash
if not valid:
return HttpResponseForbidden("Bad hash!")
expiration_days = getattr(settings, 'DAYS_TO_EXPIRE_NOMINATION_LINK', None)
if expiration_days:
request_date = datetime.date(int(date[:4]), int(date[4:6]), int(date[6:]))
if datetime.date.today() > (request_date + datetime.timedelta(days=settings.DAYS_TO_EXPIRE_NOMINATION_LINK)):
return HttpResponseForbidden("Link expired")
need_confirmation = True
nomcom = get_nomcom_by_year(year)
if nomcom.group.state_id == 'conclude':
return HttpResponseForbidden("This nomcom is concluded.")
nominee_position = get_object_or_404(NomineePosition, id=nominee_position_id)
if nominee_position.state.slug != "pending":
return HttpResponseForbidden("The nomination already was %s" % nominee_position.state)
state = get_object_or_404(NomineePositionStateName, slug=state)
messages.info(request, "Click on 'Save' to set the state of your nomination to %s to %s (this is not a final commitment - you can notify us later if you need to change this)." % (nominee_position.position.name, state.name))
if request.method == 'POST':
form = NominationResponseCommentForm(request.POST)
if form.is_valid():
nominee_position.state = state
nominee_position.save()
need_confirmation = False
if form.cleaned_data['comments']:
# This Feedback object is of type comment instead of nomina in order to not
# make answering "who nominated themselves" harder.
who = request.user
if isinstance(who,AnonymousUser):
who = None
f = Feedback.objects.create(nomcom = nomcom,
author = nominee_position.nominee.email,
subject = '%s nomination %s'%(nominee_position.nominee.name(),state),
comments = form.cleaned_data['comments'],
type_id = 'comment',
user = who,
)
f.positions.add(nominee_position.position)
f.nominees.add(nominee_position.nominee)
messages.success(request, 'Your nomination on %s has been set as %s' % (nominee_position.position.name, state.name))
else:
form = NominationResponseCommentForm()
return render_to_response('nomcom/process_nomination_status.html',
{'nomcom': nomcom,
'year': year,
'nominee_position': nominee_position,
'state': state,
'need_confirmation': need_confirmation,
'selected': 'feedback',
'form': form }, RequestContext(request))
def send_reminder_mail(request, year, type):
nomcom = get_nomcom_by_year(year)
nomcom_template_path = '/nomcom/%s/' % nomcom.group.acronym
if type=='accept':
interesting_state = 'pending'
mail_path = nomcom_template_path + NOMINEE_ACCEPT_REMINDER_TEMPLATE
reminder_description = 'accept (or decline) a nomination'
selected_tab = 'send_accept_reminder'
state_description = NomineePositionState.objects.get(slug=interesting_state).name
elif type=='questionnaire':
interesting_state = 'accepted'
mail_path = nomcom_template_path + NOMINEE_QUESTIONNAIRE_REMINDER_TEMPLATE
reminder_description = 'complete the questionnaire for a nominated position'
selected_tab = 'send_questionnaire_reminder'
state_description = NomineePositionState.objects.get(slug=interesting_state).name+' but no questionnaire has been received'
else:
raise Http404
nominees = Nominee.objects.get_by_nomcom(nomcom).not_duplicated().filter(nomineeposition__state=interesting_state).distinct()
annotated_nominees = []
for nominee in nominees:
if type=='accept':
nominee.interesting_positions = [x.position.name for x in nominee.nomineeposition_set.pending()]
else:
nominee.interesting_positions = [x.position.name for x in nominee.nomineeposition_set.accepted().without_questionnaire_response()]
if nominee.interesting_positions:
annotated_nominees.append(nominee)
mail_template = DBTemplate.objects.filter(group=nomcom.group, path=mail_path)
mail_template = mail_template and mail_template[0] or None
message = None
if request.method == 'POST':
selected_nominees = request.POST.getlist('selected')
selected_nominees = nominees.filter(id__in=selected_nominees)
if selected_nominees:
addrs = send_reminder_to_nominees(selected_nominees,type)
if addrs:
message = ('success', 'A copy of "%s" has been sent to %s'%(mail_template.title,", ".join(addrs)))
else:
message = ('warning', 'No messages were sent.')
else:
message = ('warning', "Please, select at least one nominee")
return render_to_response('nomcom/send_reminder_mail.html',
{'nomcom': nomcom,
'year': year,
'nominees': annotated_nominees,
'mail_template': mail_template,
'selected': selected_tab,
'reminder_description': reminder_description,
'state_description': state_description,
'message': message}, RequestContext(request))
def view_feedback_unrelated(request, year):
nomcom = get_nomcom_by_year(year)
feedback_types = []
for ft in FeedbackType.objects.exclude(slug__in=settings.NOMINEE_FEEDBACK_TYPES):
feedback_types.append({'ft': ft,
'feedback': ft.feedback_set.get_by_nomcom(nomcom)})
return render_to_response('nomcom/view_feedback_unrelated.html',
{'year': year,
'selected': 'view_feedback',
'feedback_types': feedback_types,
'nomcom': nomcom}, RequestContext(request))
def delete_nomcom(request, year):
nomcom = get_nomcom_by_year(year)
post_delete_redirect = reverse('nomcom_deleted')
extra_context = {'year': year,
'selected': 'edit_nomcom',
'nomcom': nomcom}
return delete_object(request,
model=NomCom,
object_id=nomcom.id,
post_delete_redirect=post_delete_redirect,
template_name='nomcom/delete_nomcom.html',
extra_context=extra_context)
def delete_nomcom(request, year):
nomcom = get_nomcom_by_year(year)
if request.method == 'POST':
nomcom.delete()
messages.success(request, "Deleted NomCom data")
return redirect('nomcom_deleted')
return render(request, 'nomcom/delete_nomcom.html', {
'year': year,
'selected': 'edit_nomcom',
'nomcom': nomcom,
})
def view_feedback(request, year):
nomcom = get_nomcom_by_year(year)
nominees = Nominee.objects.get_by_nomcom(nomcom).not_duplicated().distinct()
independent_feedback_types = []
feedback_types = []
for ft in FeedbackTypeName.objects.all():
if ft.slug in settings.NOMINEE_FEEDBACK_TYPES:
feedback_types.append(ft)
else:
independent_feedback_types.append(ft)
nominees_feedback = []
def nominee_staterank(nominee):
states=nominee.nomineeposition_set.values_list('state_id',flat=True)
if 'accepted' in states:
return 0
elif 'pending' in states:
return 1
else:
return 2
for nominee in nominees:
nominee.staterank = nominee_staterank(nominee)
sorted_nominees = sorted(nominees,key=lambda x:x.staterank)
for nominee in sorted_nominees:
last_seen = FeedbackLastSeen.objects.filter(reviewer=request.user.person,nominee=nominee).first()
nominee_feedback = []
for ft in feedback_types:
qs = nominee.feedback_set.by_type(ft.slug)
count = qs.count()
if not count:
newflag = False
elif not last_seen:
newflag = True
else:
newflag = qs.filter(time__gt=last_seen.time).exists()
nominee_feedback.append( (ft.name,count,newflag) )
nominees_feedback.append( {'nominee':nominee, 'feedback':nominee_feedback} )
independent_feedback = [ft.feedback_set.get_by_nomcom(nomcom).count() for ft in independent_feedback_types]
return render_to_response('nomcom/view_feedback.html',
{'year': year,
'selected': 'view_feedback',
'nominees': nominees,
'feedback_types': feedback_types,
'independent_feedback_types': independent_feedback_types,
'independent_feedback': independent_feedback,
'nominees_feedback': nominees_feedback,
'nomcom': nomcom}, RequestContext(request))
def remove_position(request, year, position_id):
nomcom = get_nomcom_by_year(year)
try:
position = nomcom.position_set.get(id=position_id)
except Position.DoesNotExist:
raise Http404
if request.POST.get('remove', None):
position.delete()
return HttpResponseRedirect(reverse('nomcom_list_positions', None, args=(year, )))
return render_to_response('nomcom/remove_position.html',
{'year': year,
'position': position,
'nomcom': nomcom}, RequestContext(request))
def add_questionnaire(self, *args, **kwargs):
public = kwargs.pop('public', False)
nominee_email = kwargs.pop('nominee_email', u'*****@*****.**')
nominator_email = kwargs.pop('nominator_email', "%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))
position_name = kwargs.pop('position', 'IAOC')
self.nominate_view(public=public,
nominee_email=nominee_email,
position=position_name,
nominator_email=nominator_email)
response = self.client.get(self.add_questionnaire_url)
self.assertEqual(response.status_code, 200)
nomcom = get_nomcom_by_year(self.year)
if not nomcom.public_key:
self.assertNotContains(response, "questionnnaireform")
# save the cert file in tmp
nomcom.public_key.storage.location = tempfile.gettempdir()
nomcom.public_key.save('cert', File(open(self.cert_file.name, 'r')))
response = self.client.get(self.add_questionnaire_url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "questionnnaireform")
position = Position.objects.get(name=position_name)
nominee = Nominee.objects.get(email__address=nominee_email)
comments = u'Test add questionnaire view. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'
test_data = {'comments': comments,
'nominee': '%s_%s' % (position.id, nominee.id)}
response = self.client.post(self.add_questionnaire_url, test_data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "info-message-success")
## check objects
feedback = Feedback.objects.filter(positions__in=[position],
nominees__in=[nominee],
type=FeedbackType.objects.get(slug='questio')).latest('id')
## to check feedback comments are saved like enrypted data
self.assertNotEqual(feedback.comments, comments)
self.assertEqual(check_comments(feedback.comments, comments, self.privatekey_file), True)
def feedback(request, year, public):
nomcom = get_nomcom_by_year(year)
has_publickey = nomcom.public_key and True or False
submit_disabled = True
nominee = None
position = None
selected_nominee = request.GET.get('nominee')
selected_position = request.GET.get('position')
if selected_nominee and selected_position:
nominee = get_object_or_404(Nominee, id=selected_nominee)
position = get_object_or_404(Position, id=selected_position)
submit_disabled = False
positions = Position.objects.get_by_nomcom(nomcom=nomcom).opened()
if public:
template = 'nomcom/public_feedback.html'
else:
template = 'nomcom/private_feedback.html'
if not has_publickey:
message = ('warning', "This Nomcom is not yet accepting comments")
return render_to_response(template,
{'message': message,
'nomcom': nomcom,
'year': year,
'selected': 'feedback'}, RequestContext(request))
message = None
if request.method == 'POST':
form = FeedbackForm(data=request.POST,
nomcom=nomcom, user=request.user,
public=public, position=position, nominee=nominee)
if form.is_valid():
form.save()
message = ('success', 'Your feedback has been registered.')
else:
form = FeedbackForm(nomcom=nomcom, user=request.user, public=public,
position=position, nominee=nominee)
return render_to_response(template,
{'form': form,
'message': message,
'nomcom': nomcom,
'year': year,
'positions': positions,
'submit_disabled': submit_disabled,
'selected': 'feedback'}, RequestContext(request))
def private_merge(request, year):
nomcom = get_nomcom_by_year(year)
message = None
if request.method == 'POST':
form = MergeForm(request.POST, nomcom=nomcom)
if form.is_valid():
form.save()
message = ('success', 'The emails have been unified')
else:
form = MergeForm(nomcom=nomcom)
return render_to_response('nomcom/private_merge.html',
{'nomcom': nomcom,
'year': year,
'form': form,
'message': message,
'selected': 'merge'}, RequestContext(request))
def nominate(request, year, public, newperson):
nomcom = get_nomcom_by_year(year)
has_publickey = nomcom.public_key and True or False
if public:
template = 'nomcom/public_nominate.html'
else:
template = 'nomcom/private_nominate.html'
if not has_publickey:
messages.warning(request, "This Nomcom is not yet accepting nominations")
return render_to_response(template,
{'nomcom': nomcom,
'year': year,
'selected': 'nominate'}, RequestContext(request))
if nomcom.group.state_id == 'conclude':
messages.warning(request, "Nominations to this Nomcom are closed.")
return render_to_response(template,
{'nomcom': nomcom,
'year': year,
'selected': 'nominate'}, RequestContext(request))
if request.method == 'POST':
if newperson:
form = NominateNewPersonForm(data=request.POST, nomcom=nomcom, user=request.user, public=public)
else:
form = NominateForm(data=request.POST, nomcom=nomcom, user=request.user, public=public)
if form.is_valid():
form.save()
messages.success(request, 'Your nomination has been registered. Thank you for the nomination.')
if newperson:
return redirect('nomcom_%s_nominate' % ('public' if public else 'private'), year=year)
else:
form = NominateForm(nomcom=nomcom, user=request.user, public=public)
else:
if newperson:
form = NominateNewPersonForm(nomcom=nomcom, user=request.user, public=public)
else:
form = NominateForm(nomcom=nomcom, user=request.user, public=public)
return render_to_response(template,
{'form': form,
'nomcom': nomcom,
'year': year,
'selected': 'nominate'}, RequestContext(request))
def edit_nominee(request, year, nominee_id):
nomcom = get_nomcom_by_year(year)
nominee = get_object_or_404(Nominee, id=nominee_id)
message = None
if request.method == 'POST':
form = EditNomineeForm(request.POST,
instance=nominee)
if form.is_valid():
form.save()
message = ('success', 'The nominee has been changed')
else:
form = EditNomineeForm(instance=nominee)
return render_to_response('nomcom/edit_nominee.html',
{'year': year,
'selected': 'index',
'nominee': nominee,
'form': form,
'message': message,
'nomcom': nomcom}, RequestContext(request))
def edit_position(request, year, position_id=None):
nomcom = get_nomcom_by_year(year)
if position_id:
try:
position = nomcom.position_set.get(id=position_id)
except Position.DoesNotExist:
raise Http404
else:
position = None
if request.method == 'POST':
form = PositionForm(request.POST, instance=position, nomcom=nomcom)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('nomcom_list_positions', None, args=(year, )))
else:
form = PositionForm(instance=position, nomcom=nomcom)
return render_to_response('nomcom/edit_position.html',
{'form': form,
'position': position,
'year': year,
'nomcom': nomcom}, RequestContext(request))
def private_key(request, year):
nomcom = get_nomcom_by_year(year)
message = None
if request.session.get('NOMCOM_PRIVATE_KEY_%s' % year, None):
message = ('warning', 'Alredy there is a private key in your session')
else:
message = ('warning', "There isn't a private key in your session yet")
back_url = request.GET.get('back_to', reverse('nomcom_private_index', None, args=(year, )))
if request.method == 'POST':
form = PrivateKeyForm(data=request.POST)
if form.is_valid():
store_nomcom_private_key(request, year, form.cleaned_data.get('key', ''))
return HttpResponseRedirect(back_url)
else:
form = PrivateKeyForm()
return render_to_response('nomcom/private_key.html',
{'nomcom': nomcom,
'year': year,
'back_url': back_url,
'form': form,
'message': message,
'selected': 'private_key'}, RequestContext(request))
def send_reminder_mail(request, year):
nomcom = get_nomcom_by_year(year)
nominees = Nominee.objects.get_by_nomcom(nomcom).not_duplicated().filter(nomineeposition__state='pending').distinct()
nomcom_template_path = '/nomcom/%s/' % nomcom.group.acronym
mail_path = nomcom_template_path + NOMINEE_REMINDER_TEMPLATE
mail_template = DBTemplate.objects.filter(group=nomcom.group, path=mail_path)
mail_template = mail_template and mail_template[0] or None
message = None
if request.method == 'POST':
selected_nominees = request.POST.getlist('selected')
selected_nominees = nominees.filter(id__in=selected_nominees)
if selected_nominees:
send_reminder_to_nominees(selected_nominees)
message = ('success', 'An query has been sent to each person, asking them to accept (or decline) the nominations')
else:
message = ('warning', "Please, select some nominee")
return render_to_response('nomcom/send_reminder_mail.html',
{'nomcom': nomcom,
'year': year,
'nominees': nominees,
'mail_template': mail_template,
'selected': 'send_reminder_mail',
'message': message}, RequestContext(request))
def private_index(request, year):
nomcom = get_nomcom_by_year(year)
all_nominee_positions = NomineePosition.objects.get_by_nomcom(nomcom).not_duplicated()
is_chair = nomcom.group.is_chair(request.user)
message = None
if is_chair and request.method == 'POST':
action = request.POST.get('action')
nominations_to_modify = request.POST.getlist('selected')
if nominations_to_modify:
nominations = all_nominee_positions.filter(id__in=nominations_to_modify)
if action == "set_as_accepted":
nominations.update(state='accepted')
message = ('success', 'The selected nominations have been set as accepted')
elif action == "set_as_declined":
nominations.update(state='declined')
message = ('success', 'The selected nominations have been set as declined')
elif action == "set_as_pending":
nominations.update(state='pending')
message = ('success', 'The selected nominations have been set as pending')
else:
message = ('warning', "Please, select some nominations to work with")
filters = {}
questionnaire_state = "questionnaire"
selected_state = request.GET.get('state')
selected_position = request.GET.get('position')
if selected_state and not selected_state == questionnaire_state:
filters['state__slug'] = selected_state
if selected_position:
filters['position__id'] = selected_position
nominee_positions = all_nominee_positions
if filters:
nominee_positions = nominee_positions.filter(**filters)
if selected_state == questionnaire_state:
nominee_positions = [np for np in nominee_positions if np.questionnaires]
stats = all_nominee_positions.values('position__name', 'position__id').annotate(total=Count('position'))
states = list(NomineePositionState.objects.values('slug', 'name')) + [{'slug': questionnaire_state, 'name': u'Questionnaire'}]
positions = all_nominee_positions.values('position__name', 'position__id').distinct()
for s in stats:
for state in states:
if state['slug'] == questionnaire_state:
s[state['slug']] = Feedback.objects.filter(positions__id=s['position__id'], type='questio').count()
else:
s[state['slug']] = all_nominee_positions.filter(position__name=s['position__name'],
state=state['slug']).count()
return render_to_response('nomcom/private_index.html',
{'nomcom': nomcom,
'year': year,
'nominee_positions': nominee_positions,
'stats': stats,
'states': states,
'positions': positions,
'selected_state': selected_state,
'selected_position': selected_position and int(selected_position) or None,
'selected': 'index',
'is_chair': is_chair,
'message': message}, RequestContext(request))
def nominate_view(self, *args, **kwargs):
public = kwargs.pop('public', True)
nominee_email = kwargs.pop('nominee_email', u'*****@*****.**')
nominator_email = kwargs.pop('nominator_email',
"%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))
position_name = kwargs.pop('position', 'IAOC')
if public:
nominate_url = self.public_nominate_url
else:
nominate_url = self.private_nominate_url
response = self.client.get(nominate_url)
self.assertEqual(response.status_code, 200)
nomcom = get_nomcom_by_year(self.year)
if not nomcom.public_key:
self.assertNotContains(response, "nominateform")
# save the cert file in tmp
nomcom.public_key.storage.location = tempfile.gettempdir()
nomcom.public_key.save('cert', File(open(self.cert_file.name, 'r')))
response = self.client.get(nominate_url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "nominateform")
position = Position.objects.get(name=position_name)
candidate_email = nominee_email
candidate_name = u'nominee'
comments = u'Test nominate view. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'
candidate_phone = u'123456'
test_data = {
'candidate_name': candidate_name,
'candidate_email': candidate_email,
'candidate_phone': candidate_phone,
'position': position.id,
'comments': comments
}
if not public:
test_data['nominator_email'] = nominator_email
response = self.client.post(nominate_url, test_data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "info-message-success")
# check objects
email = Email.objects.get(address=candidate_email)
Person.objects.get(name=candidate_name, address=candidate_email)
nominee = Nominee.objects.get(email=email)
NomineePosition.objects.get(position=position, nominee=nominee)
feedback = Feedback.objects.filter(
positions__in=[position],
nominees__in=[nominee],
type=FeedbackType.objects.get(slug='nomina')).latest('id')
if public:
self.assertEqual(feedback.author, nominator_email)
# to check feedback comments are saved like enrypted data
self.assertNotEqual(feedback.comments, comments)
self.assertEqual(
check_comments(feedback.comments, comments, self.privatekey_file),
True)
Nomination.objects.get(position=position,
candidate_name=candidate_name,
candidate_email=candidate_email,
candidate_phone=candidate_phone,
nominee=nominee,
comments=feedback,
nominator_email="%s%s" %
(COMMUNITY_USER, EMAIL_DOMAIN))
def feedback_view(self, *args, **kwargs):
public = kwargs.pop('public', True)
nominee_email = kwargs.pop('nominee_email', u'*****@*****.**')
nominator_email = kwargs.pop('nominator_email',
"%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))
position_name = kwargs.pop('position', 'IAOC')
self.nominate_view(public=public,
nominee_email=nominee_email,
position=position_name,
nominator_email=nominator_email)
feedback_url = self.public_feedback_url
if not public:
feedback_url = self.private_feedback_url
response = self.client.get(feedback_url)
self.assertEqual(response.status_code, 200)
nomcom = get_nomcom_by_year(self.year)
if not nomcom.public_key:
self.assertNotContains(response, "feedbackform")
# save the cert file in tmp
nomcom.public_key.storage.location = tempfile.gettempdir()
nomcom.public_key.save('cert', File(open(self.cert_file.name, 'r')))
response = self.client.get(feedback_url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "feedbackform")
position = Position.objects.get(name=position_name)
nominee = Nominee.objects.get(email__address=nominee_email)
comments = u'Test feedback view. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'
test_data = {
'comments': comments,
'position_name': position.name,
'nominee_name': nominee.email.person.name,
'nominee_email': nominee.email.address
}
if public:
test_data['nominator_email'] = nominator_email
test_data['nominator_name'] = nominator_email
feedback_url += "?nominee=%d&position=%d" % (nominee.id, position.id)
nominee_position = NomineePosition.objects.get(nominee=nominee,
position=position)
state = nominee_position.state
if not state.slug == 'accepted':
response = self.client.post(feedback_url, test_data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "info-message-error")
# accept nomination
nominee_position.state = NomineePositionState.objects.get(
slug='accepted')
nominee_position.save()
response = self.client.post(feedback_url, test_data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "info-message-success")
## check objects
feedback = Feedback.objects.filter(
positions__in=[position],
nominees__in=[nominee],
type=FeedbackType.objects.get(slug='comment')).latest('id')
if public:
self.assertEqual(feedback.author, nominator_email)
## to check feedback comments are saved like enrypted data
self.assertNotEqual(feedback.comments, comments)
self.assertEqual(
check_comments(feedback.comments, comments, self.privatekey_file),
True)
# recovery state
if state != nominee_position.state:
nominee_position.state = state
nominee_position.save()
def is_chair_or_advisor(user, year):
if not user or not year:
return False
nomcom = get_nomcom_by_year(year=year)
return nomcom.group.has_role(user, ["chair", "advisor"])
def view_feedback_pending(request, year):
nomcom = get_nomcom_by_year(year)
extra_ids = None
message = None
for message in get_messages(request):
message = ('success', message.message)
FeedbackFormSet = modelformset_factory(Feedback,
form=PendingFeedbackForm,
extra=0)
feedbacks = Feedback.objects.filter(type__isnull=True, nomcom=nomcom)
try:
default_type = FeedbackType.objects.get(slug=settings.DEFAULT_FEEDBACK_TYPE)
except FeedbackType.DoesNotExist:
default_type = None
extra_step = False
if request.method == 'POST' and request.POST.get('move_to_default'):
formset = FeedbackFormSet(request.POST)
if formset.is_valid():
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
form.move_to_default()
formset = FeedbackFormSet(queryset=feedbacks)
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
success(request, 'Feedback saved')
return HttpResponseRedirect(reverse('nomcom_view_feedback_pending', None, args=(year, )))
elif request.method == 'POST' and request.POST.get('end'):
extra_ids = request.POST.get('extra_ids', None)
extra_step = True
formset = FullFeedbackFormSet(request.POST)
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
if formset.is_valid():
formset.save()
if extra_ids:
extra = []
for key in extra_ids.split(','):
id, pk_type = key.split(':')
feedback = Feedback.objects.get(id=id)
feedback.type_id = pk_type
extra.append(feedback)
formset = FullFeedbackFormSet(queryset=Feedback.objects.filter(id__in=[i.id for i in extra]))
for form in formset.forms:
form.set_nomcom(nomcom, request.user, extra)
extra_ids = None
else:
success(request, 'Feedback saved')
return HttpResponseRedirect(reverse('nomcom_view_feedback_pending', None, args=(year, )))
elif request.method == 'POST':
formset = FeedbackFormSet(request.POST)
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
if formset.is_valid():
extra = []
nominations = []
moved = 0
for form in formset.forms:
if form.instance.type and form.instance.type.slug in settings.NOMINEE_FEEDBACK_TYPES:
if form.instance.type.slug == 'nomina':
nominations.append(form.instance)
else:
extra.append(form.instance)
else:
if form.instance.type:
moved += 1
form.save()
if extra or nominations:
extra_step = True
if nominations:
formset = FullFeedbackFormSet(queryset=Feedback.objects.filter(id__in=[i.id for i in nominations]))
for form in formset.forms:
form.set_nomcom(nomcom, request.user, nominations)
extra_ids = ','.join(['%s:%s' % (i.id, i.type.pk) for i in extra])
else:
formset = FullFeedbackFormSet(queryset=Feedback.objects.filter(id__in=[i.id for i in extra]))
for form in formset.forms:
form.set_nomcom(nomcom, request.user, extra)
if moved:
message = ('success', '%s messages classified. You must enter more information for the following feedback.' % moved)
else:
success(request, 'Feedback saved')
return HttpResponseRedirect(reverse('nomcom_view_feedback_pending', None, args=(year, )))
else:
formset = FeedbackFormSet(queryset=feedbacks)
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
type_dict = SortedDict({})
for t in FeedbackType.objects.all().order_by('pk'):
rest = t.name
slug = rest[0]
rest = rest[1:]
while slug in type_dict and rest:
slug = rest[0]
rest = rest[1]
type_dict[slug] = t
return render_to_response('nomcom/view_feedback_pending.html',
{'year': year,
'selected': 'feedback_pending',
'formset': formset,
'message': message,
'extra_step': extra_step,
'default_type': default_type,
'type_dict': type_dict,
'extra_ids': extra_ids,
'types': FeedbackType.objects.all().order_by('pk'),
'nomcom': nomcom}, RequestContext(request))
