ServiceSerializer: ajour champ average_orientation_response_delay_days

Author: ggounot

back/dora/emplois/serializers.py

@@ -1,8 +1,11 @@
 import itertools
 
 from django.core.files.storage import default_storage
+from django.db.models import Avg, DurationField, F
+from django.db.models.expressions import ExpressionWrapper
 from rest_framework import serializers
 
+from dora.orientations.models import Orientation, OrientationStatus
 from dora.services.models import Service
 
 COACH_ORIENTATION_MODES_ORDER = {
@@ -40,6 +43,7 @@ class ServiceSerializer(serializers.ModelSerializer):
     kinds = serializers.SerializerMethodField()
     is_orientable_with_dora_form = serializers.SerializerMethodField()
     is_contact_info_public = serializers.BooleanField(read_only=True)
+    average_orientation_response_delay_days = serializers.SerializerMethodField()
 
     class Meta:
         model = Service
@@ -60,6 +64,7 @@ class Meta:
             "kinds",
             "is_orientable_with_dora_form",
             "is_contact_info_public",
+            "average_orientation_response_delay_days",
         ]
 
     def get_id(self, obj):
@@ -173,3 +178,31 @@ def get_is_orientable_with_dora_form(self, obj):
             mode.value == "formulaire-dora"
             for mode in obj.coach_orientation_modes.all()
         )
+
+    def get_average_orientation_response_delay_days(self, obj):
+        """Délai moyen de réponse aux demandes d'orientation, en jours."""
+        prefetched = getattr(obj, "_prefetched_objects_cache", {}).get("orientations")
+        if prefetched is not None:
+            delays = [(o.processing_date - o.creation_date).days for o in prefetched]
+            return round(sum(delays) / len(delays)) if delays else None
+        result = (
+            Orientation.objects.filter(
+                service=obj,
+                status__in=[
+                    OrientationStatus.ACCEPTED,
+                    OrientationStatus.REJECTED,
+                ],
+                processing_date__isnull=False,
+            )
+            .annotate(
+                delay=ExpressionWrapper(
+                    F("processing_date") - F("creation_date"),
+                    output_field=DurationField(),
+                ),
+            )
+            .aggregate(avg_delay=Avg("delay"))
+        )
+        avg_delay = result["avg_delay"]
+        if avg_delay is None:
+            return None
+        return round(avg_delay.total_seconds() / 86400)

back/dora/emplois/tests/test_serializers.py

@@ -1,10 +1,14 @@
+from datetime import timedelta
+
 import pytest
 from data_inclusion.schema.v1.publics import Public as DiPublic
+from django.utils import timezone
 from model_bakery import baker
 
-from dora.core.test_utils import make_published_service
+from dora.core.test_utils import make_orientation, make_published_service
 from dora.emplois.serializers import ServiceSerializer
 from dora.emplois.views import PREFETCH_RELATED_SERVICE_LIST
+from dora.orientations.models import OrientationStatus
 from dora.services.models import (
     AccessCondition,
     BeneficiaryAccessMode,
@@ -415,6 +419,99 @@ def test_service_serializer_is_orientable_with_dora_form_when_ft_whitelisted(
     assert data["is_orientable_with_dora_form"] is True
 
 
+def test_average_orientation_response_delay_days_none_when_no_orientations():
+    service = make_published_service()
+    data = ServiceSerializer(service).data
+    assert data["average_orientation_response_delay_days"] is None
+
+
+def test_average_orientation_response_delay_days_none_when_only_pending_orientations():
+    service = make_published_service()
+    now = timezone.now()
+    make_orientation(
+        service=service,
+        status=OrientationStatus.PENDING,
+        creation_date=now - timedelta(days=5),
+        processing_date=None,
+    )
+    data = ServiceSerializer(service).data
+    assert data["average_orientation_response_delay_days"] is None
+
+
+def test_average_orientation_response_delay_days_single_orientation():
+    service = make_published_service()
+    creation = timezone.now() - timedelta(days=10)
+    processing = creation + timedelta(days=3)
+    make_orientation(
+        service=service,
+        status=OrientationStatus.ACCEPTED,
+        creation_date=creation,
+        processing_date=processing,
+    )
+    data = ServiceSerializer(service).data
+    assert data["average_orientation_response_delay_days"] == 3
+
+
+def test_average_orientation_response_delay_days_average_of_multiple_orientations():
+    service = make_published_service()
+    base = timezone.now() - timedelta(days=30)
+    make_orientation(
+        service=service,
+        status=OrientationStatus.ACCEPTED,
+        creation_date=base,
+        processing_date=base + timedelta(days=2),
+    )
+    make_orientation(
+        service=service,
+        status=OrientationStatus.REJECTED,
+        creation_date=base - timedelta(days=10),
+        processing_date=base - timedelta(days=10) + timedelta(days=4),
+    )
+    data = ServiceSerializer(service).data
+    # (2 + 4) / 2 = 3
+    assert data["average_orientation_response_delay_days"] == 3
+
+
+def test_average_orientation_response_delay_days_rounds_to_nearest_integer():
+    service = make_published_service()
+    base = timezone.now() - timedelta(days=20)
+    make_orientation(
+        service=service,
+        status=OrientationStatus.ACCEPTED,
+        creation_date=base,
+        processing_date=base + timedelta(days=1),
+    )
+    make_orientation(
+        service=service,
+        status=OrientationStatus.ACCEPTED,
+        creation_date=base - timedelta(days=5),
+        processing_date=base - timedelta(days=5) + timedelta(days=2),
+    )
+    data = ServiceSerializer(service).data
+    # (1 + 2) / 2 = 1.5 -> round to 2
+    assert data["average_orientation_response_delay_days"] == 2
+
+
+def test_average_orientation_response_delay_days_only_counts_this_service():
+    service = make_published_service()
+    other_service = make_published_service()
+    creation = timezone.now() - timedelta(days=10)
+    make_orientation(
+        service=service,
+        status=OrientationStatus.ACCEPTED,
+        creation_date=creation,
+        processing_date=creation + timedelta(days=2),
+    )
+    make_orientation(
+        service=other_service,
+        status=OrientationStatus.ACCEPTED,
+        creation_date=creation,
+        processing_date=creation + timedelta(days=10),
+    )
+    data = ServiceSerializer(service).data
+    assert data["average_orientation_response_delay_days"] == 2
+
+
 def test_service_serializer_does_not_add_queries_when_relations_prefetched(
     django_assert_max_num_queries,
 ):

back/dora/emplois/views.py

@@ -1,13 +1,20 @@
 from django.conf import settings
+from django.db.models import Prefetch
 from rest_framework import permissions, viewsets
 from rest_framework.renderers import JSONRenderer
 from rest_framework.versioning import NamespaceVersioning
 
 from dora.core.pagination import OptionalPageNumberPagination
+from dora.orientations.models import Orientation, OrientationStatus
 from dora.services.models import Service
 
 from .serializers import ServiceSerializer
 
+_ANSWERED_ORIENTATIONS_QUERYSET = Orientation.objects.filter(
+    status__in=[OrientationStatus.ACCEPTED, OrientationStatus.REJECTED],
+    processing_date__isnull=False,
+).only("creation_date", "processing_date")
+
 PREFETCH_RELATED_SERVICE_LIST = [
     "publics",
     "access_conditions",
@@ -18,6 +25,7 @@
     "coach_orientation_modes",
     "orientable_ft_services",
     "beneficiaries_access_modes",
+    Prefetch("orientations", queryset=_ANSWERED_ORIENTATIONS_QUERYSET),
 ]