def get(self, request, *args, **kwargs):
template_object = self.get_object()
template = self.get_serializer(template_object).data
data = {"template": template}
paragraphs = PicklistItem.objects.filter(
type=PicklistType.LETTER_PARAGRAPH,
id__in=template["letter_paragraphs"])
# Sort
paragraphs = [
paragraphs.get(id=paragraph_id)
for paragraph_id in template["letter_paragraphs"]
]
paragraph_text = get_paragraphs_as_html(paragraphs)
if str_to_bool(request.GET.get("generate_preview")):
data["preview"] = generate_preview(
layout=template_object.layout.filename, text=paragraph_text)
if "error" in data["preview"]:
return JsonResponse(data=data["preview"],
status=status.HTTP_400_BAD_REQUEST)
if str_to_bool(request.GET.get("text")):
data["text"] = "\n\n".join(
[paragraph.text for paragraph in paragraphs])
if str_to_bool(request.GET.get("activity")):
audit_qs = audit_trail_service.get_activity_for_user_and_model(
request.user, template_object)
data["activity"] = AuditSerializer(audit_qs, many=True).data
return JsonResponse(data=data, status=status.HTTP_200_OK)
class FlagsListCreateView(ListCreateAPIView):
authentication_classes = (GovAuthentication, )
def get_serializer_class(self):
if self.request.method == "GET":
if self.request.GET.get("include_flagging_rules"):
return FlagwithFlaggingRulesReadOnlySerializer
return FlagReadOnlySerializer
else:
return FlagSerializer
def get_queryset(self):
case = self.request.GET.get("case")
name = self.request.GET.get("name")
level = self.request.GET.get("level")
priority = self.request.GET.get("priority")
team = self.request.GET.get("team")
status = self.request.GET.get("status", FlagStatuses.ACTIVE)
include_system_flags = str_to_bool(
self.request.GET.get("include_system_flags"))
blocks_approval = str_to_bool(self.request.GET.get("blocks_approval"))
if case:
flags = get_flags(get_case(case))
else:
flags = Flag.objects.all()
if name:
flags = flags.filter(name__icontains=name)
if level:
flags = flags.filter(level=level)
if priority:
flags = flags.filter(priority=priority)
if team and team != "None":
flags = flags.filter(team=team)
if status:
flags = flags.filter(status=status)
if include_system_flags:
system_flags = Flag.objects.filter(id__in=SystemFlags.list)
flags = flags | system_flags
if blocks_approval:
flags = flags.filter(blocks_approval=True)
return flags.order_by("name").select_related("team")
def post(self, request, pk):
good = get_good(pk)
data = request.data
if data.get("has_document_to_upload"):
document_to_upload = str_to_bool(data["has_document_to_upload"])
if not document_to_upload:
good.missing_document_reason = data["missing_document_reason"]
serializer = GoodMissingDocumentSerializer(instance=good,
data=data,
partial=True)
if serializer.is_valid():
serializer.save()
good_data = GoodCreateSerializer(good).data
else:
return JsonResponse(data={"errors": serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
else:
good.missing_document_reason = None
good.save()
good_data = GoodCreateSerializer(good).data
else:
return JsonResponse(
data={
"errors": {
"has_document_to_upload":
[strings.Goods.DOCUMENT_CHECK_OPTION_NOT_SELECTED]
}
},
status=status.HTTP_400_BAD_REQUEST,
)
return JsonResponse(data={"good": good_data},
status=status.HTTP_200_OK)
def put(self, request, pk):
""" Update an application instance with route of goods data. """
application = get_application(pk)
serializer = get_application_update_serializer(application)
case = application.get_case()
data = request.data.copy()
serializer = serializer(application,
data=data,
context=get_request_user_organisation(request),
partial=True)
if not serializer.is_valid():
return JsonResponse(data={"errors": serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
previous_answer = application.is_shipped_waybill_or_lading
new_answer = str_to_bool(data.get("is_shipped_waybill_or_lading"))
if previous_answer != new_answer:
self.add_audit_entry(request, case, "is shipped waybill or lading",
previous_answer, new_answer)
if not new_answer:
previous_details = application.non_waybill_or_lading_route_details
new_details = data.get("non_waybill_or_lading_route_details")
if previous_details != new_details:
self.add_audit_entry(request, case,
"non_waybill_or_lading_route_details",
previous_details, new_details)
serializer.save()
return JsonResponse(data={}, status=status.HTTP_200_OK)
def get(self, request, pk):
good = get_good(pk)
if hasattr(request.user, "exporteruser"):
if good.organisation.id != get_request_user_organisation_id(
request):
raise PermissionDenied()
if str_to_bool(request.GET.get("full_detail")):
serializer = GoodSerializerExporterFullDetail(
good,
context={
"exporter_user":
request.user.exporteruser,
"organisation_id":
get_request_user_organisation_id(request),
},
)
else:
serializer = GoodSerializerExporter(good)
# If there's a query with this good, update the notifications on it
query = GoodsQuery.objects.filter(good=good)
if query:
delete_exporter_notifications(
user=request.user.exporteruser,
organisation_id=get_request_user_organisation_id(request),
objects=query,
)
else:
serializer = GoodSerializerInternal(good)
return JsonResponse(data={"good": serializer.data},
status=status.HTTP_200_OK)
def put(self, request, pk):
""" Respond to a control list classification."""
assert_user_has_permission(request.user.govuser, constants.GovPermissions.RESPOND_PV_GRADING)
query = get_exporter_query(pk)
if CaseStatusEnum.is_terminal(query.status.status):
return JsonResponse(
data={"errors": [strings.Applications.Generic.TERMINAL_CASE_CANNOT_PERFORM_OPERATION_ERROR]},
status=status.HTTP_400_BAD_REQUEST,
)
data = request.data
pv_grading_good_serializer = PVGradingResponseSerializer(data=data)
if pv_grading_good_serializer.is_valid():
if not str_to_bool(data.get("validate_only")):
pv_grading = pv_grading_good_serializer.save()
self.update_query_and_good(query, data, pv_grading)
self.generate_audit_trail(request.user, query)
# Send a notification to the user
for user_relationship in UserOrganisationRelationship.objects.filter(organisation=query.organisation):
user_relationship.send_notification(content_object=query, case=query)
return JsonResponse(
data={"pv_grading_query": pv_grading_good_serializer.data}, status=status.HTTP_200_OK,
)
return JsonResponse(data={"pv_grading_query": data}, status=status.HTTP_200_OK)
return JsonResponse(data={"errors": pv_grading_good_serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def create(self, validated_data):
users = []
if "users" in validated_data:
users = validated_data.pop("users")
address_data = validated_data.pop("address")
address_data["country"] = address_data["country"].id
address_serializer = AddressSerializer(data=address_data)
if address_serializer.is_valid(raise_exception=True):
address = Address(**address_serializer.validated_data)
address.save()
site = Site.objects.create(address=address, **validated_data)
if users:
site.users.set([
get_user_organisation_relationship(
user, validated_data["organisation"]) for user in users
])
if "site_records_stored_here" in self.initial_data:
if str_to_bool(self.initial_data.get("site_records_stored_here")):
site.site_records_located_at = site
site.save()
return site
def get_queryset(self):
"""
Returns a list of all picklist items, filtered by type and by show_deactivated
"""
picklist_items = PicklistItem.objects.filter(
team=self.request.user.govuser.team, )
picklist_type = self.request.GET.get("type")
name = self.request.GET.get("name")
show_deactivated = str_to_bool(
self.request.GET.get("show_deactivated"))
ids = self.request.GET.get("ids")
if picklist_type:
picklist_items = picklist_items.filter(type=picklist_type)
if name:
picklist_items = picklist_items.filter(name__icontains=name)
if not show_deactivated:
picklist_items = picklist_items.filter(
status=PickListStatus.ACTIVE)
if ids:
ids = ids.split(",")
picklist_items = picklist_items.filter(id__in=ids)
return picklist_items.order_by("-updated_at")
def create_or_update_good(serializer, validate_only, is_created):
if not serializer.is_valid():
errors = serializer.errors
pv_grading_errors = errors.pop("pv_grading_details", None)
firearm_errors = errors.pop("firearm_details", None)
# The errors need to be flattened otherwise they will be contained within a 'pv_grading_details' dict
if firearm_errors:
flattened_errors = ({
**errors,
**firearm_errors,
**pv_grading_errors
} if pv_grading_errors else {
**errors,
**firearm_errors
})
else:
flattened_errors = {
**errors,
**pv_grading_errors
} if pv_grading_errors else errors
return JsonResponse(data={"errors": flattened_errors},
status=status.HTTP_400_BAD_REQUEST)
if str_to_bool(validate_only):
return JsonResponse(data={"good": serializer.data},
status=status.HTTP_200_OK)
serializer.save()
return JsonResponse(
data={"good": serializer.data},
status=status.HTTP_201_CREATED if is_created else status.HTTP_200_OK)
def get(self, request):
type_only = request.GET.get("type_only", "True")
# If type_only is True, return only the case_type_reference key-value pairs
if str_to_bool(type_only):
case_types = CaseTypeEnum.case_types_to_representation()
else:
case_types = CaseTypeSerializer(CaseType.objects.all(), many=True).data
return JsonResponse(data={"case_types": case_types}, status=HTTP_200_OK)
def patch(self, request, *args, **kwargs):
site_id = kwargs["pk"]
if Site.objects.get(id=site_id).is_used_on_application:
return JsonResponse(
data={
"errors": {
"site_records_stored_here":
[strings.Site.CANNOT_CHANGE_SITE_IF_ALREADY_IN_USE]
}
},
status=status.HTTP_400_BAD_REQUEST,
)
if "site_records_stored_here" in request.data and "name" not in request.data:
# If records are held at the same site, set site_records_located_at to own pk
if str_to_bool(request.data["site_records_stored_here"]):
request.data["site_records_located_at"] = site_id
if (not str_to_bool(request.data["site_records_stored_here"])
and "site_records_located_at" not in request.data):
return JsonResponse(
data={
"errors": {
"site_records_located_at":
[strings.Site.NO_SITE_SELECTED]
}
},
status=status.HTTP_400_BAD_REQUEST,
)
return self.partial_update(request, *args, **kwargs)
if "name" in request.data and "site_records_stored_here" not in request.data:
return self.partial_update(request, *args, **kwargs)
else:
return JsonResponse(
data={
"errors": {
"site_records_stored_here":
[strings.Site.NO_RECORDS_LOCATED_AT]
}
},
status=status.HTTP_400_BAD_REQUEST,
)
def get(self, request):
org_pk = request.headers["ORGANISATION-ID"]
user = request.user.exporteruser
relationships = UserOrganisationRelationship.objects.select_related(
"organisation").filter(user=user)
if str_to_bool(request.GET.get("in_review", False)):
relationships = relationships.filter(
organisation__status=OrganisationStatus.IN_REVIEW)
else:
relationships = relationships.exclude(
organisation__status=OrganisationStatus.IN_REVIEW)
# Returning a dict over a serializer for performance reasons
# This endpoint is called often, so it needs to be as fast as possible
data = {
"id":
user.pk,
"first_name":
user.first_name,
"last_name":
user.last_name,
"organisations": [{
"id":
relationship.organisation.id,
"name":
relationship.organisation.name,
"joined_at":
date_to_drf_date(relationship.created_at),
"status": {
"key":
relationship.organisation.status,
"value":
get_value_from_enum(relationship.organisation.status,
OrganisationStatus),
},
} for relationship in relationships],
}
if org_pk != "None":
relationship = get_user_organisation_relationship(user, org_pk)
data.update({
"role": {
"id":
relationship.role.id,
"permissions":
convert_queryset_to_str(
relationship.role.permissions.values_list("id",
flat=True)),
}
})
return JsonResponse(data=data)
def get(self, request, *args, **kwargs):
include_system = request.GET.get("include_system", False)
disable_pagination = request.GET.get("disable_pagination", False)
if str_to_bool(include_system) and str(disable_pagination):
system_queue_data = get_system_queues()
work_queue_data = self.get_serializer(get_queues_qs(),
many=True).data
return JsonResponse(data=system_queue_data + work_queue_data,
safe=False,
status=status.HTTP_200_OK)
return super().get(request, *args, **kwargs)
def filter_queryset(self, queryset):
users_team_first = self.request.GET.get("users_team_first", False)
name = self.request.GET.get("name")
if name:
queryset = queryset.filter(name__icontains=name)
if str_to_bool(users_team_first):
queryset = queryset.annotate(users_team=(
Case(When(team=self.request.user.govuser.team, then=1),
default=0,
output_field=BinaryField()))).order_by("-users_team")
return queryset
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if hasattr(self, "initial_data"):
if not self.initial_data.get("control_list_entries"):
self.initial_data["control_list_entries"] = []
if self.get_initial().get("is_military_use"):
is_military_use = self.get_initial().get("is_military_use")
# if military answer is not "yes_modified" then remove the irrelevant details
if is_military_use in [MilitaryUse.YES_DESIGNED, MilitaryUse.NO] and hasattr(self, "initial_data"):
self.initial_data.pop("modified_military_use_details")
if self.get_initial().get("uses_information_security"):
# if information security is False then remove the irrelevant details
if not str_to_bool(self.get_initial().get("uses_information_security")) and hasattr(self, "initial_data"):
self.initial_data.pop("information_security_details")
if self.get_initial().get("firearm_details"):
firearm_details = self.get_initial().get("firearm_details")
# Remove the dependent nested fields in the data if irrelevant based on the parent option selected
if "is_covered_by_firearm_act_section_one_two_or_five" in firearm_details:
# Remove the certificate number and expiry date if the answer is a No
if firearm_details.get("is_covered_by_firearm_act_section_one_two_or_five") != "Yes":
if "section_certificate_number" in firearm_details:
firearm_details.pop("section_certificate_number")
if "section_certificate_date_of_expiry" in firearm_details:
firearm_details.pop("section_certificate_date_of_expiry")
if "has_identification_markings" in firearm_details:
# Keep only the details relevant for the yes/no answer
if str_to_bool(firearm_details.get("has_identification_markings")):
firearm_details.pop("no_identification_markings_details")
else:
firearm_details.pop("identification_markings_details")
self.goods_query_case = (
GoodsQuery.objects.filter(good=self.instance).first() if isinstance(self.instance, Good) else None
)
def filter_queryset(self, queryset):
filter_data = self.request.GET
if self.request.user.type == UserType.INTERNAL:
assert_user_has_permission(self.request.user.govuser, constants.GovPermissions.MAINTAIN_OGL)
elif self.request.user.type == UserType.EXPORTER:
if filter_data.get("site"):
queryset = queryset.filter(cases__site_id=filter_data.get("site"))
if str_to_bool(filter_data.get("active_only")):
queryset = queryset.filter(
cases__status__status__in=[
CaseStatusEnum.FINALISED,
CaseStatusEnum.REGISTERED,
CaseStatusEnum.UNDER_ECJU_REVIEW,
]
)
if str_to_bool(filter_data.get("registered")):
organisation = get_request_user_organisation(self.request)
sites = Site.objects.get_by_user_and_organisation(self.request.user.exporteruser, organisation)
queryset = queryset.filter(cases__site__in=sites).distinct()
if filter_data.get("name"):
queryset = queryset.filter(name__icontains=filter_data.get("name"))
if filter_data.get("case_type"):
queryset = queryset.filter(case_type_id=filter_data.get("case_type"))
if filter_data.get("control_list_entry"):
queryset = queryset.filter(control_list_entries__rating=filter_data.get("control_list_entry"))
if filter_data.get("country"):
queryset = queryset.filter(countries__id__contains=filter_data.get("country"))
if filter_data.get("status"):
queryset = queryset.filter(status=filter_data.get("status"))
return queryset
def post(self, request, org_pk):
if hasattr(request.user, "exporteruser"):
assert_user_has_permission(request.user.exporteruser,
ExporterPermissions.ADMINISTER_SITES,
org_pk)
data = request.data
if "records_located_step" in data:
if "site_records_stored_here" not in data:
return JsonResponse(
data={
"errors": {
"site_records_stored_here":
[strings.Site.NO_RECORDS_LOCATED_AT]
}
},
status=status.HTTP_400_BAD_REQUEST,
)
if not str_to_bool(data["site_records_stored_here"]
) and "site_records_located_at" not in data:
return JsonResponse(
data={
"errors": {
"site_records_located_at":
[strings.Site.NO_SITE_SELECTED]
}
},
status=status.HTTP_400_BAD_REQUEST,
)
data["organisation"] = org_pk
serializer = SiteCreateUpdateSerializer(data=data)
if serializer.is_valid(raise_exception=True):
if "validate_only" not in data or data["validate_only"] == "False":
site = serializer.save()
audit_trail_service.create(
actor=request.user,
verb=AuditType.CREATED_SITE,
target=site,
payload={
"site_name": site.name,
},
)
return JsonResponse(
data={"site": SiteViewSerializer(site).data},
status=status.HTTP_201_CREATED)
return JsonResponse(data={})
def _validate_agree_to_declaration(request, errors):
""" Checks the exporter has agreed to the T&Cs of the licence """
if not str_to_bool(request.data.get("agreed_to_declaration")):
errors["agreed_to_declaration"] = [
strings.Applications.Generic.AGREEMENT_TO_TCS_REQUIRED
]
if "agreed_to_foi" not in request.data:
errors["agreed_to_foi"] = [
strings.Applications.Generic.AGREEMENT_TO_FOI_REQUIRED
]
return errors
def get(self, request, org_pk):
"""
Endpoint for listing the sites of an organisation
filtered on whether or not the user belongs to the site
"""
organisation = get_organisation_by_pk(org_pk)
primary_site_id = organisation.primary_site_id
if hasattr(request.user, "exporteruser"):
sites = Site.objects.get_by_user_and_organisation(
request.user.exporteruser, organisation).exclude(
address__country__id__in=request.GET.getlist("exclude"))
else:
sites = Site.objects.filter(organisation=organisation)
if request.GET.get("postcode"):
sites = sites.filter(address__postcode=request.GET.get("postcode"))
sites = list(sites)
sites.sort(key=lambda x: x.id == primary_site_id, reverse=True)
serializer_data = SiteListSerializer(sites, many=True).data
if str_to_bool(request.GET.get("get_total_users")):
admin_users = UserOrganisationRelationship.objects.filter(
organisation=organisation,
role__permissions__id=ExporterPermissions.ADMINISTER_SITES.name
).values_list("user__pk", flat=True)
total_admin_users = len(admin_users)
relationships = (UserOrganisationRelationship.objects.filter(
sites__id__in=[site["id"] for site in serializer_data]
).exclude(user__pk__in=admin_users).values("sites__id").annotate(
count=Count("sites__id")).values("sites__id", "count"))
relationships = {
str(relationship["sites__id"]): relationship["count"]
for relationship in relationships
}
for site in serializer_data:
site[
"assigned_users_count"] = total_admin_users + relationships.get(
site["id"], 0)
return JsonResponse(data={"sites": serializer_data})
def put(self, request, pk):
""" Edit details of an organisation. """
organisation = get_organisation_by_pk(pk)
org_name_changed = False
if not check_user_has_permission(request.user.govuser,
GovPermissions.MANAGE_ORGANISATIONS):
return JsonResponse(
data={"errors": Organisations.NO_PERM_TO_EDIT},
status=status.HTTP_400_BAD_REQUEST,
)
if request.data.get("name", organisation.name) != organisation.name:
org_name_changed = True
if not check_user_has_permission(
request.user.govuser, GovPermissions.REOPEN_CLOSED_CASES):
return JsonResponse(
data={"errors": Organisations.NO_PERM_TO_EDIT_NAME},
status=status.HTTP_400_BAD_REQUEST,
)
serializer = OrganisationCreateUpdateSerializer(instance=organisation,
data=request.data,
partial=True)
if serializer.is_valid(raise_exception=True):
if str_to_bool(request.data.get("validate_only", False)):
return JsonResponse(data={"organisation": serializer.data},
status=status.HTTP_200_OK)
is_non_uk = False if organisation.primary_site.address.address_line_1 else True
audit_edited_organisation_fields(request.user,
organisation,
request.data,
is_non_uk=is_non_uk)
serializer.save()
if org_name_changed:
self.reopen_closed_cases_for_organisation(organisation)
return JsonResponse(data={"organisation": serializer.data},
status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
user = request.user.govuser
queue_id = request.GET.get("queue_id", ALL_CASES_QUEUE_ID)
is_work_queue = queue_id not in NON_WORK_QUEUES.keys()
is_system_queue = queue_id in SYSTEM_QUEUES.keys()
context = {
"queue_id": queue_id,
"is_system_queue": is_system_queue,
"is_work_queue": is_work_queue,
}
# we include hidden cases in non work queues (all cases, all open cases)
# and if the flag to include hidden is added
include_hidden = not is_work_queue or str_to_bool(request.GET.get("hidden"))
filters = {key: value for key, value in request.GET.items() if key not in ["hidden", "queue_id", "flags"]}
filters["flags"] = request.GET.getlist("flags", [])
filters["submitted_from"] = make_date_from_params("submitted_from", filters)
filters["submitted_to"] = make_date_from_params("submitted_to", filters)
filters["finalised_from"] = make_date_from_params("finalised_from", filters)
filters["finalised_to"] = make_date_from_params("finalised_to", filters)
page = self.paginate_queryset(
Case.objects.search(
queue_id=queue_id, is_work_queue=is_work_queue, user=user, include_hidden=include_hidden, **filters,
).annotate(
next_review_date=django.db.models.Case(
When(
case_review_date__team_id=user.team.id,
case_review_date__next_review_date__gte=timezone.now().date(),
then=F("case_review_date__next_review_date"),
),
default=None,
output_field=DateField(),
),
has_open_queries=Exists(
EcjuQuery.objects.filter(
case=OuterRef("pk"), raised_by_user__team_id=user.team.id, responded_at__isnull=True
)
),
)
)
def get_serializer_context(self):
user = self.request.user
if hasattr(user, "exporteruser"):
organisation = get_request_user_organisation(self.request)
sites = Site.objects.get_by_user_and_organisation(self.request.user.exporteruser, organisation)
cases = (
OpenGeneralLicenceCase.objects.filter(site__in=sites)
.select_related("status", "site", "site__address")
.annotate(records_located_at_name=F("site__site_records_located_at__name"))
)
if str_to_bool(self.request.GET.get("active_only")):
cases = cases.filter(
status__status__in=[
CaseStatusEnum.FINALISED,
CaseStatusEnum.REGISTERED,
CaseStatusEnum.UNDER_ECJU_REVIEW,
]
)
return {"user": user, "organisation": organisation, "cases": cases}
def post(self, request, pk):
"""
Add a party to an application
"""
application = get_application(pk)
data = request.data
data["organisation"] = get_request_user_organisation_id(request)
serializer = PartySerializer(data=data, application_type=application.case_type.sub_type)
if serializer.is_valid(raise_exception=True):
if str_to_bool(data.get("validate_only", False)):
return JsonResponse(data={data["type"]: serializer.initial_data}, status=status.HTTP_200_OK)
# Save party and add to application
serializer.save()
try:
party, removed_party = application.add_party(serializer.instance)
except ApplicationException as exc:
return JsonResponse(data={"errors": exc.data}, status=status.HTTP_400_BAD_REQUEST)
# Audit
if removed_party:
audit_trail_service.create(
actor=request.user,
verb=AuditType.REMOVE_PARTY,
target=application.get_case(),
payload={"party_type": removed_party.type.replace("_", " "), "party_name": removed_party.name},
)
audit_trail_service.create(
actor=request.user,
verb=AuditType.ADD_PARTY,
target=application.get_case(),
payload={"party_type": party.type.replace("_", " "), "party_name": party.name},
)
return JsonResponse(data={party.type: serializer.data}, status=status.HTTP_201_CREATED)
def put(self, request, pk):
"""
Assign users to cases on that queue
"""
queue = get_queue(pk)
data = request.data
for assignment in data.get("case_assignments"):
case = get_case(assignment["case_id"])
users = [get_user_by_pk(i) for i in assignment["users"]]
if str_to_bool(data.get("remove_existing_assignments")):
CaseAssignment.objects.filter(case=case, queue=queue).delete()
# Create a new case assignment object between that case and those users
for user in users:
try:
CaseAssignment.objects.get(case=case, queue=queue, user=user)
except CaseAssignment.DoesNotExist:
case_assignment = CaseAssignment(case=case, queue=queue, user=user)
case_assignment.save(audit_user=request.user, user=user, audit_note=data.get("note"))
# Add to queue
case.queues.add(queue)
def get_serializer_class(self):
if str_to_bool(self.request.GET.get("disable_pagination")):
return TinyPicklistSerializer
else:
return PicklistListSerializer
def paginate_queryset(self, queryset, request, view=None):
if str_to_bool(request.GET.get("disable_pagination", False)):
return
return super().paginate_queryset(queryset, request, view)
def put(self, request, pk):
""" Respond to a control list classification."""
assert_user_has_permission(request.user.govuser, constants.GovPermissions.REVIEW_GOODS)
query = get_exporter_query(pk)
if CaseStatusEnum.is_terminal(query.status.status):
return JsonResponse(
data={"errors": [strings.Applications.Generic.TERMINAL_CASE_CANNOT_PERFORM_OPERATION_ERROR]},
status=status.HTTP_400_BAD_REQUEST,
)
data = request.data
clc_good_serializer = ClcControlGoodSerializer(query.good, data=data)
if clc_good_serializer.is_valid():
if not str_to_bool(data.get("validate_only")):
previous_control_list_entries = list(
query.good.control_list_entries.values_list("rating", flat=True)
) or [strings.Goods.GOOD_NO_CONTROL_CODE]
clc_good_serializer.save()
query.clc_responded = True
query.save()
if clc_good_serializer.validated_data.get("control_list_entries"):
values = clc_good_serializer.validated_data["control_list_entries"]
new_control_list_entries = [clc.rating for clc in values]
else:
new_control_list_entries = [strings.Goods.GOOD_NO_CONTROL_CODE]
if new_control_list_entries != previous_control_list_entries:
audit_trail_service.create(
actor=request.user,
verb=AuditType.GOOD_REVIEWED,
action_object=query.good,
target=query.get_case(),
payload={
"good_name": query.good.description,
"old_control_list_entry": previous_control_list_entries,
"new_control_list_entry": new_control_list_entries,
},
)
flag = Flag.objects.get(id=SystemFlags.GOOD_CLC_QUERY_ID)
query.good.flags.remove(flag)
query.good.status = GoodStatus.VERIFIED
query.good.save()
apply_flagging_rules_to_case(query)
audit_trail_service.create(
actor=request.user, verb=AuditType.CLC_RESPONSE, action_object=query.good, target=query.get_case(),
)
# Send a notification to the user
for user_relationship in UserOrganisationRelationship.objects.filter(organisation=query.organisation):
user_relationship.send_notification(content_object=query, case=query)
return JsonResponse(
data={"control_list_classification_query": clc_good_serializer.data}, status=status.HTTP_200_OK
)
return JsonResponse(data={"control_list_classification_query": data}, status=status.HTTP_200_OK)
return JsonResponse(data={"errors": clc_good_serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, pk):
"""
Create a generated document
"""
licence = None
try:
document = get_generated_document_data(request.data, pk)
except AttributeError as e:
return JsonResponse(data={"errors": [str(e)]}, status=status.HTTP_400_BAD_REQUEST)
try:
pdf = html_to_pdf(document.document_html, document.template.layout.filename)
except Exception: # noqa
return JsonResponse(
{"errors": [strings.Cases.GeneratedDocuments.PDF_ERROR]}, status=status.HTTP_500_INTERNAL_SERVER_ERROR
)
if document.template.include_digital_signature:
pdf = sign_pdf(pdf)
if request.data.get("advice_type") in [
AdviceType.APPROVE,
AdviceType.PROVISO,
]:
try:
licence = Licence.objects.get_draft_licence(pk)
except Licence.DoesNotExist:
raise ParseError({"non_field_errors": [strings.Cases.GeneratedDocuments.LICENCE_ERROR]})
s3_key = s3_operations.generate_s3_key(document.template.name, "pdf")
# base the document name on the template name and a portion of the UUID generated for the s3 key
document_name = f"{s3_key[:len(document.template.name) + 6]}.pdf"
visible_to_exporter = str_to_bool(request.data.get("visible_to_exporter"))
# If the template is not visible to exporter this supersedes what is given for the document
# Decision documents are also hidden until finalised (see FinaliseView)
if not document.template.visible_to_exporter or request.data.get("advice_type"):
visible_to_exporter = False
try:
with transaction.atomic():
# Delete any pre-existing decision document if the documents have not been finalised
# i.e. They are not visible to the exporter
GeneratedCaseDocument.objects.filter(
case=document.case, advice_type=request.data.get("advice_type"), visible_to_exporter=False
).delete()
generated_doc = GeneratedCaseDocument.objects.create(
name=document_name,
user=request.user.govuser,
s3_key=s3_key,
virus_scanned_at=timezone.now(),
safe=True,
type=CaseDocumentState.GENERATED,
case=document.case,
template=document.template,
text=document.text,
visible_to_exporter=visible_to_exporter,
advice_type=request.data.get("advice_type"),
licence=licence,
)
audit_trail_service.create(
actor=request.user.govuser,
verb=AuditType.GENERATE_CASE_DOCUMENT,
action_object=generated_doc,
target=document.case,
payload={"file_name": document_name, "template": document.template.name},
)
s3_operations.upload_bytes_file(raw_file=pdf, s3_key=s3_key)
except Exception: # noqa
return JsonResponse(
{"errors": [strings.Cases.GeneratedDocuments.UPLOAD_ERROR]},
status=status.HTTP_500_INTERNAL_SERVER_ERROR,
)
return JsonResponse(data={"generated_document": str(generated_doc.id)}, status=status.HTTP_201_CREATED)
def get_paginated_response(self, data):
if str_to_bool(self.request.GET.get("disable_pagination")):
return JsonResponse(data={"results": data})
else:
return super().get_paginated_response(data)
def paginate_queryset(self, queryset):
if str_to_bool(self.request.GET.get("disable_pagination")):
return queryset
else:
return super().paginate_queryset(queryset)
