Merge pull request #146 from django-json-api/feature/dynamic-related-data

Added a way to relate data dynamically similar to SerializerMethodField

Author: jsenecal

example/serializers.py

@@ -11,17 +11,31 @@ class Meta:
 
 class EntrySerializer(serializers.ModelSerializer):
 
+    def __init__(self, *args, **kwargs):
+        # to make testing more concise we'll only output the
+        # `suggested` field when it's requested via `include`
+        request = kwargs.get('context', {}).get('request')
+        if request and 'suggested' not in request.query_params.get('include', []):
+            self.fields.pop('suggested')
+        super(EntrySerializer, self).__init__(*args, **kwargs)
+
     included_serializers = {
         'comments': 'example.serializers.CommentSerializer',
+        'suggested': 'example.serializers.EntrySerializer',
     }
 
     comments = relations.ResourceRelatedField(
             source='comment_set', many=True, read_only=True)
+    suggested = relations.ResourceRelatedField(
+            source='get_suggested', model=Entry, read_only=True)
+
+    def get_suggested(self, obj):
+        return Entry.objects.exclude(pk=obj.pk).first()
 
     class Meta:
         model = Entry
         fields = ('blog', 'headline', 'body_text', 'pub_date', 'mod_date',
-                'authors', 'comments',)
+                'authors', 'comments', 'suggested',)
 
 
 class AuthorSerializer(serializers.ModelSerializer):

example/tests/integration/test_includes.py

@@ -27,3 +27,12 @@ def test_included_data_on_detail(single_entry, client):
     comment_count = len([resource for resource in included if resource["type"] == "comments"])
     expected_comment_count = single_entry.comment_set.count()
     assert comment_count == expected_comment_count, 'Detail comment count is incorrect'
+
+def test_dynamic_related_data_is_included(single_entry, entry_factory, client):
+    entry_factory()
+    response = client.get(reverse("entry-detail", kwargs={'pk': single_entry.pk}) + '?include=suggested')
+    included = load_json(response.content).get('included')
+
+    assert [x.get('type') for x in included] == ['entries'], 'Dynamic included types are incorrect'
+    assert len(included) == 1, 'The dynamically included blog entries are of an incorrect count'
+

rest_framework_json_api/relations.py

@@ -31,6 +31,11 @@ def __init__(self, self_link_view_name=None, related_link_view_name=None, **kwar
         self.related_link_lookup_field = kwargs.pop('related_link_lookup_field', self.related_link_lookup_field)
         self.related_link_url_kwarg = kwargs.pop('related_link_url_kwarg', self.related_link_lookup_field)
 
+        # check for a model class that was passed in for the relation type
+        model = kwargs.pop('model', None)
+        if model:
+            self.model = model
+
         # We include this simply for dependency injection in tests.
         # We can't add it as a class attributes or it would expect an
         # implicit `self` argument to be passed.
@@ -102,6 +107,14 @@ def get_links(self, obj=None, lookup_field='pk'):
             return_data.update({'related': related_link})
         return return_data
 
+    def get_attribute(self, instance):
+        # check for a source fn defined on the serializer instead of the model
+        if self.source and hasattr(self.parent, self.source):
+            serializer_method = getattr(self.parent, self.source)
+            if hasattr(serializer_method, '__call__'):
+                return serializer_method(instance)
+        return super(ResourceRelatedField, self).get_attribute(instance)
+
     def to_internal_value(self, data):
         if isinstance(data, six.text_type):
             data = json.loads(data)

rest_framework_json_api/utils.py

@@ -167,6 +167,9 @@ def build_json_resource_obj(fields, resource, resource_instance, resource_name):
 def get_related_resource_type(relation):
     if hasattr(relation, '_meta'):
         relation_model = relation._meta.model
+    elif hasattr(relation, 'model'):
+        # the model type was explicitly passed as a kwarg to ResourceRelatedField
+        relation_model = relation.model
     elif hasattr(relation, 'get_queryset') and relation.get_queryset() is not None:
         relation_model = relation.get_queryset().model
     else:
@@ -270,8 +273,14 @@ def extract_relationships(fields, resource, resource_instance):
         try:
             source = field.source
             relation_instance_or_manager = getattr(resource_instance, source)
-        except AttributeError:  # Skip fields defined on the serializer that don't correspond to a field on the model
-            continue
+        except AttributeError:
+            # if the field is not defined on the model then we check the serializer
+            # and if no value is there we skip over the field completely
+            serializer_method = getattr(field.parent, source, None)
+            if serializer_method and hasattr(serializer_method, '__call__'):
+                relation_instance_or_manager = serializer_method(resource_instance)
+            else:
+                continue
 
         relation_type = get_related_resource_type(field)
 
@@ -432,8 +441,12 @@ def extract_included(fields, resource, resource_instance, included_resources):
         try:
             relation_instance_or_manager = getattr(resource_instance, field_name)
         except AttributeError:
-            # For ManyRelatedFields if `related_name` is not set we need to access `foo_set` from `source`
-            relation_instance_or_manager = getattr(resource_instance, field.child_relation.source)
+            try:
+                # For ManyRelatedFields if `related_name` is not set we need to access `foo_set` from `source`
+                relation_instance_or_manager = getattr(resource_instance, field.child_relation.source)
+            except AttributeError:
+                serializer_method = getattr(current_serializer, field.source)
+                relation_instance_or_manager = serializer_method(resource_instance)
 
         new_included_resources = [key.replace('%s.' % field_name, '', 1)
                                   for key in included_resources