155 lines
5.4 KiB
Python
155 lines
5.4 KiB
Python
import traceback
|
|
|
|
from rest_framework import serializers
|
|
from rest_framework.fields import CharField, ListField
|
|
from rest_framework.serializers import raise_errors_on_nested_writes
|
|
from rest_framework.utils import model_meta
|
|
|
|
from tagulous.models.managers import TagRelatedManagerMixin
|
|
|
|
from taggit_serializer.serializers import TagListSerializerField, TaggitSerializer
|
|
|
|
|
|
class SingleTag(str):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
pass
|
|
|
|
def __str__(self):
|
|
return self
|
|
|
|
|
|
class SingleTagSerializerField(serializers.Field):
|
|
child = serializers.CharField()
|
|
default_error_messages = {
|
|
'not_a_str': 'Expected a string but got type "{input_type}".',
|
|
}
|
|
order_by = None
|
|
|
|
def __init__(self, **kwargs):
|
|
super(SingleTagSerializerField, self).__init__(**kwargs)
|
|
|
|
def to_internal_value(self, value):
|
|
if isinstance(value, str):
|
|
if not value:
|
|
value = ""
|
|
|
|
if not isinstance(value, str):
|
|
self.fail('not_a_str', input_type=type(value).__name__)
|
|
|
|
return value
|
|
|
|
def to_representation(self, value):
|
|
if not isinstance(value, SingleTag):
|
|
if not isinstance(value, str):
|
|
value = value.name
|
|
value = SingleTag(value)
|
|
return value
|
|
|
|
|
|
class CustomTagSerializer(serializers.Serializer):
|
|
"""
|
|
Differentiate between tags and single-tags
|
|
"""
|
|
|
|
def create(self, validated_data):
|
|
to_be_tagged, validated_data = self._pop_tags(validated_data)
|
|
|
|
# tag_object = super(CustomTagSerializer, self).create(validated_data)
|
|
raise_errors_on_nested_writes('create', self, validated_data)
|
|
|
|
ModelClass = self.Meta.model
|
|
|
|
# Remove many-to-many relationships from validated_data.
|
|
# They are not valid arguments to the default `.create()` method,
|
|
# as they require that the instance has already been saved.
|
|
info = model_meta.get_field_info(ModelClass)
|
|
many_to_many = {}
|
|
for field_name, relation_info in info.relations.items():
|
|
if relation_info.to_many and (field_name in validated_data):
|
|
many_to_many[field_name] = validated_data.pop(field_name)
|
|
|
|
try:
|
|
instance = ModelClass._default_manager.create(**validated_data)
|
|
except TypeError:
|
|
tb = traceback.format_exc()
|
|
msg = (
|
|
'Got a `TypeError` when calling `%s.%s.create()`. '
|
|
'This may be because you have a writable field on the '
|
|
'serializer class that is not a valid argument to '
|
|
'`%s.%s.create()`. You may need to make the field '
|
|
'read-only, or override the %s.create() method to handle '
|
|
'this correctly.\nOriginal exception was:\n %s' %
|
|
(
|
|
ModelClass.__name__,
|
|
ModelClass._default_manager.name,
|
|
ModelClass.__name__,
|
|
ModelClass._default_manager.name,
|
|
self.__class__.__name__,
|
|
tb
|
|
)
|
|
)
|
|
raise TypeError(msg)
|
|
|
|
# Save many-to-many relationships after the instance is created.
|
|
if many_to_many:
|
|
for field_name, value in many_to_many.items():
|
|
field = getattr(instance, field_name)
|
|
if field_name in ('tags', 'category', 'attributes'):
|
|
for item in value:
|
|
field.set(item)
|
|
else:
|
|
field.set(value)
|
|
|
|
return self._save_tags(instance, to_be_tagged)
|
|
|
|
def update(self, instance, validated_data):
|
|
to_be_tagged, validated_data = self._pop_tags(validated_data)
|
|
|
|
raise_errors_on_nested_writes('update', self, validated_data)
|
|
info = model_meta.get_field_info(instance)
|
|
|
|
# Simply set each attribute on the instance, and then save it.
|
|
# Note that unlike `.create()` we don't need to treat many-to-many
|
|
# relationships as being a special case. During updates we already
|
|
# have an instance pk for the relationships to be associated with.
|
|
m2m_fields = []
|
|
for attr, value in validated_data.items():
|
|
if attr in info.relations and info.relations[attr].to_many:
|
|
m2m_fields.append((attr, value))
|
|
else:
|
|
setattr(instance, attr, value)
|
|
|
|
instance.save()
|
|
|
|
# Note that many-to-many fields are set after updating instance.
|
|
# Setting m2m fields triggers signals which could potentially change
|
|
# updated instance and we do not want it to collide with .update()
|
|
for attr, value in m2m_fields:
|
|
field = getattr(instance, attr)
|
|
if attr in ('tags', 'category', 'attributes'):
|
|
for item in value:
|
|
field.set(item)
|
|
else:
|
|
field.set(value)
|
|
|
|
return self._save_tags(instance, to_be_tagged)
|
|
|
|
def _save_tags(self, tag_object, tags):
|
|
for key in tags.keys():
|
|
tag_values = tags.get(key)
|
|
getattr(tag_object, key).set(*tag_values)
|
|
|
|
return tag_object
|
|
|
|
def _pop_tags(self, validated_data):
|
|
to_be_tagged = {}
|
|
|
|
for key in self.fields.keys():
|
|
field = self.fields[key]
|
|
if isinstance(field, TagListSerializerField):
|
|
if key in validated_data:
|
|
to_be_tagged[key] = validated_data.pop(key)
|
|
|
|
return (to_be_tagged, validated_data)
|