class ResultaatSerializer(serializers.HyperlinkedModelSerializer):
resultaattype = LengthHyperlinkedRelatedField(
view_name="resultaattype-detail",
lookup_field="uuid",
queryset=ResultaatType.objects.all(),
max_length=1000,
min_length=1,
validators=[IsImmutableValidator()],
help_text=get_help_text("zaken.Resultaat", "resultaattype"),
)
class Meta:
model = Resultaat
fields = ("url", "uuid", "zaak", "resultaattype", "toelichting")
validators = [CorrectZaaktypeValidator("resultaattype")]
extra_kwargs = {
"url": {
"lookup_field": "uuid"
},
"uuid": {
"read_only": True
},
"zaak": {
"lookup_field": "uuid"
},
}
class ZaakBesluitSerializer(serializers.Serializer):
"""
Serializer the reverse relation between Besluit-Zaak.
We use the UUID of the Besluit to generate the URL/UUID of the ZaakBesluit
instance, since it's a FK relationship, we can safely do this. Effectively,
we're feeding the :class:`Besluit` instance to this serializer.
"""
url = NestedHyperlinkedIdentityField(
view_name="zaakbesluit-detail",
lookup_field="uuid",
parent_lookup_kwargs={"zaak_uuid": "zaak__uuid"},
read_only=True,
)
uuid = serializers.UUIDField(
help_text=_("Unieke resource identifier (UUID4)"), read_only=True)
besluit = LengthHyperlinkedRelatedField(
queryset=Besluit.objects.all(),
view_name="besluit-detail",
lookup_field="uuid",
min_length=1,
max_length=1000,
help_text=_(
"URL-referentie naar het BESLUIT (in de Besluiten API), waar "
"ook de relatieinformatie opgevraagd kan worden."),
)
def validate_besluit(self, besluit: Besluit):
zaak = self.context["view"]._get_zaak()
if not besluit.zaak == zaak:
raise serializers.ValidationError(
_("Het Besluit verwijst niet naar de juiste zaak"),
code="invalid-zaak")
return besluit
class ObjectInformatieObjectSerializer(serializers.HyperlinkedModelSerializer):
informatieobject = EnkelvoudigInformatieObjectHyperlinkedRelatedField(
view_name="enkelvoudiginformatieobject-detail",
lookup_field="uuid",
queryset=EnkelvoudigInformatieObject.objects,
help_text=get_help_text("documenten.ObjectInformatieObject",
"informatieobject"),
)
object = LengthHyperlinkedRelatedField(
min_length=1,
max_length=1000,
view_name="",
queryset=QuerySet(),
lookup_field="uuid",
help_text=
_("URL-referentie naar het gerelateerde OBJECT (in deze of een andere API)."
),
)
class Meta:
model = ObjectInformatieObject
fields = ("url", "informatieobject", "object", "object_type")
extra_kwargs = {"url": {"lookup_field": "uuid"}}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
value_display_mapping = add_choice_values_help_text(ObjectTypes)
self.fields["object_type"].help_text += f"\n\n{value_display_mapping}"
def set_object_properties(self, object_type):
object_field = self.fields["object"]
if object_type == "besluit":
object_field.view_name = "besluit-detail"
object_field.queryset = Besluit.objects
else:
object_field.view_name = "zaak-detail"
object_field.queryset = Zaak.objects
def to_internal_value(self, data):
object_type = data["object_type"]
self.set_object_properties(object_type)
res = super().to_internal_value(data)
return res
def to_representation(self, instance):
object_type = instance.object_type
self.set_object_properties(object_type)
return super().to_representation(instance)
class RelevanteZaakSerializer(serializers.ModelSerializer):
url = LengthHyperlinkedRelatedField(
queryset=Zaak.objects.all(),
view_name="zaak-detail",
lookup_field="uuid",
min_length=1,
max_length=1000,
help_text=_("URL-referentie naar de ZAAK."),
)
class Meta:
model = RelevanteZaakRelatie
fields = ("url", "aard_relatie")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
value_display_mapping = add_choice_values_help_text(AardZaakRelatie)
self.fields["aard_relatie"].help_text += f"\n\n{value_display_mapping}"
class ZaakEigenschapSerializer(NestedHyperlinkedModelSerializer):
parent_lookup_kwargs = {"zaak_uuid": "zaak__uuid"}
eigenschap = LengthHyperlinkedRelatedField(
view_name="eigenschap-detail",
lookup_field="uuid",
queryset=Eigenschap.objects.all(),
max_length=1000,
min_length=1,
help_text=get_help_text("zaken.ZaakEigenschap", "eigenschap"),
)
class Meta:
model = ZaakEigenschap
fields = ("url", "uuid", "zaak", "eigenschap", "naam", "waarde")
extra_kwargs = {
"url": {
"lookup_field": "uuid"
},
"uuid": {
"read_only": True
},
"zaak": {
"lookup_field": "uuid"
},
"naam": {
"source": "_naam",
"read_only": True
},
}
def validate(self, attrs):
super().validate(attrs)
eigenschap = attrs["eigenschap"]
attrs["_naam"] = eigenschap.eigenschapnaam
return attrs
class BesluitSerializer(serializers.HyperlinkedModelSerializer):
besluittype = LengthHyperlinkedRelatedField(
view_name="besluittype-detail",
lookup_field="uuid",
queryset=BesluitType.objects,
max_length=200,
min_length=1,
help_text=get_help_text("besluiten.Besluit", "besluittype"),
)
zaak = LengthHyperlinkedRelatedField(
view_name="zaak-detail",
lookup_field="uuid",
queryset=Zaak.objects,
required=False,
allow_null=True,
max_length=200,
help_text=get_help_text("besluiten.Besluit", "zaak"),
)
vervalreden_weergave = serializers.CharField(
source="get_vervalreden_display", read_only=True)
class Meta:
model = Besluit
fields = (
"url",
"identificatie",
"verantwoordelijke_organisatie",
"besluittype",
"zaak",
"datum",
"toelichting",
"bestuursorgaan",
"ingangsdatum",
"vervaldatum",
"vervalreden",
"vervalreden_weergave",
"publicatiedatum",
"verzenddatum",
"uiterlijke_reactiedatum",
)
extra_kwargs = {
"url": {
"lookup_field": "uuid"
},
"identificatie": {
"validators": [IsImmutableValidator()]
},
"verantwoordelijke_organisatie": {
"validators": [IsImmutableValidator(), validate_rsin]
},
}
validators = [
UniekeIdentificatieValidator(),
BesluittypeZaaktypeValidator()
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
value_display_mapping = add_choice_values_help_text(VervalRedenen)
self.fields["vervalreden"].help_text += f"\n\n{value_display_mapping}"
class RolSerializer(PolymorphicSerializer):
roltype = LengthHyperlinkedRelatedField(
view_name="roltype-detail",
lookup_field="uuid",
queryset=RolType.objects.all(),
max_length=1000,
min_length=1,
validators=[IsImmutableValidator()],
help_text=get_help_text("zaken.Rol", "roltype"),
)
discriminator = Discriminator(
discriminator_field="betrokkene_type",
mapping={
RolTypes.natuurlijk_persoon:
RolNatuurlijkPersoonSerializer(),
RolTypes.niet_natuurlijk_persoon:
RolNietNatuurlijkPersoonSerializer(),
RolTypes.vestiging:
RolVestigingSerializer(),
RolTypes.organisatorische_eenheid:
RolOrganisatorischeEenheidSerializer(),
RolTypes.medewerker:
RolMedewerkerSerializer(),
},
group_field="betrokkene_identificatie",
same_model=False,
)
class Meta:
model = Rol
fields = (
"url",
"uuid",
"zaak",
"betrokkene",
"betrokkene_type",
"roltype",
"omschrijving",
"omschrijving_generiek",
"roltoelichting",
"registratiedatum",
"indicatie_machtiging",
)
validators = [
RolOccurenceValidator(RolOmschrijving.initiator, max_amount=1),
RolOccurenceValidator(RolOmschrijving.zaakcoordinator,
max_amount=1),
CorrectZaaktypeValidator("roltype"),
]
extra_kwargs = {
"url": {
"lookup_field": "uuid"
},
"uuid": {
"read_only": True
},
"zaak": {
"lookup_field": "uuid"
},
"betrokkene": {
"required": False
},
}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
value_display_mapping = add_choice_values_help_text(
IndicatieMachtiging)
self.fields[
"indicatie_machtiging"].help_text += f"\n\n{value_display_mapping}"
value_display_mapping = add_choice_values_help_text(RolTypes)
self.fields[
"betrokkene_type"].help_text += f"\n\n{value_display_mapping}"
value_display_mapping = add_choice_values_help_text(RolOmschrijving)
self.fields[
"omschrijving_generiek"].help_text += f"\n\n{value_display_mapping}"
def validate(self, attrs):
validated_attrs = super().validate(attrs)
betrokkene = validated_attrs.get("betrokkene", None)
betrokkene_identificatie = validated_attrs.get(
"betrokkene_identificatie", None)
if not betrokkene and not betrokkene_identificatie:
raise serializers.ValidationError(
_("betrokkene or betrokkeneIdentificatie must be provided"),
code="invalid-betrokkene",
)
return validated_attrs
@transaction.atomic
def create(self, validated_data):
group_data = validated_data.pop("betrokkene_identificatie", None)
rol = super().create(validated_data)
if group_data:
group_serializer = self.discriminator.mapping[
validated_data["betrokkene_type"]]
serializer = group_serializer.get_fields(
)["betrokkene_identificatie"]
group_data["rol"] = rol
serializer.create(group_data)
return rol
class StatusSerializer(serializers.HyperlinkedModelSerializer):
statustype = LengthHyperlinkedRelatedField(
view_name="statustype-detail",
lookup_field="uuid",
queryset=StatusType.objects.all(),
max_length=1000,
min_length=1,
help_text=get_help_text("zaken.Status", "statustype"),
)
class Meta:
model = Status
fields = (
"url",
"uuid",
"zaak",
"statustype",
"datum_status_gezet",
"statustoelichting",
)
validators = [CorrectZaaktypeValidator("statustype")]
extra_kwargs = {
"url": {
"lookup_field": "uuid"
},
"uuid": {
"read_only": True
},
"zaak": {
"lookup_field": "uuid"
},
"datum_status_gezet": {
"validators": [DateNotInFutureValidator()]
},
}
def validate(self, attrs):
validated_attrs = super().validate(attrs)
statustype = validated_attrs["statustype"]
validated_attrs["__is_eindstatus"] = statustype.is_eindstatus()
# validate that all InformationObjects have indicatieGebruiksrecht set
# and are unlocked
if validated_attrs["__is_eindstatus"]:
zaak = validated_attrs["zaak"]
if zaak.zaakinformatieobject_set.exclude(
informatieobject__lock="").exists():
raise serializers.ValidationError(
"Er zijn gerelateerde informatieobjecten die nog gelocked zijn."
"Deze informatieobjecten moet eerst unlocked worden voordat de zaak afgesloten kan worden.",
code="informatieobject-locked",
)
canonical_ids = zaak.zaakinformatieobject_set.values(
"informatieobject_id")
io_ids = (EnkelvoudigInformatieObjectCanonical.objects.filter(
id__in=Subquery(canonical_ids)).annotate(
last=Max("enkelvoudiginformatieobject")).values("last"))
if (EnkelvoudigInformatieObject.objects.filter(
id__in=Subquery(io_ids)).filter(
indicatie_gebruiksrecht__isnull=True).exists()):
# zios = zaak.zaakinformatieobject_set.all()
# for zio in zios:
# informatieobject = zio.informatieobject
# if informatieobject.latest_version.indicatie_gebruiksrecht is None:
raise serializers.ValidationError(
"Er zijn gerelateerde informatieobjecten waarvoor `indicatieGebruiksrecht` nog niet "
"gespecifieerd is. Je moet deze zetten voor je de zaak kan afsluiten.",
code="indicatiegebruiksrecht-unset",
)
brondatum_calculator = BrondatumCalculator(
zaak, validated_attrs["datum_status_gezet"])
try:
brondatum_calculator.calculate()
except Resultaat.DoesNotExist as exc:
raise serializers.ValidationError(
exc.args[0], code="resultaat-does-not-exist") from exc
except DetermineProcessEndDateException as exc:
# ideally, we'd like to do this in the validate function, but that's unfortunately too
# early since we don't know the end date yet
# thought: we _can_ use the datumStatusGezet though!
raise serializers.ValidationError(
exc.args[0], code="archiefactiedatum-error")
# nasty to pass state around...
self.context["brondatum_calculator"] = brondatum_calculator
return validated_attrs
def create(self, validated_data):
"""
Perform additional business logic
Ideally, this would be encapsulated in some utilities for a clear in-output
system, but for now we need to put a bandage on it.
NOTE: avoid doing queries outside of the transaction block - we want
everything or nothing to succeed and no limbo states.
"""
zaak = validated_data["zaak"]
_zaak_fields_changed = []
is_eindstatus = validated_data.pop("__is_eindstatus")
brondatum_calculator = self.context.pop("brondatum_calculator", None)
# are we re-opening the case?
is_reopening = zaak.einddatum and not is_eindstatus
# if the eindstatus is being set, we need to calculate some more things:
# 1. zaak.einddatum, which may be relevant for archiving purposes
# 2. zaak.archiefactiedatum, if not explicitly filled in
if is_eindstatus:
zaak.einddatum = validated_data["datum_status_gezet"].date()
else:
zaak.einddatum = None
_zaak_fields_changed.append("einddatum")
if is_eindstatus:
# in case of eindstatus - retrieve archive parameters from resultaattype
# Archiving: Use default archiefnominatie
if not zaak.archiefnominatie:
zaak.archiefnominatie = brondatum_calculator.get_archiefnominatie(
)
_zaak_fields_changed.append("archiefnominatie")
# Archiving: Calculate archiefactiedatum
if not zaak.archiefactiedatum:
zaak.archiefactiedatum = brondatum_calculator.calculate()
if zaak.archiefactiedatum is not None:
_zaak_fields_changed.append("archiefactiedatum")
elif is_reopening:
zaak.archiefnominatie = None
zaak.archiefactiedatum = None
_zaak_fields_changed += ["archiefnominatie", "archiefactiedatum"]
with transaction.atomic():
obj = super().create(validated_data)
# Save updated information on the ZAAK
zaak.save(update_fields=_zaak_fields_changed)
return obj
class ZaakSerializer(
NestedGegevensGroepMixin,
NestedCreateMixin,
NestedUpdateMixin,
serializers.HyperlinkedModelSerializer,
):
zaaktype = LengthHyperlinkedRelatedField(
view_name="zaaktype-detail",
lookup_field="uuid",
queryset=ZaakType.objects.all(),
max_length=1000,
min_length=1,
validators=[IsImmutableValidator()],
help_text=get_help_text("zaken.Zaak", "zaaktype"),
)
status = serializers.HyperlinkedRelatedField(
source="current_status_uuid",
read_only=True,
allow_null=True,
view_name="status-detail",
lookup_url_kwarg="uuid",
help_text=_("Indien geen status bekend is, dan is de waarde 'null'"),
)
kenmerken = ZaakKenmerkSerializer(
source="zaakkenmerk_set",
many=True,
required=False,
help_text=
"Lijst van kenmerken. Merk op dat refereren naar gerelateerde objecten "
"beter kan via `ZaakObject`.",
)
betalingsindicatie_weergave = serializers.CharField(
source="get_betalingsindicatie_display",
read_only=True,
help_text=_("Uitleg bij `betalingsindicatie`."),
)
verlenging = VerlengingSerializer(
required=False,
allow_null=True,
help_text=
_("Gegevens omtrent het verlengen van de doorlooptijd van de behandeling van de ZAAK"
),
)
opschorting = OpschortingSerializer(
required=False,
allow_null=True,
help_text=
_("Gegevens omtrent het tijdelijk opschorten van de behandeling van de ZAAK"
),
)
deelzaken = serializers.HyperlinkedRelatedField(
read_only=True,
many=True,
view_name="zaak-detail",
lookup_url_kwarg="uuid",
lookup_field="uuid",
help_text=_("URL-referenties naar deel ZAAKen."),
)
resultaat = serializers.HyperlinkedRelatedField(
read_only=True,
allow_null=True,
view_name="resultaat-detail",
lookup_url_kwarg="uuid",
lookup_field="uuid",
help_text=
_("URL-referentie naar het RESULTAAT. Indien geen resultaat bekend is, dan is de waarde 'null'"
),
)
relevante_andere_zaken = RelevanteZaakSerializer(
many=True,
required=False,
help_text=_("Een lijst van relevante andere zaken."))
class Meta:
model = Zaak
fields = (
"url",
"uuid",
"identificatie",
"bronorganisatie",
"omschrijving",
"toelichting",
"zaaktype",
"registratiedatum",
"verantwoordelijke_organisatie",
"startdatum",
"einddatum",
"einddatum_gepland",
"uiterlijke_einddatum_afdoening",
"publicatiedatum",
"communicatiekanaal",
# TODO: add shape validator once we know the shape
"producten_of_diensten",
"vertrouwelijkheidaanduiding",
"betalingsindicatie",
"betalingsindicatie_weergave",
"laatste_betaaldatum",
"zaakgeometrie",
"verlenging",
"opschorting",
"selectielijstklasse",
"hoofdzaak",
"deelzaken",
"relevante_andere_zaken",
# read-only veld, on-the-fly opgevraagd
"status",
# Writable inline resource, as opposed to eigenschappen for demo
# purposes. Eventually, we need to choose one form.
"kenmerken",
# Archiving
"archiefnominatie",
"archiefstatus",
"archiefactiedatum",
"resultaat",
)
extra_kwargs = {
"url": {
"lookup_field": "uuid"
},
"uuid": {
"read_only": True
},
"zaakgeometrie": {
"help_text":
"Punt, lijn of (multi-)vlak geometrie-informatie, in GeoJSON."
},
"identificatie": {
"validators": [IsImmutableValidator()]
},
"einddatum": {
"read_only": True,
"allow_null": True
},
"communicatiekanaal": {
"validators": [
ResourceValidator("CommunicatieKanaal",
settings.REFERENTIELIJSTEN_API_SPEC)
]
},
"vertrouwelijkheidaanduiding": {
"required":
False,
"help_text":
_("Aanduiding van de mate waarin het zaakdossier van de "
"ZAAK voor de openbaarheid bestemd is. Optioneel - indien "
"geen waarde gekozen wordt, dan wordt de waarde van het "
"ZAAKTYPE overgenomen. Dit betekent dat de API _altijd_ een "
"waarde teruggeeft."),
},
"selectielijstklasse": {
"validators": [
ResourceValidator(
"Resultaat",
settings.REFERENTIELIJSTEN_API_SPEC,
get_auth=get_auth,
)
]
},
"hoofdzaak": {
"lookup_field": "uuid",
"queryset": Zaak.objects.all(),
"validators": [NotSelfValidator(),
HoofdzaakValidator()],
},
"laatste_betaaldatum": {
"validators": [UntilNowValidator()]
},
}
# Replace a default "unique together" constraint.
validators = [UniekeIdentificatieValidator()]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
value_display_mapping = add_choice_values_help_text(BetalingsIndicatie)
self.fields[
"betalingsindicatie"].help_text += f"\n\n{value_display_mapping}"
value_display_mapping = add_choice_values_help_text(Archiefstatus)
self.fields[
"archiefstatus"].help_text += f"\n\n{value_display_mapping}"
value_display_mapping = add_choice_values_help_text(Archiefnominatie)
self.fields[
"archiefnominatie"].help_text += f"\n\n{value_display_mapping}"
def validate(self, attrs):
super().validate(attrs)
default_betalingsindicatie = (self.instance.betalingsindicatie
if self.instance else None)
betalingsindicatie = attrs.get("betalingsindicatie",
default_betalingsindicatie)
if betalingsindicatie == BetalingsIndicatie.nvt and attrs.get(
"laatste_betaaldatum"):
raise serializers.ValidationError(
{
"laatste_betaaldatum":
_('Laatste betaaldatum kan niet gezet worden als de betalingsindicatie "nvt" is'
)
},
code="betaling-nvt",
)
# check that productenOfDiensten are part of the ones on the zaaktype
default_zaaktype = self.instance.zaaktype if self.instance else None
zaaktype = attrs.get("zaaktype", default_zaaktype)
assert zaaktype, "Should not have passed validation - a zaaktype is needed"
producten_of_diensten = attrs.get("producten_of_diensten")
if producten_of_diensten:
if not set(producten_of_diensten).issubset(
set(zaaktype.producten_of_diensten)):
raise serializers.ValidationError(
{
"producten_of_diensten":
_("Niet alle producten/diensten komen voor in "
"de producten/diensten op het zaaktype")
},
code="invalid-products-services",
)
# Archiving
default_archiefstatus = (self.instance.archiefstatus if self.instance
else Archiefstatus.nog_te_archiveren)
archiefstatus = (attrs.get("archiefstatus", default_archiefstatus) !=
Archiefstatus.nog_te_archiveren)
if archiefstatus:
# search for related informatieobjects with status != 'gearchiveerd'
canonical_ids = self.instance.zaakinformatieobject_set.values(
"informatieobject_id")
io_ids = (EnkelvoudigInformatieObjectCanonical.objects.filter(
id__in=Subquery(canonical_ids)).annotate(
last=Max("enkelvoudiginformatieobject")).values("last"))
if (EnkelvoudigInformatieObject.objects.filter(
id__in=Subquery(io_ids)).exclude(
status="gearchiveerd").exists()):
raise serializers.ValidationError(
{
"archiefstatus",
_("Er zijn gerelateerde informatieobjecten waarvan de `status` nog niet gelijk is aan "
"`gearchiveerd`. Dit is een voorwaarde voor het zetten van de `archiefstatus` op een andere "
"waarde dan `nog_te_archiveren`."),
},
code="documents-not-archived",
)
for attr in ["archiefnominatie", "archiefactiedatum"]:
if not attrs.get(
attr,
getattr(self.instance, attr)
if self.instance else None):
raise serializers.ValidationError(
{
attr:
_("Moet van een waarde voorzien zijn als de 'Archiefstatus' een waarde heeft anders dan "
"'nog_te_archiveren'.")
},
code=f"{attr}-not-set",
)
# End archiving
return attrs
def create(self, validated_data: dict):
# set the derived value from ZTC
if "vertrouwelijkheidaanduiding" not in validated_data:
zaaktype = validated_data["zaaktype"]
validated_data[
"vertrouwelijkheidaanduiding"] = zaaktype.vertrouwelijkheidaanduiding
return super().create(validated_data)
class EnkelvoudigInformatieObjectSerializer(
serializers.HyperlinkedModelSerializer):
"""
Serializer for the EnkelvoudigInformatieObject model
"""
url = serializers.HyperlinkedIdentityField(
view_name="enkelvoudiginformatieobject-detail", lookup_field="uuid")
informatieobjecttype = LengthHyperlinkedRelatedField(
view_name="informatieobjecttype-detail",
lookup_field="uuid",
queryset=InformatieObjectType.objects,
max_length=200,
min_length=1,
help_text=get_help_text("documenten.EnkelvoudigInformatieObject",
"informatieobjecttype"),
)
inhoud = AnyBase64File(
view_name="enkelvoudiginformatieobject-download",
help_text=_(
f"Minimal accepted size of uploaded file = {settings.MIN_UPLOAD_SIZE} bytes "
f"(or {naturalsize(settings.MIN_UPLOAD_SIZE, binary=True)})"),
)
bestandsomvang = serializers.IntegerField(
source="inhoud.size",
read_only=True,
min_value=0,
help_text=_(
"Aantal bytes dat de inhoud van INFORMATIEOBJECT in beslag neemt."
),
)
integriteit = IntegriteitSerializer(
label=_("integriteit"),
allow_null=True,
required=False,
help_text=
_("Uitdrukking van mate van volledigheid en onbeschadigd zijn van digitaal bestand."
),
)
# TODO: validator!
ondertekening = OndertekeningSerializer(
label=_("ondertekening"),
allow_null=True,
required=False,
help_text=
_("Aanduiding van de rechtskracht van een informatieobject. Mag niet van een waarde "
"zijn voorzien als de `status` de waarde 'in bewerking' of 'ter vaststelling' heeft."
),
)
locked = serializers.BooleanField(
label=_("locked"),
read_only=True,
source="canonical.lock",
help_text=_(
"Geeft aan of het document gelocked is. Alleen als een document gelocked is, "
"mogen er aanpassingen gemaakt worden."),
)
class Meta:
model = EnkelvoudigInformatieObject
fields = (
"url",
"identificatie",
"bronorganisatie",
"creatiedatum",
"titel",
"vertrouwelijkheidaanduiding",
"auteur",
"status",
"formaat",
"taal",
"versie",
"begin_registratie",
"bestandsnaam",
"inhoud",
"bestandsomvang",
"link",
"beschrijving",
"ontvangstdatum",
"verzenddatum",
"indicatie_gebruiksrecht",
"ondertekening",
"integriteit",
"informatieobjecttype", # van-relatie,
"locked",
)
extra_kwargs = {"taal": {"min_length": 3}}
read_only_fields = ["versie", "begin_registratie"]
validators = [StatusValidator()]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
value_display_mapping = add_choice_values_help_text(
VertrouwelijkheidsAanduiding)
self.fields[
"vertrouwelijkheidaanduiding"].help_text += f"\n\n{value_display_mapping}"
value_display_mapping = add_choice_values_help_text(Statussen)
self.fields["status"].help_text += f"\n\n{value_display_mapping}"
def validate_indicatie_gebruiksrecht(self, indicatie):
if (self.instance and not indicatie
and self.instance.canonical.gebruiksrechten_set.exists()):
raise serializers.ValidationError(
_("De indicatie kan niet weggehaald worden of ongespecifieerd "
"zijn als er Gebruiksrechten gedefinieerd zijn."),
code="existing-gebruiksrechten",
)
# create: not self.instance or update: usage_rights exists
elif indicatie and (
not self.instance
or not self.instance.canonical.gebruiksrechten_set.exists()):
raise serializers.ValidationError(
_("De indicatie moet op 'ja' gezet worden door `gebruiksrechten` "
"aan te maken, dit kan niet direct op deze resource."),
code="missing-gebruiksrechten",
)
return indicatie
@transaction.atomic
def create(self, validated_data):
"""
Handle nested writes.
"""
integriteit = validated_data.pop("integriteit", None)
ondertekening = validated_data.pop("ondertekening", None)
# add vertrouwelijkheidaanduiding
if "vertrouwelijkheidaanduiding" not in validated_data:
informatieobjecttype = validated_data["informatieobjecttype"]
validated_data[
"vertrouwelijkheidaanduiding"] = informatieobjecttype.vertrouwelijkheidaanduiding
canonical = EnkelvoudigInformatieObjectCanonical.objects.create()
validated_data["canonical"] = canonical
eio = super().create(validated_data)
eio.integriteit = integriteit
eio.ondertekening = ondertekening
eio.save()
return eio
def update(self, instance, validated_data):
"""
Instead of updating an existing EnkelvoudigInformatieObject,
create a new EnkelvoudigInformatieObject with the same
EnkelvoudigInformatieObjectCanonical
"""
instance.integriteit = validated_data.pop("integriteit", None)
instance.ondertekening = validated_data.pop("ondertekening", None)
validated_data_field_names = validated_data.keys()
for field in instance._meta.get_fields():
if field.name not in validated_data_field_names:
validated_data[field.name] = getattr(instance, field.name)
validated_data["pk"] = None
validated_data["versie"] += 1
# Remove the lock from the data from which a new
# EnkelvoudigInformatieObject will be created, because lock is not a
# part of that model
validated_data.pop("lock")
return super().create(validated_data)