136 lines
4.6 KiB
Python
136 lines
4.6 KiB
Python
from django.utils import timezone
|
|
from rest_framework import serializers
|
|
from rest_framework.relations import SlugRelatedField
|
|
|
|
from files.models import File
|
|
from inventory.models import Event, Container, Item
|
|
from mail.models import EventAddress
|
|
|
|
|
|
#class EventAdressSerializer(serializers.ModelSerializer):
|
|
# class Meta:
|
|
# model = EventAddress
|
|
# fields = ['address']
|
|
|
|
# def to_internal_value(self, data):
|
|
# if not isinstance(data, str):
|
|
# raise serializers.ValidationError('This field must be a string.')
|
|
#
|
|
# def create(self, validated_data):
|
|
# return EventAddress.objects.create(**validated_data)
|
|
#
|
|
# def validate(self, data):
|
|
# return isinstance(data, str)
|
|
|
|
|
|
|
|
class EventSerializer(serializers.ModelSerializer):
|
|
#addresses = EventAdressSerializer(many=True, required=False)
|
|
addresses = SlugRelatedField(many=True, slug_field='address', queryset=EventAddress.objects.all())
|
|
|
|
class Meta:
|
|
model = Event
|
|
fields = ['id', 'slug', 'name', 'start', 'end', 'pre_start', 'post_end', 'addresses']
|
|
read_only_fields = ['id']
|
|
|
|
# def update(self, instance, validated_data):
|
|
# addresses = validated_data.pop('addresses', None)
|
|
# instance.save(validated_data)
|
|
# if addresses:
|
|
# for address in addresses:
|
|
# nested_instance, created = EventAddress.objects.get_or_create(address=address)
|
|
# instance.addresses.add(nested_instance)
|
|
#
|
|
# return instance
|
|
|
|
|
|
|
|
class ContainerSerializer(serializers.ModelSerializer):
|
|
itemCount = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = Container
|
|
fields = ['id', 'name', 'itemCount']
|
|
read_only_fields = ['id', 'itemCount']
|
|
|
|
def get_itemCount(self, instance):
|
|
return Item.objects.filter(container=instance.id).count()
|
|
|
|
|
|
class ItemSerializer(serializers.ModelSerializer):
|
|
dataImage = serializers.CharField(write_only=True, required=False)
|
|
cid = serializers.SerializerMethodField()
|
|
box = serializers.SerializerMethodField()
|
|
file = serializers.SerializerMethodField()
|
|
returned = serializers.SerializerMethodField(required=False)
|
|
event = serializers.SlugRelatedField(slug_field='slug', queryset=Event.objects.all(),
|
|
allow_null=True, required=False)
|
|
|
|
class Meta:
|
|
model = Item
|
|
fields = ['cid', 'box', 'id', 'description', 'file', 'dataImage', 'returned', 'event']
|
|
read_only_fields = ['id']
|
|
|
|
def get_cid(self, instance):
|
|
return instance.container.id
|
|
|
|
def get_box(self, instance):
|
|
return instance.container.name
|
|
|
|
def get_file(self, instance):
|
|
if len(instance.files.all()) > 0:
|
|
return instance.files.all().order_by('-created_at')[0].hash
|
|
return None
|
|
|
|
def get_returned(self, instance):
|
|
return instance.returned_at is not None
|
|
|
|
def to_internal_value(self, data):
|
|
container = None
|
|
returned = False
|
|
if 'cid' in data:
|
|
container = Container.objects.get(id=data['cid'])
|
|
if 'returned' in data:
|
|
returned = data['returned']
|
|
internal = super().to_internal_value(data)
|
|
if container:
|
|
internal['container'] = container
|
|
if returned:
|
|
internal['returned_at'] = timezone.now()
|
|
return internal
|
|
|
|
def validate(self, attrs):
|
|
if not 'container' in attrs and not self.partial:
|
|
raise serializers.ValidationError("This field cannot be empty.")
|
|
return super().validate(attrs)
|
|
|
|
def create(self, validated_data):
|
|
if 'dataImage' in validated_data:
|
|
file = File.objects.create(data=validated_data['dataImage'])
|
|
validated_data.pop('dataImage')
|
|
item = Item.objects.create(**validated_data)
|
|
item.files.set([file])
|
|
return item
|
|
return Item.objects.create(**validated_data)
|
|
|
|
def update(self, instance, validated_data):
|
|
if 'returned' in validated_data:
|
|
if validated_data['returned']:
|
|
validated_data['returned_at'] = timezone.now()
|
|
validated_data.pop('returned')
|
|
if 'dataImage' in validated_data:
|
|
file = File.objects.create(data=validated_data['dataImage'])
|
|
validated_data.pop('dataImage')
|
|
instance.files.add(file)
|
|
return super().update(instance, validated_data)
|
|
|
|
|
|
class SearchResultSerializer(serializers.Serializer):
|
|
search_score = serializers.IntegerField()
|
|
item = ItemSerializer()
|
|
|
|
def to_representation(self, instance):
|
|
return {**ItemSerializer(instance['item']).data, 'search_score': instance['search_score']}
|
|
|
|
class Meta:
|
|
model = Item
|