Qualification default expiration time

ephios/api/urls.py

@@ -25,6 +25,7 @@
     UserParticipationView,
     UserProfileMeView,
     UserViewSet,
+    calculate_expiration_date,
 )
 from ephios.extra.permissions import staff_required
 
@@ -109,5 +110,10 @@
         SpectacularSwaggerSplitView.as_view(url_name="openapi-schema"),
         name="swagger-ui",
     ),
+    path(
+        "qualifications/default-expiration-date/calculate/",
+        calculate_expiration_date,
+        name="default_expiration_time_calculate"
+    ),
     path("", include(router.urls)),
 ]

ephios/api/views/users.py

@@ -1,4 +1,8 @@
+from datetime import date
+from django.http import JsonResponse
 from django_filters.rest_framework import DjangoFilterBackend
+from django.utils.translation import gettext_lazy as _
+from django.views.decorators.http import require_GET
 from oauth2_provider.contrib.rest_framework import IsAuthenticatedOrTokenHasScope
 from rest_framework import viewsets
 from rest_framework.exceptions import PermissionDenied
@@ -22,7 +26,11 @@
     UserinfoParticipationSerializer,
     UserProfileSerializer,
 )
-from ephios.core.models import AbstractParticipation, UserProfile
+from ephios.core.models import (
+    AbstractParticipation,
+    UserProfile,
+    Qualification,
+)
 
 
 class UserProfileMeView(RetrieveAPIView):
@@ -84,3 +92,80 @@ def get_queryset(self):
         return AbstractParticipation.objects.filter(
             localparticipation__user=self.kwargs.get("user")
         ).select_related("shift", "shift__event", "shift__event__type")
+
+
+@require_GET
+def calculate_expiration_date(request):
+    qualification_id = request.GET.get("qualification")
+    qualification_date_str = request.GET.get("qualification_date")
+
+    # Eingaben prüfen
+    if not qualification_id:
+        return JsonResponse(
+            {
+                "error": _("No qualification selected."),
+                "expiration_date": "",
+            },
+            status=400,
+        )
+    if not qualification_date_str:
+        return JsonResponse(
+            {
+                "error": _("No qualification date provided."),
+                "expiration_date": "",
+            },
+            status=400,
+        )
+
+    try:
+        qualification = Qualification.objects.get(pk=qualification_id)
+    except Qualification.DoesNotExist:
+        return JsonResponse(
+            {
+                "error": _("Selected qualification does not exist."),
+                "expiration_date": "",
+            },
+            status=400,
+        )
+    try:
+        qualification_date = date.fromisoformat(qualification_date_str)
+    except ValueError:
+        return JsonResponse(
+            {
+                "error": _("Invalid qualification date format."),
+                "expiration_date": "",
+            },
+            status=400,
+        )
+
+    # Default Expiration Time prüfen
+    default_expiration = getattr(qualification, "default_expiration_time", None)
+    if not default_expiration:
+        return JsonResponse(
+            {
+                "error": _("This qualification has no default expiration time defined."),
+                "expiration_date": "",
+            },
+            status=200,
+        )
+
+    # Ablaufdatum berechnen
+    try:
+        expiration_date = default_expiration.apply_to(qualification_date)
+    except Exception as e:
+        return JsonResponse(
+            {
+                "error": _("Error while calculating expiration date: %(error)s") % {"error": str(e)},
+                "expiration_date": "",
+            },
+            status=500,
+        )
+
+    # Erfolg
+    return JsonResponse(
+        {
+            "error": "",
+            "expiration_date": expiration_date.isoformat() if expiration_date else "",
+        },
+        status=200,
+    )

ephios/core/models/users.py

@@ -32,9 +32,10 @@
 from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
 
-from ephios.extra.fields import EndOfDayDateTimeField
+from ephios.extra.fields import EndOfDayDateTimeField, RelativeTimeField
 from ephios.extra.json import CustomJSONDecoder, CustomJSONEncoder
-from ephios.extra.widgets import CustomDateInput
+from ephios.extra.relative_time import RelativeTimeModelField
+from ephios.extra.widgets import CustomDateInput, RelativeTimeWidget
 from ephios.modellogging.log import (
     ModelFieldsLogConfig,
     add_log_recorder,
@@ -275,6 +276,17 @@ class QualificationManager(models.Manager):
     def get_by_natural_key(self, qualification_uuid, *args):
         return self.get(uuid=qualification_uuid)
 
+class DefaultExpirationTimeField(RelativeTimeModelField):
+    """
+    A model field whose formfield is a RelativeTimeField
+    """
+
+    def formfield(self, **kwargs):
+        return super().formfield(
+            widget = RelativeTimeWidget,
+            form_class=RelativeTimeField,
+            **kwargs,
+        )
 
 class Qualification(Model):
     uuid = models.UUIDField(unique=True, default=uuid.uuid4, verbose_name="UUID")
@@ -294,6 +306,14 @@ class Qualification(Model):
         symmetrical=False,
         blank=True,
     )
+    default_expiration_time = DefaultExpirationTimeField(
+        verbose_name=_("Default expiration time"),
+        help_text=_(
+            "The default expiration time for this qualification."
+        ),
+        null=True,
+        blank=True,
+    )
     is_imported = models.BooleanField(verbose_name=_("imported"), default=True)
 
     objects = QualificationManager()
@@ -317,7 +337,6 @@ def natural_key(self):
 
     natural_key.dependencies = ["core.QualificationCategory"]
 
-
 register_model_for_logging(
     Qualification,
     ModelFieldsLogConfig(),

ephios/extra/fields.py

@@ -1,8 +1,12 @@
 import datetime
 
+from django.utils.translation import gettext as _
 from django import forms
 from django.forms.utils import from_current_timezone
+from ephios.extra.relative_time import RelativeTimeTypeRegistry
+from ephios.extra.widgets import RelativeTimeWidget
 
+import json
 
 class EndOfDayDateTimeField(forms.DateTimeField):
     """
@@ -21,3 +25,89 @@ def to_python(self, value):
                 day=result.day,
             )
         )
+
+class RelativeTimeField(forms.JSONField):
+    """
+    A form field that dynamically adapts to all registered RelativeTime types.
+    """
+
+    widget = RelativeTimeWidget
+
+    def bound_data(self, data, initial):
+        if isinstance(data, list):
+            return data
+        return super().bound_data(data, initial)
+
+    def to_python(self, value):
+        if not value:
+            return None
+
+        try:
+            # Determine all known types and their parameters
+            type_names = [name for name, _ in RelativeTimeTypeRegistry.all()]
+
+            if isinstance(value, list):
+                # first element = type index
+                type_index = int(value[0]) if value and value[0] is not None else 0
+                type_name = type_names[type_index] if 0 <= type_index < len(type_names) else None
+                handler = RelativeTimeTypeRegistry.get(type_name)
+                if not handler:
+                    raise ValueError(_("Invalid choice"))
+
+                params = {}
+                # remaining values correspond to all known parameters
+                all_param_names = sorted({p for _, h in RelativeTimeTypeRegistry.all() for p in getattr(h, "fields", [])})
+                for param_name, param_value in zip(all_param_names, value[1:]):
+                    if param_value not in (None, ""):
+                        params[param_name] = int(param_value)
+                return {"type": type_name, **params}
+
+            if isinstance(value, str):
+                data = json.loads(value)
+            else:
+                data = value
+
+            if not isinstance(data, dict):
+                raise ValueError("Not a dict")
+
+            type_name = data.get("type")
+            handler = RelativeTimeTypeRegistry.get(type_name)
+            if not handler:
+                raise ValueError(_("Unknown type"))
+
+            # basic validation: ensure required params exist
+            for param in getattr(handler, "fields", []):
+                if param not in data:
+                    raise ValueError(_("Missing field: {param}").format(param=param))
+
+            return data
+
+        except (json.JSONDecodeError, ValueError, TypeError) as e:
+            raise forms.ValidationError(
+                _("Invalid format: {error}").format(error=e)
+            ) from e
+
+    def prepare_value(self, value):
+        if value is None:
+            return [0] + [None] * len({p for _, h in RelativeTimeTypeRegistry.all() for p in getattr(h, "fields", [])})
+
+        if isinstance(value, list):
+            return value
+
+        if isinstance(value, str):
+            try:
+                value = json.loads(value)
+            except json.JSONDecodeError:
+                return [0] + [None] * len({p for _, h in RelativeTimeTypeRegistry.all() for p in getattr(h, "fields", [])})
+
+        if not isinstance(value, dict):
+            return [0] + [None] * len({p for _, h in RelativeTimeTypeRegistry.all() for p in getattr(h, "fields", [])})
+
+        type_names = [name for name, _ in RelativeTimeTypeRegistry.all()]
+        type_name = value.get("type", "no_expiration")
+        type_index = type_names.index(type_name) if type_name in type_names else 0
+
+        all_param_names = sorted({p for _, h in RelativeTimeTypeRegistry.all() for p in getattr(h, "fields", [])})
+        params = [value.get(p) for p in all_param_names]
+
+        return [type_index] + params