def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
form_class = self.get_form_class()
form = self.get_form(form_class)
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.AUDIT)
if form.is_valid():
user = self.request.user
audit = create_or_get_audit(post_data,
user.userprofile,
result_form,
form)
url = audit_action(audit, post_data, result_form, self.success_url)
return redirect(url, tally_id=tally_id)
else:
return self.render_to_response(self.get_context_data(form=form,
result_form=result_form,
tally_id=tally_id))
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_data_entry_state(result_form)
formset, forms_and_candidates = get_formset_and_candidates(
result_form, post_data)
recon_form = ReconForm(post_data)
data_entry_number = get_data_entry_number(result_form.form_state)
candidates = result_form.candidates
CandidateFormSet = formset_factory(CandidateForm,
extra=len(candidates),
formset=BaseCandidateFormSet)
formset = CandidateFormSet(post_data)
if (not result_form.has_recon
or recon_form.is_valid()) and formset.is_valid():
check_form = check_state_and_group(result_form, self.request.user,
recon_form)
if check_form:
return self.form_invalid(check_form)
entry_version = None
new_state = None
if result_form.form_state == FormState.DATA_ENTRY_1:
entry_version = EntryVersion.DATA_ENTRY_1
new_state = FormState.DATA_ENTRY_2
else:
entry_version = EntryVersion.DATA_ENTRY_2
new_state = FormState.CORRECTION
for i, form in enumerate(formset.forms):
votes = form.cleaned_data['votes']
Result.objects.create(candidate=candidates[i],
result_form=result_form,
entry_version=entry_version,
votes=votes,
user=self.request.user)
if result_form.has_recon:
re_form = recon_form.save(commit=False)
re_form.entry_version = entry_version
re_form.result_form = result_form
re_form.user = self.request.user
re_form.save()
result_form.form_state = new_state
result_form.save()
return redirect(self.success_url)
else:
return self.render_to_response(
self.get_context_data(
formset=formset,
forms_and_candidates=forms_and_candidates,
reconciliation_form=recon_form,
result_form=result_form,
data_entry_number=data_entry_number))
def form_valid(self, form):
tally_id = self.kwargs.get('tally_id', None)
self.initial = {
'tally_id': tally_id,
}
tally = Tally.objects.get(id=tally_id)
result_form = ResultForm.objects.create(
barcode=form.data['barcode'],
form_state=form.data['form_state'],
tally=tally)
self.request.session['result_form'] = result_form.pk
post_data = self.request.POST.copy()
post_data['result_form'] = self.request.session['result_form']
pk = session_matches_post_result_form(post_data, self.request)
result_form = ResultForm.objects.get(pk=pk)
if result_form.center or result_form.station_number\
or result_form.ballot or result_form.office:
# We are writing a form we should not be, bail out.
del self.request.session['result_form']
return redirect(self.success_url, tally_id=tally_id)
form = CreateResultForm(post_data,
instance=result_form,
initial=self.initial)
form.save()
self.success_message = _(
u"Successfully Created form %(form)s"
% {'form': form.data['barcode']})
return super(CreateResultFormView, self).form_valid(form)
def form_valid(self, form):
tally_id = self.kwargs.get('tally_id', None)
self.initial = {
'tally_id': tally_id,
}
tally = Tally.objects.get(id=tally_id)
result_form = ResultForm.objects.create(
barcode=form.data['barcode'],
form_state=form.data['form_state'],
tally=tally)
self.request.session['result_form'] = result_form.pk
post_data = self.request.POST.copy()
post_data['result_form'] = self.request.session['result_form']
pk = session_matches_post_result_form(post_data, self.request)
result_form = ResultForm.objects.get(pk=pk)
if result_form.center or result_form.station_number\
or result_form.ballot or result_form.office:
# We are writing a form we should not be, bail out.
del self.request.session['result_form']
return redirect(self.success_url, tally_id=tally_id)
form = CreateResultForm(post_data,
instance=result_form,
initial=self.initial)
form.save()
self.success_message = _(
u"Successfully Created form %(form)s"
% {'form': form.data['barcode']})
return super(CreateResultFormView, self).form_valid(form)
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
form_class = self.get_form_class()
form = self.get_form(form_class)
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.AUDIT)
if form.is_valid():
user = self.request.user
audit = create_or_get_audit(post_data, user, result_form, form)
url = audit_action(audit, post_data, result_form, self.success_url)
return redirect(url, tally_id=tally_id)
else:
return self.render_to_response(
self.get_context_data(form=form,
result_form=result_form,
tally_id=tally_id))
return redirect(self.success_url, tally_id=tally_id)
def post(self, *args, **kwargs):
post_data = self.request.POST
form_class = self.get_form_class()
center_form = self.get_form(form_class)
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form = safe_form_in_state(result_form, FormState.INTAKE,
center_form)
if form:
return self.form_invalid(form)
if center_form.is_valid():
center_number = center_form.cleaned_data.get('center_number')
station_number = center_form.cleaned_data.get('station_number')
center = Center.objects.get(code=center_number)
if result_form.intaken(center, station_number):
# a form already exists, send to clearance
self.request.session['intake-error'] = INTAKEN_MESSAGE
result_form.send_to_clearance()
return redirect('intake-clearance')
else:
result_form.center = center
result_form.station_number = station_number
result_form.save()
return redirect(self.success_url)
else:
return self.render_to_response(self.get_context_data(
form=center_form, header_text=_('Intake'),
result_form=result_form))
def post(self, *args, **kwargs):
post_data = self.request.POST
form_class = self.get_form_class()
center_form = self.get_form(form_class)
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form = safe_form_in_state(result_form, FormState.INTAKE, center_form)
if form:
return self.form_invalid(form)
if center_form.is_valid():
center_number = center_form.cleaned_data.get('center_number')
station_number = center_form.cleaned_data.get('station_number')
center = Center.objects.get(code=center_number)
if result_form.intaken(center, station_number):
# a form already exists, send to clearance
self.request.session['intake-error'] = INTAKEN_MESSAGE
result_form.send_to_clearance()
return redirect('intake-clearance')
else:
result_form.center = center
result_form.station_number = station_number
result_form.save()
return redirect(self.success_url)
else:
return self.render_to_response(
self.get_context_data(form=center_form,
header_text=_('Intake'),
result_form=result_form))
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
if 'result_form' in post_data:
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm,
pk=pk,
tally__id=tally_id)
form_in_state(result_form, FormState.AUDIT)
# Track audit clerks result form processing time
if groups.user_groups(self.request.user)[0] == groups.AUDIT_CLERK:
encoded_start_time = self.request.session.get(
'encoded_result_form_audit_start_time')
save_result_form_processing_stats(self.request,
encoded_start_time,
result_form)
del self.request.session['result_form']
return redirect('audit', tally_id=tally_id)
return self.render_to_response(
self.get_context_data(result_form=result_form, tally_id=tally_id))
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
user = self.request.user
form_class = self.get_form_class()
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.CLEARANCE)
form = self.get_form(form_class)
encoded_start_time = self.request.session.get(
'encoded_result_form_clearance_start_time')
# Track clearance clerks review result form processing time
save_result_form_processing_stats(self.request, encoded_start_time,
result_form)
if form.is_valid():
clearance = get_clearance(result_form, post_data, user, form)
url = clearance_action(post_data, clearance, result_form,
self.success_url)
return redirect(url, tally_id=tally_id)
else:
return self.render_to_response(
self.get_context_data(form=form,
result_form=result_form,
tally_id=tally_id))
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
form_class = self.get_form_class()
form = self.get_form(form_class)
if form.is_valid():
pk = session_matches_post_result_form(
form.cleaned_data, self.request)
result_form = get_object_or_404(ResultForm,
pk=pk,
tally__id=tally_id)
form_in_state(result_form, [FormState.CORRECTION])
if not result_form.corrections_passed:
raise Exception(_(u"Results do not match."))
save_final_results(result_form, self.request.user)
save_unchanged_final_recon_form(result_form, self.request.user)
result_form.form_state = FormState.QUALITY_CONTROL
result_form.save()
del self.request.session['result_form']
return redirect(self.success_url, tally_id=tally_id)
else:
return self.form_invalid(form)
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
self.initial = {
'tally_id': tally_id,
}
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = ResultForm.objects.get(pk=pk, )
if 'abort-submit' in self.request.POST:
result_form.delete()
return redirect(self.success_url, tally_id=tally_id)
else:
if result_form.center or result_form.station_number\
or result_form.ballot or result_form.office:
# We are writing a form we should not be, bail out.
del self.request.session['result_form']
return redirect(self.success_url, tally_id=tally_id)
result_form.created_user = self.request.user
form = NewResultForm(post_data, instance=result_form, initial=self.initial)
if form.is_valid():
form.save()
del self.request.session['result_form']
return redirect(self.success_url, tally_id=tally_id)
else:
return self.render_to_response(self.get_context_data(
form=form, result_form=result_form,
tally_id=tally_id))
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
form_class = self.get_form_class()
form = self.get_form(form_class)
if form.is_valid():
pk = session_matches_post_result_form(form.cleaned_data,
self.request)
result_form = get_object_or_404(ResultForm,
pk=pk,
tally__id=tally_id)
form_in_state(result_form, [FormState.CORRECTION])
if not result_form.corrections_passed:
raise Exception(_(u"Results do not match."))
save_final_results(result_form, self.request.user)
save_unchanged_final_recon_form(result_form, self.request.user)
result_form.form_state = FormState.QUALITY_CONTROL
result_form.save()
encoded_start_time = self.request.session.get(
'encoded_result_form_corrections_start_time')
# Track corrections clerks result form processing time
save_result_form_processing_stats(self.request, encoded_start_time,
result_form)
del self.request.session['result_form']
return redirect(self.success_url, tally_id=tally_id)
else:
return self.form_invalid(form)
def post(self, race_type):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.CORRECTION)
if 'submit_corrections' in post_data:
user = self.request.user
try:
with transaction.atomic():
if result_form.reconciliationform_exists:
save_recon(post_data, user, result_form)
save_component_results(result_form, post_data, user)
save_general_results(result_form, post_data, user)
save_women_results(result_form, post_data, user)
except ValidationError as e:
return self.corrections_response(result_form, u"%s" % e)
except SuspiciousOperation as e:
self.request.session['error_message'] = u"%s" % e
if result_form.form_state == FormState.DATA_ENTRY_1:
result_form.save()
return redirect(self.failed_url)
else:
result_form.form_state = FormState.QUALITY_CONTROL
result_form.save()
return redirect(self.success_url)
else:
return incorrect_checks(post_data, result_form, 'corrections')
def post(self, race_type):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.CORRECTION)
if 'submit_corrections' in post_data:
user = self.request.user
try:
with transaction.atomic():
if result_form.reconciliationform_exists:
save_recon(post_data, user, result_form)
save_component_results(result_form, post_data, user)
save_general_results(result_form, post_data, user)
save_women_results(result_form, post_data, user)
except ValidationError as e:
return self.corrections_response(result_form, u"%s" % e)
except SuspiciousOperation as e:
self.request.session['error_message'] = u"%s" % e
if result_form.form_state == FormState.DATA_ENTRY_1:
result_form.save()
return redirect(self.failed_url)
else:
result_form.form_state = FormState.QUALITY_CONTROL
result_form.save()
return redirect(self.success_url)
else:
return incorrect_checks(post_data, result_form, 'corrections')
def post(self, *args, **kwargs):
post_data = self.request.POST
form_class = self.get_form_class()
center_form = self.get_form(form_class)
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form = safe_form_in_state(result_form, FormState.INTAKE,
center_form)
if form:
return self.form_invalid(form)
if center_form.is_valid():
station_number = center_form.cleaned_data.get('station_number')
center_number = center_form.cleaned_data.get('center_number')
center = Center.objects.get(code=center_number)
#Checks if center ballot number and form ballot number are the same
general_check = center.sub_constituency and\
result_form.ballot.number != center.sub_constituency.code
women_check = center.sub_constituency.ballot_women and\
result_form.ballot.number != center.sub_constituency.\
ballot_women.number
if general_check is True and women_check is True:
form = add_generic_error(center_form,
_(u"Ballot number do not match for"
u"center and form"))
return self.render_to_response(self.get_context_data(
form=form, header_text=_('Intake'),
result_form=result_form))
duplicated_forms = result_form.get_duplicated_forms(center,
station_number)
if duplicated_forms:
result_form.station_number = station_number
result_form.center = center
# a form already exists, send to clearance
self.request.session['intake-error'] = INTAKEN_MESSAGE
result_form.send_to_clearance()
for oneDuplicatedForm in duplicated_forms:
if oneDuplicatedForm.form_state != FormState.CLEARANCE:
oneDuplicatedForm.send_to_clearance()
return redirect('intake-clearance')
self.request.session['station_number'] = station_number
self.request.session['center_number'] = center_number
return redirect(self.success_url)
else:
return self.render_to_response(self.get_context_data(
form=center_form, header_text=_('Intake'),
result_form=result_form))
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
possible_states = states_for_form(self.request.user, result_form)
form_in_state(result_form, possible_states)
result_form.form_state = FormState.AUDIT if result_form.audit else FormState.ARCHIVED
result_form.save()
return redirect(self.success_url)
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
possible_states = states_for_form(self.request.user, result_form)
form_in_state(result_form, possible_states)
result_form.form_state = FormState.AUDIT if result_form.audit else\
FormState.ARCHIVED
result_form.save()
return redirect(self.success_url)
def post(self, *args, **kwargs):
post_data = self.request.POST
if 'result_form' in post_data:
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.AUDIT)
del self.request.session['result_form']
return redirect('audit')
return self.render_to_response(
self.get_context_data(result_form=result_form))
def post(self, *args, **kwargs):
post_data = self.request.POST
if 'result_form' in post_data:
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.CLEARANCE)
del self.request.session['result_form']
return redirect('clearance')
return self.render_to_response(
self.get_context_data(result_form=result_form))
def post(self, *args, **kwargs):
post_data = self.request.POST
if 'result_form' in post_data:
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
possible_states = states_for_form(self.request.user,
[FormState.INTAKE], result_form)
form_in_state(result_form, possible_states)
result_form.form_state = FormState.DATA_ENTRY_1
result_form.save()
return redirect('intaken')
return self.render_to_response(
self.get_context_data(result_form=result_form))
def post(self, *args, **kwargs):
"""We arrive here after the cover has been printed and the user
confirms this with a button click. Fetch form and if form had an audit,
set it to audit state, otherwise to archived state.
"""
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.QUALITY_CONTROL)
tally_id = kwargs.get('tally_id')
result_form.form_state = FormState.AUDIT if result_form.audit else\
FormState.ARCHIVED
result_form.save()
return redirect(self.success_url, tally_id=tally_id)
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
if 'result_form' in post_data:
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.CLEARANCE)
del self.request.session['result_form']
return redirect('clearance', tally_id=tally_id)
return self.render_to_response(
self.get_context_data(result_form=result_form,
tally_id=tally_id))
def post(self, *args, **kwargs):
"""We arrive here after the cover has been printed and the user
confirms this with a button click. Fetch form and if form had an audit,
set it to audit state, otherwise to archived state.
"""
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.QUALITY_CONTROL)
tally_id = kwargs.get('tally_id')
result_form.form_state = FormState.AUDIT if result_form.audit else\
FormState.ARCHIVED
result_form.save()
return redirect(self.success_url, tally_id=tally_id)
def post(self, *args, **kwargs):
post_data = self.request.POST
if 'result_form' in post_data:
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
possible_states = states_for_form(self.request.user,
[FormState.INTAKE], result_form)
form_in_state(result_form, possible_states)
result_form.form_state = FormState.DATA_ENTRY_1
result_form.save()
return redirect('intaken')
return self.render_to_response(
self.get_context_data(result_form=result_form))
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
quality_control = result_form.qualitycontrol
url = self.success_url
ballot = Ballot.objects.get(id=result_form.ballot_id)
form_ballot_marked_as_released = ballot.available_for_release
if 'correct' in post_data:
# send to dashboard
quality_control.passed_general = True
quality_control.passed_reconciliation = True
quality_control.passed_women = True
result_form.save()
# run quarantine checks
check_quarantine(result_form, self.request.user)
elif 'incorrect' in post_data:
# send to confirm reject page
if form_ballot_marked_as_released:
url = 'quality-control-confirm-reject'
# send to reject page
else:
quality_control.passed_general = False
quality_control.passed_reconciliation = False
quality_control.passed_women = False
quality_control.active = False
result_form.reject()
url = 'quality-control-reject'
del self.request.session['result_form']
elif 'abort' in post_data:
# send to entry
quality_control.active = False
url = 'quality-control'
del self.request.session['result_form']
else:
raise SuspiciousOperation('Missing expected POST data')
if not form_ballot_marked_as_released:
quality_control.save()
return redirect(url, tally_id=tally_id)
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
if 'result_form' in post_data:
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm,
pk=pk,
tally__id=tally_id)
form_in_state(result_form, FormState.AUDIT)
del self.request.session['result_form']
return redirect('audit', tally_id=tally_id)
return self.render_to_response(
self.get_context_data(result_form=result_form, tally_id=tally_id))
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
quality_control = result_form.qualitycontrol
url = self.success_url
ballot = Ballot.objects.get(id=result_form.ballot_id)
form_ballot_marked_as_released = ballot.available_for_release
if 'correct' in post_data:
# send to dashboard
quality_control.passed_general = True
quality_control.passed_reconciliation = True
quality_control.passed_women = True
result_form.save()
# run quarantine checks
check_quarantine(result_form, self.request.user)
elif 'incorrect' in post_data:
# send to confirm reject page
if form_ballot_marked_as_released:
url = 'quality-control-confirm-reject'
# send to reject page
else:
quality_control.passed_general = False
quality_control.passed_reconciliation = False
quality_control.passed_women = False
quality_control.active = False
result_form.reject()
url = 'quality-control-reject'
del self.request.session['result_form']
elif 'abort' in post_data:
# send to entry
quality_control.active = False
url = 'quality-control'
del self.request.session['result_form']
else:
raise SuspiciousOperation('Missing expected POST data')
if not form_ballot_marked_as_released:
quality_control.save()
return redirect(url, tally_id=tally_id)
def post(self, *args, **kwargs):
form_class = self.get_form_class()
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.CLEARANCE)
form = self.get_form(form_class)
if form.is_valid():
user = self.request.user
clearance = get_clearance(result_form, post_data, user, form)
url = clearance_action(post_data, clearance, result_form,
self.success_url)
return redirect(url)
else:
return self.render_to_response(self.get_context_data(form=form,
result_form=result_form))
def post(self, *args, **kwargs):
form_class = self.get_form_class()
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.CLEARANCE)
form = self.get_form(form_class)
if form.is_valid():
user = self.request.user
clearance = get_clearance(result_form, post_data, user, form)
url = clearance_action(post_data, clearance, result_form,
self.success_url)
return redirect(url)
else:
return self.render_to_response(
self.get_context_data(form=form, result_form=result_form))
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
form_class = self.get_form_class()
form = self.get_form(form_class)
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
if form.is_valid():
check_form = check_state_and_group(result_form, self.request.user,
form)
if check_form:
return self.form_invalid(check_form)
center_number = form.cleaned_data['center_number']
center = Center.objects.get(code=center_number, tally__id=tally_id)
station_number = form.cleaned_data['station_number']
try:
check_form_for_center_station(center, station_number,
result_form)
except SuspiciousOperation as e:
errors = form._errors.setdefault("__all__", ErrorList())
errors.append(e)
return self.render_to_response(
self.get_context_data(form=form, result_form=result_form))
check_form = check_state_and_group(result_form, self.request.user,
form)
if check_form:
return self.form_invalid(check_form)
return redirect(self.success_url, tally_id=tally_id)
else:
return self.render_to_response(
self.get_context_data(
form=form,
result_form=result_form,
tally_id=tally_id,
header_text=get_header_text(result_form)))
def post(self, *args, **kwargs):
post_data = self.request.POST
tally_id = self.kwargs['tally_id']
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_intake_state(result_form)
url = None
if 'is_match' in post_data:
# When result form is not assigned a center/station
if not result_form.center:
station_number = self.request.session.get('station_number')
center_number = self.request.session.get('center_number')
center = Center.objects.get(code=center_number,
tally__id=tally_id)
result_form.station_number = station_number
result_form.center = center
if 'station_number' in self.request.session:
del self.request.session['station_number']
if 'center_number' in self.request.session:
del self.request.session['center_number']
# send to print cover
url = 'intake-printcover'
elif 'is_not_match' in post_data:
# send to clearance
result_form.form_state = FormState.CLEARANCE
url = 'intake-clearance'
else:
del self.request.session['result_form']
result_form.form_state = FormState.UNSUBMITTED
result_form.duplicate_reviewed = False
url = 'intake'
result_form.date_seen = now()
result_form.save()
return redirect(url, tally_id=tally_id)
def post(self, *args, **kwargs):
post_data = self.request.POST
tally_id = self.kwargs['tally_id']
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_intake_state(result_form)
url = None
if 'is_match' in post_data:
# When result form is not assigned a center/station
if not result_form.center:
station_number = self.request.session.get('station_number')
center_number = self.request.session.get('center_number')
center = Center.objects.get(code=center_number,
tally__id=tally_id)
result_form.station_number = station_number
result_form.center = center
if 'station_number' in self.request.session:
del self.request.session['station_number']
if 'center_number' in self.request.session:
del self.request.session['center_number']
# send to print cover
url = 'intake-printcover'
elif 'is_not_match' in post_data:
# send to clearance
result_form.form_state = FormState.CLEARANCE
url = 'intake-clearance'
else:
del self.request.session['result_form']
result_form.form_state = FormState.UNSUBMITTED
result_form.duplicate_reviewed = False
url = 'intake'
result_form.date_seen = now()
result_form.save()
return redirect(url, tally_id=tally_id)
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
quality_control = result_form.qualitycontrol
url = self.success_url
if 'correct' in post_data:
# send to dashboard
quality_control.passed_general = True
quality_control.passed_reconciliation = True
quality_control.passed_women = True
result_form.form_state = FormState.ARCHIVING
result_form.save()
self.request.session['result_form'] = result_form.pk
elif 'incorrect' in post_data:
# send to reject page
quality_control.passed_general = False
quality_control.passed_reconciliation = False
quality_control.passed_women = False
quality_control.active = False
result_form.reject()
url = 'quality-control-reject'
del self.request.session['result_form']
elif 'abort' in post_data:
# send to entry
quality_control.active = False
url = 'quality-control'
del self.request.session['result_form']
else:
raise SuspiciousOperation('Missing expected POST data')
quality_control.save()
return redirect(url, tally_id=tally_id)
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
form_class = self.get_form_class()
form = self.get_form(form_class)
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.AUDIT)
if form.is_valid():
user = self.request.user
audit = create_or_get_audit(post_data, user.userprofile,
result_form, form)
url = audit_action(audit, post_data, result_form, self.success_url)
# Track supervisors result form reviewing processing time
if groups.user_groups(user)[0] in [
groups.AUDIT_SUPERVISOR, groups.SUPER_ADMINISTRATOR,
groups.TALLY_MANAGER
]:
encoded_start_time = self.request.session.get(
'encoded_result_form_audit_start_time')
approved_by_supervisor =\
audit.for_superadmin and audit.active
save_result_form_processing_stats(self.request,
encoded_start_time,
result_form,
approved_by_supervisor,
audit.reviewed_supervisor)
return redirect(url, tally_id=tally_id)
else:
return self.render_to_response(
self.get_context_data(form=form,
result_form=result_form,
tally_id=tally_id))
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = ResultForm.objects.get(pk=pk)
if result_form.center or result_form.station_number\
or result_form.ballot or result_form.office:
# We are writing a form we should not be, bail out.
del self.request.session['result_form']
return redirect('clearance')
result_form.created_user = self.request.user
form = NewResultForm(post_data, instance=result_form)
if form.is_valid():
form.save()
del self.request.session['result_form']
return redirect(self.success_url)
else:
return self.render_to_response(self.get_context_data(
form=form, result_form=result_form))
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = ResultForm.objects.get(pk=pk)
if result_form.center or result_form.station_number\
or result_form.ballot or result_form.office:
# We are writing a form we should not be, bail out.
del self.request.session['result_form']
return redirect('clearance')
result_form.created_user = self.request.user
form = NewResultForm(post_data, instance=result_form)
if form.is_valid():
form.save()
del self.request.session['result_form']
return redirect(self.success_url)
else:
return self.render_to_response(
self.get_context_data(form=form, result_form=result_form))
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
quality_control = result_form.qualitycontrol
url = self.success_url
if 'correct' in post_data:
# send to dashboard
quality_control.passed_general = True
quality_control.passed_reconciliation = True
quality_control.passed_women = True
result_form.form_state = FormState.ARCHIVING
result_form.save()
self.request.session['result_form'] = result_form.pk
elif 'incorrect' in post_data:
# send to reject page
quality_control.passed_general = False
quality_control.passed_reconciliation = False
quality_control.passed_women = False
quality_control.active = False
result_form.reject()
url = 'quality-control-reject'
del self.request.session['result_form']
elif 'abort' in post_data:
# send to entry
quality_control.active = False
url = 'quality-control'
del self.request.session['result_form']
else:
raise SuspiciousOperation('Missing expected POST data')
quality_control.save()
return redirect(url, tally_id=tally_id)
def post(self, *args, **kwargs):
form_class = self.get_form_class()
form = self.get_form(form_class)
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
if form.is_valid():
check_form = check_state_and_group(
result_form, self.request.user, form)
if check_form:
return self.form_invalid(check_form)
center_number = form.cleaned_data['center_number']
center = Center.objects.get(code=center_number)
station_number = form.cleaned_data['station_number']
try:
check_form_for_center_station(center, station_number,
result_form)
except SuspiciousOperation as e:
errors = form._errors.setdefault("__all__", ErrorList())
errors.append(e)
return self.render_to_response(self.get_context_data(
form=form, result_form=result_form))
check_form = check_state_and_group(
result_form, self.request.user, form)
if check_form:
return self.form_invalid(check_form)
return redirect(self.success_url)
else:
return self.render_to_response(self.get_context_data(form=form,
result_form=result_form))
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_intake_state(result_form)
url = None
if 'is_match' in post_data:
# send to print cover
url = 'intake-printcover'
elif 'is_not_match' in post_data:
# send to clearance
result_form.form_state = FormState.CLEARANCE
url = 'intake-clearance'
else:
del self.request.session['result_form']
result_form.form_state = FormState.UNSUBMITTED
url = 'intake'
result_form.date_seen = now()
result_form.save()
return redirect(url)
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_intake_state(result_form)
url = None
if 'is_match' in post_data:
# send to print cover
url = 'intake-printcover'
elif 'is_not_match' in post_data:
# send to clearance
result_form.form_state = FormState.CLEARANCE
url = 'intake-clearance'
else:
del self.request.session['result_form']
result_form.form_state = FormState.UNSUBMITTED
url = 'intake'
result_form.date_seen = now()
result_form.save()
return redirect(url)
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
self.initial = {
'tally_id': tally_id,
}
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = ResultForm.objects.get(pk=pk, )
if 'abort-submit' in self.request.POST:
result_form.delete()
return redirect(self.success_url, tally_id=tally_id)
else:
if result_form.center or result_form.station_number\
or result_form.ballot or result_form.office:
# We are writing a form we should not be, bail out.
del self.request.session['result_form']
return redirect(self.success_url, tally_id=tally_id)
result_form.created_user = self.request.user
form = NewResultForm(post_data,
instance=result_form,
initial=self.initial)
if form.is_valid():
form.save()
del self.request.session['result_form']
return redirect(self.success_url, tally_id=tally_id)
else:
return self.render_to_response(
self.get_context_data(form=form,
result_form=result_form,
tally_id=tally_id))
def post(self, *args, **kwargs):
form_class = self.get_form_class()
form = self.get_form(form_class)
if form.is_valid():
pk = session_matches_post_result_form(
form.cleaned_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, [FormState.CORRECTION])
if not result_form.corrections_passed:
raise Exception(_(u"Results do not match."))
save_final_results(result_form, self.request.user)
save_unchanged_final_recon_form(result_form, self.request.user)
result_form.form_state = FormState.QUALITY_CONTROL
result_form.save()
del self.request.session['result_form']
return redirect(self.success_url)
else:
return self.form_invalid(form)
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
form_class = self.get_form_class()
center_form = self.get_form(form_class)
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form = safe_form_in_state(result_form, FormState.INTAKE,
center_form)
if form:
return self.form_invalid(form)
if center_form.is_valid():
station_number = center_form.cleaned_data.get('station_number')
center_number = center_form.cleaned_data.get('center_number')
center = Center.objects.get(code=center_number, tally__id=tally_id)
# Checks if center ballot number and form ballot number are the
# same
is_error = False
center_sub = center.sub_constituency
if center_sub:
is_general = result_form.ballot.number == \
center.sub_constituency.code
if not is_general:
is_women = center_sub.ballot_women is not None
if not is_women or (
is_women and
result_form.ballot.number !=
center_sub.ballot_women.number):
is_error = True
if is_error:
form = add_generic_error(center_form,
_(u"Ballot number do not match for"
u"center and form"))
return self.render_to_response(self.get_context_data(
form=form, header_text=_('Intake'),
result_form=result_form,
tally_id=tally_id))
duplicated_forms = result_form.get_duplicated_forms(center,
station_number)
if duplicated_forms:
result_form.station_number = station_number
result_form.center = center
# a form already exists, send to clearance
self.request.session[
'intake-error'] = INTAKE_DUPLICATE_ERROR_MESSAGE
if result_form.form_state != FormState.CLEARANCE:
result_form.send_to_clearance()
for form in duplicated_forms:
if form.form_state != FormState.CLEARANCE:
form.send_to_clearance()
return redirect('intake-clearance', tally_id=tally_id)
self.request.session['station_number'] = station_number
self.request.session['center_number'] = center_number
return redirect(self.success_url, tally_id=tally_id)
else:
return self.render_to_response(self.get_context_data(
form=center_form, header_text=_('Intake'),
result_form=result_form))
def post(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
form_class = self.get_form_class()
center_form = self.get_form(form_class)
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form = safe_form_in_state(result_form, FormState.INTAKE, center_form)
if form:
return self.form_invalid(form)
if center_form.is_valid():
station_number = center_form.cleaned_data.get('station_number')
center_number = center_form.cleaned_data.get('center_number')
center = Center.objects.get(code=center_number, tally__id=tally_id)
# Checks if center ballot number and form ballot number are the
# same
is_error = False
center_sub = center.sub_constituency
if center_sub:
is_general = result_form.ballot.number == \
center.sub_constituency.code
if not is_general:
is_women = center_sub.ballot_women is not None
if not is_women or (is_women and result_form.ballot.number
!= center_sub.ballot_women.number):
is_error = True
if is_error:
form = add_generic_error(
center_form,
_(u"Ballot number do not match for"
u"center and form"))
return self.render_to_response(
self.get_context_data(form=form,
header_text=_('Intake'),
result_form=result_form,
tally_id=tally_id))
duplicated_forms = result_form.get_duplicated_forms(
center, station_number)
if duplicated_forms:
result_form.station_number = station_number
result_form.center = center
# a form already exists, send to clearance
self.request.session[
'intake-error'] = INTAKE_DUPLICATE_ERROR_MESSAGE
if result_form.form_state != FormState.CLEARANCE:
result_form.send_to_clearance()
for form in duplicated_forms:
if form.form_state != FormState.CLEARANCE:
form.send_to_clearance()
return redirect('intake-clearance', tally_id=tally_id)
self.request.session['station_number'] = station_number
self.request.session['center_number'] = center_number
return redirect(self.success_url, tally_id=tally_id)
else:
return self.render_to_response(
self.get_context_data(form=center_form,
header_text=_('Intake'),
result_form=result_form))
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = session_matches_post_result_form(post_data, self.request)
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_data_entry_state(result_form)
formset, forms_and_candidates = get_formset_and_candidates(result_form,
post_data)
recon_form = ReconForm(post_data)
data_entry_number = get_data_entry_number(result_form.form_state)
candidates = result_form.candidates
CandidateFormSet = formset_factory(CandidateForm,
extra=len(candidates),
formset=BaseCandidateFormSet)
formset = CandidateFormSet(post_data)
if (not result_form.has_recon or
recon_form.is_valid()) and formset.is_valid():
check_form = check_state_and_group(
result_form, self.request.user, recon_form)
if check_form:
return self.form_invalid(check_form)
entry_version = None
new_state = None
if result_form.form_state == FormState.DATA_ENTRY_1:
entry_version = EntryVersion.DATA_ENTRY_1
new_state = FormState.DATA_ENTRY_2
else:
entry_version = EntryVersion.DATA_ENTRY_2
new_state = FormState.CORRECTION
for i, form in enumerate(formset.forms):
votes = form.cleaned_data['votes']
Result.objects.create(
candidate=candidates[i],
result_form=result_form,
entry_version=entry_version,
votes=votes,
user=self.request.user
)
if result_form.has_recon:
re_form = recon_form.save(commit=False)
re_form.entry_version = entry_version
re_form.result_form = result_form
re_form.user = self.request.user
re_form.save()
result_form.form_state = new_state
result_form.save()
return redirect(self.success_url)
else:
return self.render_to_response(self.get_context_data(
formset=formset,
forms_and_candidates=forms_and_candidates,
reconciliation_form=recon_form,
result_form=result_form,
data_entry_number=data_entry_number))
