Merge pull request #253 from editorsnotes/rest-framework-3

Upgrade to Django REST framework 3

Author: ptgolden

editorsnotes/api/filters.py

@@ -41,7 +41,7 @@ def filter_queryset(self, request, queryset, view):
             query['query']['filtered']['filter'] = { 'and': filters }
 
         en_index = get_index('main')
-        return en_index.search_model(view.model, query)
+        return en_index.search_model(view.queryset.model, query)
 
 class ElasticSearchAutocompleteFilterBackend(BaseFilterBackend):
     def filter_queryset(self, request, queryset, view):
@@ -109,8 +109,8 @@ def filter_queryset(self, request, queryset, view):
                 'post_tags': ['</strong>']
             }
 
-        if hasattr(view, 'model') and view.model is not None:
-            return en_index.search_model(view.model, query)
+        if hasattr(view, 'queryset') and view.queryset is not None:
+            return en_index.search_model(view.queryset.model, query)
         else:
             # Should boost notes most of all
             return en_index.search(query)

editorsnotes/api/serializers/activity.py

@@ -11,11 +11,11 @@
 
 # TODO: make these fields nested, maybe
 class ActivitySerializer(serializers.ModelSerializer):
-    user = serializers.Field(source='user.username')
-    project = serializers.Field(source='project.slug')
-    type = serializers.Field(source='content_type.model')
+    user = serializers.ReadOnlyField(source='user.username')
+    project = serializers.ReadOnlyField(source='project.slug')
+    type = serializers.ReadOnlyField(source='content_type.model')
     url = serializers.SerializerMethodField('get_object_url')
-    title = serializers.Field(source='display_title')
+    title = serializers.ReadOnlyField(source='display_title')
     action = serializers.SerializerMethodField('get_action_repr')
     class Meta:
         model = LogActivity

editorsnotes/api/serializers/base.py

@@ -1,16 +1,27 @@
-from django.core.urlresolvers import NoReverseMatch
-from rest_framework.relations import HyperlinkedRelatedField, RelatedField
+from django.core.urlresolvers import resolve, NoReverseMatch, Resolver404
+from rest_framework.relations import (HyperlinkedRelatedField, RelatedField,
+                                      get_attribute)
 from rest_framework.reverse import reverse
-from rest_framework.serializers import Field
+from rest_framework.serializers import ReadOnlyField, ModelSerializer, SerializerMethodField
 
-from editorsnotes.main.models import Topic, TopicAssignment
+from editorsnotes.main.models import Topic, TopicAssignment, Project
 
 def nested_getattr(obj, attr_string):
     for attr in attr_string.split('.'):
         obj = getattr(obj, attr)
     return obj
 
-class URLField(Field):
+class CurrentProjectDefault:
+    def set_context(self, serializer_field):
+        self.project = serializer_field.context['request'].project
+
+    def __call__(self):
+        return self.project
+
+    def __repr__(self):
+        return u'%s()' % self.__class__.__name__
+
+class URLField(ReadOnlyField):
     """
     An identity URL field.
 
@@ -26,113 +37,119 @@ def _get_default_view_name(self, obj):
         return 'api:api-{}-detail'.format(obj.__class__._meta.verbose_name_plural[:])
     def _get_lookup_args(self, obj):
         return tuple(nested_getattr(obj, attr) for attr in self.lookup_args)
-    def field_to_native(self, obj, field):
-        view = self.view_name or self._get_default_view_name(obj)
-        args = self._get_lookup_args(obj)
+    def get_attribute(self, obj):
+        return obj
+    def to_representation(self, value):
+        view = self.view_name or self._get_default_view_name(value)
+        args = self._get_lookup_args(value)
         return reverse(view, args=args, request=self.context['request'])
 
-class ProjectSlugField(Field):
-    read_only = True
-    def field_to_native(self, obj, field_name):
-        project = obj.get_affiliation()
-        url = reverse('api:api-project-detail', args=(project.slug,),
+class ProjectSlugField(ReadOnlyField):
+    def __init__(self, *args, **kwargs):
+        self.queryset = Project.objects.all()
+        super(ProjectSlugField, self).__init__(*args, **kwargs)
+    def get_attribute(self, obj):
+        return obj.get_affiliation()
+    def to_representation(self, value):
+        url = reverse('api:api-project-detail', args=(value.slug,),
                       request=self.context['request'])
-        return { 'name': project.name, 'url': url }
+        return { 'name': value.name, 'url': url }
 
 class HyperlinkedProjectItemField(HyperlinkedRelatedField):
-    def to_native(self, obj):
+    def get_attribute(self, obj):
+        return get_attribute(obj, self.source_attrs)
+    def to_representation(self, value):
         """
         Return URL from item requiring project slug kwarg
         """
         try:
             return reverse(
-                self.view_name, args=[obj.project.slug, obj.id],
+                self.view_name, args=[value.project.slug, value.id],
                 request=self.context.get('request', None),
                 format=self.format or self.context.get('format', None))
         except NoReverseMatch:
             raise Exception('Could not resolve URL for document.')
 
-class ProjectSpecificItemMixin(object):
-    """
-    Sets a restored instance's `project` attribute based on the serializer's
-    context.
-    """
-    def __init__(self, *args, **kwargs):
-        super(ProjectSpecificItemMixin, self).__init__(*args, **kwargs)
-        if self.object is None and 'project' not in self.context:
-            # FIXME: is this the best error to raise?
-            raise ValueError(
-                'Unbound instances of {0} must be instantiated with a context '
-                'object containing a project, e.g.: '
-                '{0}(context={{\'project\': project_instance}})'.format(
-                    self.__class__.__name__))
-    def restore_object(self, attrs, instance=None):
-        instance = super(ProjectSpecificItemMixin, self).restore_object(attrs, instance)
-        if not instance.pk:
-            instance.project = self.context['project']
-        elif 'project' in self.context and instance.project != self.context['project']:
-            raise ValueError('Can\'t change project from serializer.')
-        return instance
-
-class UpdatersField(Field):
+class UpdatersField(ReadOnlyField):
     read_only = True
-    def field_to_native(self, obj, field_name):
-        return [u.username for u in obj.get_all_updaters()]
+    def get_attribute(self, obj):
+        return obj.get_all_updaters()
+    def to_representation(self, value):
+        return [u.username for u in value]
+
+class MinimalTopicSerializer(ModelSerializer):
+    url = URLField(lookup_arg_attrs=('project.slug', 'topic_node_id'))
+    topic_node_id = SerializerMethodField()
+    class Meta:
+        model = Topic
+        fields = ('id', 'topic_node_id', 'preferred_name', 'url',)
+    def get_topic_node_id(self, obj):
+        return obj.topic_node_id
 
 class TopicAssignmentField(RelatedField):
+    default_error_messages = {
+        'no_match': 'No topic matches this URL.',
+        'outside_project': 'Related topics must be within the same project.',
+        'bad_path': 'This URL is not a topic API url.'
+    }
     def __init__(self, *args, **kwargs):
+        kwargs['queryset'] = Topic.objects.all()
         super(TopicAssignmentField, self).__init__(*args, **kwargs)
-        self.many = True
-    def format_topic_assignment(self, ta):
-        url = reverse('api:api-topics-detail',
-                      args=(ta.topic.project.slug, ta.topic.id),
-                      request=self.context['request'])
-        return {
-            'id': ta.topic.id,
-            'preferred_name': ta.topic.preferred_name,
-            'url': url
-        }
-    def field_to_native(self, obj, field_name):
-        if obj is None:
-            ret = []
-        else:
-            ret = [self.format_topic_assignment(ta) for ta in obj.related_topics.all()]
-        return ret
-    def field_from_native(self, data, files, field_name, into):
+    def get_attribute(self, obj):
+        return [ta.topic for ta in obj.related_topics.all()]
+    def to_representation(self, topics):
+        return [ MinimalTopicSerializer(topic, context=self.context).data
+                 for topic in topics ]
+    def to_internal_value(self, data):
         if self.read_only:
             return
-        into[field_name] = data.get(field_name, [])
+        return [self._topic_from_url(url) for url in data]
+    def _topic_from_url(self, url):
+        try:
+            match = resolve(url)
+        except Resolver404:
+            self.fail('no_match')
+
+        if match.view_name != 'api:api-topics-detail':
+            self.fail('bad_path')
+
+        current_project = self.context['request'].project
+        lookup_project_slug = match.kwargs.pop('project_slug')
+        if lookup_project_slug != current_project.slug:
+            self.fail('outside_project')
+
+        return self.get_queryset().get(project=current_project, **match.kwargs)
 
 class RelatedTopicSerializerMixin(object):
     def save_related_topics(self, obj, topics):
         """
         Given an array of names, make sure obj is related to those topics.
         """
-        to_create = topics[:]
-        to_delete = []
-
-        for assignment in obj.related_topics.select_related('topic').all():
-            topic_name = assignment.topic.preferred_name
-            if topic_name in topics:
-                to_create.remove(topic_name)
-            else:
-                to_delete.append(assignment)
-
-        for assignment in to_delete:
-            assignment.delete()
-
-        user = self.context['request'].user
-        project = self.context['request'].project
-
-        for topic_name in to_create:
-            topic = Topic.objects.get_or_create_by_name(
-                topic_name, project, user)
-            obj.related_topics.create(topic=topic, creator_id=user.id)
-
-    def save_object(self, obj, **kwargs):
-        # Need to change to allow partial updates, etc.
-        topics = []
-        if getattr(obj, '_m2m_data', None):
-            topics = obj._m2m_data.pop('related_topics')
-        super(RelatedTopicSerializerMixin, self).save_object(obj, **kwargs)
-        self.save_related_topics(obj, topics)
+        rel_topics = obj.related_topics.select_related('topic').all()
+
+        new_topics = set(topics)
+        existing_topics = { ta.topic for ta in rel_topics }
+
+        to_create = new_topics.difference(existing_topics)
+        to_delete = existing_topics.difference(new_topics)
+
+        # Delete unused topic assignments
+        rel_topics.filter(topic__in=to_delete).delete()
+
+        # Create new topic assignments
+        for topic in to_create:
+            obj.related_topics.create(
+                topic=topic, creator_id=self.context['request'].user.id)
+
+    def create(self, validated_data):
+        topics = validated_data.pop('related_topics', None)
+        obj = super(RelatedTopicSerializerMixin, self).create(validated_data)
+        if topics is not None:
+            self.save_related_topics(obj, topics)
+        return obj
+    def update(self, instance, validated_data):
+        topics = validated_data.pop('related_topics', None)
+        super(RelatedTopicSerializerMixin, self).update(instance, validated_data)
+        if topics is not None:
+            self.save_related_topics(instance, topics)
+        return instance

editorsnotes/api/serializers/documents.py

@@ -4,19 +4,20 @@
 from lxml import etree
 from rest_framework import serializers
 from rest_framework.reverse import reverse
+from rest_framework.validators import UniqueValidator
 
 from editorsnotes.main.models import Document, Citation, Scan, Transcript
+from editorsnotes.main.utils import remove_stray_brs
 
-from .base import (RelatedTopicSerializerMixin, ProjectSpecificItemMixin,
+from .base import (RelatedTopicSerializerMixin, CurrentProjectDefault,
                    URLField, ProjectSlugField, HyperlinkedProjectItemField,
                    TopicAssignmentField)
 
-class ZoteroField(serializers.WritableField):
-    def to_native(self, zotero_data):
-        return zotero_data and json.loads(zotero_data,
-                                          object_pairs_hook=OrderedDict)
-    def from_native(self, data):
-        return data and json.dumps(data)
+class ZoteroField(serializers.Field):
+    def to_representation(self, value):
+        return value and json.loads(value, object_pairs_hook=OrderedDict)
+    def to_internal_value(self, data):
+        return json.dumps(data)
 
 class HyperLinkedImageField(serializers.ImageField):
     def to_native(self, value):
@@ -29,52 +30,76 @@ def to_native(self, value):
         return ret
 
 class ScanSerializer(serializers.ModelSerializer):
-    creator = serializers.Field('creator.username')
+    creator = serializers.ReadOnlyField(source='creator.username')
     image = HyperLinkedImageField()
     image_thumbnail = HyperLinkedImageField(read_only=True)
     class Meta:
         model = Scan
         fields = ('id', 'image', 'image_thumbnail', 'ordering', 'created',
                   'creator',)
 
-class DocumentSerializer(RelatedTopicSerializerMixin, ProjectSpecificItemMixin,
+class UniqueDocumentDescriptionValidator:
+    message = u'Document with this description already exists.'
+    def set_context(self, serializer):
+        self.instance = getattr(self, 'instance', None)
+    def __call__(self, attrs):
+        if self.instance is not None:
+            description = attrs.get('description', self.instance.description)
+        else:
+            description = attrs['description']
+
+        project = attrs['project']
+        qs = Document.objects.filter(
+            description_digest=Document.hash_description(description),
+            project=project)
+        if self.instance is not None:
+            qs = qs.exclude(id=self.instance.id)
+        if qs.exists():
+            raise serializers.ValidationError({ 'description': [self.message] })
+
+class DocumentSerializer(RelatedTopicSerializerMixin,
                          serializers.ModelSerializer):
     url = URLField()
-    project = ProjectSlugField()
+    project = ProjectSlugField(default=CurrentProjectDefault())
     transcript = serializers.SerializerMethodField('get_transcript_url')
     zotero_data = ZoteroField(required=False)
     related_topics = TopicAssignmentField()
     scans = ScanSerializer(many=True, required=False, read_only=True)
-    def get_validation_exclusions(self):
-        # TODO: This can be removed in future versions of django rest framework.
-        # It's necessary because for the time being, DRF excludes non-required
-        # fields from validation (not something I find particularly useful, but
-        # they must've had their reasons...)
-        exclusions = super(DocumentSerializer, self).get_validation_exclusions()
-        exclusions.remove('zotero_data')
-        return exclusions
+    class Meta:
+        model = Document
+        fields = ('id', 'description', 'url', 'project', 'last_updated',
+                  'scans', 'transcript', 'related_topics', 'zotero_data',)
+        validators = [
+            UniqueDocumentDescriptionValidator()
+        ]
     def get_transcript_url(self, obj):
         if not obj.has_transcript():
             return None
         return reverse('api:api-transcripts-detail',
                        args=(obj.project.slug, obj.id),
                        request=self.context.get('request', None))
-    class Meta:
-        model = Document
-        fields = ('id', 'description', 'url', 'project', 'last_updated',
-                  'scans', 'transcript', 'related_topics', 'zotero_data',)
+    def validate_description(self, value):
+        description_stripped = Document.strip_description(value)
+        if not description_stripped:
+            raise serializer.ValidationError('Field required.')
+        remove_stray_brs(value)
+        return value
+
 
 class TranscriptSerializer(serializers.ModelSerializer):
     url = URLField(lookup_arg_attrs=('document.project.slug', 'document.id'))
-    document = HyperlinkedProjectItemField(
-        required=True, view_name='api:api-documents-detail')
+    document = HyperlinkedProjectItemField(view_name='api:api-documents-detail',
+                                           queryset=Document.objects,
+                                           required=True)
     class Meta:
         model = Transcript
 
 class CitationSerializer(serializers.ModelSerializer):
     url = URLField('api:api-topic-citations-detail',
                    ('content_object.project.slug', 'content_object.topic_node_id', 'id'))
-    document = HyperlinkedProjectItemField(view_name='api:api-documents-detail')
+    document = HyperlinkedProjectItemField(view_name='api:api-documents-detail',
+                                           queryset=Document.objects,
+                                           required=True)
     document_description = serializers.SerializerMethodField('get_document_description')
     class Meta:
         model = Citation