reimplemented depth logic to abstract serializer

Author: calumbell

api_v2/serializers/abstracts.py

@@ -3,12 +3,11 @@
 
 from api_v2 import models
 
-
 class GameContentSerializer(serializers.HyperlinkedModelSerializer):  
 
     def remove_unwanted_fields(self, dynamic_params):
         """
-        Takes the value of the 'fields', a string of comma-seperated values, 
+        Takes the value of the 'fields', a string of comma-separated values, 
         and removes all other fields from the serializer
         """
         if fields_to_keep := dynamic_params.pop("fields", None):
@@ -28,24 +27,12 @@ def get_or_create_dynamic_params(self, child):
 
     @staticmethod
     def split_param(dynamic_param):
-        """
-        Splits a dynamic parameter into a key value pair. The key is used to
-        index into the serializers context to pass nested parameters
-
-        document__fields=name -> ['document', 'fields=name']
-        document__licenses__fields=name -> ['document', 'licenses__fields=name']
-
-        '__'s after the first are preserved so that the dynamic parameter can 
-        be passed recursively down to more deeply-nested serializers
-        """
         crumbs = dynamic_param.split("__")
         return crumbs[0], "__".join(crumbs[1:]) if len(crumbs) > 1 else None
 
     def set_dynamic_params_for_children(self, dynamic_params):
         """
-        Passes nested dynamic params to child serializer. ie. 
-        "document__fields=name" would pass the query param "fields=name" to the
-        nested Document Serializer via the 'context' prop
+        Passes nested dynamic params to child serializer.
         """
         for param, fields in dynamic_params.items():
             child, child_dynamic_param = self.split_param(param)
@@ -55,68 +42,54 @@ def set_dynamic_params_for_children(self, dynamic_params):
 
     @staticmethod
     def is_param_dynamic(p):
-        """
-        Only the 'fields' query param supported, so we test for that
-        """
         return p.endswith("fields")
 
     def get_dynamic_params_for_root(self, request):
-        """
-        Checks query params in request and returns dynamic parameters
-        """
         query_params = request.query_params.items()
         return {k: v for k, v in query_params if self.is_param_dynamic(k)}
 
     def get_dynamic_params(self):
-        """
-        When dynamic params get passed down in set_context_for_children
-        If the child is a subclass of ListSerializer (has many=True)
-        The context must be fetched from ListSerializer Class
-        """
         if isinstance(self.parent, serializers.ListSerializer):
             return self.parent._context.get("dynamic_params", {})
         return self._context.get("dynamic_params", {})
 
-    def set_depth(self, depth):
-        """
-        Add appropriate 'depth' param to self.Meta based on 'depth' query param
-        """
-        if not depth:
-            self.Meta.depth = 0
-            return
-        try:
-            depth = int(depth)
-            if depth > 0 and depth < 3:
-                # This value going above 1 could cause performance issues.
-                # Limited to 1 and 2 for now.
-                self.Meta.depth = depth
-            # Depth does not reset by default on subsequent requests with malformed urls.
-            else:
-                self.Meta.depth = 0
-        except ValueError:
-            pass  # it was not castable to an int.
-
-
     def __init__(self, *args, **kwargs):
         request = kwargs.get("context", {}).get("request")
         super().__init__(*args, **kwargs)
 
-
-        # "request" doesn't exist on the child serializers, or when generating OAS spec
-        # So this if only evaluates as true on the root serializer
-
-        is_root = bool(request)
-        if is_root:
-            self.set_depth(request.query_params.get('depth'))
+        if request:
+            self._context["max_depth"] = int(request.query_params.get("depth", 0))
             dynamic_params = self.get_dynamic_params_for_root(request)
             self._context.update({"dynamic_params": dynamic_params})
-    
-    def to_representation(self, *args, **kwargs):
+
+    def to_representation(self, instance):
+        max_depth = self._context.get("max_depth", 0)
+        current_depth = self._context.get("current_depth", 0)
+
+        # Process dynamic parameters for filtering fields
         if dynamic_params := self.get_dynamic_params().copy():
             self.remove_unwanted_fields(dynamic_params)
             self.set_dynamic_params_for_children(dynamic_params)
 
-        return super().to_representation(*args, **kwargs)
+        # Collect only the fields that need to be included in the representation
+        representation = super().to_representation(instance)
+
+        if current_depth >= max_depth:
+            # Remove fields that are HyperlinkedModelSerializers (nested fields)
+            for field_name, field in self.fields.items():
+                if isinstance(field, serializers.HyperlinkedModelSerializer):
+                    # Check if the nested field has a 'url' attribute in the representation
+                    nested_representation = representation.get(field_name)
+                    if nested_representation and "url" in nested_representation:
+                        # Replace the entire nested structure with the URL field
+                        representation[field_name] = nested_representation["url"]
+        else:
+            # Update depth level in children
+            for field_name, field in self.fields.items():
+                if isinstance(field, GameContentSerializer):
+                    field._context["current_depth"] = current_depth + 1
+
+        return representation
 
     class Meta:
         abstract = True