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"]}))
