301 lines
12 KiB
Python
301 lines
12 KiB
Python
"""DRF-serializers voor het kerndomein."""
|
|
from rest_framework import serializers
|
|
|
|
from .models import (
|
|
Activiteit, Afwezigheid, BlokUitzondering, Functie, Groep, KalenderDag,
|
|
Locatie, Persoon, Roosterblok, Schooljaar, Subgroep, Tijdslot,
|
|
)
|
|
|
|
|
|
class FunctieSerializer(serializers.ModelSerializer):
|
|
aantal_personen = serializers.IntegerField(source="personen.count", read_only=True)
|
|
|
|
class Meta:
|
|
model = Functie
|
|
fields = ["id", "naam", "omschrijving", "actief", "aantal_personen", "aangemaakt_op"]
|
|
read_only_fields = ["aangemaakt_op"]
|
|
|
|
|
|
class GroepSerializer(serializers.ModelSerializer):
|
|
aantal_leerlingen = serializers.IntegerField(source="leerlingen.count", read_only=True)
|
|
|
|
class Meta:
|
|
model = Groep
|
|
fields = ["id", "naam", "omschrijving", "actief", "aantal_leerlingen", "aangemaakt_op"]
|
|
read_only_fields = ["aangemaakt_op"]
|
|
|
|
|
|
class PersoonSerializer(serializers.ModelSerializer):
|
|
volledige_naam = serializers.CharField(read_only=True)
|
|
rol_label = serializers.CharField(source="get_rol_display", read_only=True)
|
|
groep_naam = serializers.CharField(source="groep.naam", read_only=True, default=None)
|
|
stamgroep_naam = serializers.CharField(source="stamgroep.naam", read_only=True, default=None)
|
|
functies = serializers.PrimaryKeyRelatedField(
|
|
many=True, queryset=Functie.objects.all(), required=False
|
|
)
|
|
functies_namen = serializers.SerializerMethodField()
|
|
vakken = serializers.PrimaryKeyRelatedField(
|
|
many=True, queryset=Activiteit.objects.all(), required=False
|
|
)
|
|
vakken_namen = serializers.SerializerMethodField()
|
|
begeleide_subgroepen = serializers.PrimaryKeyRelatedField(
|
|
many=True, queryset=Subgroep.objects.all(), required=False
|
|
)
|
|
begeleide_subgroepen_namen = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = Persoon
|
|
fields = [
|
|
"id", "voornaam", "achternaam", "volledige_naam",
|
|
"rol", "rol_label", "groep", "groep_naam",
|
|
"stamgroep", "stamgroep_naam",
|
|
"functies", "functies_namen", "vakken", "vakken_namen",
|
|
"begeleide_subgroepen", "begeleide_subgroepen_namen",
|
|
"geboortedatum", "actief", "opmerkingen", "aangemaakt_op",
|
|
]
|
|
read_only_fields = ["aangemaakt_op"]
|
|
|
|
def get_functies_namen(self, obj):
|
|
return [{"id": f.id, "naam": f.naam} for f in obj.functies.all()]
|
|
|
|
def get_vakken_namen(self, obj):
|
|
return [{"id": a.id, "naam": a.naam} for a in obj.vakken.all()]
|
|
|
|
def get_begeleide_subgroepen_namen(self, obj):
|
|
return [{"id": s.id, "naam": s.naam} for s in obj.begeleide_subgroepen.all()]
|
|
|
|
def validate(self, data):
|
|
# Functies/vakken/subgroep-begeleiding horen alleen bij medewerkers.
|
|
# (De M2M wordt door DRF ná save() gezet, dus hier afdwingen.)
|
|
rol = data.get("rol", getattr(self.instance, "rol", None))
|
|
if rol == "leerling":
|
|
data["functies"] = []
|
|
data["vakken"] = []
|
|
data["begeleide_subgroepen"] = []
|
|
return data
|
|
|
|
@staticmethod
|
|
def _met_theorievakken(gekozen):
|
|
"""Voeg de theorievakken toe aan de gekozen vakken (zonder dubbelen)."""
|
|
theorie = list(Activiteit.objects.filter(theorievak=True, actief=True))
|
|
ids = {v.id for v in gekozen}
|
|
return gekozen + [a for a in theorie if a.id not in ids]
|
|
|
|
def create(self, validated_data):
|
|
# begeleide_subgroepen is een reverse-M2M: apart afhandelen na save.
|
|
subg = validated_data.pop("begeleide_subgroepen", None)
|
|
if validated_data.get("rol") == "leerkracht":
|
|
validated_data["vakken"] = self._met_theorievakken(validated_data.get("vakken", []))
|
|
instance = super().create(validated_data)
|
|
if subg is not None:
|
|
instance.begeleide_subgroepen.set(subg)
|
|
return instance
|
|
|
|
def update(self, instance, validated_data):
|
|
subg = validated_data.pop("begeleide_subgroepen", "__keep__")
|
|
rol = validated_data.get("rol", instance.rol)
|
|
if rol == "leerkracht" and "vakken" in validated_data:
|
|
validated_data["vakken"] = self._met_theorievakken(validated_data["vakken"])
|
|
instance = super().update(instance, validated_data)
|
|
if subg != "__keep__":
|
|
instance.begeleide_subgroepen.set(subg)
|
|
return instance
|
|
|
|
|
|
class SubgroepSerializer(serializers.ModelSerializer):
|
|
leden = serializers.PrimaryKeyRelatedField(
|
|
many=True, queryset=Persoon.objects.filter(rol="leerling"), required=False
|
|
)
|
|
leden_namen = serializers.SerializerMethodField()
|
|
aantal_leden = serializers.SerializerMethodField()
|
|
groep_naam = serializers.CharField(source="groep.naam", read_only=True, default=None)
|
|
begeleiders = serializers.PrimaryKeyRelatedField(
|
|
many=True, queryset=Persoon.objects.exclude(rol="leerling"), required=False
|
|
)
|
|
begeleiders_namen = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = Subgroep
|
|
fields = [
|
|
"id", "naam", "omschrijving", "actief",
|
|
"groep", "groep_naam",
|
|
"leden", "leden_namen", "aantal_leden",
|
|
"begeleiders", "begeleiders_namen", "aangemaakt_op",
|
|
]
|
|
read_only_fields = ["aangemaakt_op"]
|
|
|
|
def get_leden_namen(self, obj):
|
|
return [{"id": p.id, "naam": p.volledige_naam} for p in obj.leden.all()]
|
|
|
|
def get_aantal_leden(self, obj):
|
|
return obj.leden.count()
|
|
|
|
def get_begeleiders_namen(self, obj):
|
|
return [{"id": p.id, "naam": p.volledige_naam} for p in obj.begeleiders.all()]
|
|
|
|
|
|
# --- Fase 2 ---------------------------------------------------------------
|
|
|
|
class SchooljaarSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = Schooljaar
|
|
fields = ["id", "naam", "start_datum", "eind_datum", "actief"]
|
|
|
|
def validate(self, data):
|
|
start = data.get("start_datum", getattr(self.instance, "start_datum", None))
|
|
eind = data.get("eind_datum", getattr(self.instance, "eind_datum", None))
|
|
if start and eind and eind <= start:
|
|
raise serializers.ValidationError("De einddatum moet na de startdatum liggen.")
|
|
return data
|
|
|
|
|
|
class KalenderDagSerializer(serializers.ModelSerializer):
|
|
type_label = serializers.CharField(source="get_type_display", read_only=True)
|
|
|
|
class Meta:
|
|
model = KalenderDag
|
|
fields = ["id", "schooljaar", "datum", "type", "type_label", "omschrijving"]
|
|
|
|
|
|
class TijdslotSerializer(serializers.ModelSerializer):
|
|
dag_label = serializers.CharField(source="get_dag_display", read_only=True)
|
|
|
|
groep_naam = serializers.CharField(source="groep.naam", read_only=True, default=None)
|
|
|
|
class Meta:
|
|
model = Tijdslot
|
|
fields = ["id", "naam", "dag", "dag_label", "start_tijd", "eind_tijd", "volgorde", "groep", "groep_naam", "actief"]
|
|
|
|
def validate(self, data):
|
|
start = data.get("start_tijd", getattr(self.instance, "start_tijd", None))
|
|
eind = data.get("eind_tijd", getattr(self.instance, "eind_tijd", None))
|
|
if start and eind and eind <= start:
|
|
raise serializers.ValidationError("De eindtijd moet na de starttijd liggen.")
|
|
return data
|
|
|
|
|
|
class ActiviteitSerializer(serializers.ModelSerializer):
|
|
kleur = serializers.RegexField(
|
|
regex=r"^#[0-9a-fA-F]{6}$",
|
|
error_messages={"invalid": "Kleur moet een hex-code zijn, bv. #2563eb."},
|
|
)
|
|
|
|
class Meta:
|
|
model = Activiteit
|
|
fields = ["id", "naam", "kleur", "omschrijving", "theorievak", "actief"]
|
|
|
|
|
|
class LocatieSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = Locatie
|
|
fields = ["id", "naam", "omschrijving", "actief"]
|
|
|
|
|
|
class RoosterblokSerializer(serializers.ModelSerializer):
|
|
activiteit_naam = serializers.CharField(source="activiteit.naam", read_only=True)
|
|
activiteit_kleur = serializers.CharField(source="activiteit.kleur", read_only=True)
|
|
tijdslot_label = serializers.CharField(source="tijdslot.__str__", read_only=True)
|
|
locatie_naam = serializers.CharField(source="locatie.naam", read_only=True, default=None)
|
|
doel_type = serializers.CharField(read_only=True)
|
|
doel_naam = serializers.SerializerMethodField()
|
|
begeleiders_namen = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = Roosterblok
|
|
fields = [
|
|
"id", "schooljaar", "tijdslot", "tijdslot_label",
|
|
"activiteit", "activiteit_naam", "activiteit_kleur",
|
|
"locatie", "locatie_naam",
|
|
"groep", "subgroep", "leerling", "doel_type", "doel_naam",
|
|
"begeleiders", "begeleiders_namen", "opmerkingen", "aangemaakt_op",
|
|
]
|
|
read_only_fields = ["aangemaakt_op"]
|
|
|
|
def get_doel_naam(self, obj):
|
|
if obj.groep_id:
|
|
return obj.groep.naam
|
|
if obj.subgroep_id:
|
|
return obj.subgroep.naam
|
|
if obj.leerling_id:
|
|
return obj.leerling.volledige_naam
|
|
return None
|
|
|
|
def get_begeleiders_namen(self, obj):
|
|
return [{"id": p.id, "naam": p.volledige_naam} for p in obj.begeleiders.all()]
|
|
|
|
def validate(self, data):
|
|
# Precies één doelgroep (groep / subgroep / leerling).
|
|
groep = data.get("groep", getattr(self.instance, "groep", None))
|
|
subgroep = data.get("subgroep", getattr(self.instance, "subgroep", None))
|
|
leerling = data.get("leerling", getattr(self.instance, "leerling", None))
|
|
gevuld = [x for x in (groep, subgroep, leerling) if x]
|
|
if len(gevuld) != 1:
|
|
raise serializers.ValidationError(
|
|
"Kies precies één doelgroep: groep, subgroep of leerling."
|
|
)
|
|
# Inzetregels voor begeleiders t.o.v. het vak (de activiteit):
|
|
# - een leerling kan geen begeleider zijn;
|
|
# - een klassenondersteuner kan overal worden ingezet;
|
|
# - een leerkracht mag op theorievakken én op de aan hem/haar gekoppelde
|
|
# vakken; een praktijkondersteuner alleen op de gekoppelde vakken.
|
|
activiteit = data.get("activiteit", getattr(self.instance, "activiteit", None))
|
|
begeleiders = data.get("begeleiders", None)
|
|
if begeleiders is None and self.instance is not None:
|
|
begeleiders = list(self.instance.begeleiders.all())
|
|
for p in (begeleiders or []):
|
|
if p.rol == "leerling":
|
|
raise serializers.ValidationError(
|
|
f"'{p.volledige_naam}' is een leerling en kan geen begeleider zijn."
|
|
)
|
|
if p.rol == "klassenondersteuner":
|
|
continue
|
|
if activiteit is None:
|
|
continue
|
|
mag = p.vakken.filter(pk=activiteit.pk).exists()
|
|
if p.rol == "leerkracht" and getattr(activiteit, "theorievak", False):
|
|
mag = True
|
|
if not mag:
|
|
raise serializers.ValidationError(
|
|
f"'{p.volledige_naam}' is niet gekoppeld aan het vak '{activiteit.naam}'."
|
|
)
|
|
return data
|
|
|
|
|
|
class AfwezigheidSerializer(serializers.ModelSerializer):
|
|
persoon_naam = serializers.CharField(source="persoon.volledige_naam", read_only=True)
|
|
persoon_rol = serializers.CharField(source="persoon.rol", read_only=True)
|
|
|
|
class Meta:
|
|
model = Afwezigheid
|
|
fields = [
|
|
"id", "persoon", "persoon_naam", "persoon_rol",
|
|
"start_datum", "eind_datum", "reden", "aangemaakt_op",
|
|
]
|
|
read_only_fields = ["aangemaakt_op"]
|
|
|
|
def validate(self, data):
|
|
start = data.get("start_datum", getattr(self.instance, "start_datum", None))
|
|
eind = data.get("eind_datum", getattr(self.instance, "eind_datum", None))
|
|
if start and eind and eind < start:
|
|
raise serializers.ValidationError("De einddatum ligt vóór de startdatum.")
|
|
return data
|
|
|
|
|
|
class BlokUitzonderingSerializer(serializers.ModelSerializer):
|
|
vervanger_naam = serializers.CharField(
|
|
source="vervanger.volledige_naam", read_only=True, default=None
|
|
)
|
|
|
|
class Meta:
|
|
model = BlokUitzondering
|
|
fields = [
|
|
"id", "roosterblok", "datum", "vervalt",
|
|
"vervanger", "vervanger_naam", "opmerking",
|
|
]
|
|
|
|
def validate_vervanger(self, value):
|
|
if value is not None and value.rol == "leerling":
|
|
raise serializers.ValidationError(
|
|
"Een leerling kan geen vervanger zijn."
|
|
)
|
|
return value
|