implemented basic filtering via 'fields' query param

Author: calumbell

api_v2/serializers/abstracts.py

@@ -4,32 +4,72 @@
 from api_v2 import models
 
 
-class GameContentSerializer(serializers.HyperlinkedModelSerializer):
+class GameContentSerializer(serializers.HyperlinkedModelSerializer):  
 
-    def remove_unwanted_fields(self, fields_to_keep):
-        fields_to_keep = set(fields_to_keep.split(","))
-        all_fields = set(self.fields.keys())
-        for field in all_fields - fields_to_keep:
-            self.fields.pop(field, None)
-    
+    def remove_unwanted_fields(self, dynamic_params):
+        """
+        Takes the value of the 'fields', a string of comma-seperated values, 
+        and removes all other fields from the serializer
+        """
+        if fields_to_keep := dynamic_params.pop("fields", None):
+            fields_to_keep = set(fields_to_keep.split(","))
+            all_fields = set(self.fields.keys())
+            for field in all_fields - fields_to_keep:
+                self.fields.pop(field, None)
 
-    # Adding dynamic "fields" qs parameter.
-    def __init__(self, *args, **kwargs):
+    def get_or_create_dynamic_params(self, child):
+        """
+        Creates dynamic params on the serializer context if it doesn't already
+        exist, then returns the dynamic parameters
+        """
+        if "dynamic_params" not in self.fields[child]._context:
+            self.fields[child]._context.update({"dynamic_params": {}})
+        return self.fields[child]._context["dynamic_params"]
+
+    @staticmethod
+    def split_param(dynamic_param):
+        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):
+        for param, fields in dynamic_params.items():
+            child, child_dynamic_param = self.split_param(param)
+            if child in set(self.fields.keys()):
+                dynamic_params = self.get_or_create_dynamic_params(child)
+                dynamic_params.update({child_dynamic_param: fields})
+
+    @staticmethod
+    def is_param_dynamic(p):
+        """
+        Currently only the 'fields' query param is supported
+        """
+        return p.endswith("fields")
+
+    def get_dynamic_params_for_root(self, request):
+        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 __init__(self, *args, **kwargs):
         request = kwargs.get("context", {}).get("request")
-        # Instantiate the superclass normally
-        super(GameContentSerializer, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
-        # request only exists on root, not on nested queries or when generating OAS file
+        # "request" doesn't exist on the child serializers, or when generating OAS spec
         is_root = bool(request)
-
         if is_root:
-            fields = request.query_params.get('fields')
-            if fields:
-                self.remove_unwanted_fields(fields)
+            if request.method != "GET":
+                return
 
-            depth = request.query_params.get('depth')
-            if depth:
+            if depth:= request.query_params.get('depth'):
                 try:
                     depth_value = int(depth)
                     if depth_value > 0 and depth_value < 3:
@@ -44,5 +84,16 @@ def __init__(self, *args, **kwargs):
             else:
                 self.Meta.depth = 0 #The default.
 
+            # 
+            dynamic_params = self.get_dynamic_params_for_root(request)
+            self._context.update({"dynamic_params": dynamic_params})
+    
+    def to_representation(self, *args, **kwargs):
+        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)
+
     class Meta:
-        abstract = True
+        abstract = True

api_v2/serializers/alignment.py

@@ -5,13 +5,15 @@
 from api_v2 import models
 
 from .abstracts import GameContentSerializer
+from .document import DocumentSerializer
 
 class AlignmentSerializer(GameContentSerializer):
     key = serializers.ReadOnlyField()
     morality = serializers.ReadOnlyField()
     societal_attitude = serializers.ReadOnlyField()
     short_name = serializers.ReadOnlyField()
-
+    document = DocumentSerializer()
+    
     class Meta:
         model = models.Alignment
         fields = '__all__'

api_v2/serializers/background.py

@@ -5,6 +5,7 @@
 from api_v2 import models
 
 from .abstracts import GameContentSerializer
+from .document import DocumentSerializer
 
 class BackgroundBenefitSerializer(serializers.ModelSerializer):
     class Meta:
@@ -17,6 +18,7 @@ class BackgroundSerializer(GameContentSerializer):
     benefits = BackgroundBenefitSerializer(
         many=True
     )
+    document = DocumentSerializer()
 
     class Meta:
         model = models.Background

api_v2/serializers/characterclass.py

@@ -5,13 +5,14 @@
 from api_v2 import models
 
 from .abstracts import GameContentSerializer
+from .document import DocumentSerializer
 
-class ClassFeatureItemSerializer(serializers.ModelSerializer):
+class ClassFeatureItemSerializer(GameContentSerializer):
     class Meta:
         model = models.ClassFeatureItem
         fields = ['name','desc','type']
 
-class ClassFeatureSerializer(serializers.ModelSerializer):
+class ClassFeatureSerializer(GameContentSerializer):
     key = serializers.ReadOnlyField()
 
     class Meta:
@@ -24,6 +25,7 @@ class CharacterClassSerializer(GameContentSerializer):
         many=True, context={'request': {}})
     levels = serializers.ReadOnlyField()
     hit_points = serializers.ReadOnlyField()
+    document = DocumentSerializer()
 
     class Meta:
         model = models.CharacterClass

api_v2/serializers/condition.py

@@ -5,9 +5,11 @@
 from api_v2 import models
 
 from .abstracts import GameContentSerializer
+from .document import DocumentSerializer
 
 class ConditionSerializer(GameContentSerializer):
     key = serializers.ReadOnlyField()
+    document = DocumentSerializer()
 
     class Meta:
         model = models.Condition

api_v2/serializers/creature.py

@@ -7,6 +7,7 @@
 from api_v2 import models
 
 from .abstracts import GameContentSerializer
+from .document import DocumentSerializer
 from .size import SizeSerializer
 from drf_spectacular.utils import extend_schema_field, inline_serializer
 from drf_spectacular.types import OpenApiTypes
@@ -59,7 +60,7 @@ class CreatureSerializer(GameContentSerializer):
     speed_all = serializers.SerializerMethodField()
     challenge_rating_text = serializers.SerializerMethodField()
     experience_points = serializers.SerializerMethodField()
-
+    document = DocumentSerializer()
 
     class Meta:
         '''Serializer meta options.'''

api_v2/serializers/document.py

@@ -4,23 +4,23 @@
 
 from api_v2 import models
 
-class GameSystemSerializer(serializers.HyperlinkedModelSerializer):
+class GameSystemSerializer(GameContentSerializer):
     key = serializers.ReadOnlyField()
 
     class Meta:
         model = models.GameSystem
         fields = '__all__'
 
 
-class LicenseSerializer(serializers.HyperlinkedModelSerializer):
+class LicenseSerializer(GameContentSerializer):
     key = serializers.ReadOnlyField()
 
     class Meta:
         model = models.License
         fields = '__all__'
 
 
-class PublisherSerializer(serializers.HyperlinkedModelSerializer):
+class PublisherSerializer(GameContentSerializer):
     key = serializers.ReadOnlyField()
 
     class Meta:
@@ -30,6 +30,9 @@ class Meta:
 
 class DocumentSerializer(GameContentSerializer):
     key = serializers.ReadOnlyField()
+    licenses = LicenseSerializer(many=True)
+    publisher = PublisherSerializer()
+    gamesystem = GameSystemSerializer()
 
     class Meta:
         model = models.Document

api_v2/serializers/feat.py

@@ -5,6 +5,7 @@
 from api_v2 import models
 
 from .abstracts import GameContentSerializer
+from .document import DocumentSerializer
 
 class FeatBenefitSerializer(serializers.ModelSerializer):
     class Meta:
@@ -16,6 +17,7 @@ class FeatSerializer(GameContentSerializer):
     has_prerequisite = serializers.ReadOnlyField()
     benefits = FeatBenefitSerializer(
         many=True)
+    document = DocumentSerializer()
 
     class Meta:
         model = models.Feat

api_v2/serializers/item.py

@@ -6,6 +6,7 @@
 
 from .abstracts import GameContentSerializer
 from .size import SizeSerializer
+from .document import DocumentSerializer
 from drf_spectacular.utils import extend_schema_field
 from drf_spectacular.types import OpenApiTypes
 
@@ -52,6 +53,7 @@ class ItemSerializer(GameContentSerializer):
     is_magic_item = serializers.ReadOnlyField()
     weapon = WeaponSerializer(read_only=True, context={'request':{}})
     armor = ArmorSerializer(read_only=True, context={'request':{}})
+    document = DocumentSerializer()
 
     class Meta:
         model = models.Item

api_v2/serializers/language.py

@@ -5,10 +5,11 @@
 from api_v2 import models
 
 from .abstracts import GameContentSerializer
+from .document import DocumentSerializer
 
-class LanguageSerializer(serializers.ModelSerializer):
+class LanguageSerializer(GameContentSerializer):
     key = serializers.ReadOnlyField()
-    
+    document = DocumentSerializer()
     class Meta:
         model = models.Language
         fields = '__all__'