def init(self, request, **kwargs):
user_pk = str(kwargs["user_pk"])
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.form = users_team_queues(request, kwargs["queue_pk"], self.object_pk, user_pk)
self.action = put_queue_single_case_assignment
self.context = {"case": case}
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.form = assign_user_and_work_queue(request, kwargs["queue_pk"],
self.object_pk)
self.action = get_gov_user_from_form_selection
self.context = {"case": case}
def init(self, request, **kwargs):
self.action = put_rerun_case_routing_rules
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.context = {"case": case}
self.form = rerun_routing_rules_confirmation_form()
self.success_url = reverse_lazy(
"cases:case", kwargs={"queue_pk": self.kwargs["queue_pk"], "pk": self.object_pk}
)
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 init(self, request, **kwargs):
self.object_pk = str(kwargs["pk"])
case = get_case(request, self.object_pk)
self.case_type = case.type
self.case_sub_type = case.sub_type
permissible_statuses = get_permissible_statuses(request, case)
self.data = case.data
self.form = change_status_form(get_queue(request, kwargs["queue_pk"]), case, permissible_statuses)
self.context = {"case": case}
def init(self, request, **kwargs):
self.action = reissue_ogl
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.context = {"case": case}
self.form = reissue_ogl_confirmation_form(self.object_pk, self.kwargs["queue_pk"])
self.success_url = reverse_lazy(
"cases:case", kwargs={"queue_pk": self.kwargs["queue_pk"], "pk": self.object_pk}
)
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.data = case
self.form = move_case_form(request, get_queue(request, kwargs["queue_pk"]), case)
self.action = put_case_queues
self.context = {"case": case}
self.success_message = cases.Manage.MoveCase.SUCCESS_MESSAGE
self.success_url = reverse_lazy(
"cases:case", kwargs={"queue_pk": self.kwargs["queue_pk"], "pk": self.object_pk}
)
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.data = {"queues": [str(kwargs["queue_pk"])]}
self.context = {"case": case}
has_review_date = (
case.next_review_date
and datetime.datetime.strptime(case.next_review_date, "%Y-%m-%d").date() > timezone.localtime().date()
)
self.form = done_with_case_form(request, kwargs["queue_pk"], self.object_pk, has_review_date)
self.action = put_unassign_queues
self.success_url = reverse_lazy("queues:cases", kwargs={"queue_pk": kwargs["queue_pk"]})
self.success_message = DoneWithCaseOnQueueForm.SUCCESS_MESSAGE.format(case.reference_code)
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.data = {"gov_user_pk": case.case_officer.get("id")}
self.form = assign_case_officer_form(
request,
case.case_officer,
self.kwargs["queue_pk"],
self.object_pk,
is_compliance=True if case.case_type["type"]["key"] == CaseType.COMPLIANCE.value else False,
)
self.context = {"case": case}
self.success_url = reverse("cases:case", kwargs={"queue_pk": self.kwargs["queue_pk"], "pk": self.object_pk})
self.get_action()
def init(self, request, **kwargs):
self.back_url = reverse_lazy(
"cases:case", kwargs={"queue_pk": kwargs["queue_pk"], "pk": kwargs["pk"], "tab": "documents"}
)
self.contacts = get_case_additional_contacts(request, kwargs["pk"])
self.applicant = get_case_applicant(request, kwargs["pk"])
self.template = request.POST.get(TEMPLATE)
params = {"case": self.kwargs["pk"], "page": self.request.GET.get("page", 1)}
if self.kwargs.get("decision_key"):
params["decision"] = self.kwargs["decision_key"]
self.templates, _ = get_letter_templates(self.request, convert_dict_to_query_params(params))
self.data = {"total_pages": self.templates["total_pages"]}
if self.template and not request.POST.get(TEXT):
template, _ = get_letter_template(request, self.template, params=convert_dict_to_query_params({TEXT: True}))
self.data[TEXT] = template[TEXT]
self.object_pk = kwargs["pk"]
self.action = self._validate
self.additional_context = {
"case": get_case(request, self.object_pk),
"applicant": self.applicant,
"contacts": self.contacts,
}
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
self.level = self.get_level()
flags = self.get_potential_flags()
self.success_message = getattr(SetFlagsForm,
self.level).SUCCESS_MESSAGE
if self.level == FlagLevel.ORGANISATIONS:
self.form = set_flags_form(flags, self.level)
self.form.back_link = BackLink(url=reverse(
"organisations:organisation", kwargs={"pk": self.object_pk}))
else:
self.case = get_case(request, self.object_pk)
self.context = {"case": self.case, "hide_flags_row": True}
show_sidebar = False
if self.level == FlagLevel.GOODS or self.level == FlagLevel.DESTINATIONS:
show_sidebar = True
self.context["goods"] = get_param_goods(
self.request, self.case)
self.context["destinations"] = get_param_destinations(
self.request, self.case)
self.form = set_flags_form(flags,
self.level,
show_case_header=True,
show_sidebar=show_sidebar)
self.form.back_link = BackLink(
url=reverse("cases:case",
kwargs={
"queue_pk": kwargs["queue_pk"],
"pk": self.object_pk
}))
self.data = {"flags": self.get_object_flags()}
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
self.context = {"case": get_case(request, self.object_pk)}
self.data = {"people_present": get_compliance_people_present(request, self.object_pk)}
self.form = people_present_form(kwargs["queue_pk"], kwargs["pk"])
self.success_url = reverse("cases:case", kwargs=kwargs)
self.success_message = ComplianceForms.PeoplePresent.SUCCESS
self.action = post_compliance_person_present
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.context = {"case": case}
self.form = respond_to_clc_query_form(request, kwargs["queue_pk"],
case)
self.action = put_goods_query_clc
self.success_url = reverse("cases:case", kwargs=kwargs)
self.success_message = CLCReviewGoods.SUCCESS_MESSAGE
if not has_permission(request, Permission.REVIEW_GOODS):
return redirect(
reverse_lazy("cases:case",
kwargs={
"queue_pk": kwargs["queue_pk"],
"pk": self.object_pk
}))
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.context = {"case": case}
self.form = respond_to_grading_query_form(request, kwargs["queue_pk"],
case)
self.action = put_goods_query_pv_grading
self.success_url = reverse("cases:case", kwargs=kwargs)
self.success_message = PVGradingForm.SUCCESS_MESSAGE
if not has_permission(request, Permission.RESPOND_PV_GRADING):
return redirect(
reverse_lazy("cases:case",
kwargs={
"queue_pk": kwargs["queue_pk"],
"pk": self.object_pk
}))
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):
self.case_id = str(kwargs["pk"])
self.case = get_case(request, self.case_id)
self.queue_id = kwargs["queue_pk"]
self.queue = get_queue(request, self.queue_id)
self.permissions = get_user_permissions(self.request)
if hasattr(self, "get_" + self.case.sub_type + "_" + self.case.type):
getattr(self, "get_" + self.case.sub_type + "_" + self.case.type)()
class SanctionRevokeView(LoginRequiredMixin, SuccessMessageMixin, FormView):
template_name = "external_data/sanction-revoke.html"
success_message = "Sanction match successfully removed"
form_class = forms.SanctionRevoke
def get_context_data(self, **kwargs):
case = get_case(self.request, self.kwargs["pk"])
return super().get_context_data(
case=case, queue_id=self.kwargs["queue_pk"], case_id=self.kwargs["pk"], **kwargs
)
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
self.form = add_additional_contact_form(request, self.kwargs["queue_pk"], self.object_pk)
self.action = post_case_additional_contacts
self.success_message = cases.CasePage.AdditionalContactsTab.SUCCESS_MESSAGE
self.context = {"case": get_case(request, self.object_pk)}
self.success_url = reverse(
"cases:case",
kwargs={"queue_pk": self.kwargs["queue_pk"], "pk": self.object_pk, "tab": "additional-contacts"},
)
def init(self, request, **kwargs):
document, _ = get_generated_document(request, str(kwargs["pk"]), str(kwargs["dpk"]))
template = document["template"]
self.data = {TEXT: document.get(TEXT)}
self.object_pk = kwargs["pk"]
self.form = edit_document_text_form(
{"queue_pk": self.kwargs["queue_pk"], "pk": self.kwargs["pk"], "tpk": template},
post_url="cases:generate_document_preview",
)
self.context = {"case": get_case(request, self.object_pk)}
def get_object_flags(self):
if self.level == FlagLevel.CASES:
return get_case(self.request, self.object_pk)["flags"]
elif self.level == FlagLevel.ORGANISATIONS:
return get_organisation(self.request, self.object_pk)["flags"]
elif self.level == FlagLevel.GOODS:
goods = get_param_goods(self.request, self.case)
return get_matching_flags(goods)
elif self.level == FlagLevel.DESTINATIONS:
destinations = get_param_destinations(self.request, self.case)
return get_matching_flags(destinations)
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
self.form = generate_documents_form(kwargs["queue_pk"], self.object_pk)
decisions, _ = get_final_decision_documents(request, self.object_pk)
decisions = decisions["documents"]
can_submit = all(
[decision.get("document") for decision in decisions.values()])
self.context = {
"case": case,
"can_submit": can_submit,
"decisions": decisions,
}
self.action = grant_licence
self.success_message = GenerateGoodsDecisionForm.SUCCESS_MESSAGE
self.success_url = reverse_lazy("cases:case",
kwargs={
"queue_pk": kwargs["queue_pk"],
"pk": self.object_pk
})
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
self.data = get_case(request, self.object_pk)
self.form = set_next_review_date_form(
self.kwargs["queue_pk"],
self.object_pk,
)
self.success_url = reverse("cases:case",
kwargs={
"queue_pk": self.kwargs["queue_pk"],
"pk": self.object_pk
})
def get_context_data(self, **kwargs):
form = self.get_form()
goa_documents = get_good_on_application_documents(
self.request, self.object["application"],
self.object["good"]["id"])
case = get_case(self.request, self.kwargs["pk"])
organisation_documents = {
item["document_type"].replace("-", "_"): item
for item in case.organisation["documents"]
}
return super().get_context_data(
good_on_application=self.object,
good_on_application_documents=goa_documents,
case=case,
other_cases=self.other_cases,
# for pagination
data={"total_pages": self.other_cases["count"] //
form.page_size} if self.other_cases else {},
organisation_documents=organisation_documents,
**kwargs,
)
def init(self, request, **kwargs):
case_url = reverse("cases:case",
kwargs={
"queue_pk": kwargs["queue_pk"],
"pk": kwargs["pk"]
})
if not has_permission(request, Permission.REVIEW_GOODS):
return redirect(case_url)
self.object_pk = kwargs["pk"]
case = get_case(request, self.object_pk)
param_goods = get_param_goods(request, case)
control_list_entries = get_control_list_entries(
request, convert_to_options=True)
self.data = flatten_goods_data(param_goods)
self.form = review_goods_form(
control_list_entries=control_list_entries, back_url=case_url)
self.context = {"case": case, "goods": param_goods}
self.action = post_review_goods
self.success_url = case_url
def init(self, request, **kwargs):
query_type = request.GET.get("query_type", ECJUQueryTypes.ECJU_QUERY)
self.object_pk = kwargs["pk"]
self.context = {"case": get_case(request, self.object_pk)}
self.form = new_ecju_query_form(kwargs["queue_pk"], self.object_pk,
query_type)
self.action = post_ecju_query
self.success_message = "ECJU query sent successfully"
self.success_url = reverse("cases:case",
kwargs={
"queue_pk": kwargs["queue_pk"],
"pk": self.object_pk,
"tab": "ecju-queries"
})
class Denials(LoginRequiredMixin, TemplateView):
template_name = "case/denial-for-case.html"
def get_context_data(self, **kwargs):
case = get_case(self.request, self.kwargs["pk"])
search = []
for key in self.request.GET.keys():
if key in case.data:
search.append(case.data[key]["name"])
search.append(case.data[key]["address"])
if search:
response = search_denials(request=self.request, search=search)
results = [item["_source"] for item in response.json()["hits"]["hits"]]
else:
results = []
return super().get_context_data(case=case, results=results, **kwargs)
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
self.context = {
"case":
get_case(request, self.object_pk),
"goods_type_country_decisions":
get_good_countries_decisions(request, self.object_pk),
"decisions": {
"approve": "Approve",
"refuse": "Reject"
},
}
self.form = finalise_goods_countries_form(kwargs["pk"],
kwargs["queue_pk"])
self.action = post_good_countries_decisions
self.success_url = reverse_lazy("cases:finalise",
kwargs={
"queue_pk": kwargs["queue_pk"],
"pk": self.object_pk
})
class ClearFinalAdvice(LoginRequiredMixin, TemplateView):
"""
Clear final advice
"""
def post(self, request, **kwargs):
case = get_case(request, kwargs["pk"])
if request.POST.get("action") == "delete":
clear_final_advice(request, case.get("id"))
messages.success(self.request, "Final advice cleared successfully")
return redirect(
reverse("cases:case",
kwargs={
"queue_pk": kwargs["queue_pk"],
"pk": kwargs["pk"],
"tab": "final-advice"
}) + "?grouped-advice-view=" +
request.GET.get("grouped-advice-view", ""))
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
self.case = get_case(request, self.object_pk)
self.tab = kwargs["tab"]
self.data = flatten_advice_data(
request,
self.case,
[
*get_param_goods(request, self.case),
*get_param_destinations(request, self.case)
],
self.tab,
)
self.form = give_advice_form(
request,
self.case,
self.tab,
kwargs["queue_pk"],
get_denial_reasons(request, True, True),
)
self.context = {
"case": self.case,
"goods": get_param_goods(request, self.case),
"destinations": get_param_destinations(request, self.case),
}
self.success_message = "Advice posted successfully"
self.success_url = (reverse("cases:case",
kwargs={
"queue_pk": kwargs["queue_pk"],
"pk": self.object_pk,
"tab": self.tab
}) + "?grouped-advice-view=" +
request.GET.get("grouped-advice-view", ""))
if self.tab not in ["user-advice", "team-advice", "final-advice"]:
raise Http404
kwargs["queue_pk"])
return form_page(request,
form,
data=form_data,
extra_data={"case": case})
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 post(self, request, *args, **kwargs):
case = get_case(request, str(kwargs["pk"]))
application_id = case.data.get("id")
data = request.POST.copy()
res = finalise_application(request, application_id, data)
licence_data, _ = get_licence(request, str(kwargs["pk"]))
licence = licence_data.get("licence")
if res.status_code == HTTPStatus.FORBIDDEN:
return error_page(request, "You do not have permission.")
if res.status_code != HTTPStatus.OK:
# 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"])
