Add expandable backoffice_assets and datacenter_assets fields to Supports API (#3921)

Author: awieckowski

src/ralph/supports/api.py

@@ -1,15 +1,20 @@
 # -*- coding: utf-8 -*-
 import django_filters
+from django.contrib.contenttypes.models import ContentType
 from django.db.models import Prefetch
 from rest_framework import serializers
 
+from django.urls import reverse
+
 from ralph.api import RalphAPISerializer, RalphAPIViewSet, router
 from ralph.assets.api.serializers import (
     ServiceEnvironmentSimpleSerializer,
     StrField,
     TypeFromContentTypeSerializerMixin,
 )
 from ralph.assets.models import BaseObject
+from ralph.back_office.models import BackOfficeAsset
+from ralph.data_center.models import DataCenterAsset
 from ralph.lib.permissions.api import PermissionsForObjectFilter
 from ralph.lib.visibility_scope.filters import visibility_scope_asset_support_filter
 from ralph.supports.models import BaseObjectsSupport, Support, SupportType
@@ -44,18 +49,118 @@ class Meta:
         _skip_tags_field = True
 
 
+class BackOfficeAssetForSupportSerializer(RalphAPISerializer):
+    id = serializers.IntegerField(source="pk")
+    model = serializers.CharField(source="model.name", read_only=True)
+    manufacturer = serializers.CharField(source="model.manufacturer.name", read_only=True)
+    category = serializers.CharField(source="model.category.name", read_only=True)
+    service_env = ServiceEnvironmentSimpleSerializer(read_only=True)
+    property_of = serializers.CharField(source="property_of.name", read_only=True)
+    status = serializers.CharField(source="get_status_display", read_only=True)
+
+    class Meta:
+        model = BackOfficeAsset
+        exclude_from_registry = True
+        fields = [
+            "id",
+            "barcode",
+            "sn",
+            "hostname",
+            "model",
+            "manufacturer",
+            "category",
+            "status",
+            "service_env",
+            "property_of",
+            "order_no",
+        ]
+        _skip_tags_field = True
+
+
+class DataCenterAssetForSupportSerializer(RalphAPISerializer):
+    id = serializers.IntegerField(source="pk")
+    model = serializers.CharField(source="model.name", read_only=True)
+    manufacturer = serializers.CharField(source="model.manufacturer.name", read_only=True)
+    category = serializers.CharField(source="model.category.name", read_only=True)
+    service_env = ServiceEnvironmentSimpleSerializer(read_only=True)
+    property_of = serializers.CharField(source="property_of.name", read_only=True)
+    status = serializers.CharField(source="get_status_display", read_only=True)
+
+    class Meta:
+        model = DataCenterAsset
+        exclude_from_registry = True
+        fields = [
+            "id",
+            "barcode",
+            "sn",
+            "hostname",
+            "model",
+            "manufacturer",
+            "category",
+            "status",
+            "service_env",
+            "property_of",
+            "order_no",
+        ]
+        _skip_tags_field = True
+
+
 class SupportSerializer(TypeFromContentTypeSerializerMixin, RalphAPISerializer):
     __str__ = StrField(show_type=True)
-    base_objects = serializers.HyperlinkedRelatedField(
-        many=True, view_name="baseobject-detail", read_only=True
-    )
+    base_objects = serializers.SerializerMethodField()
     service_env = ServiceEnvironmentSimpleSerializer()
+    backoffice_assets = serializers.SerializerMethodField()
+    datacenter_assets = serializers.SerializerMethodField()
+
+    def get_base_objects(self, obj):
+        request = self.context.get('request')
+        base_objects = [bos.baseobject for bos in obj.baseobjectssupport_set.all()]
+        return [
+            request.build_absolute_uri(
+                reverse('baseobject-detail', kwargs={'pk': bo.pk})
+            )
+            for bo in base_objects
+        ]
 
     class Meta:
         model = Support
         depth = 1
         exclude = ("content_type", "configuration_path")
 
+    def get_fields(self):
+        fields = super().get_fields()
+        request = self.context.get('request')
+        if request and not request.query_params.get('include_assets'):
+            fields.pop('backoffice_assets', None)
+            fields.pop('datacenter_assets', None)
+        return fields
+
+    def get_backoffice_assets(self, obj):
+        request = self.context.get('request')
+        if not request or not request.query_params.get('include_assets'):
+            return []
+
+        backoffice_ct_id = ContentType.objects.get_for_model(BackOfficeAsset).id
+
+        backoffice_assets = [
+            bos.baseobject for bos in obj.baseobjectssupport_set.all()
+            if bos.baseobject.content_type_id == backoffice_ct_id
+        ]
+        return BackOfficeAssetForSupportSerializer(backoffice_assets, many=True).data
+
+    def get_datacenter_assets(self, obj):
+        request = self.context.get('request')
+        if not request or not request.query_params.get('include_assets'):
+            return []
+
+        datacenter_ct_id = ContentType.objects.get_for_model(DataCenterAsset).id
+
+        datacenter_assets = [
+            bos.baseobject for bos in obj.baseobjectssupport_set.all()
+            if bos.baseobject.content_type_id == datacenter_ct_id
+        ]
+        return DataCenterAssetForSupportSerializer(datacenter_assets, many=True).data
+
 
 class BaseObjectsFilter(django_filters.FilterSet):
     """
@@ -91,6 +196,7 @@ class SupportViewSet(RalphAPIViewSet):
     )
     filterset_class = BaseObjectsFilter
     select_related = [
+        "content_type",
         "region",
         "budget_info",
         "support_type",
@@ -101,9 +207,48 @@ class SupportViewSet(RalphAPIViewSet):
     ]
     prefetch_related = [
         "tags",
-        Prefetch("base_objects", queryset=BaseObject.objects.all()),
     ]
 
+    def get_queryset(self):
+        queryset = super().get_queryset()
+
+        if self.request.query_params.get("include_assets"):
+            queryset = queryset.prefetch_related(
+                Prefetch(
+                    "baseobjectssupport_set__baseobject",
+                    queryset=BaseObject.polymorphic_objects.select_related(
+                        "content_type"
+                    ).polymorphic_select_related(
+                        BackOfficeAsset=[
+                            "model",
+                            "model__manufacturer",
+                            "model__category",
+                            "service_env",
+                            "service_env__service",
+                            "service_env__environment",
+                            "property_of",
+                        ],
+                        DataCenterAsset=[
+                            "model",
+                            "model__manufacturer",
+                            "model__category",
+                            "service_env",
+                            "service_env__service",
+                            "service_env__environment",
+                            "property_of",
+                        ],
+                    ),
+                )
+            )
+        else:
+            queryset = queryset.prefetch_related(
+                Prefetch(
+                    "baseobjectssupport_set__baseobject",
+                    queryset=BaseObject.polymorphic_objects.all(),
+                )
+            )
+        return queryset
+
 
 class BaseObjectsSupportSerializer(RalphAPISerializer):
     support = SupportSimpleSerializer()

src/ralph/supports/tests/test_api.py

@@ -8,7 +8,11 @@
 from ralph.api.tests._base import RalphAPITestCase
 from ralph.assets.tests.factories import ServiceEnvironmentFactory
 from ralph.supports.models import Support, SupportStatus
-from ralph.supports.tests.factories import SupportFactory
+from ralph.supports.tests.factories import (
+    BackOfficeAssetSupportFactory,
+    DataCenterAssetSupportFactory,
+    SupportFactory,
+)
 
 
 class SupportAPITests(RalphAPITestCase):
@@ -74,3 +78,64 @@ def test_patch_support(self):
         self.assertEqual(self.support.name, "support2")
         self.assertEqual(self.support.contract_id, "12345")
         self.assertEqual(self.support.date_to, date(2015, 12, 31))
+
+    def test_support_with_include_assets(self):
+        support1 = SupportFactory(name="support_with_assets_1")
+        support2 = SupportFactory(name="support_with_assets_2")
+        support3 = SupportFactory(name="support_with_assets_3")
+
+        BackOfficeAssetSupportFactory.create_batch(3, support=support1)
+        BackOfficeAssetSupportFactory.create_batch(2, support=support2)
+
+        DataCenterAssetSupportFactory.create_batch(2, support=support1)
+        DataCenterAssetSupportFactory.create_batch(3, support=support3)
+
+        # Mix of both base_object types for one support
+        BackOfficeAssetSupportFactory.create_batch(2, support=support3)
+
+        support4 = SupportFactory(name="support_with_assets_4")
+        BackOfficeAssetSupportFactory.create_batch(3, support=support4)
+        DataCenterAssetSupportFactory.create_batch(3, support=support4)
+        SupportFactory.create_batch(10)
+
+        url = reverse("support-list")
+
+        with self.assertQueriesMoreOrLess(7, plus_minus=2):
+            response = self.client.get(
+                url, {"include_assets": "true"}, format="json"
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data["count"], 15)  # 4 with assets + 10 without + 1 from setUp
+
+        for result in response.data["results"]:
+            if result["name"] == "support_with_assets_1":
+                self.assertEqual(len(result["backoffice_assets"]), 3)
+                self.assertEqual(len(result["datacenter_assets"]), 2)
+                self.assertIn("model", result["backoffice_assets"][0])
+                self.assertIn("manufacturer", result["backoffice_assets"][0])
+                self.assertIn("service_env", result["backoffice_assets"][0])
+            elif result["name"] == "support_with_assets_2":
+                self.assertEqual(len(result["backoffice_assets"]), 2)
+                self.assertEqual(len(result["datacenter_assets"]), 0)
+            elif result["name"] == "support_with_assets_3":
+                self.assertEqual(len(result["backoffice_assets"]), 2)
+                self.assertEqual(len(result["datacenter_assets"]), 3)
+
+    def test_support_without_include_assets_parameter(self):
+        support = SupportFactory(name="support_minimal")
+        BackOfficeAssetSupportFactory.create_batch(2, support=support)
+        DataCenterAssetSupportFactory.create_batch(2, support=support)
+
+        url = reverse("support-detail", args=(support.id,))
+        with self.assertQueriesMoreOrLess(6, plus_minus=2):
+            response = self.client.get(url, format="json")
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data["name"], "support_minimal")
+
+        self.assertIn("base_objects", response.data)
+        self.assertEqual(len(response.data["base_objects"]), 4)
+
+        self.assertNotIn("backoffice_assets", response.data)
+        self.assertNotIn("datacenter_assets", response.data)