Add support for related links using parent view and its permissions

example/serializers.py

@@ -155,14 +155,35 @@ class Meta:
 
 
 class AuthorSerializer(serializers.ModelSerializer):
+    bio = relations.ResourceRelatedField(
+        related_link_view_name='author-related',
+        self_link_view_name='author-relationships',
+        queryset=AuthorBio.objects,
+    )
+    entries = relations.ResourceRelatedField(
+        related_link_view_name='author-related',
+        self_link_view_name='author-relationships',
+        queryset=Entry.objects,
+        many=True
+    )
+    first_entry = relations.SerializerMethodResourceRelatedField(
+        related_link_view_name='author-related',
+        self_link_view_name='author-relationships',
+        model=Entry,
+        read_only=True,
+        source='get_first_entry'
+    )
     included_serializers = {
         'bio': AuthorBioSerializer,
         'type': AuthorTypeSerializer
     }
 
     class Meta:
         model = Author
-        fields = ('name', 'email', 'bio', 'entries', 'type')
+        fields = ('name', 'email', 'bio', 'entries', 'first_entry', 'type')
+
+    def get_first_entry(self, obj):
+        return obj.entries.first()
 
 
 class WriterSerializer(serializers.ModelSerializer):

example/urls.py

@@ -45,6 +45,10 @@
         EntryViewSet.as_view({'get': 'retrieve'}),
         name='entry-featured'),
 
+    url(r'^authors/(?P<pk>[^/.]+)/(?P<related_field>\w+)/$',
+        AuthorViewSet.as_view({'get': 'retrieve_related'}),
+        name='author-related'),
+
     url(r'^entries/(?P<pk>[^/.]+)/relationships/(?P<related_field>\w+)',
         EntryRelationshipView.as_view(),
         name='entry-relationships'),

example/urls_test.py

@@ -56,6 +56,10 @@
         EntryViewSet.as_view({'get': 'retrieve'}),
         name='entry-featured'),
 
+    url(r'^authors/(?P<pk>[^/.]+)/(?P<related_field>\w+)/$',
+        AuthorViewSet.as_view({'get': 'retrieve_related'}),
+        name='author-related'),
+
     url(r'^entries/(?P<pk>[^/.]+)/relationships/(?P<related_field>\w+)',
         EntryRelationshipView.as_view(),
         name='entry-relationships'),

example/views.py

@@ -95,6 +95,11 @@ class NonPaginatedEntryViewSet(EntryViewSet):
 class AuthorViewSet(ModelViewSet):
     queryset = Author.objects.all()
     serializer_class = AuthorSerializer
+    related_serializers = {
+        'bio': 'example.serializers.AuthorBioSerializer',
+        'entries': 'example.serializers.EntrySerializer',
+        'first_entry': 'example.serializers.EntrySerializer'
+    }
 
 
 class CommentViewSet(ModelViewSet):

rest_framework_json_api/relations.py

@@ -116,7 +116,19 @@ def get_links(self, obj=None, lookup_field='pk'):
         })
         self_link = self.get_url('self', self.self_link_view_name, self_kwargs, request)
 
-        related_kwargs = {self.related_link_url_kwarg: kwargs[self.related_link_lookup_field]}
+        """
+        Assuming RelatedField will be declared in two ways:
+        1. url(r'^authors/(?P<pk>[^/.]+)/(?P<related_field>\w+)/$',
+                AuthorViewSet.as_view({'get': 'retrieve_related'}))
+        2. url(r'^authors/(?P<author_pk>[^/.]+)/bio/$',
+                AuthorBioViewSet.as_view({'get': 'retrieve'}))
+        So, if related_link_url_kwarg == 'pk' it will add 'related_field' parameter to reverse()
+        """
+        if self.related_link_url_kwarg == 'pk':
+            related_kwargs = self_kwargs
+        else:
+            related_kwargs = {self.related_link_url_kwarg: kwargs[self.related_link_lookup_field]}
+
         related_link = self.get_url('related', self.related_link_view_name, related_kwargs, request)
 
         if self_link:

rest_framework_json_api/views.py

@@ -1,3 +1,5 @@
+from collections import Iterable
+
 from django.core.exceptions import ImproperlyConfigured
 from django.db.models import Model
 from django.db.models.fields.related_descriptors import (
@@ -9,6 +11,7 @@
 from django.db.models.manager import Manager
 from django.db.models.query import QuerySet
 from django.urls import NoReverseMatch
+from django.utils.module_loading import import_string as import_class_from_dotted_path
 from rest_framework import generics, viewsets
 from rest_framework.exceptions import MethodNotAllowed, NotFound
 from rest_framework.response import Response
@@ -98,12 +101,87 @@ def get_queryset(self, *args, **kwargs):
         return qs
 
 
-class ModelViewSet(AutoPrefetchMixin, PrefetchForIncludesHelperMixin, viewsets.ModelViewSet):
+class RelatedMixin(object):
+    """
+    This mixin handles all related entities, whose Serializers are declared in "related_serializers"
+    """
+    related_serializers = {}
+    related_field_mapping = {}
+
+    def retrieve_related(self, request, *args, **kwargs):
+        serializer_kwargs = {}
+        instance = self.get_related_instance()
+
+        if hasattr(instance, 'all'):
+            instance = instance.all()
+
+        if callable(instance):
+            instance = instance()
+
+        if instance is None:
+            return Response(data=None)
+
+        if isinstance(instance, Iterable):
+            serializer_kwargs['many'] = True
+
+        serializer = self.get_serializer(instance, **serializer_kwargs)
+        return Response(serializer.data)
+
+    def get_serializer_class(self):
+        parent_serializer_class = super(RelatedMixin, self).get_serializer_class()
+
+        if 'related_field' in self.kwargs:
+            field_name = self.kwargs['related_field']
+
+            assert hasattr(parent_serializer_class, 'included_serializers')\
+                or self.related_serializers,\
+                'Either "included_serializers" or ' \
+                '"related_serializers" should be configured'
+
+            # Try get the class from related_serializers
+            class_str = self.related_serializers.get(field_name, None)
+
+            if class_str is None:
+                # Class was not found in related_serializers, look for it in included_serializers
+                class_str = getattr(self, 'included_serializers', {}).get(field_name, None)
+
+                if class_str is None:
+                    raise NotFound
+            return import_class_from_dotted_path(class_str)
+
+        return parent_serializer_class
+
+    def get_related_field_name(self):
+        field_name = self.kwargs['related_field']
+        if field_name in self.related_field_mapping:
+            return self.related_field_mapping[field_name]
+        return field_name
+
+    def get_related_instance(self):
+        parent_obj = self.get_object()
+        parent_serializer = self.serializer_class(parent_obj)
+        field_name = self.get_related_field_name()
+        field = parent_serializer.fields.get(field_name, None)
+
+        if field is not None:
+            return field.get_attribute(parent_obj)
+        else:
+            try:
+                return getattr(parent_obj, field_name)
+            except AttributeError:
+                raise NotFound
+
+
+class ModelViewSet(AutoPrefetchMixin,
+                   PrefetchForIncludesHelperMixin,
+                   RelatedMixin,
+                   viewsets.ModelViewSet):
     pass
 
 
 class ReadOnlyModelViewSet(AutoPrefetchMixin,
                            PrefetchForIncludesHelperMixin,
+                           RelatedMixin,
                            viewsets.ReadOnlyModelViewSet):
     pass