Include parameter now supports paths

Author: jsenecal

rest_framework_json_api/serializers.py

@@ -65,19 +65,37 @@ def __init__(self, *args, **kwargs):
         request = context.get('request') if context else None
         view = context.get('view') if context else None
 
+        def validate_path(serializer_class, field_path, serializers, path):
+            serializers = {
+                key: serializer_class if serializer == 'self' else serializer
+                for key, serializer in serializers.items()
+                } if serializers else dict()
+            if serializers is None:
+                raise ParseError('This endpoint does not support the include parameter')
+            this_field_name = field_path[0]
+            this_included_serializer = serializers.get(this_field_name)
+            if this_included_serializer is None:
+                raise ParseError(
+                    'This endpoint does not support the include parameter for path {}'.format(
+                        path
+                    )
+                )
+            if len(field_path) > 1:
+                new_included_field_path = field_path[-1:]
+                # We go down one level in the path
+                validate_path(this_included_serializer, new_included_field_path, serializers, path)
+
         if request and view:
             include_resources_param = request.query_params.get('include') if request else None
             if include_resources_param:
                 included_resources = include_resources_param.split(',')
                 for included_field_name in included_resources:
-                    if not hasattr(view, 'included_serializers'):
-                        raise ParseError('This endpoint does not support the include parameter')
-                    if view.included_serializers.get(included_field_name) is None:
-                        raise ParseError(
-                            'This endpoint does not support the include parameter for field {}'.format(
-                                included_field_name
-                            )
-                        )
+                    included_field_path = included_field_name.split('.')
+                    this_serializer_class = view.serializer_class
+                    included_serializers = getattr(this_serializer_class, 'included_serializers', None)
+                    # lets validate the current path
+                    validate_path(this_serializer_class, included_field_path, included_serializers, included_field_name)
+
         super(IncludedResourcesValidationMixin, self).__init__(*args, **kwargs)
 
 
@@ -115,4 +133,4 @@ class ModelSerializer(IncludedResourcesValidationMixin, SparseFieldsetsMixin, Mo
     Included Mixins:
     * A mixin class to enable sparse fieldsets is included
     * A mixin class to enable validation of included resources is included
-    """
+    """

rest_framework_json_api/utils.py

@@ -5,12 +5,11 @@
 from django.conf import settings
 from django.utils import six, encoding
 from django.utils.translation import ugettext_lazy as _
-import re
 from rest_framework.serializers import BaseSerializer, ListSerializer, ModelSerializer
 from rest_framework.relations import RelatedField, HyperlinkedRelatedField, PrimaryKeyRelatedField, \
     HyperlinkedIdentityField
 from rest_framework.settings import api_settings
-from rest_framework.exceptions import APIException, ParseError
+from rest_framework.exceptions import APIException
 
 try:
     from rest_framework.compat import OrderedDict
@@ -190,7 +189,6 @@ def get_related_resource_type(relation):
 
 
 def get_instance_or_manager_resource_type(resource_instance_or_manager):
-
     if hasattr(resource_instance_or_manager, 'model'):
         return get_resource_type_from_manager(resource_instance_or_manager)
     if hasattr(resource_instance_or_manager, '_meta'):
@@ -398,14 +396,14 @@ def extract_relationships(fields, resource, resource_instance):
 def extract_included(fields, resource, resource_instance, included_resources):
     included_data = list()
 
-    context = fields.serializer.context
-    included_serializers = getattr(context['view'], 'included_serializers', None)
+    current_serializer = fields.serializer
+    context = current_serializer.context
+    included_serializers = getattr(fields.serializer, 'included_serializers', None)
 
-    for resource_name in included_resources:
-        # we do not support inclusion of resources in a path
-        match = re.search(r'\.', resource_name)
-        if match is not None:
-            raise ParseError('This endpoint does not support inclusion of resources from a path')
+    included_serializers = {
+        key: current_serializer.__class__ if serializer == 'self' else serializer
+        for key, serializer in included_serializers.items()
+        } if included_serializers else dict()
 
     for field_name, field in six.iteritems(fields):
         # Skip URL field
@@ -416,13 +414,15 @@ def extract_included(fields, resource, resource_instance, included_resources):
         if not isinstance(field, (RelatedField, ManyRelatedField, BaseSerializer)):
             continue
 
-        # Skip fields not in requested included resources
-        if field_name not in included_resources:
+        try:
+            included_resources.remove(field_name)
+            relation_instance_or_manager = getattr(resource_instance, field_name)
+            serializer_data = resource.get(field_name)
+            new_included_resources = [key.replace('%s.' % field_name, '', 1) for key in included_resources]
+        except ValueError:
+            # Skip fields not in requested included resources
             continue
 
-        relation_instance_or_manager = getattr(resource_instance, field_name)
-        serializer_data = resource.get(field_name)
-
         if isinstance(field, ManyRelatedField):
             serializer_class = included_serializers.get(field_name)
             field = serializer_class(relation_instance_or_manager.all(), many=True, context=context)
@@ -450,6 +450,11 @@ def extract_included(fields, resource, resource_instance, included_resources):
                             serializer_fields, serializer_resource, nested_resource_instance, relation_type
                         )
                     )
+                    included_data.extend(
+                        extract_included(
+                            serializer_fields, serializer_resource, nested_resource_instance, new_included_resources
+                        )
+                    )
 
         if isinstance(field, ModelSerializer):
             model = field.Meta.model
@@ -459,7 +464,13 @@ def extract_included(fields, resource, resource_instance, included_resources):
             serializer_fields = get_serializer_fields(field)
             if serializer_data:
                 included_data.append(
-                    build_json_resource_obj(serializer_fields, serializer_data, relation_instance_or_manager, relation_type)
+                    build_json_resource_obj(serializer_fields, serializer_data, relation_instance_or_manager,
+                                            relation_type)
+                )
+                included_data.extend(
+                    extract_included(
+                        serializer_fields, serializer_data, relation_instance_or_manager, new_included_resources
+                    )
                 )
 
     return format_keys(included_data)