Completed support for ResourceRelatedField

jsenecal · jsenecal · commit 23d0af686ca9 · 2015-09-23T00:28:11.000-04:00
* self and related links are supported and added by the renderer if their corresponding view names are defined
* meta count is added by the renderer
diff --git a/rest_framework_json_api/relations.py b/rest_framework_json_api/relations.py
@@ -1,9 +1,12 @@
 from rest_framework.exceptions import ValidationError
+from rest_framework.fields import MISSING_ERROR_MESSAGE
 from rest_framework.relations import *
-from rest_framework_json_api.utils import format_relation_name, get_related_resource_type, \
-    get_resource_type_from_queryset, get_resource_type_from_instance
 from django.utils.translation import ugettext_lazy as _
 
+from rest_framework_json_api.exceptions import Conflict
+from rest_framework_json_api.utils import format_relation_name, Hyperlink, \
+    get_resource_type_from_queryset, get_resource_type_from_instance
+
 
 class HyperlinkedRelatedField(HyperlinkedRelatedField):
     """
@@ -40,23 +43,26 @@ def to_internal_value(self, data):
 
 
 class ResourceRelatedField(PrimaryKeyRelatedField):
-    lookup_field = 'pk'
-    view_name = None
-
-
-
+    self_link_view_name = None
+    related_link_view_name = None
+    related_link_lookup_field = 'pk'
 
     default_error_messages = {
         'required': _('This field is required.'),
         'does_not_exist': _('Invalid pk "{pk_value}" - object does not exist.'),
-        'incorrect_type': _('Incorrect type. Expected pk value, received {data_type}.'),
+        'incorrect_type': _('Incorrect type. Expected resource identifier object, received {data_type}.'),
         'incorrect_relation_type': _('Incorrect relation type. Expected {relation_type}, received {received_type}.'),
         'no_match': _('Invalid hyperlink - No URL match.'),
     }
 
-    def __init__(self, view_name=None, **kwargs):
-        self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
-        self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
+    def __init__(self, self_link_view_name=None, related_link_view_name=None, **kwargs):
+        if self_link_view_name is not None:
+            self.self_link_view_name = self_link_view_name
+        if related_link_view_name is not None:
+            self.related_link_view_name = related_link_view_name
+
+        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)
 
         # We include this simply for dependency injection in tests.
         # We can't add it as a class attributes or it would expect an
@@ -65,30 +71,80 @@ def __init__(self, view_name=None, **kwargs):
 
         super(ResourceRelatedField, self).__init__(**kwargs)
 
-    def get_url(self, obj, view_name, request):
+    def use_pk_only_optimization(self):
+        # We need the real object to determine its type...
+        return False
+
+    def conflict(self, key, **kwargs):
         """
-        Given an object, return the URL that hyperlinks to the object.
+        A helper method that simply raises a validation error.
+        """
+        try:
+            msg = self.error_messages[key]
+        except KeyError:
+            class_name = self.__class__.__name__
+            msg = MISSING_ERROR_MESSAGE.format(class_name=class_name, key=key)
+            raise AssertionError(msg)
+        message_string = msg.format(**kwargs)
+        raise Conflict(message_string)
+
+    def get_url(self, name, view_name, kwargs, request):
+        """
+        Given a name, view name and kwargs, return the URL that hyperlinks to the object.
 
         May raise a `NoReverseMatch` if the `view_name` and `lookup_field`
         attributes are not configured to correctly match the URL conf.
         """
-        # Unsaved objects will not yet have a valid URL.
-        if hasattr(obj, 'pk') and obj.pk is None:
+
+        # Return None if the view name is not supplied
+        if not view_name:
+            return None
+
+        # Return the hyperlink, or error if incorrectly configured.
+        try:
+            url = self.reverse(view_name, kwargs=kwargs, request=request)
+        except NoReverseMatch:
+            msg = (
+                'Could not resolve URL for hyperlinked relationship using '
+                'view name "%s".'
+            )
+            raise ImproperlyConfigured(msg % view_name)
+
+        if url is None:
             return None
 
-        lookup_value = getattr(obj, self.lookup_field)
-        kwargs = {self.lookup_url_kwarg: lookup_value}
-        return self.reverse(view_name, kwargs=kwargs, request=request)
+        return Hyperlink(url, name)
+
+    def get_links(self):
+        request = self.context.get('request', None)
+        view = self.context.get('view', None)
+        return_data = OrderedDict()
+        self_kwargs = view.kwargs.copy()
+        self_kwargs.update({'related_field': self.field_name if self.field_name else self.parent.field_name})
+        self_link = self.get_url('self', self.self_link_view_name, self_kwargs, request)
+
+        related_kwargs = {self.related_link_url_kwarg: view.kwargs[self.related_link_lookup_field]}
+        related_link = self.get_url('related', self.related_link_view_name, related_kwargs, request)
+
+        if self_link:
+            return_data.update({'self': self_link})
+        if related_link:
+            return_data.update({'related': related_link})
+        return return_data
 
     def to_internal_value(self, data):
         expected_relation_type = get_resource_type_from_queryset(self.queryset)
+        if not isinstance(data, dict):
+            self.fail('incorrect_type', data_type=type(data).__name__)
         if data['type'] != expected_relation_type:
-            self.fail('incorrect_relation_type', relation_type=expected_relation_type, received_type=data['type'])
+            self.conflict('incorrect_relation_type', relation_type=expected_relation_type, received_type=data['type'])
         return super(ResourceRelatedField, self).to_internal_value(data['id'])
 
     def to_representation(self, value):
-        return {
-            'type': format_relation_name(get_resource_type_from_instance(value)),
-            'id': str(value.pk)
-        }
+        if self.pk_field is not None:
+            pk = self.pk_field.to_representation(value.pk)
+        else:
+            pk = value.pk
+
+        return OrderedDict([('type', format_relation_name(get_resource_type_from_instance(value))), ('id', str(pk))])
 
diff --git a/rest_framework_json_api/utils.py b/rest_framework_json_api/utils.py
@@ -11,6 +11,7 @@
 from rest_framework.settings import api_settings
 from rest_framework.exceptions import APIException
 
+
 try:
     from rest_framework.compat import OrderedDict
 except ImportError:
@@ -237,6 +238,9 @@ def extract_attributes(fields, resource):
 
 
 def extract_relationships(fields, resource, resource_instance):
+    # Avoid circular deps
+    from rest_framework_json_api.relations import ResourceRelatedField
+
     data = OrderedDict()
 
     # Don't try to extract relationships from a non-existent resource
@@ -254,7 +258,7 @@ def extract_relationships(fields, resource, resource_instance):
 
         try:
             relation_instance_or_manager = getattr(resource_instance, field_name)
-        except AttributeError: # Skip fields defined on the serializer that don't correspond to a field on the model
+        except AttributeError:  # Skip fields defined on the serializer that don't correspond to a field on the model
             continue
 
         relation_type = get_related_resource_type(field)
@@ -282,6 +286,20 @@ def extract_relationships(fields, resource, resource_instance):
             }})
             continue
 
+        if isinstance(field, ResourceRelatedField):
+            # special case for ResourceRelatedField
+            relation_data = {
+                'data': resource.get(field_name)
+            }
+
+            field_links = field.get_links()
+            relation_data.update(
+                {'links': field_links}
+                if field_links else dict()
+            )
+            data.update({field_name: relation_data})
+            continue
+
         if isinstance(field, (PrimaryKeyRelatedField, HyperlinkedRelatedField)):
             relation_id = relation_instance_or_manager.pk if resource.get(field_name) else None
 
@@ -299,6 +317,28 @@ def extract_relationships(fields, resource, resource_instance):
             continue
 
         if isinstance(field, ManyRelatedField):
+
+            if isinstance(field.child_relation, ResourceRelatedField):
+                # special case for ResourceRelatedField
+                relation_data = {
+                    'data': resource.get(field_name)
+                }
+
+                field_links = field.child_relation.get_links()
+                relation_data.update(
+                    {'links': field_links}
+                    if field_links else dict()
+                )
+                relation_data.update(
+                    {
+                        'meta': {
+                            'count': len(resource.get(field_name))
+                        }
+                    }
+                )
+                data.update({field_name: relation_data})
+                continue
+
             relation_data = list()
             for related_object in relation_instance_or_manager.all():
                 related_object_type = get_instance_or_manager_resource_type(relation_instance_or_manager)
