128 lines
4.6 KiB
Python
128 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 inventory.shared_serializers import BasicItemSerializer
|
|
from mail.models import EventAddress
|
|
from tickets.shared_serializers import BasicIssueSerializer
|
|
|
|
|
|
class EventSerializer(serializers.ModelSerializer):
|
|
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 to_internal_value(self, data):
|
|
data = data.copy()
|
|
addresses = data.pop('addresses', None)
|
|
dict = super().to_internal_value(data)
|
|
if addresses:
|
|
dict['addresses'] = [EventAddress.objects.get_or_create(address=x)[0] for x in addresses]
|
|
return dict
|
|
|
|
|
|
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 len(instance.items)
|
|
|
|
|
|
class ItemSerializer(BasicItemSerializer):
|
|
timeline = serializers.SerializerMethodField()
|
|
dataImage = serializers.CharField(write_only=True, required=False)
|
|
related_issues = BasicIssueSerializer(many=True, read_only=True)
|
|
|
|
class Meta:
|
|
model = Item
|
|
fields = ['cid', 'box', 'id', 'description', 'file', 'dataImage', 'returned', 'event', 'related_issues',
|
|
'timeline']
|
|
read_only_fields = ['id']
|
|
|
|
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)
|
|
|
|
@staticmethod
|
|
def get_timeline(obj):
|
|
timeline = []
|
|
for comment in obj.comments.all():
|
|
timeline.append({
|
|
'type': 'comment',
|
|
'id': comment.id,
|
|
'timestamp': comment.timestamp,
|
|
'comment': comment.comment,
|
|
})
|
|
for relation in (obj.issue_relation_changes.all()):
|
|
timeline.append({
|
|
'type': 'issue_relation',
|
|
'id': relation.id,
|
|
'status': relation.status,
|
|
'timestamp': relation.timestamp,
|
|
'issue_thread': BasicIssueSerializer(relation.issue_thread).data,
|
|
})
|
|
for placement in (obj.container_history.all()):
|
|
timeline.append({
|
|
'type': 'placement',
|
|
'id': placement.id,
|
|
'timestamp': placement.timestamp,
|
|
'cid': placement.container.id,
|
|
'box': placement.container.name
|
|
})
|
|
return sorted(timeline, key=lambda x: x['timestamp'])
|
|
|
|
|
|
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
|