259 lines
8.4 KiB
Python
259 lines
8.4 KiB
Python
from rest_framework import serializers
|
|
from django.utils.text import slugify
|
|
|
|
from product import models
|
|
from location import models as location_models
|
|
from tag import models as tag_models
|
|
from establishment import models as establishment_models
|
|
from transfer import models as transfer_models
|
|
from utils.methods import get_point_from_coordinates
|
|
from transfer.mixins import TransferSerializerMixin
|
|
from django.conf import settings
|
|
|
|
|
|
class WineColorSerializer(TransferSerializerMixin):
|
|
TAG_CATEGORY = 'wine_color'
|
|
|
|
id = serializers.IntegerField()
|
|
name = serializers.CharField(allow_null=True)
|
|
order_number = serializers.IntegerField(allow_null=True)
|
|
|
|
class Meta:
|
|
model = tag_models.Tag
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'order_number',
|
|
)
|
|
|
|
def validate(self, attrs):
|
|
value = attrs.pop('name')
|
|
attrs['old_id'] = attrs.pop('id', None)
|
|
attrs['label'] = {settings.FALLBACK_LOCALE: value}
|
|
attrs['value'] = slugify(value)
|
|
attrs['priority'] = attrs.pop('order_number')
|
|
attrs['category'] = self.tag_category
|
|
return attrs
|
|
|
|
@property
|
|
def tag_category(self):
|
|
qs = tag_models.TagCategory.objects.filter(index_name=self.TAG_CATEGORY)
|
|
if qs.exists():
|
|
return qs.first()
|
|
|
|
|
|
class BottlesProducedSerializer(TransferSerializerMixin):
|
|
TAG_CATEGORY = 'bottles_produced'
|
|
|
|
bottles_produced = serializers.IntegerField()
|
|
|
|
class Meta:
|
|
model = tag_models.Tag
|
|
fields = (
|
|
'bottles_produced',
|
|
)
|
|
|
|
def validate(self, attrs):
|
|
value = attrs.pop('bottles_produced')
|
|
attrs['label'] = {settings.FALLBACK_LOCALE: value}
|
|
attrs['value'] = slugify(value)
|
|
attrs['category'] = self.tag_category
|
|
return attrs
|
|
|
|
@property
|
|
def tag_category(self):
|
|
qs = tag_models.TagCategory.objects.filter(index_name=self.TAG_CATEGORY)
|
|
if qs.exists():
|
|
return qs.first()
|
|
|
|
|
|
class WineStandardSerializer(TransferSerializerMixin):
|
|
id = serializers.IntegerField()
|
|
name = serializers.CharField()
|
|
type = serializers.ChoiceField(choices=models.WineStandard.STANDARDS,
|
|
allow_null=True)
|
|
longitude = serializers.FloatField(allow_null=True)
|
|
latitude = serializers.FloatField(allow_null=True)
|
|
|
|
class Meta:
|
|
model = models.WineStandard
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'type',
|
|
'longitude',
|
|
'latitude',
|
|
)
|
|
|
|
def validate(self, attrs):
|
|
latitude = attrs.pop('latitude', None)
|
|
longitude = attrs.pop('longitude', None)
|
|
|
|
attrs['coordinates'] = get_point_from_coordinates(latitude, longitude)
|
|
attrs['old_id'] = attrs.get('id')
|
|
attrs['standard_type'] = attrs.pop('type', None)
|
|
return attrs
|
|
|
|
|
|
class WineStandardClassificationSerializer(serializers.ModelSerializer):
|
|
|
|
id = serializers.IntegerField()
|
|
name = serializers.CharField()
|
|
possible_type_id = serializers.IntegerField(allow_null=True)
|
|
possible_color_id = serializers.IntegerField()
|
|
parent_id = serializers.IntegerField()
|
|
|
|
class Meta:
|
|
model = models.WineClassification
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'possible_type_id',
|
|
'possible_color_id',
|
|
'parent_id',
|
|
)
|
|
|
|
def validate(self, attrs):
|
|
possible_type_id = attrs.pop('possible_type_id', None)
|
|
possible_color_id = attrs.pop('possible_color_id', None)
|
|
parent_id = attrs.pop('parent_id', None)
|
|
attrs['old_id'] = attrs.pop('id')
|
|
attrs['possible_subtype'] = self.get_possible_type(possible_type_id)
|
|
attrs['possible_color_tag'] = self.get_possible_color_tag(possible_color_id)
|
|
attrs['standard'] = self.get_wine_standard(parent_id)
|
|
return attrs
|
|
|
|
def create(self, validated_data):
|
|
possible_color_tag = validated_data.pop('possible_color_tag', None)
|
|
obj = super().create(validated_data)
|
|
if possible_color_tag:
|
|
obj.tags.add(possible_color_tag)
|
|
return obj
|
|
|
|
def get_possible_type(self, possible_type_id):
|
|
legacy_qs = transfer_models.WineClassification.objects.filter(id=possible_type_id)
|
|
if legacy_qs.exists():
|
|
qs = models.ProductSubType.objects.filter(index_name=legacy_qs.first())
|
|
if qs.exists():
|
|
return qs.first()
|
|
|
|
def get_possible_color_tag(self, possible_color_id):
|
|
qs = tag_models.Tag.objects.filter(
|
|
old_id=possible_color_id,
|
|
category__index_name=slugify(WineColorSerializer.TAG_CATEGORY))
|
|
if qs.exists():
|
|
return qs.first()
|
|
|
|
def get_wine_standard(self, parent_id):
|
|
qs = models.WineStandard.objects.filter(old_id=parent_id)
|
|
if qs.exists():
|
|
return qs.first()
|
|
|
|
|
|
class ProductBrandSerializer(TransferSerializerMixin):
|
|
|
|
brand = serializers.CharField()
|
|
|
|
class Meta:
|
|
model = models.ProductBrand
|
|
fields = (
|
|
'brand',
|
|
)
|
|
|
|
def validate(self, attrs):
|
|
attrs['name'] = attrs.pop('brand')
|
|
return attrs
|
|
|
|
|
|
class ProductSerializer(TransferSerializerMixin):
|
|
|
|
establishment_id = serializers.PrimaryKeyRelatedField(
|
|
queryset=transfer_models.Establishments.objects.all(),
|
|
allow_null=True)
|
|
classification_id = serializers.PrimaryKeyRelatedField(
|
|
queryset=transfer_models.WineClassification.objects.all(),
|
|
allow_null=True)
|
|
wine_region_id = serializers.PrimaryKeyRelatedField(
|
|
queryset=transfer_models.WineLocations.objects.all(),
|
|
allow_null=True)
|
|
wine_type_id = serializers.PrimaryKeyRelatedField(
|
|
queryset=transfer_models.WineType.objects.all(),
|
|
allow_null=True)
|
|
wine_color_id = serializers.PrimaryKeyRelatedField(
|
|
queryset=transfer_models.WineColor.objects.all(),
|
|
allow_null=True)
|
|
appellation_id = serializers.PrimaryKeyRelatedField(
|
|
queryset=transfer_models.WineClassification.objects.all(),
|
|
allow_null=True)
|
|
village_id = serializers.PrimaryKeyRelatedField(
|
|
queryset=transfer_models.WineLocations.objects.all(),
|
|
allow_null=True)
|
|
vineyard_id = serializers.PrimaryKeyRelatedField(
|
|
queryset=transfer_models.WineLocations.objects.all(),
|
|
allow_null=True)
|
|
wine_quality_id = serializers.PrimaryKeyRelatedField(
|
|
queryset=transfer_models.WineClassification.objects.all(),
|
|
allow_null=True)
|
|
|
|
brand = serializers.CharField(allow_null=True)
|
|
name = serializers.CharField(allow_null=True)
|
|
vintage = serializers.CharField(allow_null=True)
|
|
type = serializers.CharField(allow_null=True)
|
|
price = serializers.CharField(allow_null=True)
|
|
average_price_in_shops = serializers.CharField(allow_null=True)
|
|
wine_sub_region_id = serializers.CharField(allow_null=True)
|
|
state = serializers.CharField()
|
|
bottles_produced = serializers.CharField(allow_null=True)
|
|
|
|
class Meta:
|
|
model = models.Product
|
|
fields = (
|
|
'establishment_id',
|
|
'classification_id',
|
|
'wine_region_id',
|
|
'wine_type_id',
|
|
'wine_color_id',
|
|
'appellation_id',
|
|
'village_id',
|
|
'vineyard_id',
|
|
'wine_quality_id',
|
|
'brand',
|
|
'name',
|
|
'vintage',
|
|
'type',
|
|
'price',
|
|
'average_price_in_shops',
|
|
'wine_sub_region_id',
|
|
'state',
|
|
'bottles_produced',
|
|
)
|
|
|
|
def validate(self, attrs):
|
|
establishment_old_id = attrs.pop('establishment_id', None)
|
|
state = attrs.pop('state', None)
|
|
brand = attrs.pop('brand', None)
|
|
|
|
attrs['establishment'] = self.get_establishment(establishment_old_id)
|
|
attrs['state'] = self.get_state(state)
|
|
attrs['brand'] = self.get_brand(brand)
|
|
import ipdb; ipdb.set_trace()
|
|
return attrs
|
|
|
|
def get_establishment(self, establishment_old_id):
|
|
qs = establishment_models.Establishment.objects.filter(
|
|
old_id=establishment_old_id)
|
|
if qs.exists():
|
|
return qs.first()
|
|
|
|
def get_state(self, state):
|
|
if state == 'published':
|
|
return models.Product.PUBLISHED
|
|
elif state == 'out_of_production':
|
|
return models.Product.OUT_OF_PRODUCTION
|
|
return models.Product.WAITING
|
|
|
|
def get_brand(self, brand):
|
|
qs = models.ProductBrand.objects.filter(brand__icontains=brand)
|
|
if qs.exists():
|
|
return qs.first()
|