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)