gault-millau/apps/establishment/serializers/common.py
2019-11-16 18:32:38 +03:00

412 lines
13 KiB
Python

"""Establishment serializers."""
from django.utils.translation import ugettext_lazy as _
from rest_framework import serializers
from comment import models as comment_models
from comment.serializers import common as comment_serializers
from establishment import models
from location.serializers import AddressBaseSerializer, CitySerializer, AddressDetailSerializer, CityShortSerializer
from main.serializers import AwardSerializer, CurrencySerializer
from tag.serializers import TagBaseSerializer
from timetable.serialziers import ScheduleRUDSerializer
from utils import exceptions as utils_exceptions
from utils.serializers import (ProjectModelSerializer, TranslatedField,
FavoritesCreateSerializer)
from review.serializers import ReviewShortSerializer
class ContactPhonesSerializer(serializers.ModelSerializer):
"""Contact phone serializer"""
class Meta:
model = models.ContactPhone
fields = [
'phone'
]
class ContactEmailsSerializer(serializers.ModelSerializer):
"""Contact email serializer"""
class Meta:
model = models.ContactEmail
fields = [
'email'
]
class SocialNetworkRelatedSerializers(serializers.ModelSerializer):
"""Social network serializers."""
class Meta:
model = models.SocialNetwork
fields = [
'id',
'network',
'url',
]
class PlateSerializer(ProjectModelSerializer):
name_translated = TranslatedField()
currency = CurrencySerializer(read_only=True)
class Meta:
model = models.Plate
fields = [
'name_translated',
'currency',
'price',
'is_signature_plate',
]
class MenuSerializers(ProjectModelSerializer):
plates = PlateSerializer(read_only=True, many=True, source='plate_set')
category_translated = serializers.CharField(read_only=True)
class Meta:
model = models.Menu
fields = [
'id',
'category',
'category_translated',
'plates',
'establishment'
]
class MenuRUDSerializers(ProjectModelSerializer):
plates = PlateSerializer(read_only=True, many=True, source='plate_set')
class Meta:
model = models.Menu
fields = [
'id',
'category',
'plates',
'establishment'
]
class EstablishmentTypeBaseSerializer(serializers.ModelSerializer):
"""Serializer for EstablishmentType model."""
name_translated = TranslatedField()
class Meta:
"""Meta class."""
model = models.EstablishmentType
fields = [
'id',
'name',
'name_translated',
'use_subtypes',
'index_name',
]
extra_kwargs = {
'name': {'write_only': True},
'use_subtypes': {'write_only': True},
}
class EstablishmentTypeGeoSerializer(EstablishmentTypeBaseSerializer):
"""Serializer for EstablishmentType model w/ index_name."""
class Meta(EstablishmentTypeBaseSerializer.Meta):
fields = EstablishmentTypeBaseSerializer.Meta.fields + [
'index_name'
]
extra_kwargs = {
**EstablishmentTypeBaseSerializer.Meta.extra_kwargs,
'index_name': {'read_only': True},
}
class EstablishmentSubTypeBaseSerializer(serializers.ModelSerializer):
"""Serializer for EstablishmentSubType models."""
name_translated = TranslatedField()
class Meta:
"""Meta class."""
model = models.EstablishmentSubType
fields = [
'id',
'name',
'name_translated',
'establishment_type',
'index_name',
]
extra_kwargs = {
'name': {'write_only': True},
'establishment_type': {'write_only': True}
}
class EstablishmentSubTypeGeoSerializer(EstablishmentSubTypeBaseSerializer):
"""Serializer for EstablishmentSuType model w/ index_name."""
class Meta(EstablishmentSubTypeBaseSerializer.Meta):
fields = EstablishmentSubTypeBaseSerializer.Meta.fields + [
'index_name'
]
extra_kwargs = {
**EstablishmentSubTypeBaseSerializer.Meta.extra_kwargs,
'index_name': {'read_only': True},
}
class EstablishmentEmployeeSerializer(serializers.ModelSerializer):
"""Serializer for actual employees."""
id = serializers.IntegerField(source='employee.id')
name = serializers.CharField(source='employee.name')
position_translated = serializers.CharField(source='position.name_translated')
awards = AwardSerializer(source='employee.awards', many=True)
priority = serializers.IntegerField(source='position.priority')
position_index_name = serializers.CharField(source='position.index_name')
class Meta:
"""Meta class."""
model = models.Employee
fields = ('id', 'name', 'position_translated', 'awards', 'priority', 'position_index_name')
class EstablishmentShortSerializer(serializers.ModelSerializer):
"""Short serializer for establishment."""
city = CitySerializer(source='address.city', allow_null=True)
establishment_type = EstablishmentTypeGeoSerializer()
establishment_subtypes = EstablishmentSubTypeBaseSerializer(many=True)
class Meta:
"""Meta class."""
model = models.Establishment
fields = [
'id',
'name',
'index_name',
'slug',
'city',
'establishment_type',
'establishment_subtypes',
]
class EstablishmentProductShortSerializer(serializers.ModelSerializer):
"""SHORT Serializer for displaying info about an establishment on product page."""
establishment_type = EstablishmentTypeGeoSerializer()
establishment_subtypes = EstablishmentSubTypeBaseSerializer(many=True)
address = AddressBaseSerializer()
city = CityShortSerializer(source='address.city', allow_null=True)
class Meta:
"""Meta class."""
model = models.Establishment
fields = [
'id',
'name',
'index_name',
'slug',
'city',
'establishment_type',
'establishment_subtypes',
'address',
]
class EstablishmentProductSerializer(EstablishmentShortSerializer):
"""Serializer for displaying info about an establishment on product page."""
address = AddressBaseSerializer()
class Meta(EstablishmentShortSerializer.Meta):
"""Meta class."""
fields = EstablishmentShortSerializer.Meta.fields + [
'address',
]
class EstablishmentBaseSerializer(ProjectModelSerializer):
"""Base serializer for Establishment model."""
preview_image = serializers.URLField(source='preview_image_url')
address = AddressBaseSerializer()
in_favorites = serializers.BooleanField(allow_null=True)
tags = TagBaseSerializer(read_only=True, many=True)
currency = CurrencySerializer()
type = EstablishmentTypeBaseSerializer(source='establishment_type', read_only=True)
subtypes = EstablishmentSubTypeBaseSerializer(many=True, source='establishment_subtypes')
class Meta:
"""Meta class."""
model = models.Establishment
fields = [
'id',
'name',
'transliterated_name',
'index_name',
'price_level',
'toque_number',
'public_mark',
'slug',
'preview_image',
'in_favorites',
'address',
'tags',
'currency',
'type',
'subtypes',
]
class EstablishmentListRetrieveSerializer(EstablishmentBaseSerializer):
"""Establishment with city serializer."""
address = AddressDetailSerializer()
schedule = ScheduleRUDSerializer(many=True, allow_null=True)
class Meta(EstablishmentBaseSerializer.Meta):
"""Meta class."""
fields = EstablishmentBaseSerializer.Meta.fields + [
'schedule',
]
class EstablishmentGeoSerializer(EstablishmentBaseSerializer):
"""Serializer for Geo view."""
type = EstablishmentTypeGeoSerializer(source='establishment_type', read_only=True)
subtypes = EstablishmentSubTypeGeoSerializer(many=True, source='establishment_subtypes')
class Meta(EstablishmentBaseSerializer.Meta):
"""Meta class."""
fields = EstablishmentBaseSerializer.Meta.fields
class RangePriceSerializer(serializers.Serializer):
max = serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True, default=0)
min = serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True, default=0)
class EstablishmentDetailSerializer(EstablishmentBaseSerializer):
"""Serializer for Establishment model."""
description_translated = TranslatedField()
image = serializers.URLField(source='image_url')
awards = AwardSerializer(many=True)
schedule = ScheduleRUDSerializer(many=True, allow_null=True)
phones = ContactPhonesSerializer(read_only=True, many=True)
emails = ContactEmailsSerializer(read_only=True, many=True)
review = ReviewShortSerializer(source='last_published_review', allow_null=True)
employees = EstablishmentEmployeeSerializer(source='actual_establishment_employees',
many=True)
address = AddressDetailSerializer(read_only=True)
menu = MenuSerializers(source='menu_set', many=True, read_only=True)
best_price_menu = serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
best_price_carte = serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
range_price_menu = RangePriceSerializer(read_only=True)
range_price_carte = RangePriceSerializer(read_only=True)
vintage_year = serializers.ReadOnlyField()
class Meta(EstablishmentBaseSerializer.Meta):
"""Meta class."""
fields = EstablishmentBaseSerializer.Meta.fields + [
'description_translated',
'image',
'awards',
'schedule',
'website',
'facebook',
'twitter',
'lafourchette',
'booking',
'phones',
'emails',
'review',
'employees',
'menu',
'best_price_menu',
'best_price_carte',
'range_price_menu',
'range_price_carte',
'transportation',
'vintage_year',
]
class EstablishmentSimilarSerializer(EstablishmentBaseSerializer):
"""Serializer for Establishment model."""
address = AddressDetailSerializer(read_only=True)
class EstablishmentCommentCreateSerializer(comment_serializers.CommentSerializer):
"""Create comment serializer"""
mark = serializers.IntegerField()
class Meta:
"""Serializer for model Comment"""
model = comment_models.Comment
fields = [
'id',
'created',
'text',
'mark',
'nickname',
'profile_pic',
]
def validate(self, attrs):
"""Override validate method"""
# Check establishment object
establishment_slug = self.context.get('request').parser_context.get('kwargs').get('slug')
establishment_qs = models.Establishment.objects.filter(slug=establishment_slug)
if not establishment_qs.exists():
raise serializers.ValidationError({'detail': _('Establishment not found.')})
attrs['establishment'] = establishment_qs.first()
return attrs
def create(self, validated_data, *args, **kwargs):
"""Override create method"""
validated_data.update({
'user': self.context.get('request').user,
'content_object': validated_data.pop('establishment')
})
return super().create(validated_data)
class EstablishmentFavoritesCreateSerializer(FavoritesCreateSerializer):
"""Serializer to favorite object w/ model Establishment."""
def validate(self, attrs):
"""Overridden validate method"""
# Check establishment object
establishment_qs = models.Establishment.objects.filter(slug=self.slug)
# Check establishment obj by slug from lookup_kwarg
if not establishment_qs.exists():
raise serializers.ValidationError({'detail': _('Object not found.')})
else:
establishment = establishment_qs.first()
# Check existence in favorites
if establishment.favorites.filter(user=self.user).exists():
raise utils_exceptions.FavoritesError()
attrs['establishment'] = establishment
return attrs
def create(self, validated_data, *args, **kwargs):
"""Overridden create method"""
validated_data.update({
'user': self.user,
'content_object': validated_data.pop('establishment')
})
return super().create(validated_data)