validators place the validated values at field.source

Author: claytondaley

drf_writable_nested/mixins.py

@@ -1,11 +1,12 @@
 # -*- coding: utf-8 -*-
+import logging
 from collections import OrderedDict, defaultdict
 
 from django.contrib.contenttypes.fields import GenericRelation
 from django.contrib.contenttypes.models import ContentType
 from django.db import transaction
 from django.db.models import ProtectedError, FieldDoesNotExist, OneToOneRel
-from django.db.models.fields.related import ForeignObjectRel, OneToOneField, ManyToManyField
+from django.db.models.fields.related import ForeignObjectRel, ManyToManyField
 from django.utils.translation import ugettext_lazy as _
 from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
@@ -429,6 +430,10 @@ def update(self, instance, validated_data):
 
 class FieldLookupMixin(serializers.Serializer):
 
+    def __init__(self, *args, **kwargs):
+        self.logger = logging.getLogger(self.__class__.__name__)
+        super(FieldLookupMixin, self).__init__(*args, **kwargs)
+
     def _get_model_field(self, source):
         """Returns the field on the model"""
         # for serializers like ModelSerializer, the Meta.model can be used to classify fields
@@ -472,6 +477,8 @@ def _populate_field_types(self):
         self._cache_field_types = {}
         self._cache_field_sources = {}
         for field_name, field in self.fields.items():
+            if isinstance(self._get_model_field(field.source), GenericRelation):
+                raise TypeError("GenericRelation not currently supported")
             if field.read_only:
                 self._cache_field_types[field_name] = self.TYPE_READ_ONLY
                 self._cache_field_sources[field.source] = self.TYPE_READ_ONLY
@@ -506,7 +513,9 @@ class RelatedSaveMixin(FieldLookupMixin):
 
     def run_validation(self, data=empty):
         """Cache nested call to `to_representation` on _validate_data for use when saving."""
+        self.logger.debug("{} validating: {}".format(self.__class__.__name__, data))
         self._validated_data = super(RelatedSaveMixin, self).run_validation(data)
+        self.logger.debug("{} validated: {}".format(self.__class__.__name__, self._validated_data))
         self._errors = {}
         return self._validated_data
 
@@ -538,9 +547,9 @@ def validated_data(self):
                 if k not in self.field_sources or self.field_sources[k] != self.TYPE_REVERSE}
 
     def save(self, **kwargs):
-        """We already converted the inputs into a model so we need to save that model"""
+        """Convert validated data into related objects and save."""
         # Create or update direct relations (foreign key, one-to-one)
-        print("RelatedSaveMixin.save for {}".format(self.__class__.__name__))
+        print("RelatedSaveMixin.save for {} with data, kwargs: {}, {}".format(self.__class__.__name__, self._validated_data, kwargs))
         self._save_direct_relations(kwargs=kwargs)
         instance = super(RelatedSaveMixin, self).save(**kwargs)
         self._save_reverse_relations(instance=instance, kwargs=kwargs)
@@ -551,14 +560,14 @@ def _save_direct_relations(self, kwargs):
         for field_name, field in self.fields.items():
             if self.field_types[field_name] != self.TYPE_DIRECT:
                 continue
-            print("{} direct save {}".format(self.__class__.__name__, field_name))
-            if self._validated_data.get(field_name, empty) == empty and kwargs.get(field_name, empty) == empty:
+            print("{} direct save {} with data, kwargs;  {}, {}".format(self.__class__.__name__, field_name, self._validated_data.get(field.source, empty), kwargs.get(field_name, {})))
+            if self._validated_data.get(field.source, empty) == empty and kwargs.get(field_name, empty) == empty:
                 continue  # nothing to save
             #if self._validated_data.get(field_name) is None or kwargs.get(field_name) is None:
             #    continue  # delete existing objects
             # we need to pop from kwargs so the value doesn't "overwrite" the value generated by save
-            self._validated_data[field_name] = field.save(**kwargs.pop(field_name, {}))
-            print("{}._validated_data[{}] to direct {}".format(self.__class__.__name__, field_name, self._validated_data[field_name]))
+            self._validated_data[field.source] = field.save(**kwargs.pop(field_name, {}))
+            print("{}._validated_data[{}] set to direct {}".format(self.__class__.__name__, field_name, self._validated_data[field.source]))
 
     def _format_generic_lookup(self, instance, related_field):
         return {
@@ -571,20 +580,23 @@ def _save_reverse_relations(self, instance, kwargs):
         for field_name, field in self.fields.items():
             if self.field_types[field_name] != self.TYPE_REVERSE:
                 continue
-            if self._validated_data.get(field_name, empty) == empty and kwargs.get(field_name, empty) == empty:
+            if self._validated_data.get(field.source, empty) == empty and kwargs.get(field_name, empty) == empty:
                 continue  # nothing to save
             # inject the instance into reverse relations so the <parent>_id ForeignKey field is valid when saved
             related_field = self._get_model_field(field.source).field
+            print("{} populating reverse field {}".format(self.__class__.__name__, related_field.name))
             if isinstance(field, serializers.ListSerializer):
                 for obj in field._validated_data:
                     obj[related_field.name] = instance
             elif isinstance(field, serializers.ModelSerializer):
+                if field._validated_data is None:
+                    field._validated_data = {}  # delete situation, but need a place to put FK
                 field._validated_data[related_field.name] = instance
             else:
                 raise Exception("unexpected serializer type")
             # no tests fail if we do not cache this value in _validated_data, but it's consistent with forward relations
-            self._validated_data[field_name] = field.save(**kwargs.get(field_name, {}))
-            print("{}._validated_data[{}] to reverse {}".format(self.__class__.__name__, field_name, self._validated_data[field_name]))
+            self._validated_data[field.source] = field.save(**kwargs.get(field_name, {}))
+            print("{}._validated_data[{}] to reverse {}".format(self.__class__.__name__, field_name, self._validated_data[field.source]))
 
 
 class FocalSaveMixin(FieldLookupMixin):
@@ -594,12 +606,25 @@ class FocalSaveMixin(FieldLookupMixin):
         'incorrect_type': _('Nested field received an incorrect data type ({data_type}):  {exception_message}'),
     }
 
+    def to_internal_value(self, data):
+        """Injects the PK of this field into reverse relations so they validate when created in to_internal_value."""
+        # to_internal_value only preserves writable fields and match_on may need read-only like PK
+        self._validated_data = super(FocalSaveMixin, self).to_internal_value(data)
+        # patch read-only fields for match_on
+        for field_name, field in self.fields.items():
+            if not field.read_only:
+                continue
+            if field_name not in data:
+                continue
+            self._validated_data[field.source] = field.to_internal_value(data[field_name])
+        return self._validated_data
+
     def build_match_on(self, kwargs):
         match_on = {}
         for field_name, field in self.fields.items():
             if self.match_on == '__all__' or field_name in self.match_on:
                 # build match_on dict
-                match_on[field.source or field_name] = kwargs.get(field_name, self._validated_data.get(field_name))
+                match_on[field.source] = kwargs.get(field_name, self._validated_data.get(field.source))
         # a parent serializer may inject a value that isn't among the fields, but is in `match_on`
         for key in self.match_on:
             if key not in self.fields.keys():
@@ -613,20 +638,22 @@ def build_direct_values(self, kwargs):
                 continue  # m2m fields
             elif self.field_types[field_name] == self.TYPE_LOCAL:
                 # need to check kwargs dict since there's no pre-processing
-                values[field_name] = kwargs.get(field_name, self._validated_data.get(field_name))
+                values[field.source] = kwargs.get(field_name, self._validated_data.get(field.source))
             elif self.field_types[field_name] == self.TYPE_DIRECT:
                 # kwargs should have been injected into _validated_data when direct relations were saved
-                values[field_name] = self._validated_data.get(field_name)
+                values[field.source] = self._validated_data.get(field.source)
             # reverse relations aren't sent to a create
         return values
 
     def match(self, kwargs):
-        print("FocalSaveMixin.match with no super")
+        print("FocalSaveMixin.match with no super and kwargs {}".format(kwargs))
         return self.instance
 
     @transaction.atomic
     def save(self, **kwargs):
-        print("FocalSaveMixin.save for {}".format(self.__class__.__name__))
+        print("FocalSaveMixin.save for {} with data, kwargs {}".format(self.__class__.__name__, self._validated_data, kwargs))
+        if self._validated_data is None and kwargs == {}:
+            return None  # deleted
         match = self.match(kwargs)
         print("Match: {}".format(match))
         self.do_update(match, kwargs)
@@ -648,6 +675,10 @@ def do_m2m_update(self, match, kwargs):
 class NestedSaveListSerializer(serializers.ListSerializer):
     """Need a special save() method that cascades to the list of child instances"""
 
+    def __init__(self, *args, **kwargs):
+        self.logger = logging.getLogger(self.__class__.__name__)
+        super(NestedSaveListSerializer, self).__init__(*args, **kwargs)
+
     def save(self, **kwargs):
         """
         Save and return a list of object instances.
@@ -661,24 +692,27 @@ def save(self, **kwargs):
             "need to set extra attributes on the saved model instance. "
             "For example: 'serializer.save(owner=request.user)'.'"
         )
-        print("List-{} save: {}, {}".format(self.child.__class__.__name__, self._validated_data, kwargs))
+        print("List-{} save with data, kwargs: {}, {}".format(self.child.__class__.__name__, self._validated_data, kwargs))
 
         new_values = []
 
         for item in self._validated_data:
             # integrate save kwargs
             self.child._validated_data = item
-            # since we reuse the serializer, we need to re-inject the new _validated_data using save kwargs
-            new_values.append(self.child.save(**kwargs))
+            new_value = self.child.save(**kwargs)
+            # None indicates a deleted item
+            if new_value is not None:
+                new_values.append(new_value)
 
         print("List-{} saved: {}".format(self.child.__class__.__name__, new_values))
         return new_values
 
     def run_validation(self, data=empty):
         """Since a nested serializer is treated like a Field, `is_valid` will not be called so we need to set
         _validated_data in the mixin."""
+        self.logger.debug("List-{} validating: {}".format(self.child.__class__.__name__, data))
         self._validated_data = super(NestedSaveListSerializer, self).run_validation(data)
-        print("List-{} validated: {}".format(self.child.__class__.__name__, self._validated_data))
+        self.logger.debug("List-{} validated: {}".format(self.child.__class__.__name__, self._validated_data))
         return self._validated_data
 
 
@@ -707,6 +741,8 @@ class Meta:
         return super(NestedSaveSerializer, cls).many_init(*args, **kwargs)
 
     def __init__(self, *args, **kwargs):
+        if kwargs.get('partial', False) is True:
+            raise ValueError("Partial Updates not currently supported by NestedSaveSerializer")
         self.queryset = kwargs.pop('queryset', self.queryset)
         if self.queryset is None and hasattr(self, 'Meta') and hasattr(self.Meta, 'model'):
             self.queryset = self.Meta.model.objects.all()
@@ -722,9 +758,11 @@ def __init__(self, *args, **kwargs):
 
     def run_validation(self, data=empty):
         """A nested serializer is treated like a Field so `is_valid` will not be called and `_validated_data` not set."""
+        self.logger.debug("{} validating: {}".format(self.__class__.__name__, data))
         # ensure Unique and UniqueTogether don't collide with a DB match
         validators = self.remove_validation_unique()
         self._validated_data = super(NestedSaveSerializer, self).run_validation(data)
+        self.logger.debug("{} validated: {}".format(self.__class__.__name__, self._validated_data))
         # restore Unique or UniqueTogether
         self.restore_validation_unique(validators)
         return self._validated_data
@@ -763,6 +801,10 @@ def restore_validation_unique(self, unique_validators):
             for validator in validators:
                 fields[name].validators.append(validator)
 
+    def save(self, **kwargs):
+        print("NestedSaveSerializer.save with data, kwargs: {}, {}".format(self._validated_data, kwargs))
+        return super().save(**kwargs)
+
     def update(self, instance, validated_data):
         raise KeyError(
             "Update should never be called on a NestedSerializerBase.  Make sure parent object uses NestedSaveMixin")
@@ -773,6 +815,7 @@ def create(self, validated_data):
 
 
 class UpdateDoSaveMixin(NestedSaveSerializer):
+    """Adds behavior to update the focal object, including M2M relations"""
 
     def do_update(self, match, kwargs):
         update_values = self.build_direct_values(kwargs)
@@ -787,17 +830,21 @@ def do_m2m_update(self, match, kwargs):
             # we don't care whether it's forward or reverse
             # if we provide a custom serializer, it may not inherit from ManyRelatedField
             if isinstance(field, ManyRelatedField) or isinstance(self._get_model_field(field.source), ManyToManyField):
-                value = kwargs.get(field_name, self._validated_data.get(field_name))
-                print("{}:  m2m set to {}, {}".format(self.__class__.__name__, field_name, value))
-                getattr(match, field_name).set(value)
+                value = kwargs.get(field_name, self._validated_data.get(field.source, empty))
+                if value is empty:
+                    continue  # no information
+                if value is None:
+                    value = []  # explicitly clear
+                print("{}:  m2m set to {}, {}".format(self.__class__.__name__, field.source, value))
+                getattr(match, field.source).set(value)
 
 
 class GetOnlyNestedSerializerMixin(NestedSaveSerializer):
     """Gets (without updating) requetsed object or fails."""
 
     def match(self, kwargs):
         match = super(GetOnlyNestedSerializerMixin, self).match(kwargs)
-        print("GetOnlyNestedSerializerMixin.match with super: {}".format(match))
+        print("GetOnlyNestedSerializerMixin.match with super {} and kwargs {}".format(match, kwargs))
         if match is not None:
             return match
         try:
@@ -817,7 +864,7 @@ class GetOrCreateNestedSerializerMixin(GetOnlyNestedSerializerMixin):
 
     def match(self, kwargs):
         match = super(GetOrCreateNestedSerializerMixin, self).match(kwargs)
-        print("GetOrCreateNestedSerializerMixin.match with super: {}".format(match))
+        print("GetOrCreateNestedSerializerMixin.match with super {} and kwargs {}".format(match, kwargs))
         if match is not None:
             return match
         create_values = self.build_direct_values(kwargs)
@@ -832,7 +879,7 @@ class CreateOnlyNestedSerializerMixin(NestedSaveSerializer):
     """Creates requested object or fails."""
 
     def match(self, kwargs):
-        print("CreateOnlyNestedSerializerMixin.match with no super")
+        print("GetOrCreateNestedSerializerMixin.match with no super and kwargs {}".format(kwargs))
         create_values = self.build_direct_values(kwargs)
         return self.queryset.model(**create_values)