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 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, *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): 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): 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): 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): 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): 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))