def get_success_url(self):
if "good_pk" in self.kwargs:
return reverse_lazy("applications:add_good_summary",
kwargs={
"pk": self.application_id,
"good_pk": self.object_pk
})
good = get_good(self.request, self.object_pk, full_detail=True)[0]
raise_a_clc_query = good["is_good_controlled"] is None
raise_a_pv_query = "grading_required" == good["is_pv_graded"]["key"]
if self.draft_pk:
return reverse(
"goods:good_detail_application",
kwargs={
"pk": self.object_pk,
"type": "application",
"draft_pk": self.draft_pk
},
)
elif not good.get("documents") and not good.get(
"missing_document_reason"):
return reverse_lazy("goods:add_document",
kwargs={"pk": self.object_pk})
elif raise_a_clc_query or raise_a_pv_query:
return reverse_lazy("goods:raise_goods_query",
kwargs={"pk": self.object_pk})
else:
return reverse_lazy("goods:good", kwargs={"pk": self.object_pk})
def get_success_url(self):
good = get_good(self.request, self.object_pk, full_detail=True)[0]
is_software_technology = good.get("item_category")["key"] in ["group3_software", "group3_technology"]
# Next question information security if good is software/hardware
if is_software_technology:
if good.get("uses_information_security") is None:
if "good_pk" in self.kwargs:
return reverse_lazy(
"applications:good_information_security",
kwargs={"pk": self.application_id, "good_pk": self.object_pk},
)
elif self.draft_pk:
return reverse(
"goods:good_detail_application",
kwargs={"pk": self.object_pk, "type": "application", "draft_pk": self.draft_pk},
)
else:
return reverse_lazy("goods:good_information_security", kwargs={"pk": self.object_pk})
if self.draft_pk:
return reverse(
"goods:good_detail_application",
kwargs={"pk": self.object_pk, "type": "application", "draft_pk": self.draft_pk},
)
elif self.application_id and self.object_pk:
return return_to_good_summary(self.kwargs, self.application_id, self.object_pk)
elif self.object_pk:
return reverse_lazy("goods:good", kwargs={"pk": self.object_pk})
def post_good_on_application(request, pk, json):
good = None
preexisting = str_to_bool(request.GET.get("preexisting"))
if json.get("good_id"):
good, _ = services.get_good(request, json["good_id"])
post_data = serialize_good_on_app_data(json, good, preexisting)
response = client.post(request, f"/applications/{pk}/goods/", post_data)
return response.json(), response.status_code
def dispatch(self, request, *args, **kwargs):
self.good_id = str(kwargs["pk"])
self.good = get_good(request, self.good_id, full_detail=True)[0]
self.view_type = kwargs["type"]
if self.view_type not in ["application", "case-notes", "ecju-queries", "ecju-generated-documents"]:
return Http404
return super(GoodsDetail, self).dispatch(request, *args, **kwargs)
def dispatch(self, request, *args, **kwargs):
self.case_id = str(kwargs["case_pk"])
self.object_type = kwargs["object_type"]
self.ecju_query_id = str(kwargs["query_pk"])
self.ecju_query = get_ecju_query(request, self.case_id,
self.ecju_query_id)
self.extra_id = kwargs.get("extra_pk")
if self.object_type == "good":
self.extra_id = kwargs["extra_pk"]
good, _ = get_good(request, self.extra_id, full_detail=True)
self.case_id = good["case_id"]
self.ecju_query = get_ecju_query(request, self.case_id,
self.ecju_query_id)
if self.object_type == "application":
self.back_link = reverse_lazy("applications:application",
kwargs={
"pk": self.case_id,
"type": "ecju-queries"
})
elif self.object_type == "good":
self.back_link = reverse_lazy("goods:good_detail",
kwargs={
"pk": self.extra_id,
"type": "ecju-queries"
})
elif self.object_type == "end-user-advisory":
self.back_link = reverse_lazy("end_users:end_user_detail",
kwargs={
"pk": self.case_id,
"type": "ecju-queries"
})
elif self.object_type == "compliance-site":
self.back_link = reverse_lazy("compliance:compliance_site_details",
kwargs={
"pk": self.case_id,
"tab": "ecju-queries"
})
elif self.object_type == "compliance-visit":
self.extra_id = kwargs["extra_pk"]
self.back_link = reverse_lazy(
"compliance:compliance_visit_details",
kwargs={
"site_case_id": self.extra_id,
"pk": self.case_id,
"tab": "ecju-queries"
},
)
if self.ecju_query["response"]:
return redirect(self.back_link)
return super(RespondToQuery, self).dispatch(request, *args, **kwargs)
def init(self, request, **kwargs):
if "good_pk" in kwargs:
# coming from the application
self.object_pk = str(kwargs["good_pk"])
self.application_id = str(kwargs["pk"])
else:
self.object_pk = str(kwargs["pk"])
self.draft_pk = str(kwargs.get("draft_pk", ""))
self.data = get_good(request, self.object_pk)[0]
self.form = edit_grading_form(request, self.object_pk)
self.action = edit_good_pv_grading
def post(self, request, **kwargs):
if self.view_type != "case-notes":
return Http404
good_id = kwargs["pk"]
data, _ = get_good(request, str(good_id), full_detail=True)
response, _ = post_case_notes(request, data["case_id"], request.POST)
if "errors" in response:
return self.get(request, error=response["errors"]["text"][0], text=request.POST.get("text"), **kwargs)
return redirect(reverse_lazy("goods:good_detail", kwargs={"pk": good_id, "type": "case-notes"}))
def get_success_url(self):
if "good_pk" in self.kwargs:
return reverse_lazy(
"applications:add_good_summary", kwargs={"pk": self.application_id, "good_pk": self.object_pk}
)
good = get_good(self.request, self.object_pk, full_detail=True)[0]
if self.draft_pk:
return reverse(
"goods:good_detail_application",
kwargs={"pk": self.object_pk, "type": "application", "draft_pk": self.draft_pk},
)
elif not good.get("documents") and not good.get("is_document_available"):
return reverse_lazy("goods:add_document", kwargs={"pk": self.object_pk})
else:
return reverse_lazy("goods:good", kwargs={"pk": self.object_pk})
def init(self, request, **kwargs):
self.object_pk = str(kwargs["pk"])
self.draft_pk = str(kwargs.get("draft_pk", ""))
good, _ = get_good(request, self.object_pk)
raise_a_clc_query = good["is_good_controlled"] is None
raise_a_pv_query = "grading_required" == good["is_pv_graded"]["key"]
self.form = raise_a_goods_query(self.object_pk, raise_a_clc_query, raise_a_pv_query)
self.action = raise_goods_query
if self.draft_pk:
self.success_url = reverse_lazy(
"goods:good_detail_application",
kwargs={"pk": self.object_pk, "type": "application", "draft_pk": self.draft_pk},
)
else:
self.success_url = reverse_lazy("goods:good", kwargs={"pk": self.object_pk})
def get(self, request, **kwargs):
application_id = str(kwargs["pk"])
good_id = str(kwargs["good_pk"])
good = get_good(request, good_id, full_detail=True)[0]
good_application_documents, status = get_application_documents(
request, application_id, good_id) # noqa
context = {
"good": good,
"application_id": application_id,
"good_id": good_id,
"good_application_documents":
good_application_documents["documents"],
}
return render(request,
"applications/goods/add-good-detail-summary.html",
context)
def post(self, request, **kwargs):
self.request.upload_handlers.insert(0, S3FileUploadHandler(request))
good_id = str(kwargs["pk"])
draft_pk = str(kwargs.get("draft_pk", ""))
good, _ = get_good(request, good_id)
data, error = add_document_data(request)
if error:
return error_page(request, error)
data, status_code = post_good_documents(request, good_id, data)
if status_code != HTTPStatus.CREATED:
return error_page(request, data["errors"]["file"])
raise_a_clc_query = good["is_good_controlled"] is None
raise_a_pv_query = "grading_required" == good["is_pv_graded"]["key"]
if draft_pk:
if not (raise_a_clc_query or raise_a_pv_query):
return redirect(
reverse(
"goods:good_detail_application",
kwargs={
"pk": good_id,
"type": "application",
"draft_pk": draft_pk
},
))
else:
return redirect(
reverse("goods:raise_goods_query_add_application",
kwargs={
"pk": good_id,
"draft_pk": draft_pk
}))
else:
if not (raise_a_clc_query or raise_a_pv_query):
return redirect(reverse("goods:good", kwargs={"pk": good_id}))
else:
return redirect(
reverse("goods:raise_goods_query", kwargs={"pk": good_id}))
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
self.good_pk = kwargs["good_pk"]
application = get_application(self.request, self.object_pk)
good, _ = get_good(request, self.good_pk)
sub_case_type = application["case_type"]["sub_type"]
is_preexisting = str_to_bool(request.GET.get("preexisting", True))
self.forms = good_on_application_form_group(
request,
is_preexisting=is_preexisting,
good=good,
sub_case_type=sub_case_type,
draft_pk=self.object_pk)
self.action = validate_good_on_application
self.success_url = reverse_lazy(
"applications:attach-firearms-certificate-existing-good",
kwargs={
"pk": self.object_pk,
"good_pk": self.good_pk
},
)
def get(self, request, **kwargs):
data, _ = get_good(request, str(kwargs["pk"]))
return form_page(request, delete_good_form(data))
def good(self):
good_id = str(self.kwargs["good_pk"])
return get_good(self.request, good_id, full_detail=True)[0]
def good(self):
good, _ = get_good(self.request, self.good_pk)
return good