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")
