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 get(self, *args, **kwargs):
tally_id = self.kwargs['tally_id']
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, [FormState.CORRECTION])
return self.corrections_response(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)
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, *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 get(self, *args, **kwargs):
tally_id = kwargs['tally_id']
pk = self.request.session.get('result_form')
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']
older_duplicated = result_form.get_duplicated_forms().first()
if older_duplicated:
result_form = older_duplicated
encoded_start_time = self.request.session.get(
'encoded_result_form_intake_start_time')
# Track intake clerks result form processing time
save_result_form_processing_stats(self.request, encoded_start_time,
result_form)
error_msg = self.request.session.get('intake-error')
if error_msg:
del self.request.session['intake-error']
return self.render_to_response(
self.get_context_data(error_msg=error_msg,
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)
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):
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 get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, [FormState.CORRECTION])
return self.render_to_response(
self.get_context_data(result_form=result_form))
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 get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, [FormState.CORRECTION])
return self.render_to_response(
self.get_context_data(result_form=result_form))
def get(self, *args, **kwargs):
tally_id = self.kwargs['tally_id']
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, [FormState.CORRECTION])
return self.corrections_response(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)
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 get(self, *args, **kwargs):
pk = self.request.session.get("result_form")
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)
return self.render_to_response(self.get_context_data(result_form=result_form))
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = post_data['result_form']
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.CLEARANCE)
self.request.session['result_form'] = result_form.pk
return redirect(self.success_url)
def get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.CLEARANCE)
problems = result_form.clearance.get_problems()
return self.render_to_response(
self.get_context_data(result_form=result_form, problems=problems))
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = post_data['result_form']
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.CLEARANCE)
self.request.session['result_form'] = result_form.pk
return redirect(self.success_url)
def get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
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)
return self.render_to_response(
self.get_context_data(result_form=result_form, printed_url=reverse(self.printed_url, args=(pk,))))
def get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.AUDIT)
problems = result_form.audit.get_problems()
return self.render_to_response(
self.get_context_data(result_form=result_form,
problems=problems))
def get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
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)
return self.render_to_response(
self.get_context_data(result_form=result_form))
def post(self, *args, **kwargs):
post_data = self.request.POST
pk = post_data['result_form']
result_form = get_object_or_404(ResultForm, pk=pk)
valid_form_state = result_form.form_state
if (valid_form_state == FormState.CLEARANCE or valid_form_state == FormState.CLEARANCE_PENDING_STATE):
form_in_state(result_form, valid_form_state)
self.request.session['result_form'] = result_form.pk
return redirect(self.success_url)
def get(self, *args, **kwargs):
"""Display print view with a cover for audit if an audit exists
for the form, otherwise with a cover for archive.
"""
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.QUALITY_CONTROL)
return self.render_to_response(
self.get_context_data(result_form=result_form))
def get(self, *args, **kwargs):
"""Display print view with a cover for audit if an audit exists
for the form, otherwise with a cover for archive.
"""
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.QUALITY_CONTROL)
return self.render_to_response(
self.get_context_data(result_form=result_form))
def get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.CLEARANCE)
problems = result_form.clearance.get_problems()
return self.render_to_response(
self.get_context_data(result_form=result_form,
problems=problems,
printed_url = reverse(self.printed_url, args = (pk,))))
def get(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
pk = self.request.session.get('result_form')
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)
check_quarantine(result_form, self.request.user)
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 = post_data['result_form']
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.AUDIT)
self.request.session['result_form'] = result_form.pk
return redirect(self.success_url, 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)
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 get(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
pk = self.request.session.get('result_form')
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)
check_quarantine(result_form, self.request.user)
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 = post_data['result_form']
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.AUDIT)
self.request.session['result_form'] = result_form.pk
return redirect(self.success_url, tally_id=tally_id)
def post(self, *args, **kwargs):
self.request.session[
'encoded_result_form_clearance_start_time'] =\
json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder))
tally_id = kwargs.get('tally_id')
post_data = self.request.POST
pk = post_data['result_form']
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.CLEARANCE)
self.request.session['result_form'] = result_form.pk
return redirect(self.success_url, 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)
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 get(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.AUDIT)
problems = result_form.audit.get_problems()
return self.render_to_response(
self.get_context_data(result_form=result_form,
problems=problems,
tally_id=tally_id))
def get(self, *args, **kwargs):
tally_id = kwargs.get('tally_id')
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
form_in_state(result_form, FormState.CLEARANCE)
problems = result_form.clearance.get_problems()
return self.render_to_response(
self.get_context_data(result_form=result_form,
problems=problems,
printed_url=reverse(self.printed_url,
args=(pk, )),
tally_id=tally_id))
def get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, [FormState.CLEARANCE])
del self.request.session['result_form']
error_msg = self.request.session.get('intake-error')
if error_msg:
del self.request.session['intake-error']
return self.render_to_response(
self.get_context_data(error_msg=error_msg,
result_form=result_form))
def get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, [FormState.CLEARANCE])
del self.request.session['result_form']
error_msg = self.request.session.get('intake-error')
if error_msg:
del self.request.session['intake-error']
return self.render_to_response(
self.get_context_data(error_msg=error_msg,
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)
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 get(self, *args, **kwargs):
tally_id = kwargs['tally_id']
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id)
possible_states = states_for_form(self.request.user,
[FormState.INTAKE], result_form)
form_in_state(result_form, possible_states)
return self.render_to_response(
self.get_context_data(result_form=result_form,
printed_url=reverse(
self.printed_url,
args=(pk, ),
),
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):
"""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
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):
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
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 get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.QUALITY_CONTROL)
reconciliation_form = ReconForm(data=model_to_dict(
result_form.reconciliationform
)) if result_form.reconciliationform else None
results_component = results_for_race(result_form, None)
results_general = results_for_race(result_form, RaceType.GENERAL)
results_women = results_for_race(result_form, RaceType.WOMEN)
return self.render_to_response(
self.get_context_data(result_form=result_form,
reconciliation_form=reconciliation_form,
results_component=results_component,
results_women=results_women,
results_general=results_general))
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 get(self, *args, **kwargs):
pk = self.request.session.get('result_form')
result_form = get_object_or_404(ResultForm, pk=pk)
form_in_state(result_form, FormState.QUALITY_CONTROL)
reconciliation_form = ReconForm(data=model_to_dict(
result_form.reconciliationform
)) if result_form.reconciliationform else None
results_component = results_for_race(result_form, None)
results_general = results_for_race(result_form, RaceType.GENERAL)
results_women = results_for_race(result_form, RaceType.WOMEN)
return self.render_to_response(
self.get_context_data(result_form=result_form,
reconciliation_form=reconciliation_form,
results_component=results_component,
results_women=results_women,
results_general=results_general))
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 get(self, *args, **kwargs):
tally_id = kwargs['tally_id']
pk = self.request.session.get('result_form')
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']
older_duplicated = result_form.get_duplicated_forms().first()
if older_duplicated:
result_form = older_duplicated
error_msg = self.request.session.get('intake-error')
if error_msg:
del self.request.session['intake-error']
return self.render_to_response(
self.get_context_data(error_msg=error_msg,
result_form=result_form,
tally_id=tally_id))
def get(self, *args, **kwargs):
tally_id = kwargs['tally_id']
pk = self.request.session.get('result_form')
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']
older_duplicated = result_form.get_duplicated_forms().first()
if older_duplicated:
result_form = older_duplicated
error_msg = self.request.session.get('intake-error')
if error_msg:
del self.request.session['intake-error']
return self.render_to_response(
self.get_context_data(error_msg=error_msg,
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)
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):
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)
