class Admin2APISerializer(serializers.HyperlinkedModelSerializer):
_default_view_name = 'admin2:%(app_label)s_%(model_name)s_api_detail'
pk = fields.ReadOnlyField()
__unicode__ = fields.ReadOnlyField(source='__str__')
def get_extra_kwargs(self):
extra_kwargs = super(Admin2APISerializer, self).get_extra_kwargs()
extra_kwargs.update({
'url': {
'view_name': self._get_default_view_name(self.Meta.model)
}
})
return extra_kwargs
def _get_default_view_name(self, model):
"""
Return the view name to use if 'view_name' is not specified in 'Meta'
"""
model_meta = model._meta
format_kwargs = {
'app_label': model_meta.app_label,
'model_name': model_meta.object_name.lower()
}
return self._default_view_name % format_kwargs
class HerbariumRawSerializer(serializers.ModelSerializer):
name = fields.ReadOnlyField(source='kind.__str__', )
kind_key = fields.ReadOnlyField(source='kind.key', )
seasons = SeasonSerializer(many=True, )
class Meta:
model = Herbarium
fields = 'name latin_name description seasons photo kind_key'.split()
class UserSerializer(serializers.HyperlinkedModelSerializer):
username = fields.ReadOnlyField()
first_name = fields.SerializerMethodField('get_first_name_to_friend')
last_name = fields.SerializerMethodField('get_last_name_to_friend')
isFriend = fields.SerializerMethodField('check_friend')
class Meta:
model = User
fields = ('id', 'username', 'first_name', 'last_name', 'avatar',
'isFriend')
depth = 3
def get_first_name_to_friend(self, obj):
request = self.context['request']
if obj.friends.filter(friend__id=request.user.id).exists(
) or request.user.is_staff or obj == request.user:
return obj.first_name
return None
def get_last_name_to_friend(self, obj):
request = self.context['request']
if obj.friends.filter(friend__id=request.user.id).exists(
) or request.user.is_staff or obj == request.user:
return obj.last_name
return None
def check_friend(self, obj):
return obj.friends.all().filter(
author=self.context['request'].user).exists()
class DocumentSerializer(serializers.ModelSerializer):
# The slug field isn't part of a SourceFile, but we get it from the filetype
sourcefiles = serializers.SlugRelatedField(many=True,
slug_field='slug',
read_only=True)
derivedfiles = fields.ReadOnlyField(source='derivedmap', read_only=True)
collections = serializers.SlugRelatedField(many=True,
slug_field='slug',
read_only=True)
class Meta:
model = models.Document
fields = [
'collections', 'derivedfiles', 'sourcefiles',
'external_identifier', 'title'
]
def create(self, validated_data):
args = self.context["view"].kwargs
collection = validated_data.pop('collection')
rel_collection = get_object_or_404(models.Collection, **collection)
external = args["external_identifier"]
document, created = models.Document.objects.get_or_create(
collections=collection,
external_identifier=external,
defaults=validated_data)
return document
class ParticipantSerializer(ModelSerializer):
user = UserSerializer()
position = geo_fields.PointField(str_points=True)
crisis = fields.ReadOnlyField(source="crisis_id")
class Meta:
model = Participant
fields = "__all__"
class HerbariumRawSerializer(serializers.ModelSerializer):
kind_key = fields.ReadOnlyField(source="kind.key", )
seasons = SeasonSerializer(many=True, )
class Meta:
model = Herbarium
fields = "name latin_name description seasons photo kind_key".split()
class UserRetrieveSerializer(serializers.ModelSerializer):
"""
Сериализатор пользователя
"""
role_display = fields.ReadOnlyField(source='get_role_display')
class Meta:
model = User
fields = ('id', 'comment_author_name', 'role_display')
class BaseSnippetSerializer(serializers.ModelSerializer):
id = fields.ReadOnlyField(source='pk')
title = fields.SerializerMethodField()
edit_url = fields.SerializerMethodField()
def get_title(self, instance):
return str(instance)
def get_edit_url(self, instance):
return reverse('wagtailsnippets:edit', args=[instance._meta.app_label, instance._meta.model_name, quote(instance.id)])
class ProfileRetrieveSerializer(serializers.ModelSerializer):
"""
Сериализатор профиля пользователя
"""
role_display = fields.ReadOnlyField(source='get_role_display')
class Meta:
model = User
fields = ('id', 'email', 'first_name', 'last_name', 'middle_name',
'role_display')
def test_get_field_names(self):
def check(serializer, expected):
self.assertListEqual(serializer.get_field_names(), expected)
check(self.create_serializer(Person),
['name', 'length', 'birth_date'])
check(self.create_serializer(Person, meta={'fields': ['name', 'length']}),
['name', 'length'])
check(self.create_serializer(Person, meta={'fields': serializers.ALL_FIELDS}),
['name', 'length', 'birth_date'])
check(self.create_serializer(Person, meta={'fields': (serializers.ALL_FIELDS, 'age')}),
['age', 'name', 'length', 'birth_date'])
check(self.create_serializer(Person, meta={'fields': ('age', )}),
['age'])
check(self.create_serializer(Person, meta={'exclude': ['name']}),
['length', 'birth_date'])
check(self.create_serializer(Person, declared={'age': fields.ReadOnlyField()}),
['age', 'name', 'length', 'birth_date'])
# invalid `fields` specification
with self.assertRaises(TypeError):
self.create_serializer(Person, meta={'fields': 'invalid'}).get_field_names()
# invalid `exclude` specification
with self.assertRaises(TypeError):
self.create_serializer(Person, meta={'exclude': 'invalid'}).get_field_names()
# declared field not in `fields`
with self.assertRaises(AssertionError):
self.create_serializer(Person,
declared={'name': fields.SlugField()},
meta={'fields': ['length']}).get_field_names()
# declared field in `exclude`
with self.assertRaises(AssertionError):
self.create_serializer(Person,
declared={'name': fields.SlugField()},
meta={'exclude': ['name']}).get_field_names()
# non-existing field in `fields`
with self.assertRaises(AssertionError):
self.create_serializer(Person, meta={'fields': ['nonexisting']}).get_field_names()
# non-existing field in `exclude`
with self.assertRaises(AssertionError):
self.create_serializer(Person, meta={'exclude': ['nonexisting']}).get_field_names()
# both `fields` and `exclude` specified
with self.assertRaises(AssertionError):
self.create_serializer(Person, meta={'fields': ['name'], 'exclude': ['length']}).get_field_names()
class PostSerializer(serializers.ModelSerializer):
comments = CommentSerializer(many=True, read_only=True)
author = fields.ReadOnlyField(source='author.username')
class Meta:
model = Post
fields = ['id', 'content', 'created_at', 'author', 'comments']
def create(self, validated_data):
user = self.context['request'].user
return Post.objects.create(author=user,
content=validated_data['content'])
def update(self, instance, validated_data):
instance.content = validated_data['content']
instance.save()
return instance
class FeedbackSerializer(PotatoCaptchaSerializer):
feedback = fields.CharField(allow_blank=False)
chromeless = fields.CharField(required=False)
from_url = fields.CharField(required=False)
user = fields.ReadOnlyField(required=False)
platform = fields.CharField(required=False, allow_null=True)
def to_representation(self, attrs):
attrs = super(FeedbackSerializer, self).to_representation(attrs)
if not attrs.get('platform'):
attrs['platform'] = self.request.GET.get('dev', '')
if self.request.user.is_authenticated():
attrs['user'] = unicode(self.request.user)
else:
attrs['user'] = None
return attrs
class ReplySerializer(serializers.ModelSerializer):
author = fields.ReadOnlyField(source='author.username')
class Meta:
model = Reply
fields = ['id', 'content', 'created_at', 'author', 'comment']
def create(self, validated_data):
user = self.context['request'].user
comment = validated_data['comment']
return Reply.objects.create(author=user,
comment=comment,
content=validated_data['content'])
def update(self, instance, validated_data):
instance.content = validated_data['content']
instance.save()
return instance
class UserSerializer(serializers.ModelSerializer):
"""
UserProxy model serializer that takes optional `with_secret_key` argument
that controls whether the secret_key for the user should be displayed.
"""
def __init__(self, *args, **kwargs):
# Don't pass `with_secret_key` up to the superclass
self.with_secret_key = kwargs.pop('with_secret_key', None)
super(UserSerializer, self).__init__(*args, **kwargs)
# If we haven't passed `with_secret_key`, don't show the secret_key
# field.
if self.with_secret_key is None:
self.fields.pop('secret_key')
permissions = fields.ReadOnlyField(source='get_permissions')
class Meta:
model = get_user_model()
fields = ('id', 'email', 'permissions', 'secret_key')
class CommentSerializer(serializers.ModelSerializer):
replies = ReplySerializer(many=True, read_only=True)
post = serializers.PrimaryKeyRelatedField(queryset=Post.objects.all(),
required=False)
author = fields.ReadOnlyField(source='author.username')
class Meta:
model = Comment
fields = ['id', 'content', 'created_at', 'author', 'replies', 'post']
def create(self, validated_data):
user = self.context['request'].user
post = validated_data['post']
return Comment.objects.create(author=user,
post=post,
content=validated_data['content'])
def update(self, instance, validated_data):
instance.content = validated_data['content']
instance.save()
return instance
class UserSerializer(serializers.HyperlinkedModelSerializer):
first_login = fields.ReadOnlyField(source='userprofile.first_login')
followed_tags = TagNameSerializer(source='userprofile.followed_tags',
many=True)
saved_places = FixedHyperlinkedRelatedField(
view_name='place-detail',
source='userprofile.saved_places',
many=True,
read_only=True)
class Meta:
model = User
fields = ('url', 'username', 'first_login', 'first_name', 'last_name',
'followed_tags', 'saved_places')
def to_representation(self, instance):
data = super(UserSerializer, self).to_representation(instance)
if self.context['request'].user != instance:
del data['followed_tags']
del data['saved_places']
return data
def create(self, validated_data):
raise NotImplementedError('No creation via JSON')
def update(self, instance, validated_data):
for attr, value in validated_data.items():
if attr == 'userprofile':
continue
setattr(instance, attr, value)
instance.save()
instance.userprofile.followed_tags.clear()
for tagname in validated_data['userprofile']['followed_tags']:
instance.userprofile.followed_tags.add(
Tag.objects.get(name=tagname))
instance.userprofile.save()
return instance
def build_property_field(self, field_name, info):
return fields.ReadOnlyField()
class SourceSerializer(serializers.HyperlinkedModelSerializer):
"""
Source serializer for main/database orm.
TODO: fileRef_id and collection_id should be checked to belong to the
same organisation as the source.
"""
fileRef = FileSerializer(allow_null=True, required=False, read_only=True)
annotations = AnnotationSerializer(many=True, read_only=True)
# Writable related fields - see create / update for how to manually
# deal with it upon serialization
tags = TagSerializer(allow_null=True,
required=False,
many=True,
read_only=False)
stories = StorySerializer(allow_null=True,
required=False,
many=True,
read_only=False)
collection = CollectionSerializer(allow_null=True,
required=False,
read_only=True)
# Force serializer to accept the id directly
fileRef_id = fields.IntegerField(required=False, allow_null=True)
# For setting collection
collection_id = fields.IntegerField(required=False, allow_null=True)
shareUrl = fields.ReadOnlyField()
downloadUrl = fields.ReadOnlyField()
owner = UserSerializer(read_only=True)
class Meta:
model = Source
fields = ('id', 'title', 'description', 'sourcetype', 'stories',
'tags', 'public', 'collection', 'collection_id', 'sourceId',
'sourceURL', 'externalServiceId', 'externalServiceName',
'embedId', 'fileRef', 'fileRef_id', 'annotations',
'shareUrl', 'downloadUrl', 'owner', 'language', 'country',
'date', 'publishedDate', 'created_at', 'updated_at')
def create(self, validated_data):
"""
Custom create - saves tags + stories.
"""
tagNames = self._popRelatedList(validated_data, 'tags')
storiesNames = self._popRelatedList(validated_data, 'stories')
# Create via base class after validated_data was cleaned
instance = super().create(validated_data)
tagObjects = [
Tag.getOrCreate(t, instance.organisation) for t in tagNames
]
instance.tags.set(tagObjects)
storiesObjects = [
Story.getOrCreate(t, instance.organisation) for t in storiesNames
]
instance.stories.set(storiesObjects)
return instance
def update(self, instance, validated_data):
"""
Custom update - saves tags + stories.
"""
tagNames = self._popRelatedList(validated_data, 'tags')
storiesNames = self._popRelatedList(validated_data, 'stories')
tagObjects = [
Tag.getOrCreate(t, instance.organisation) for t in tagNames
]
instance.tags.set(tagObjects)
storiesObjects = [
Story.getOrCreate(t, instance.organisation) for t in storiesNames
]
instance.stories.set(storiesObjects)
return super().update(instance, validated_data)
def _popRelatedList(self, validated_data, attr_name):
items = validated_data.pop(attr_name) \
if attr_name in validated_data else None
items = items if items is not None else []
itemNames = [t['name'] for t in items]
return itemNames
