Added support for meta objects in serializers and list serializers

Author: jerel

example/serializers.py

@@ -1,12 +1,19 @@
+from datetime import datetime
 from rest_framework_json_api import serializers, relations
 from example.models import Blog, Entry, Author, Comment
 
 
 class BlogSerializer(serializers.ModelSerializer):
 
+    copyright = serializers.SerializerMethodField()
+
+    def get_copyright(self, obj):
+        return datetime.now().year
+
     class Meta:
         model = Blog
         fields = ('name', )
+        meta_fields = ('copyright',)
 
 
 class EntrySerializer(serializers.ModelSerializer):
@@ -24,6 +31,7 @@ def __init__(self, *args, **kwargs):
         'suggested': 'example.serializers.EntrySerializer',
     }
 
+    body_format = serializers.SerializerMethodField()
     comments = relations.ResourceRelatedField(
             source='comment_set', many=True, read_only=True)
     suggested = relations.SerializerMethodResourceRelatedField(
@@ -32,10 +40,14 @@ def __init__(self, *args, **kwargs):
     def get_suggested(self, obj):
         return Entry.objects.exclude(pk=obj.pk).first()
 
+    def get_body_format(self, obj):
+        return 'text'
+
     class Meta:
         model = Entry
         fields = ('blog', 'headline', 'body_text', 'pub_date', 'mod_date',
                 'authors', 'comments', 'suggested',)
+        meta_fields = ('body_format',)
 
 
 class AuthorSerializer(serializers.ModelSerializer):

rest_framework_json_api/renderers.py

@@ -319,6 +319,20 @@ def extract_included(fields, resource, resource_instance, included_resources):
 
         return utils.format_keys(included_data)
 
+    @staticmethod
+    def extract_meta(serializer, resource):
+        if hasattr(serializer, 'child'):
+            meta = getattr(serializer.child, 'Meta', None)
+        else:
+            meta = getattr(serializer, 'Meta', None)
+        meta_fields = getattr(meta, 'meta_fields', {})
+        data = OrderedDict()
+        for field_name in meta_fields:
+            data.update({
+                field_name: resource.get(field_name)
+            })
+        return data
+
     @staticmethod
     def build_json_resource_obj(fields, resource, resource_instance, resource_name):
         resource_data = [
@@ -409,8 +423,13 @@ def render(self, data, accepted_media_type=None, renderer_context=None):
             for position in range(len(serializer_data)):
                 resource = serializer_data[position]  # Get current resource
                 resource_instance = resource_serializer.instance[position]  # Get current instance
-                json_api_data.append(
-                    self.build_json_resource_obj(fields, resource, resource_instance, resource_name))
+
+                json_resource_obj = self.build_json_resource_obj(fields, resource, resource_instance, resource_name)
+                meta = self.extract_meta(resource_serializer, resource)
+                if meta:
+                    json_resource_obj.update({'meta': utils.format_keys(meta)})
+                json_api_data.append(json_resource_obj)
+
                 included = self.extract_included(fields, resource, resource_instance, included_resources)
                 if included:
                     json_api_included.extend(included)
@@ -420,6 +439,11 @@ def render(self, data, accepted_media_type=None, renderer_context=None):
                 fields = utils.get_serializer_fields(data.serializer)
                 resource_instance = data.serializer.instance
                 json_api_data = self.build_json_resource_obj(fields, data, resource_instance, resource_name)
+
+                meta = self.extract_meta(data.serializer, data)
+                if meta:
+                    json_api_data.update({'meta': utils.format_keys(meta)})
+
                 included = self.extract_included(fields, data, resource_instance, included_resources)
                 if included:
                     json_api_included.extend(included)
@@ -453,7 +477,8 @@ def render(self, data, accepted_media_type=None, renderer_context=None):
             render_data['included'] = sorted(unique_compound_documents, key=lambda item: (item['type'], item['id']))
 
         if isinstance(data, dict) and data.get('meta'):
-            render_data['meta'] = data.get('meta')
+            # add top level meta (such as pagination data)
+            render_data.update({'meta': utils.format_keys(data.get('meta'))})
 
         return super(JSONRenderer, self).render(
             render_data, accepted_media_type, renderer_context

rest_framework_json_api/serializers.py

@@ -136,3 +136,24 @@ class ModelSerializer(IncludedResourcesValidationMixin, SparseFieldsetsMixin, Mo
     * A mixin class to enable validation of included resources is included
     """
     serializer_related_field = ResourceRelatedField
+
+    def __init__(self, *args, **kwargs):
+        meta_fields = getattr(self.Meta, 'meta_fields', [])
+        # we add meta_fields to fields so they will be serialized like usual
+        self.Meta.fields = tuple(tuple(self.Meta.fields) + tuple(meta_fields))
+        super(ModelSerializer, self).__init__(*args, **kwargs)
+
+    def get_field_names(self, declared_fields, info):
+        """
+        We override the parent to omit explicity defined meta fields (such
+        as SerializerMethodFields) from the list of declared fields
+        """
+        meta_fields = getattr(self.Meta, 'meta_fields', None)
+
+        declared = OrderedDict()
+        for field_name in declared_fields.keys():
+            field = declared_fields[field_name]
+            if field_name not in meta_fields:
+                declared[field_name] = field
+        return super(ModelSerializer, self).get_field_names(declared, info)
+

rest_framework_json_api/utils.py

@@ -65,11 +65,22 @@ def get_resource_name(context):
 
 
 def get_serializer_fields(serializer):
+    fields = None
     if hasattr(serializer, 'child'):
-        return getattr(serializer.child, 'fields')
+        fields = getattr(serializer.child, 'fields')
+        meta = getattr(serializer.child, 'Meta', None)
     if hasattr(serializer, 'fields'):
-        return getattr(serializer, 'fields')
+        fields = getattr(serializer, 'fields')
+        meta = getattr(serializer, 'Meta', None)
 
+    if fields:
+        meta_fields = getattr(meta, 'meta_fields', {})
+        for field in meta_fields:
+            try:
+                fields.pop(field)
+            except KeyError:
+                pass
+        return fields
 
 def format_keys(obj, format_type=None):
     """