def change_point_thumbnail(picture: Picture, context):
"""
Change the point thumbnail of the given Picture instance. The context is mandatory as it will be used to determine
the picture location.
:param Picture picture: Picture instance used to update its related point thumbnail property.
:param context: The context containing the original request instance.
:return:
"""
""" Change the picture's point thumbnail """
terra_opp_versatile_serializer = VersatileImageFieldSerializer("terra_opp")
terra_opp_versatile_serializer._context = context
last_picture_sizes = terra_opp_versatile_serializer.to_representation(picture.file)
# Use best image thumbnail
with Image.open(picture.file) as pic:
width, height = pic.size
if width < height:
picture.viewpoint.point.properties[
"viewpoint_picture"
] = last_picture_sizes["thumbnail_vertical"]
else:
picture.viewpoint.point.properties[
"viewpoint_picture"
] = last_picture_sizes["thumbnail"]
picture.viewpoint.point.save()
class OfferImageSerializer(serializers.ModelSerializer):
class Meta:
model = OfferImage
fields = (
'id',
'position',
'image',
'image_urls',
'_removed',
)
id = serializers.IntegerField(required=False)
_removed = serializers.BooleanField(required=False)
image = VersatileImageFieldSerializer(
sizes='offer_image',
required=True,
allow_null=False,
write_only=True,
)
image_urls = VersatileImageFieldSerializer(
sizes='offer_image',
source='image',
read_only=True,
)
class AuthUserSerializer(serializers.ModelSerializer):
photo = VersatileImageFieldSerializer(sizes='user_profile', required=False, allow_null=True, write_only=True)
photo_urls = VersatileImageFieldSerializer(sizes='user_profile', read_only=True, source='photo')
class Meta:
model = get_user_model()
fields = [
'id', 'display_name', 'email', 'unverified_email', 'password', 'mobile_number', 'address', 'latitude',
'longitude', 'description', 'mail_verified', 'current_group', 'language', 'photo', 'photo_urls'
]
read_only_fields = ('unverified_email', 'mail_verified')
extra_kwargs = {
'password': {
'write_only': True
},
'description': {
'trim_whitespace': False,
'max_length': settings.DESCRIPTION_MAX_LENGTH
},
'mail_verified': {
'default': False
},
}
def validate_email(self, email):
if self.context['request'].method != 'POST':
return email
similar = get_user_model().objects.filter_by_similar_email(email)
if similar.exists():
raise serializers.ValidationError(_('Similar e-mail exists: ') + similar.first().email)
return email
def validate_current_group(self, group):
user = self.context['request'].user
if group and not group.is_member(user):
raise serializers.ValidationError()
return group
def create(self, validated_data):
try:
user = self.Meta.model.objects.create_user(**validated_data)
except AnymailAPIError:
raise serializers.ValidationError(_('We could not send you an e-mail.'))
return user
def update(self, user, validated_data):
if 'password' in validated_data:
del validated_data['password']
if 'email' in validated_data:
del validated_data['email']
if 'language' in validated_data and validated_data['language'] != user.language:
user.update_language(validated_data.pop('language'))
if 'photo' in validated_data and validated_data['photo'] is None:
user.delete_photo()
return super().update(user, validated_data)
class VersatileImageTestModelSerializer(ModelSerializer):
"""Serializes VersatileImageTestModel instances"""
image = VersatileImageFieldSerializer(sizes='test_set')
optional_image = VersatileImageFieldSerializer(sizes='test_set')
class Meta:
model = VersatileImageTestModel
exclude = ('img_type', 'height', 'width', 'optional_image_2',
'optional_image_3')
class VersatileImageTestModelSerializer(ModelSerializer):
"""Serializes VersatileImageTestModel instances"""
image = VersatileImageFieldSerializer(sizes='test_set')
optional_image = VersatileImageFieldSerializer(sizes='test_set')
class Meta:
model = VersatileImageTestModel
fields = (
'image',
'optional_image',
)
class AktuelModelSerializer(serializers.ModelSerializer):
image_aktuel = VersatileImageFieldSerializer(sizes='image_aktuel')
image_aktuel_comp = VersatileImageFieldSerializer(sizes='image_aktuel_comp')
class Meta:
model = Aktuel
fields = [
'id',
'slug',
'image_aktuel',
'image_aktuel_comp'
]
class ProductImageSerializer(FlexFieldsModelSerializer):
"""Serializer for :model:`product.ProductImage`:
`**Fields:**`
01. `alt` : `CharField`
02. `id` : `AutoField`
03. `image` : `FileField`
04. `ppoi` : `CharField`
05. `product` : `ForeignKey` [:model:`product.Product`]
06. `sort_order` : `PositiveIntegerField`
`**Reverse Fields:**`
01. `productvariant` : `ManyToManyField` [:model:`product.ProductVariant`]
02. `variant_images` : `ForeignKey` [:model:`product.VariantImage`]
"""
image = VersatileImageFieldSerializer(sizes=get_rendition_keys())
class Meta:
model = ProductImage
fields = [
# Fields
'alt',
'id',
'image',
'ppoi',
'product',
'sort_order',
# Reverse Fields
# 'productvariant',
# 'variant_images',
]
read_only_fields = []
class UserSerializer(serializers.ModelSerializer):
"""Serializes User instances"""
profile_pic = VersatileImageFieldSerializer(sizes=[(
'full_size',
'url'), ('thumbnail',
'thumbnail__100x100'), (
'medium_square_crop',
'crop__400x400'), ('small_square_crop', 'crop__50x50')])
addresses = serializers.SerializerMethodField(read_only=True)
class Meta:
model = User
fields = (
'username',
'first_name',
'last_name',
'profile_pic',
'email',
'addresses',
)
def get_addresses(self, obj):
adresses = Address.objects.filter(user=obj)
serializer = AddressSerializer(adresses, many=True)
return serializer.data
class CreateUserSerializer(serializers.ModelSerializer):
profile_picture = VersatileImageFieldSerializer(required=False,
allow_null=True,
sizes='profile_picture')
def create(self, validated_data):
# call create_user on user object. Without this
# the password will be stored in plain text.
user = User.objects.create_user(**validated_data)
return user
class Meta:
model = User
fields = (
'id',
'username',
'password',
'first_name',
'last_name',
'email',
'auth_token',
'profile_picture',
)
read_only_fields = ('auth_token', )
extra_kwargs = {'password': {'write_only': True}}
class CategorySerializer(serializers.ModelSerializer):
class Meta:
model = Category
icon = VersatileImageFieldSerializer(
required=False,
sizes=[
('full_size', 'url'),
('thumbnail', 'thumbnail__150x150'),
('medium_square_crop', 'crop__555x238'),
]
)
@staticmethod
def get_size(size, instance):
if size == 'url':
return instance.url
kind, size = size.split("__")
return getattr(instance, kind)[size].url
def to_representation(self, instance):
data = super(CategorySerializer, self).to_representation(instance)
if not data['icon']:
data['icon'] = dict(
map(lambda args: (args[0], self.get_size(args[1], instance.icon),),
self.fields['icon'].sizes)
)
return data
class BenefitSerializer(FlexFieldsModelSerializer):
"""Serializer for :model:`widget.Benefit`:
`**Fields:**`
01. `id` : `AutoField`
02. `image` : `FileField`
03. `is_active` : `BooleanField`
04. `name` : `CharField`
05. `text` : `TextField`
`**Reverse Fields:**`
01. `translations` : `ForeignKey` [:model:`widget.BenefitTranslation`]
"""
image = VersatileImageFieldSerializer(sizes=get_rendition_keys())
class Meta:
model = Benefit
fields = [
# Fields
'id',
'image',
'is_active',
'name',
'text',
# Reverse Fields
# 'translations',
]
read_only_fields = []
class CommentSerializer(serializers.ModelSerializer):
content_type = ContentTypeField()
image = VersatileImageFieldSerializer(required=False,
allow_null=True,
sizes='image_size')
user = UserSerializer(read_only=True, many=False)
user_id = serializers.IntegerField(
default=serializers.CreateOnlyDefault(CurrentUserDefault()))
child = serializers.SerializerMethodField()
class Meta:
model = Comment
fields = '__all__'
def get_child(self, obj):
queryset = Comment.objects.filter(object_id=obj.id,
content_type__model='comment')
serializers = CommentSerializer(queryset,
many=True,
context=self.context)
return serializers.data
class MoleCreateSerializer(MoleSerializer):
photo = VersatileImageFieldSerializer(sizes='main_set',
required=True,
write_only=True)
age = serializers.IntegerField(required=False, allow_null=True)
study = serializers.PrimaryKeyRelatedField(queryset=Study.objects.all(),
write_only=True,
required=False)
class Meta(MoleSerializer.Meta):
fields = ('anatomical_site', 'patient_anatomical_site',
'position_info', 'photo', 'age', 'study')
validate_position_info = validate_position_info
validate = validate
def create(self, validated_data):
photo = validated_data.pop('photo')
age = validated_data.pop('age', None)
study = validated_data.pop('study', None)
mole = super(MoleCreateSerializer, self).create(validated_data)
MoleImage.objects.create(mole=mole, photo=photo, age=age, study=study)
return mole
class TableListSerializer(serializers.ModelSerializer):
update_url = serializers.HyperlinkedIdentityField(
view_name='student:update')
delete_url = serializers.HyperlinkedIdentityField(
view_name='student:api-delete')
adm_no = serializers.SerializerMethodField()
course = serializers.SerializerMethodField()
image = VersatileImageFieldSerializer(sizes=[(
'full_size',
'url'), ('thumbnail',
'thumbnail__100x100'), (
'medium_square_crop',
'crop__400x400'), ('small_square_crop', 'crop__50x50')])
class Meta:
model = Table
fields = ('id', 'adm_no', 'course', 'first_name', 'middle_name',
'last_name', 'nationality', 'dob', 'pob', 'gender',
'religion', 'parents', 'image', 'update_url', 'delete_url')
def get_adm_no(self, obj):
try:
return obj.student_official.first().adm_no
except:
return ''
def get_course(self, obj):
try:
return obj.student_official.first().course.name
except:
return ''
class GroupPreviewSerializer(GroupBaseSerializer):
"""
Public information for all visitors
should be readonly
"""
application_questions = serializers.SerializerMethodField()
photo_urls = VersatileImageFieldSerializer(sizes='group_logo',
read_only=True,
source='photo')
class Meta:
model = GroupModel
fields = [
'id',
'name',
'public_description',
'application_questions',
'address',
'latitude',
'longitude',
'members',
'status',
'theme',
'is_open',
'photo_urls',
]
def get_application_questions(self, group):
return group.get_application_questions_or_default()
class AppSerializer(serializers.ModelSerializer):
image = VersatileImageFieldSerializer(sizes='app_size')
class Meta:
model = App
fields = '__all__'
class PhotoCreateSerializer(serializers.ModelSerializer):
photo = VersatileImageFieldSerializer(
sizes=VERSATILEIMAGEFIELD_SETTINGS['sizes'], required=False)
tags = TagListField(many=True)
class Meta:
model = models.Photo
fields = ('photo', 'motive', 'date_taken', 'security_level',
'category', 'media', 'album', 'place', 'image_number',
'page', 'tags', 'scanned', 'on_home_page', 'splash', 'lapel')
def create(self, validated_data):
tags = validated_data.pop('tags')
photo = models.Photo.objects.create(**validated_data)
tags = tags if isinstance(tags, list) else [tags] # works
for tag_name in tags:
if not len(tag_name):
continue
tag, _ = models.Tag.objects.get_or_create(name=tag_name)
photo.tags.add(tag)
photo.save()
return photo
class SlideSerializer(FlexFieldsModelSerializer):
"""Serializer for :model:`widget.Slide`:
`**Fields:**`
01. `alt` : `CharField`
02. `id` : `AutoField`
03. `image` : `FileField`
04. `ppoi` : `CharField`
05. `slider` : `ForeignKey` [:model:`widget.Slider`]
06. `sort_order` : `PositiveIntegerField`
`**Reverse Fields:**`
"""
image = VersatileImageFieldSerializer(sizes=get_rendition_keys())
class Meta:
model = Slide
fields = [
# Fields
'alt',
'id',
'image',
# 'ppoi',
'slider',
'sort_order',
# Reverse Fields
]
read_only_fields = []
class ProfessionalSerializer(serializers.ModelSerializer):
user = UserSerializer(many=False)
profile_picture = VersatileImageFieldSerializer(sizes=[(
'full_size',
'url'), ('thumbnail',
'thumbnail__100x100'), (
'medium_square_crop',
'crop__400x400'), ('small_square_crop', 'crop__50x50')])
class Meta:
model = Professional
fields = ("id", "average", "count", "user", "experience", "rut",
"region", "city", "street", "house_number", "phone_number",
"identification", "profile_picture")
depth = 2
def update(self, instance, validated_data):
user_data = validated_data.pop('user', None)
if user_data:
for attr, value in user_data.items():
setattr(instance.user, attr, value)
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.user.save()
instance.save()
return instance
def create(self, validated_data):
user_data = validated_data.pop('user')
password = user_data.pop('password')
user, created = User.objects.get_or_create(**user_data)
user.set_password(password)
user.save()
professional = Professional.objects.create(user=user, **validated_data)
return professional
class ClientSerializer(serializers.ModelSerializer):
user = UserSerializer(many=False)
profile_picture = VersatileImageFieldSerializer(sizes=[(
'full_size',
'url'), ('thumbnail',
'thumbnail__100x100'), (
'medium_square_crop',
'crop__400x400'), ('small_square_crop', 'crop__50x50')])
class Meta:
model = Client
fields = ("id", "user", "profile_picture")
depth = 2
def update(self, instance, validated_data):
user_data = validated_data.pop('user', None)
if user_data:
for attr, value in user_data.items():
setattr(instance.user, attr, value)
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.user.save()
instance.save()
return instance
def create(self, validated_data):
user_data = validated_data.pop('user')
password = user_data.pop('password')
user, created = User.objects.get_or_create(**user_data)
user.set_password(password)
user.save()
client = Client.objects.create(user=user, **validated_data)
return client
class MoleImageSerializer(serializers.ModelSerializer):
photo = VersatileImageFieldSerializer(sizes='main_set', required=True)
class Meta:
model = MoleImage
fields = ('pk', 'date_created', 'date_modified', 'path_diagnosis',
'clinical_diagnosis', 'prediction', 'prediction_accuracy',
'photo', 'biopsy', 'biopsy_data', 'approved', 'age', 'study')
extra_kwargs = {
'age': {
'read_only': True,
},
}
def validate_biopsy_data(self, biopsy_data):
if isinstance(biopsy_data, str):
return json.loads(biopsy_data)
return biopsy_data
def validate_approved(self, data):
if data != self.instance.approved and \
not Coordinator.objects.filter(
doctor_ptr_id=self.context['request'].user.id).exists():
raise serializers.ValidationError(
"Only coordinator can approve images")
return data
def validate_study(self, study):
validate_study_consent_for_patient(
study, self.context['view'].kwargs['patient_pk'])
return study
class NewsSerializer(serializers.ModelSerializer):
image = VersatileImageFieldSerializer(sizes='news_image')
category = CategorySerializer(read_only=True)
class Meta:
model = News
fields = ('pk', 'title', 'description', 'category', 'created_at', 'updated_at', 'image', 'extra')
class ImageSerializer(ModelSerializer):
image = VersatileImageFieldSerializer(sizes=[
('full_size', 'url'),
('thumbnail', 'thumbnail__100x100'),
('medium_square_crop', 'crop__400x400'),
('small_square_crop', 'crop__50x50'),
], )
class Meta:
model = Image
fields = [
'id',
'creator',
'title',
'image',
'created_at',
'modified_at',
]
read_only_fields = [
'id',
'creator',
'image',
'created_at',
'modified_at',
]
class UserSerializer(serializers.ModelSerializer):
# groups = GroupSerializer(required=False, many=True)
# is_active = serializers.BooleanField(required=False)
# is_superuser = serializers.BooleanField(required=False)
# first_name = serializers.CharField(required=False)
# last_name = serializers.CharField(required=False)
photo = VersatileImageFieldSerializer(required=False,
allow_null=True,
sizes='image_size')
groups_id = serializers.PrimaryKeyRelatedField(
required=False,
write_only=True,
many=True,
allow_null=True,
queryset=Group.objects.all())
name = serializers.SerializerMethodField()
email = serializers.SerializerMethodField()
class Meta:
model = User
exclude = ('password', )
def get_name(self, obj):
return obj.name
def get_email(self, obj):
try:
email_address = obj.email_address.latest('join')
serializers = EmailAddressSerializer(email_address,
context=self.context)
return serializers.data
except EmailAddress.DoesNotExist:
return None
# def get_photo(self, obj):
# photo = obj.images.all().filter(tag='photo').last()
# if photo:
# serializer = ImageSerializer(photo, context=self.context)
# return serializer.data
def update(self, instance, validated_data):
groups_id = validated_data.pop('groups_id', None)
if groups_id is not None:
for group in list(instance.groups.all()):
instance.groups.remove(group)
for id in groups_id:
instance.groups.add(id)
return super().update(instance, validated_data)
class UserProfileModelSerializer(serializers.ModelSerializer):
userphoto = VersatileImageFieldSerializer(sizes='userphoto')
class Meta:
model = UserProfile
fields = [
'id', 'name', 'surname', 'birthday', 'gender', 'phone', 'userphoto'
]
class AlbumSerializer(serializers.ModelSerializer):
main_image = VersatileImageFieldSerializer(sizes='album_image')
images = ImageSerializer(many=True, read_only=True)
event = GalleryEventSerializer(read_only=True)
class Meta:
model = Album
fields = ('pk', 'name', 'description', 'event', 'main_image', 'images')
class EventSerializer(serializers.ModelSerializer):
poster = VersatileImageFieldSerializer(sizes='event_poster')
artists = ArtistSerializer(many=True, read_only=True)
class Meta:
model = Event
fields = ('pk', 'name', 'artists', 'info', 'date', 'start',
'discounts', 'price', 'is_special', 'poster', 'extra')
class actorSerializer(serializers.HyperlinkedModelSerializer):
owner = serializers.ReadOnlyField(source='owner.username')
pic = VersatileImageFieldSerializer(sizes='image_cut')
class Meta:
model = actor
fields = ('url', 'first_name', 'last_name', 'get_full_name', 'pic',
'gender', 'age', 'owner')
class SetSerializer(serializers.ModelSerializer):
menu = MenuSetSerializer(source='menuset_set', many=True)
photo = VersatileImageFieldSerializer(sizes='set_photo')
prices = PriceSerializer(many=True, read_only=True)
class Meta:
model = Set
fields = ('pk', 'name', 'description', 'created_at', 'menu', 'prices', 'photo')
class MenuSerializer(serializers.ModelSerializer):
photo = VersatileImageFieldSerializer(sizes='menu_photo')
prices = PriceSerializer(many=True, read_only=True)
category = CategorySerializer(read_only=True)
class Meta:
model = Menu
fields = ('pk', 'name', 'description', 'category', 'created_at', 'detail', 'prices', 'photo')
