class F680ClearanceViewSerializer(PartiesSerializerMixin, GenericApplicationViewSerializer): goods = GoodOnApplicationViewSerializer(many=True, read_only=True) destinations = serializers.SerializerMethodField() additional_documents = serializers.SerializerMethodField() types = F680ClearanceTypeSerializer(read_only=True, many=True) clearance_level = KeyValueChoiceField(choices=PvGrading.choices, allow_null=True, required=False, allow_blank=True) expedited = serializers.BooleanField(required=False) expedited_date = serializers.DateField(required=False) foreign_technology = serializers.BooleanField(required=False) foreign_technology_description = serializers.CharField(max_length=2000, allow_blank=True, required=False) locally_manufactured = serializers.BooleanField(required=False) locally_manufactured_description = serializers.CharField(max_length=2000, allow_blank=True, required=False) mtcr_type = KeyValueChoiceField(choices=MTCRAnswers.choices, allow_blank=True, required=False) electronic_warfare_requirement = serializers.BooleanField(required=False) uk_service_equipment = serializers.BooleanField(required=False) uk_service_equipment_description = serializers.CharField(max_length=2000, allow_blank=True, required=False) uk_service_equipment_type = KeyValueChoiceField( choices=ServiceEquipmentType.choices, allow_blank=True, required=False) prospect_value = serializers.DecimalField(required=False, allow_null=True, max_digits=15, decimal_places=2) class Meta: model = F680ClearanceApplication fields = (GenericApplicationViewSerializer.Meta.fields + constants.F680.ADDITIONAL_INFORMATION_FIELDS + ( "case_officer", "end_user", "third_parties", "goods", "activity", "usage", "destinations", "additional_documents", "types", "clearance_level", "intended_end_use", ))
class PicklistListSerializer(TinyPicklistSerializer): type = KeyValueChoiceField(choices=PicklistType.choices, read_only=True) status = KeyValueChoiceField(choices=PickListStatus.choices, read_only=True) team = TeamReadOnlySerializer(read_only=True) class Meta: model = PicklistItem fields = TinyPicklistSerializer.Meta.fields + ( "team", "type", "status", )
class CaseTypeSerializer(serializers.ModelSerializer): reference = KeyValueChoiceField(choices=CaseTypeReferenceEnum.choices) type = KeyValueChoiceField(choices=CaseTypeTypeEnum.choices) sub_type = KeyValueChoiceField(choices=CaseTypeSubTypeEnum.choices) class Meta: model = CaseType fields = ( "id", "reference", "type", "sub_type", )
class GoodOnApplicationViewSerializer(serializers.ModelSerializer): good = GoodSerializerInternal(read_only=True) good_application_documents = serializers.SerializerMethodField() unit = KeyValueChoiceField(choices=Units.choices) flags = serializers.SerializerMethodField() control_list_entries = ControlListEntrySerializer(many=True) audit_trail = serializers.SerializerMethodField() is_good_controlled = KeyValueChoiceField(choices=GoodControlled.choices) firearm_details = FirearmDetailsSerializer() class Meta: model = GoodOnApplication fields = ( "id", "good", "application", "quantity", "unit", "value", "is_good_incorporated", "flags", "item_type", "other_item_type", "is_good_controlled", "control_list_entries", "end_use_control", "comment", "report_summary", "audit_trail", "firearm_details", "good_application_documents", "is_precedent", ) def get_flags(self, instance): return list(instance.good.flags.values("id", "name", "colour", "label")) def get_good_application_documents(self, instance): documents = GoodOnApplicationDocument.objects.filter( application=instance.application, good=instance.good, safe=True) return GoodOnApplicationDocumentViewSerializer(documents, many=True).data def get_audit_trail(self, instance): # this serializer is used by a few views. Most views do not need to know audit trail if not self.context.get("include_audit_trail"): return [] return AuditSerializer(instance.audit_trail.all(), many=True).data
class CaseDocumentViewSerializer(serializers.ModelSerializer): created_at = serializers.DateTimeField(read_only=True) case = serializers.PrimaryKeyRelatedField(queryset=Case.objects.all()) user = GovUserSimpleSerializer() metadata_id = serializers.SerializerMethodField() type = KeyValueChoiceField(choices=CaseDocumentState.choices) def get_metadata_id(self, instance): return instance.id if instance.safe else "File not ready" class Meta: model = CaseDocument fields = ( "id", "name", "type", "metadata_id", "user", "size", "case", "created_at", "safe", "description", "visible_to_exporter", )
class LicenceSerializer(serializers.ModelSerializer): application = ApplicationLicenceSerializer(source="case.baseapplication") goods = serializers.SerializerMethodField() status = KeyValueChoiceField(choices=LicenceStatus.choices) document = serializers.SerializerMethodField() class Meta: model = Licence fields = ( "application", "reference_code", "status", "start_date", "duration", "goods", "document", ) read_only_fields = fields def get_goods(self, instance): return serialize_goods_on_licence(instance) def get_document(self, instance): document = GeneratedCaseDocument.objects.get(licence=instance) return {"id": document.id}
class SimpleAdviceSerializer(serializers.ModelSerializer): type = KeyValueChoiceField(choices=AdviceType.choices) class Meta: model = Advice fields = ("type", "text", "proviso") read_only_fields = fields
class EcjuQueryGovSerializer(serializers.ModelSerializer): raised_by_user_name = serializers.SerializerMethodField() responded_by_user_name = serializers.SerializerMethodField() query_type = KeyValueChoiceField(choices=ECJUQueryType.choices, required=False) documents = serializers.SerializerMethodField() class Meta: model = EcjuQuery fields = ( "id", "question", "response", "case", "responded_by_user_name", "raised_by_user_name", "created_at", "responded_at", "query_type", "documents", ) def get_raised_by_user_name(self, instance): return instance.raised_by_user.baseuser_ptr.get_full_name() def get_responded_by_user_name(self, instance): if instance.responded_by_user: return instance.responded_by_user.baseuser_ptr.get_full_name() def get_documents(self, instance): documents = EcjuQueryDocument.objects.filter(query=instance) return SimpleEcjuQueryDocumentViewSerializer(documents, many=True).data
class TinyCaseTypeSerializer(serializers.ModelSerializer): sub_type = KeyValueChoiceField(choices=CaseTypeSubTypeEnum.choices) class Meta: model = CaseType fields = ("sub_type", ) read_only_fields = fields
class GoodListSerializer(serializers.Serializer): id = serializers.UUIDField() name = serializers.CharField() description = serializers.CharField() control_list_entries = ControlListEntrySerializer(many=True, allow_null=True) part_number = serializers.CharField() status = KeyValueChoiceField(choices=GoodStatus.choices)
class PVGradingResponseSerializer(serializers.ModelSerializer): grading = KeyValueChoiceField( choices=PvGrading.gov_choices, allow_null=False, allow_blank=False, required=True, error_messages={ "invalid_choice": strings.PvGrading.NO_GRADING, "required": strings.PvGrading.NO_GRADING }, ) prefix = serializers.CharField(allow_blank=True, allow_null=True, max_length=30) suffix = serializers.CharField(allow_blank=True, allow_null=True, max_length=30) class Meta: model = PvGradingDetails fields = ( "id", "prefix", "grading", "suffix", )
class GoodOnLicenceViewSerializer(serializers.Serializer): good_on_application_id = serializers.UUIDField(source="good.id") usage = serializers.FloatField() description = serializers.CharField(source="good.good.description") units = KeyValueChoiceField(source="good.unit", choices=Units.choices) applied_for_quantity = serializers.FloatField(source="good.quantity") applied_for_value = serializers.FloatField(source="good.value") licenced_quantity = serializers.FloatField(source="quantity") licenced_value = serializers.FloatField(source="value") applied_for_value_per_item = serializers.SerializerMethodField() licenced_value_per_item = serializers.SerializerMethodField() control_list_entries = ControlListEntrySerializer( source="good.good.control_list_entries", many=True) advice = serializers.SerializerMethodField() def get_advice(self, instance): advice = instance.good.good.advice.get( level=AdviceLevel.FINAL, case_id=instance.licence.case_id) return SimpleAdviceSerializer(instance=advice).data def get_applied_for_value_per_item(self, instance): if instance.good.value and instance.good.quantity: return float(instance.good.value) / instance.good.quantity def get_licenced_value_per_item(self, instance): if instance.value and instance.quantity: return float(instance.value) / instance.quantity
class AdditionalContactSerializer(serializers.ModelSerializer): name = serializers.CharField(error_messages=PartyErrors.NAME, max_length=100) email = serializers.EmailField(error_messages=PartyErrors.EMAIL) phone_number = serializers.CharField( error_messages=PartyErrors.PHONE_NUMBER, max_length=50) details = serializers.CharField(error_messages=PartyErrors.DETAILS, max_length=256) address = serializers.CharField(error_messages=PartyErrors.ADDRESS, max_length=256) country = CountrySerializerField() type = KeyValueChoiceField(choices=PartyType.choices, required=True) organisation = relations.PrimaryKeyRelatedField( queryset=Organisation.objects.all()) class Meta: model = Party fields = ( "id", "name", "phone_number", "email", "details", "address", "country", "type", "organisation", ) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if hasattr(self, "initial_data"): self.initial_data["type"] = PartyType.ADDITIONAL_CONTACT self.initial_data["organisation"] = self.context["organisation_pk"]
class OrganisationListSerializer(serializers.ModelSerializer): type = KeyValueChoiceField(OrganisationType.choices) status = KeyValueChoiceField(OrganisationStatus.choices) class Meta: model = Organisation fields = ( "id", "name", "sic_number", "eori_number", "type", "status", "registration_number", "vat_number", "created_at", )
class DecisionSerializer(serializers.ModelSerializer): name = KeyValueChoiceField(choices=AdviceType.choices) class Meta: model = Decision fields = ( "id", "name", )
class OrganisationStatusUpdateSerializer(serializers.ModelSerializer): status = KeyValueChoiceField(choices=OrganisationStatus.choices, required=True, allow_null=False, allow_blank=False) class Meta: model = Organisation fields = ("status", )
class GoodSerializerExporter(serializers.Serializer): id = serializers.UUIDField() name = serializers.CharField() description = serializers.CharField() control_list_entries = ControlListEntryField(many=True) part_number = serializers.CharField() is_good_controlled = KeyValueChoiceField(choices=GoodControlled.choices) is_pv_graded = KeyValueChoiceField(choices=GoodPvGraded.choices) item_category = KeyValueChoiceField(choices=ItemCategory.choices) is_military_use = KeyValueChoiceField(choices=MilitaryUse.choices) is_component = KeyValueChoiceField(choices=Component.choices) uses_information_security = serializers.BooleanField() modified_military_use_details = serializers.CharField() component_details = serializers.CharField() information_security_details = serializers.CharField() pv_grading_details = PvGradingDetailsSerializer(allow_null=True, required=False) software_or_technology_details = serializers.CharField() firearm_details = FirearmDetailsSerializer(allow_null=True, required=False)
class CaseLicenceViewSerializer(serializers.ModelSerializer): status = KeyValueChoiceField(LicenceStatus.choices, required=False) class Meta: model = Licence fields = ( "start_date", "duration", "status", )
class DocumentLicenceListSerializer(serializers.ModelSerializer): advice_type = KeyValueChoiceField(choices=AdviceType.choices) class Meta: model = GeneratedCaseDocument fields = ( "advice_type", "id", ) read_only_fields = fields
class UserOrganisationRelationshipSerializer(serializers.ModelSerializer): status = KeyValueChoiceField(choices=UserStatuses.choices) role = serializers.PrimaryKeyRelatedField(queryset=Role.objects.filter( type=UserType.EXPORTER)) class Meta: model = UserOrganisationRelationship fields = ( "status", "role", )
class PicklistUpdateCreateSerializer(ModelSerializer): name = CharField( allow_blank=False, required=True, error_messages={"blank": strings.Picklists.BLANK_NAME}, ) text = CharField( allow_blank=False, max_length=5000, required=True, error_messages={"blank": strings.Picklists.BLANK_TEXT}, ) type = KeyValueChoiceField( choices=PicklistType.choices, required=True, error_messages={"invalid_choice": strings.Picklists.BLANK_TYPE}, allow_null=False, allow_blank=False, ) status = KeyValueChoiceField( choices=PickListStatus.choices, error_messages={"invalid_choice": strings.Picklists.BLANK_STATUS}, ) team = PrimaryKeyRelatedField(queryset=Team.objects.all()) team_name = SerializerMethodField() def get_team_name(self, instance): return instance.team.name class Meta: model = PicklistItem fields = ( "id", "team", "name", "text", "type", "status", "team_name", "updated_at", )
class AdviceDocumentGovSerializer(serializers.ModelSerializer): user = GovUserViewSerializer() advice_type = KeyValueChoiceField(choices=AdviceType.choices) class Meta: model = GeneratedCaseDocument fields = ( "id", "advice_type", "user", "created_at", )
class GoodSerializerExporterFullDetail(GoodSerializerExporter): case_id = serializers.SerializerMethodField() documents = serializers.SerializerMethodField() missing_document_reason = KeyValueChoiceField(choices=GoodMissingDocumentReasons.choices) status = KeyValueChoiceField(choices=GoodStatus.choices) query = serializers.SerializerMethodField() case_officer = serializers.SerializerMethodField() case_status = serializers.SerializerMethodField() def __init__(self, *args, **kwargs): super(GoodSerializerExporterFullDetail, self).__init__(*args, **kwargs) self.goods_query = GoodsQuery.objects.filter(good=self.instance).first() def get_case_id(self, instance): return str(self.goods_query.id) if self.goods_query else None def get_documents(self, instance): documents = GoodDocument.objects.filter(good=instance) return SimpleGoodDocumentViewSerializer(documents, many=True).data def get_query(self, instance): from api.queries.goods_query.serializers import ExporterReadGoodQuerySerializer if self.goods_query: serializer = ExporterReadGoodQuerySerializer( instance=self.goods_query, context={"exporter_user": self.context.get("exporter_user"), "total_count": False}, ) return serializer.data def get_case_status(self, instance): if self.goods_query: return { "key": self.goods_query.status.status, "value": get_status_value_from_case_status_enum(self.goods_query.status.status), } def get_case_officer(self, instance): if self.goods_query: return GovUserSimpleSerializer(self.goods_query.case_officer).data
class GoodSerializerInternal(serializers.Serializer): id = serializers.UUIDField() name = serializers.CharField() description = serializers.CharField() part_number = serializers.CharField() control_list_entries = ControlListEntrySerializer(many=True) comment = serializers.CharField() is_good_controlled = KeyValueChoiceField(choices=GoodControlled.choices) report_summary = serializers.CharField(allow_blank=True, required=False) flags = GoodsFlagSerializer(many=True) documents = serializers.SerializerMethodField() is_pv_graded = serializers.CharField() grading_comment = serializers.CharField() pv_grading_details = PvGradingDetailsSerializer(allow_null=True, required=False) status = KeyValueChoiceField(choices=GoodStatus.choices) item_category = KeyValueChoiceField(choices=ItemCategory.choices) is_military_use = KeyValueChoiceField(choices=MilitaryUse.choices) is_component = KeyValueChoiceField(choices=Component.choices) uses_information_security = serializers.BooleanField() modified_military_use_details = serializers.CharField() component_details = serializers.CharField() information_security_details = serializers.CharField() missing_document_reason = KeyValueChoiceField(choices=GoodMissingDocumentReasons.choices) software_or_technology_details = serializers.CharField() firearm_details = FirearmDetailsSerializer(allow_null=True, required=False) is_precedent = serializers.BooleanField(required=False, default=False) def get_documents(self, instance): documents = GoodDocument.objects.filter(good=instance) return SimpleGoodDocumentViewSerializer(documents, many=True).data
class OrganisationDetailSerializer(serializers.ModelSerializer): primary_site = PrimaryKeyRelatedSerializerField( queryset=Site.objects.all(), serializer=SiteListSerializer) type = KeyValueChoiceField(OrganisationType.choices) flags = serializers.SerializerMethodField() status = KeyValueChoiceField(OrganisationStatus.choices) def get_flags(self, instance): # TODO remove try block when other end points adopt generics try: if hasattr(self.context.get("request").user, "govuser"): return list( instance.flags.values("id", "name", "colour", "label", "priority")) except AttributeError: return list( instance.flags.values("id", "name", "colour", "label", "priority")) class Meta: model = Organisation fields = "__all__"
class GoodMissingDocumentSerializer(serializers.ModelSerializer): missing_document_reason = KeyValueChoiceField( choices=GoodMissingDocumentReasons.choices, allow_blank=False, required=True, error_messages={"invalid_choice": strings.Goods.INVALID_MISSING_DOCUMENT_REASON}, ) class Meta: model = Good fields = ( "id", "missing_document_reason", )
class PvGradingDetailsSerializer(serializers.ModelSerializer): grading = KeyValueChoiceField(choices=PvGrading.choices, allow_null=True, allow_blank=True) custom_grading = serializers.CharField(allow_blank=True, allow_null=True) prefix = serializers.CharField(allow_blank=True, allow_null=True) suffix = serializers.CharField(allow_blank=True, allow_null=True) issuing_authority = serializers.CharField(allow_blank=False, allow_null=False) reference = serializers.CharField(allow_blank=False, allow_null=False) date_of_issue = serializers.DateField( allow_null=False, error_messages={"invalid": "Enter the products date of issue and include a day, month, year."}, ) class Meta: model = PvGradingDetails fields = ( "grading", "custom_grading", "prefix", "suffix", "issuing_authority", "reference", "date_of_issue", ) def validate(self, data): validated_data = super(PvGradingDetailsSerializer, self).validate(data) self.valudate_custom_grading(data) return validated_data def valudate_custom_grading(self, data): if not data.get("grading") and not data.get("custom_grading"): raise serializers.ValidationError({"custom_grading": [strings.Goods.NO_CUSTOM_GRADING_ERROR]}) if data.get("grading") and data.get("custom_grading"): raise serializers.ValidationError( {"custom_grading": [strings.Goods.PROVIDE_ONLY_GRADING_OR_CUSTOM_GRADING_ERROR]} ) def to_internal_value(self, data): try: return super().to_internal_value(data) except serializers.ValidationError as error: # vanilla behavior of DRF is when a field-level validation error (such as required) occurs then .validate # is not called. Circumventing this here to benefit the frontend. try: self.valudate_custom_grading(data) except serializers.ValidationError as inner_error: error.detail.update(inner_error.detail) raise error
def __init__(self, context=None, *args, **kwargs): if context and context.get( "application_type").sub_type == CaseTypeSubTypeEnum.STANDARD: self.fields["have_you_been_informed"] = KeyValueChoiceField( required=True, choices=ApplicationExportLicenceOfficialType.choices, error_messages={"required": strings.Goods.INFORMED}, ) if kwargs.get( "data").get("have_you_been_informed" ) == ApplicationExportLicenceOfficialType.YES: self.fields[ "reference_number_on_information_form"] = serializers.CharField( required=True, allow_blank=True, max_length=255) super().__init__(*args, **kwargs)
class LicenceListSerializer(serializers.ModelSerializer): application = ApplicationLicenceListSerializer( source="case.baseapplication") goods = serializers.SerializerMethodField() status = KeyValueChoiceField(choices=LicenceStatus.choices) class Meta: model = Licence fields = ( "id", "reference_code", "status", "application", "goods", ) read_only_fields = fields ordering = ["created_at"] def get_goods(self, instance): return serialize_goods_on_licence(instance)
class AdviceViewSerializer(serializers.Serializer): id = serializers.UUIDField() text = serializers.CharField() note = serializers.CharField() type = KeyValueChoiceField(choices=AdviceType.choices) level = serializers.CharField() proviso = serializers.CharField() denial_reasons = serializers.PrimaryKeyRelatedField( queryset=DenialReason.objects.all(), many=True) footnote = serializers.CharField() user = PrimaryKeyRelatedSerializerField(queryset=GovUser.objects.all(), serializer=GovUserListSerializer) created_at = serializers.DateTimeField() good = serializers.UUIDField(source="good_id") goods_type = serializers.UUIDField(source="goods_type_id") country = serializers.UUIDField(source="country_id") end_user = serializers.UUIDField(source="end_user_id") ultimate_end_user = serializers.UUIDField(source="ultimate_end_user_id") consignee = serializers.UUIDField(source="consignee_id") third_party = serializers.UUIDField(source="third_party_id")