Merge pull request #274 from maykinmedia/issue/#234-unrelated-items

🐛 - #234 - fix unrelated zaaktypen being shown in select on vario…

Author: SilviaAmAm

backend/src/openarchiefbeheer/utils/tests/gherkin.py

@@ -224,7 +224,9 @@ async def handle(route):
             await page.route("**/*/api/v1/_selectielijstklasse-choices/?zaak=*", handle)
 
         async def zaken_are_indexed(self, amount, **kwargs):
-            return await self._get_or_create_batch(ZaakFactory, amount, **kwargs)
+            return await self._get_or_create_batch(
+                ZaakFactory, amount, with_expand=True, **kwargs
+            )
 
         @sync_to_async
         def _orm_get(self, model, **kwargs):
@@ -254,7 +256,14 @@ async def _get_or_create(self, factory, **kwargs):
                 return await self._factory_create(factory, **kwargs)
 
         async def _get_or_create_batch(self, factory, amount, **kwargs):
-            queryset = await self._orm_filter(factory._meta.model, **kwargs)
+            # Remove any traits of the factory
+            orm_params = {
+                key: value
+                for key, value in kwargs.items()
+                if key not in factory._meta.parameters
+            }
+
+            queryset = await self._orm_filter(factory._meta.model, **orm_params)
             if queryset:
                 return queryset
             return await self._factory_create_batch(factory, amount, **kwargs)

backend/src/openarchiefbeheer/zaken/api/serializers.py

@@ -3,7 +3,9 @@
 from rest_framework import serializers
 from rest_framework_gis.fields import GeometryField
 
-from openarchiefbeheer.zaken.models import Zaak
+from openarchiefbeheer.destruction.models import DestructionList, DestructionListReview
+
+from ..models import Zaak
 
 
 class ZaakSerializer(serializers.ModelSerializer):
@@ -86,3 +88,17 @@ class SelectielijstklasseChoicesQueryParamSerializer(serializers.Serializer):
             "The URL of the zaak for which the selectielijstklasse choices are needed."
         )
     )
+
+
+class ZaakTypeChoicesQueryParamSerializer(serializers.Serializer):
+    destruction_list = serializers.SlugRelatedField(
+        slug_field="uuid",
+        required=False,
+        queryset=DestructionList.objects.all().prefetch_related("items__zaak"),
+    )
+    review = serializers.PrimaryKeyRelatedField(
+        required=False,
+        queryset=DestructionListReview.objects.all().prefetch_related(
+            "item_reviews__destruction_list_item__zaak",
+        ),
+    )

backend/src/openarchiefbeheer/zaken/api/views.py

@@ -15,11 +15,17 @@
 
 from ..models import Zaak
 from ..tasks import retrieve_and_cache_zaken_from_openzaak
-from ..utils import retrieve_selectielijstklasse_choices, retrieve_zaaktypen_choices
+from ..utils import (
+    get_zaaktypen_choices_from_list,
+    get_zaaktypen_choices_from_review,
+    retrieve_selectielijstklasse_choices,
+    retrieve_zaaktypen_choices,
+)
 from .serializers import (
     SelectielijstklasseChoicesQueryParamSerializer,
     SelectielijstklasseChoicesSerializer,
     ZaaktypeChoiceSerializer,
+    ZaakTypeChoicesQueryParamSerializer,
 )
 
 
@@ -51,13 +57,25 @@ class ZaaktypenChoicesView(APIView):
             "The response is cached for 15 minutes."
         ),
         tags=["private"],
+        parameters=[ZaakTypeChoicesQueryParamSerializer],
         responses={
             200: ZaaktypeChoiceSerializer,
         },
     )
     @method_decorator(cache_page(60 * 15))
     def get(self, request, *args, **kwargs):
-        zaaktypen_choices = retrieve_zaaktypen_choices()
+        param_serializer = ZaakTypeChoicesQueryParamSerializer(
+            data=request.query_params
+        )
+        param_serializer.is_valid(raise_exception=True)
+
+        if destruction_list := param_serializer.validated_data.get("destruction_list"):
+            zaaktypen_choices = get_zaaktypen_choices_from_list(destruction_list)
+        elif review := param_serializer.validated_data.get("review"):
+            zaaktypen_choices = get_zaaktypen_choices_from_review(review)
+        else:
+            zaaktypen_choices = retrieve_zaaktypen_choices()
+
         serializer = ZaaktypeChoiceSerializer(data=zaaktypen_choices, many=True)
         serializer.is_valid(raise_exception=True)
         return Response(serializer.data, status=status.HTTP_200_OK)

backend/src/openarchiefbeheer/zaken/tests/factories.py

@@ -31,6 +31,7 @@ class Params:
                         "url": "https://selectielijst.nl/api/v1/procestypen/7ff2b005-4d84-47fe-983a-732bfa958ff5",
                     },
                     "omschrijving": "Aangifte behandelen",
+                    "identificatie": "ZAAKTYPE-01",
                 },
                 "resultaat": {
                     "resultaattype": "http://catalogue-api.nl/catalogi/api/v1/resultaattypen/111-111-111",

backend/src/openarchiefbeheer/zaken/tests/test_views.py

@@ -11,6 +11,13 @@
 from zgw_consumers.test.factories import ServiceFactory
 
 from openarchiefbeheer.accounts.tests.factories import UserFactory
+from openarchiefbeheer.destruction.constants import ListItemStatus
+from openarchiefbeheer.destruction.tests.factories import (
+    DestructionListFactory,
+    DestructionListItemFactory,
+    DestructionListItemReviewFactory,
+    DestructionListReviewFactory,
+)
 
 from ..tasks import retrieve_and_cache_zaken_from_openzaak
 from .factories import ZaakFactory
@@ -172,6 +179,187 @@ def test_response_cached(self, m):
         history = m.request_history
         self.assertEqual(len(history), 1)
 
+    def test_retrieve_zaaktypen_choices_for_destruction_list(self):
+        user = UserFactory.create(role__can_start_destruction=True)
+
+        destruction_list = DestructionListFactory.create()
+        # The zaaktypen of these items should be returned,
+        # because they are in the destruction list with status 'suggested'
+        items_in_list = DestructionListItemFactory.create_batch(
+            3,
+            with_zaak=True,
+            zaak__with_expand=True,
+            destruction_list=destruction_list,
+            status=ListItemStatus.suggested,
+        )
+        # We simulate 2 items having different versions of the same zaaktype
+        items_in_list[0].zaak._expand["zaaktype"]["identificatie"] = "ZAAKTYPE-1"
+        items_in_list[0].zaak.save()
+        items_in_list[1].zaak._expand["zaaktype"]["identificatie"] = "ZAAKTYPE-1"
+        items_in_list[1].zaak.save()
+        items_in_list[2].zaak._expand["zaaktype"]["identificatie"] = "ZAAKTYPE-2"
+        items_in_list[2].zaak.save()
+
+        # This zaaktype should NOT be returned because it has status 'removed'
+        DestructionListItemFactory.create(
+            with_zaak=True,
+            destruction_list=destruction_list,
+            status=ListItemStatus.removed,
+        )
+        # These zaaktypen should NOT be returned because it is not related to the list
+        DestructionListItemFactory.create_batch(2, with_zaak=True)
+
+        self.client.force_authenticate(user=user)
+        endpoint = furl(reverse("api:retrieve-zaaktypen-choices"))
+        endpoint.args["destruction_list"] = destruction_list.uuid
+
+        response = self.client.get(endpoint.url)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        choices = sorted(response.json(), key=lambda choice: choice["label"])
+
+        self.assertEqual(len(choices), 2)
+        self.assertEqual(choices[0]["label"], "ZAAKTYPE-1")
+        self.assertEqual(choices[1]["label"], "ZAAKTYPE-2")
+
+        values = choices[0]["value"].split(",")
+
+        self.assertEqual(len(values), 2)
+        self.assertIn(items_in_list[0].zaak.zaaktype, values)
+        self.assertIn(items_in_list[1].zaak.zaaktype, values)
+
+        self.assertEqual(choices[1]["value"], items_in_list[2].zaak.zaaktype)
+
+    @Mocker()
+    def test_not_cached_if_query_param_chages(self, m):
+        user = UserFactory.create(role__can_start_destruction=True)
+
+        destruction_list = DestructionListFactory.create()
+
+        items_in_list = DestructionListItemFactory.create_batch(
+            2,
+            with_zaak=True,
+            zaak__with_expand=True,
+            destruction_list=destruction_list,
+            status=ListItemStatus.suggested,
+        )
+        items_in_list[0].zaak._expand["zaaktype"]["identificatie"] = "ZAAKTYPE-1"
+        items_in_list[0].zaak.save()
+        items_in_list[1].zaak._expand["zaaktype"]["identificatie"] = "ZAAKTYPE-2"
+        items_in_list[1].zaak.save()
+
+        ServiceFactory.create(
+            api_type=APITypes.ztc,
+            api_root="http://catalogi-api.nl/catalogi/api/v1",
+        )
+        ZaakFactory.create(
+            zaaktype="http://catalogi-api.nl/catalogi/api/v1/zaakypen/111-111-111",
+            _expand={"zaaktype": {"identificatie": "ZAAKTYPE-3"}},
+        )
+        ZaakFactory.create(
+            zaaktype="http://catalogi-api.nl/catalogi/api/v1/zaakypen/222-222-222",
+            _expand={"zaaktype": {"identificatie": "ZAAKTYPE-4"}},
+        )
+        ZaakFactory.create(
+            zaaktype="http://catalogi-api.nl/catalogi/api/v1/zaakypen/333-333-333",
+            _expand={"zaaktype": {"identificatie": "ZAAKTYPE-5"}},
+        )
+
+        m.get(
+            "http://catalogi-api.nl/catalogi/api/v1/zaaktypen",
+            json={
+                "count": 2,
+                "results": [
+                    {
+                        "url": "http://catalogi-api.nl/catalogi/api/v1/zaakypen/111-111-111",
+                        "identificatie": "ZAAKTYPE-3",
+                    },
+                    {
+                        "url": "http://catalogi-api.nl/catalogi/api/v1/zaakypen/222-222-222",
+                        "identificatie": "ZAAKTYPE-4",
+                    },
+                    {
+                        "url": "http://catalogi-api.nl/catalogi/api/v1/zaakypen/333-333-333",
+                        "identificatie": "ZAAKTYPE-5",
+                    },
+                ],
+            },
+        )
+
+        self.client.force_authenticate(user=user)
+        endpoint = furl(reverse("api:retrieve-zaaktypen-choices"))
+        endpoint.args["destruction_list"] = destruction_list.uuid
+
+        response = self.client.get(endpoint.url)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(len(response.json()), 2)
+
+        del endpoint.args["destruction_list"]
+        response = self.client.get(endpoint.url)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(len(response.json()), 3)
+
+    def test_retrieve_zaaktypen_choices_for_review(self):
+        user = UserFactory.create(role__can_start_destruction=True)
+
+        review = DestructionListReviewFactory.create()
+        # The zaaktypen of these items should be returned,
+        # because they are in the review
+        review_items = DestructionListItemReviewFactory.create_batch(
+            3,
+            destruction_list_item__with_zaak=True,
+            destruction_list_item__zaak__with_expand=True,
+            destruction_list=review.destruction_list,
+            review=review,
+        )
+        # We simulate 2 items having different versions of the same zaaktype
+        review_items[0].destruction_list_item.zaak._expand["zaaktype"][
+            "identificatie"
+        ] = "ZAAKTYPE-1"
+        review_items[0].destruction_list_item.zaak.save()
+        review_items[1].destruction_list_item.zaak._expand["zaaktype"][
+            "identificatie"
+        ] = "ZAAKTYPE-1"
+        review_items[1].destruction_list_item.zaak.save()
+        review_items[2].destruction_list_item.zaak._expand["zaaktype"][
+            "identificatie"
+        ] = "ZAAKTYPE-2"
+        review_items[2].destruction_list_item.zaak.save()
+
+        # These zaaktypen should NOT be returned because they are not in the review
+        DestructionListItemReviewFactory.create_batch(
+            3,
+            destruction_list_item__with_zaak=True,
+            destruction_list_item__zaak__with_expand=True,
+        )
+
+        self.client.force_authenticate(user=user)
+        endpoint = furl(reverse("api:retrieve-zaaktypen-choices"))
+        endpoint.args["review"] = review.pk
+
+        response = self.client.get(endpoint.url)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        choices = sorted(response.json(), key=lambda choice: choice["label"])
+
+        self.assertEqual(len(choices), 2)
+        self.assertEqual(choices[0]["label"], "ZAAKTYPE-1")
+        self.assertEqual(choices[1]["label"], "ZAAKTYPE-2")
+
+        values = choices[0]["value"].split(",")
+
+        self.assertEqual(len(values), 2)
+        self.assertIn(review_items[0].destruction_list_item.zaak.zaaktype, values)
+        self.assertIn(review_items[1].destruction_list_item.zaak.zaaktype, values)
+
+        self.assertEqual(
+            choices[1]["value"], review_items[2].destruction_list_item.zaak.zaaktype
+        )
+
 
 class SelectielijstklasseChoicesViewTests(APITestCase):
     def setUp(self):

backend/src/openarchiefbeheer/zaken/utils.py

@@ -1,7 +1,7 @@
 import traceback
 from collections import defaultdict
 from functools import lru_cache, partial
-from typing import Callable, Generator, Literal
+from typing import TYPE_CHECKING, Callable, Generator, Literal
 
 from django.conf import settings
 
@@ -18,11 +18,18 @@
 from zgw_consumers.models import Service
 from zgw_consumers.utils import PaginatedResponseData
 
+from openarchiefbeheer.destruction.constants import ListItemStatus
 from openarchiefbeheer.utils.results_store import ResultStore
 
 from .models import Zaak
 from .types import DropDownChoice
 
+if TYPE_CHECKING:
+    from openarchiefbeheer.destruction.models import (
+        DestructionList,
+        DestructionListReview,
+    )
+
 
 def pagination_helper(
     client: APIClient, paginated_response: PaginatedResponseData, **kwargs
@@ -108,6 +115,44 @@ def retrieve_zaaktypen_choices() -> list[DropDownChoice]:
     return sorted(zaaktypen_choices, key=lambda zaaktype: zaaktype["label"])
 
 
+def _get_zaaktype_choices(zaaktypen_to_include: dict[list]) -> list[DropDownChoice]:
+    """Return formatted zaaktype choices
+
+    Takes a dictionary where the key is the identificatie of a zaaktype and
+    the value is a list of all the URLs for the different versions of that zaaktype."""
+    zaaktypen = defaultdict(list)
+    for zaaktype_url, zaaktype_identificatie in zaaktypen_to_include:
+        zaaktypen[zaaktype_identificatie].append(zaaktype_url)
+
+    zaaktypen_choices = [
+        {"label": key, "value": ",".join(value)} for key, value in zaaktypen.items()
+    ]
+    return sorted(zaaktypen_choices, key=lambda zaaktype: zaaktype["label"])
+
+
+def get_zaaktypen_choices_from_list(
+    destruction_list: "DestructionList",
+) -> list[DropDownChoice]:
+    zaaktypen_to_include = (
+        destruction_list.items.filter(status=ListItemStatus.suggested)
+        .distinct("zaak__zaaktype")
+        .values_list("zaak__zaaktype", "zaak___expand__zaaktype__identificatie")
+    )
+    return _get_zaaktype_choices(zaaktypen_to_include)
+
+
+def get_zaaktypen_choices_from_review(
+    review: "DestructionListReview",
+) -> list[DropDownChoice]:
+    zaaktypen_to_include = review.item_reviews.distinct(
+        "destruction_list_item__zaak__zaaktype"
+    ).values_list(
+        "destruction_list_item__zaak__zaaktype",
+        "destruction_list_item__zaak___expand__zaaktype__identificatie",
+    )
+    return _get_zaaktype_choices(zaaktypen_to_include)
+
+
 def format_selectielijstklasse_choice(resultaat: Resultaat) -> DropDownChoice:
     description = f"{resultaat.get('volledig_nummer', resultaat['nummer'])} - {resultaat['naam']} - {resultaat['waardering']}"
     if resultaat.get("bewaartermijn"):