def post(self, request, **kwargs): application_id = str(kwargs["pk"]) edit_type = request.POST.get("edit-type") if edit_type == "major": data, status_code = set_application_status(request, str(kwargs["pk"]), APPLICANT_EDITING) if status_code != HTTPStatus.OK: return form_page(request, edit_type_form(str(kwargs["pk"])), errors=data) elif edit_type is None: return form_page( request, edit_type_form(application_id), errors={ "edit-type": ["Select the type of edit you need to make"] }, ) return redirect( reverse_lazy("applications:task_list", kwargs={"pk": str(kwargs["pk"])}))
def post(self, request, **kwargs): self.init(request, **kwargs) data = self.on_submission(request, **kwargs) # Handle lists (such as checkboxes) data = handle_lists(data) self._validated_data = data if self.get_object_pk(): validated_data, _ = self.get_action()(request, self.get_object_pk(), self.clean_data( data.copy())) # noqa else: validated_data, _ = self.get_action()(request, self.clean_data( data.copy())) # noqa if "errors" in validated_data: return form_page(request, self.get_form(), data=data, errors=validated_data.get("errors"), extra_data=self.context) self._validated_data = validated_data self.post_success_step() if self.redirect: return redirect(self.get_success_url()) else: return form_page(request, self.get_form(), data=data)
def get_next_form_page(self, form_pk, action, request, post_errors): form = copy.deepcopy(next(form for form in self.get_forms().forms if str(form.pk) == form_pk)) # Add form fields to validated_data if they dont exist for component in get_all_form_components(form): if component.name not in self._validated_data and component.name[:-2] not in self._validated_data: self._validated_data[component.name] = "" if action == Actions.SUBMIT or action == Actions.RETURN: validated_data = validate_data_unknown( self.get_object_pk(), self.get_action(), request, nest_data(self.get_validated_data()) ) validated_data["errors"] = validated_data.get("errors", {}) errors = validated_data["errors"] if post_errors: errors.update(post_errors) if errors: errors = flatten_data(validated_data["errors"]) errors = remove_unused_errors(errors, form) if errors: insert_hidden_fields(self.get_validated_data(), form) if action == Actions.RETURN: form = convert_form_to_summary_list_instance(form) return form_page( request, form, data=self.get_validated_data(), errors=errors, extra_data={"form_pk": form.pk, **self.additional_context}, ) if action != Actions.RETURN: next_form = get_next_form(form.pk, self.get_forms()) if next_form: insert_hidden_fields(self.get_validated_data(), next_form) return form_page( request, next_form, data=self.get_validated_data(), extra_data={"form_pk": next_form.pk, **self.additional_context}, ) elif action == Actions.CHANGE: insert_hidden_fields(self.get_validated_data(), form) return form_page( request, convert_form_to_summary_list_instance(form), data=self.get_validated_data(), extra_data={"form_pk": form.pk, **self.additional_context}, ) if self.validate_only_until_final_submission: return self.generate_summary_list() return redirect(request.path)
def post(self, request, **kwargs): good_id = str(kwargs["good_pk"]) draft_id = str(kwargs["pk"]) back_link = BackLink( "Back", reverse("applications:document_grading", kwargs={ "pk": draft_id, "good_pk": good_id })) data, error = add_document_data(request) if error: form = attach_documents_form(back_link) return form_page(request, form, errors={"file": ["Select a document"]}) data, status_code = post_good_documents(request, good_id, data) if status_code != HTTPStatus.CREATED: return error_page(request, data["errors"]["file"]) return redirect( reverse_lazy("applications:add_good_to_application", kwargs={ "pk": draft_id, "good_pk": good_id }) + f"?preexisting={self.request.GET.get('preexisting', False)}")
def post(self, request, **kwargs): draft_id = str(kwargs["pk"]) option = request.POST.get("delete_document_confirmation") if option is None: return form_page( request, get_delete_confirmation_page(request.path, str(kwargs["pk"])), errors={ "delete_document_confirmation": ["Select yes to confirm you want to delete the document"] }, ) else: if option == "yes": action = document_switch(request.path)["delete"] if len(signature(action).parameters) == 2: status_code = action(request, draft_id) else: status_code = action(request, draft_id, kwargs["obj_pk"]) if status_code == HTTPStatus.NO_CONTENT: return get_homepage(request, draft_id) else: return error_page( request, strings.applications.DeleteDocument. DOCUMENT_DELETE_GENERIC_ERROR) else: return get_homepage(request, draft_id)
def post(self, request, **kwargs): organisation_id = str(request.session["organisation"]) data = { "expiry_date": format_date(request.POST, "expiry_date_"), "reference_code": self.request.POST["reference_code"], "document_type": self.document_type, } errors = validate_expiry_date(request, "expiry_date_") if errors: form = self.form_function(back_url=reverse("organisation:details")) return form_page(request, form, data=request.POST, errors={"expiry_date": errors}) file = request.FILES.get("file") if file: data["document"] = { "name": getattr(file, "original_name", file.name), "s3_key": file.name, "size": int(file.size // 1024) if file.size else 0, # in kilobytes } post_document_on_organisation(request=request, organisation_id=organisation_id, data=data) return redirect(reverse("organisation:details"))
def post(self, request, **kwargs): draft_pk = str(kwargs.get("draft_pk", "")) good_id = str(kwargs["pk"]) back_link = BackLink( AttachDocumentForm.BACK_FORM_LINK, reverse("goods:check_document_sensitivity", kwargs={"pk": good_id}), ) data, error = add_document_data(request) if error: form = attach_documents_form(back_link) return form_page(request, form, errors={"file": ["Select a document"]}) data, status_code = post_good_documents(request, good_id, data) if status_code != HTTPStatus.CREATED: return error_page(request, data["errors"]["file"]) if draft_pk: return redirect( reverse( "goods:good_detail_application", kwargs={"pk": good_id, "type": "application", "draft_pk": draft_pk}, ) ) else: return redirect(reverse("goods:good", kwargs={"pk": good_id}))
def submit_single_form(request, form: Form, action: Callable, object_pk=None, override_data=None): """ Function to handle the submission of data for a single, supplied form. :param request: Standard Django request object :param form: The Form for which to handle a submit :param action: The callback action to be invoked to submit the form's data :param object_pk: Entity primary key to be supplied with the submission, if any :param override_data: Data to be used instead of the request's data, if applicable """ data = request.POST.copy() if override_data: data = override_data if object_pk: validated_data, _ = action(request, object_pk, data) else: validated_data, _ = action(request, data) if "errors" in validated_data: return ( form_page(request, form, data=data, errors=validated_data.get("errors")), None, ) return None, validated_data
def get(self, request, **kwargs): override_return = self.init(request, **kwargs) # noqa if override_return: if isinstance(override_return, str): return redirect(override_return) return override_return return form_page(request, self.get_form(), data=self.get_data(), extra_data=self.context)
def get(self, request, **kwargs): data = {"organisation": str(request.session.get("organisation"))} return form_page( request, self.form, data=data, extra_data={"user_in_limbo": data["organisation"] == "None"})
def get(self, request, **kwargs): letter_template = get_letter_template(request, str(kwargs["pk"]))[0]["template"] letter_template_case_types = letter_template.pop("case_types") or [] letter_template_decisions = letter_template.pop("decisions") or [] letter_template_case_types = [ case_type["reference"]["key"] for case_type in letter_template_case_types ] letter_template.update(case_types=letter_template_case_types) letter_template_decisions = [ decision["name"]["key"] for decision in letter_template_decisions ] letter_template.update(decisions=letter_template_decisions) case_type_options = [ Option(option["key"], option["value"]) for option in get_case_types(request) ] decision_options = [ Option(decision["key"], decision["value"]) for decision in get_decisions(request)[0] ] return form_page( request, edit_letter_template(request, letter_template, case_type_options, decision_options), data=letter_template, )
def form_with_hidden_fields(request, data, post_data, form, return_data, additional_context): for key, value in post_data.items(): # If the key is already in the questions in the next form, don't copy them # because the user will input their answers again form_question_names = [ q.name for q in form.questions if hasattr(q, "name") ] if key in form_question_names or f"{key}[]" in form_question_names: continue # If the keys value is a list, insert each individually if isinstance(value, list): for sub_value in value: form.questions.insert(0, HiddenField(key + "[]", sub_value)) else: form.questions.insert(0, HiddenField(key, value)) # Go to the next page return ( form_page(request, form, data=data, extra_data={ "form_pk": form.pk, **additional_context }), return_data, )
def get(self, request, **kwargs): return_to_good_page = request.GET.get("goodpage", "no") good_id = str(kwargs["pk"]) extra_data = {"good_id": good_id} draft_pk = str(kwargs.get("draft_pk", "")) if draft_pk: extra_data["draft_pk"] = draft_pk if return_to_good_page == "yes": if draft_pk: back_link = BackLink( AttachDocumentForm.BACK_GOOD_LINK, reverse( "goods:good_detail_application", kwargs={"pk": good_id, "type": "application", "draft_pk": draft_pk}, ), ) else: back_link = BackLink(AttachDocumentForm.BACK_GOOD_LINK, reverse("goods:good", kwargs={"pk": good_id})) else: if draft_pk: back_link = BackLink( AttachDocumentForm.BACK_FORM_LINK, reverse("goods:add_document_add_application", kwargs={"pk": good_id, "draft_pk": draft_pk}), ) else: back_link = BackLink( AttachDocumentForm.BACK_FORM_LINK, reverse("goods:check_document_sensitivity", kwargs={"pk": good_id}), ) form = attach_documents_form(back_link) return form_page(request, form, extra_data=extra_data)
def get(self, request, **kwargs): application_id = str(kwargs["pk"]) data = get_application(request, application_id) if data.get("status") and data.get("status").get("key") == APPLICANT_EDITING: return redirect(reverse_lazy("applications:task_list", kwargs={"pk": application_id})) return form_page(request, edit_type_form(application_id))
class Finalise(LoginRequiredMixin, TemplateView): """ Finalise a case and change the case status to finalised """ @staticmethod def _get_goods(request, pk, case_type): goods = [] if case_type == CaseType.STANDARD.value: goods, status_code = get_finalise_application_goods(request, pk) if status_code != HTTPStatus.OK: return error_page(request, FinaliseLicenceForm.GOODS_ERROR) goods = goods["goods"] return goods def get(self, request, *args, **kwargs): case = get_case(request, str(kwargs["pk"])) case_type = case.data["case_type"]["sub_type"]["key"] if case_type == CaseType.OPEN.value: approve = get_open_licence_decision(request, str(kwargs["pk"])) == "approve" nlr = False else: advice = filter_advice_by_level(case["advice"], "final") items = [item["type"]["key"] for item in advice] approve = any( [item == "approve" or item == "proviso" for item in items]) nlr = not approve and "refuse" not in items case_id = case["id"] if approve: licence_data, _ = get_licence(request, str(kwargs["pk"])) licence = licence_data.get("licence") # If there are licenced goods, we want to use the reissue goods flow. if licence: form, form_data = reissue_finalise_form( request, licence, case, kwargs["queue_pk"]) else: goods = self._get_goods(request, str(kwargs["pk"]), case_type) form, form_data = finalise_form(request, case, goods, kwargs["queue_pk"]) return form_page( request, form, data=form_data, extra_data={ "case": case, "has_proviso": any([item == "proviso" for item in items]) }, ) else: return form_page( request, deny_licence_form( kwargs["queue_pk"], case_id, case.data["case_type"] ["sub_type"]["key"] == CaseType.OPEN.value, nlr), )
def get(self, request, **kwargs): case_id = str(kwargs["pk"]) case = get_case(request, case_id) form = attach_documents_form( reverse("cases:case", kwargs={"queue_pk": kwargs["queue_pk"], "pk": case_id, "tab": "documents"}) ) return form_page(request, form, extra_data={"case_id": case_id, "case": case})
def get(self, request, **kwargs): back_link = build_firearm_back_link_create( form_url=reverse("applications:new_good", kwargs={"pk": kwargs["pk"]}), form_data=request.session.get(self.firearms_data_id, {}), ) form = upload_firearms_act_certificate_form( section=self.selected_section, filename="", back_link=back_link) return form_page(request, form)
def get(self, request, **kwargs): self.init(request, **kwargs) form = self.get_forms().forms[0] return form_page(request, form, data=self.get_data(), extra_data={ "form_pk": form.pk, **self.additional_context })
def get(self, request, **kwargs): good_id = str(kwargs["good_pk"]) draft_id = str(kwargs["pk"]) back_link = reverse_lazy("applications:add_good_to_application", kwargs={ "pk": draft_id, "good_pk": good_id }) form = attach_documents_form(back_link) return form_page(request, form, extra_data={"good_id": good_id})
def get(self, request, **kwargs): self.init(request, **kwargs) if self.data: self._validated_data = self.data.copy() return self.generate_summary_list() form = self.get_forms().forms[0] return form_page( request, form, data=self.get_data(), extra_data={"form_pk": form.pk, **self.additional_context} )
def get(self, request, **kwargs): good_id = str(kwargs["good_pk"]) draft_id = str(kwargs["pk"]) back_link = BackLink( "Back", reverse("applications:document_grading", kwargs={ "pk": draft_id, "good_pk": good_id })) form = attach_documents_form(back_link) return form_page(request, form, extra_data={"good_id": good_id})
def get(self, request, **kwargs): return_to_good_page = request.GET.get("goodpage", "no") good_id = str(kwargs["pk"]) if return_to_good_page == "yes": back_link = BackLink(AttachDocumentForm.BACK_GOOD_LINK, reverse("goods:good", kwargs={"pk": good_id})) else: back_link = BackLink( AttachDocumentForm.BACK_FORM_LINK, reverse("goods:add_document", kwargs={"pk": good_id})) form = attach_documents_form(back_link) return form_page(request, form, extra_data={"good_id": good_id})
def post(self, request, **kwargs): response = request.POST.get("copy_existing") if response: if response == "yes": return redirect(reverse_lazy(self.copy_url, kwargs=kwargs)) else: return redirect(reverse_lazy(self.new_url, kwargs=kwargs)) else: return form_page( request, party_create_new_or_copy_existing_form(kwargs["pk"]), errors={"copy_existing": [AddPartyForm.ERROR]}, )
def get(self, request, **kwargs): self.back_link = BackLink( ecju_queries.UploadDocumentForm.BACK_FORM_LINK, self.success_url) form = upload_documents_form(self.back_link) return form_page( request, form, extra_data={ "case_id": self.case_pk, "ecju_query_id": self.query_pk, "object_type": self.object_type }, )
def post(self, request, **kwargs): self.init(request, **kwargs) if not request.POST.get("confirm"): return form_page( request, self.get_form(), data=self.get_data(), errors={"confirm": [Manage.ReissueOGL.ERROR]}, extra_data=self.context, ) elif request.POST.get("confirm") == "False": return redirect(self.success_url) return super(ReissueOGL, self).post(request, **kwargs)
def post(self, request, **kwargs): self.init(request, **kwargs) if not request.POST.get("confirm"): return form_page( request, self.get_form(), data=self.get_data(), errors={"confirm": ["select an option"]}, extra_data=self.context, ) elif request.POST.get("confirm") == "no": return redirect(self.success_url) return super(RerunRoutingRules, self).post(request, **kwargs)
def post(self, request, **kwargs): self.init(request, **kwargs) if not request.POST.get("confirm"): return form_page( request, self.get_form(), data=self.get_data(), errors={"confirm": [strings.FlaggingRules.Status.NO_SELECTION_ERROR]}, extra_data=self.context, ) elif request.POST.get("confirm") == "no": return redirect(self.success_url) return super(ChangeFlaggingRuleStatus, self).post(request, **kwargs)
def post(self, request, **kwargs): self.init(request, **kwargs) if not request.POST.get("confirm"): return form_page( request, self.get_form(), data=self.get_data(), errors={"confirm": [CONFIRM_FORM_ERROR]}, extra_data=self.context, ) elif request.POST.get("confirm") == "no": return redirect(self.success_url) return super(ChangeRoutingRuleActiveStatus, self).post(request, **kwargs)
def post(self, request, **kwargs): # If no data is given, error if not request.POST.get("organisation"): return form_page(request, self.form, errors={"organisation": ["Select an organisation to use"]}) request.session["organisation"] = request.POST["organisation"] organisation = get_organisation(request, request.POST["organisation"]) if "errors" in organisation: return redirect(reverse_lazy("core:register_an_organisation_confirm") + "?show_back_link=True") request.session["organisation_name"] = organisation["name"] return redirect("/")
def post(self, request, org_id): data = { "name": request.POST["name"], "application_type": CaseTypes.CRE, "organisation": str(org_id) } response, status_code = post_applications(request, data) if status_code != HTTPStatus.CREATED: return form_page(request, reference_name_form(), errors=response.get("errors")) else: return redirect( reverse_lazy("applications:task_list", kwargs={"pk": response["id"]}))