def create_licence(
application: Case,
status: LicenceStatus,
reference_code=None,
decisions=None,
hmrc_integration_sent_at=None,
start_date=None,
):
if not decisions:
decisions = [Decision.objects.get(name=AdviceType.APPROVE)]
if not reference_code:
reference_code = get_licence_reference_code(
application.reference_code)
if not start_date:
start_date = django.utils.timezone.now().date()
licence = Licence.objects.create(
case=application,
reference_code=reference_code,
start_date=start_date,
duration=get_default_duration(application),
status=status,
hmrc_integration_sent_at=hmrc_integration_sent_at,
)
licence.decisions.set(decisions)
return licence
def get(self, request, pk):
"""
Retrieve default duration for an application.
"""
application = get_application(pk)
duration = get_default_duration(application)
return JsonResponse(data={"licence_duration": duration},
status=status.HTTP_200_OK)
def test_no_duration_finalise_success(self):
self._set_user_permission([GovPermissions.MANAGE_LICENCE_FINAL_ADVICE])
data = {"action": AdviceType.APPROVE}
data.update(self.post_date)
response = self.client.put(self.url, data=data, **self.gov_headers)
response_data = response.json()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response_data["duration"],
get_default_duration(self.standard_application))
self.assertTrue(
Licence.objects.filter(case=self.standard_application,
status=LicenceStatus.DRAFT).exists())
def setUp(self):
super().setUp()
self.gov_user.role.permissions.set(
[GovPermissions.MANAGE_LICENCE_FINAL_ADVICE.name])
self.standard_application = self.create_standard_application_case(
self.organisation)
self.url = reverse("applications:finalise",
kwargs={"pk": self.standard_application.id})
self.date = timezone.now()
self.data = {
"action": AdviceType.APPROVE,
"duration": get_default_duration(self.standard_application),
"year": self.date.year,
"month": self.date.month,
"day": self.date.day,
}
self.create_advice(self.gov_user, self.standard_application, "good",
AdviceType.APPROVE, AdviceLevel.FINAL)
def put(self, request, pk):
"""
Finalise an application
"""
application = get_application(pk)
# Check permissions
is_mod_clearance = application.case_type.sub_type in CaseTypeSubTypeEnum.mod
if not can_status_be_set_by_gov_user(
request.user.govuser, application.status.status,
CaseStatusEnum.FINALISED, is_mod_clearance):
return JsonResponse(
data={
"errors": [
strings.Applications.Generic.Finalise.Error.
SET_FINALISED
]
},
status=status.HTTP_400_BAD_REQUEST,
)
licence_data = request.data.copy()
action = licence_data.get("action")
if not action:
return JsonResponse(
data={
"errors":
[strings.Applications.Finalise.Error.NO_ACTION_GIVEN]
},
status=status.HTTP_400_BAD_REQUEST,
)
# Refusals & NLRs
if action in [AdviceType.REFUSE, AdviceType.NO_LICENCE_REQUIRED]:
return JsonResponse(data={"application": str(application.id)},
status=status.HTTP_200_OK)
# Approvals & Provisos
else:
# Check if any blocking flags are on the case
blocking_flags = (get_flags(application.get_case()).filter(
status=FlagStatuses.ACTIVE,
blocks_approval=True).order_by("name").values_list("name",
flat=True))
if blocking_flags:
raise PermissionDenied([
f"{strings.Applications.Finalise.Error.BLOCKING_FLAGS}{','.join(list(blocking_flags))}"
])
try:
active_licence = Licence.objects.get_active_licence(
application)
default_licence_duration = active_licence.duration
except Licence.DoesNotExist:
default_licence_duration = get_default_duration(application)
licence_data["duration"] = licence_data.get(
"duration", default_licence_duration)
# Check change default duration permission
if licence_data[
"duration"] != default_licence_duration and not request.user.govuser.has_permission(
GovPermissions.MANAGE_LICENCE_DURATION):
raise PermissionDenied([
strings.Applications.Finalise.Error.SET_DURATION_PERMISSION
])
# Validate date
try:
start_date = timezone.datetime(year=int(licence_data["year"]),
month=int(
licence_data["month"]),
day=int(licence_data["day"]))
except (KeyError, ValueError):
raise ParseError({
"start_date":
[strings.Applications.Finalise.Error.INVALID_DATE]
})
# Delete existing draft if one exists
try:
licence = Licence.objects.get_draft_licence(application)
except Licence.DoesNotExist:
licence = None
licence_data["start_date"] = start_date.strftime("%Y-%m-%d")
if licence:
# Update Draft Licence object
licence_serializer = LicenceCreateSerializer(instance=licence,
data=licence_data,
partial=True)
else:
# Create Draft Licence object
licence_data["case"] = application.id
licence_data["status"] = LicenceStatus.DRAFT
licence_data["reference_code"] = get_licence_reference_code(
application.reference_code)
licence_serializer = LicenceCreateSerializer(data=licence_data)
if not licence_serializer.is_valid():
raise ParseError(licence_serializer.errors)
licence = licence_serializer.save()
# Delete draft licence document that may now be invalid
GeneratedCaseDocument.objects.filter(
case_id=pk,
advice_type=AdviceType.APPROVE,
visible_to_exporter=False).delete()
# Only validate & save GoodsOnLicence (quantities & values) for Standard applications
if application.case_type.sub_type == CaseTypeSubTypeEnum.STANDARD:
errors = validate_and_create_goods_on_licence(
pk, licence.id, request.data)
if errors:
raise ParseError(errors)
return JsonResponse(data=LicenceCreateSerializer(licence).data,
status=status.HTTP_200_OK)