greater_wms/container/serializers.py

from rest_framework import serializers

from .models import ContainerListModel,ContainerDetailModel,ContainerOperationModel,TaskModel,ContainerWCSModel,out_batch_detail,ContainerDetailLogModel,batchLogModel
from bound.models import BoundBatchModel,BoundDetailModel

from utils import datasolve
from decimal import Decimal

class batchLogModelSerializer(serializers.ModelSerializer):

    # 定义批次日志的序列化器，用于获取操作，字段只读
    bound_code = serializers.SerializerMethodField()
    batch_code = serializers.CharField(source='batch.bound_number', read_only=True)
    goods_unit = serializers.CharField(source='batch.goods_unit', read_only=True)
    check_status = serializers.IntegerField(source='batch.check_status', read_only=True)
    create_time = serializers.DateTimeField(format='%Y-%m-%d %H:%M', required=False)
    class Meta:
        # 指定模型和排除字段
        model = batchLogModel
        fields= ['id', 'bound_code', 'batch_code', 'log_type', 'goods_code', 'goods_desc', 'goods_in_qty', 'goods_out_qty', 'goods_unit','check_status','create_time']
        read_only_fields = ['id']

    def get_bound_code(self, obj):
        """ 动态序列化关联的批次数据 """
        return obj.bound.bound_code if obj.bound else '无主单，涉及手动操作'
    
   
    
class WCSTaskGetSerializer(serializers.ModelSerializer):
    class Meta:
        # 指定模型和排除字段
        model = ContainerWCSModel
        fields= '__all__'
        read_only_fields = ['id']

class ContainerDetailLogSerializer(serializers.ModelSerializer):
    batch = serializers.SerializerMethodField()
    container_code = serializers.SerializerMethodField()
    goods_code = serializers.SerializerMethodField()
    goods_desc = serializers.SerializerMethodField()
    detail_goods_qty = serializers.SerializerMethodField()
    goods_qty = serializers.SerializerMethodField()
    goods_out_qty = serializers.SerializerMethodField()

    batch_goods_qty = serializers.SerializerMethodField() #计划入库数量 
    batch_goods_in_qty = serializers.SerializerMethodField() #实际入库数量 
    batch_goods_in_location_qty = serializers.SerializerMethodField() #实际在库数量 
    batch_goods_out_qty = serializers.SerializerMethodField()
    create_time = serializers.DateTimeField(format='%Y-%m-%d %H:%M', required=False)
    class Meta:
        # 指定模型和排除字段
        model = ContainerDetailLogModel
        fields= '__all__'
        read_only_fields = ['id']

    def get_batch(self, obj):
        """ 动态序列化关联的批次数据 """
        return obj.container_detail.batch.bound_number if obj.container_detail.batch else 'N/A'
    def get_container_code(self, obj):
        return obj.container_detail.container.container_code if obj.container_detail.container.container_code else 'N/A'
    def get_goods_code(self, obj):
        return obj.container_detail.goods_code if obj.container_detail.goods_code else 'N/A'
    def get_goods_desc(self, obj):
        return obj.container_detail.goods_desc if obj.container_detail.goods_desc else 'N/A'
    
    # 获取托盘最小单元detail的入库数量
    def get_detail_goods_qty(self, obj):
        return obj.container_detail.goods_qty if obj.container_detail.goods_qty else Decimal('0')
    
    # 获取托盘最小单元detail的 入库操作数量
    def get_goods_qty(self, obj):
       
        new_goods_qty = obj.new_goods_qty if obj.new_goods_qty else Decimal('0')
        old_goods_qty = obj.old_goods_qty if obj.old_goods_qty else Decimal('0')

        goods_qty = new_goods_qty - old_goods_qty
        return goods_qty if goods_qty else Decimal('0')
    
    # 获取托盘最小单元detail的 出库操作数量
    def get_goods_out_qty(self, obj):
        
        new_goods_out_qty = obj.new_goods_out_qty if obj.new_goods_out_qty else Decimal('0')
        old_goods_out_qty = obj.old_goods_out_qty if obj.old_goods_out_qty else Decimal('0')
        goods_out_qty = new_goods_out_qty - old_goods_out_qty
        return goods_out_qty if goods_out_qty else Decimal('0')
    
    # 获取批次的计划入库数量
    def get_batch_goods_qty(self, obj):
        return obj.container_detail.batch.goods_qty if obj.container_detail.batch.goods_qty else Decimal('0')
    # 获取批次的实际入库数量
    def get_batch_goods_in_qty(self, obj):
        return obj.container_detail.batch.goods_in_qty if obj.container_detail.batch.goods_in_qty else Decimal('0')
    # 获取批次的实际在库数量
    def get_batch_goods_in_location_qty(self, obj):
        return obj.container_detail.batch.goods_in_location_qty if obj.container_detail.batch.goods_in_location_qty else Decimal('0')
    # 获取批次的出库数量
    def get_batch_goods_out_qty(self, obj):
        return obj.container_detail.batch.goods_out_qty if obj.container_detail.batch.goods_out_qty else Decimal('0')
    

    
    
class ContainerListGetSerializer(serializers.ModelSerializer):
    # 定义主单列表的序列化器，用于获取操作，字段只读
    container_code = serializers.IntegerField(read_only=True, required=False)
    current_location = serializers.CharField(read_only=True, required=False)
    target_location = serializers.CharField(read_only=True, required=False)
    status = serializers.IntegerField(read_only=True, required=False)
    last_operation = serializers.DateTimeField(read_only=True, format='%Y-%m-%d', required=False)

    class Meta:
        # 指定模型和排除字段
        model = ContainerListModel
        fields= '__all__'
        read_only_fields = ['id']

class ContainerListPostSerializer(serializers.ModelSerializer):
    # 定义主单列表的序列化器，用于创建操作，允许部分字段写入
    container_code = serializers.IntegerField(read_only=False, required=True, validators=[datasolve.data_validate])
    current_location = serializers.CharField(read_only=False, required=False, validators=[datasolve.data_validate])
    target_location = serializers.CharField(read_only=False, required=False, validators=[datasolve.data_validate])
    status = serializers.IntegerField(read_only=False, required=False, validators=[datasolve.data_validate])
    last_operation = serializers.DateTimeField(read_only=False, format='%Y-%m-%d', required=False, validators=[datasolve.data_validate])


    class Meta:
        # 指定模型和排除字段
        model = ContainerListModel
        fields= '__all__'
        read_only_fields = ['id' ]

class ContainerDetailSimpleGetSerializer(serializers.ModelSerializer):
    batch = serializers.SerializerMethodField()
    class Meta:
        # 指定模型和排除字段
        model = ContainerDetailModel
        fields= '__all__'
        read_only_fields = ['id']
    def get_batch(self, obj):
        """ 动态序列化关联的批次数据 """
        from bound.models import BoundBatchModel
        return BoundBatchModel.objects.get(id=obj.batch_id).bound_number

class ContainerDetailGetSerializer(serializers.ModelSerializer):
    # 定义明细单列表的序列化器，用于获取操作，字段只读
    month = serializers.IntegerField(read_only=True, required=False)
    container = serializers.SerializerMethodField()
    batch = serializers.SerializerMethodField()
    goods_code = serializers.CharField(read_only=True, required=False)
    goods_desc = serializers.CharField(read_only=True, required=False)
    goods_qty = serializers.DecimalField(read_only=False, required=False, max_digits=10, decimal_places=3)
    goods_weight = serializers.DecimalField(read_only=True, required=False, max_digits=10, decimal_places=2)
    goods_class = serializers.IntegerField(read_only=True, required=False)
    status = serializers.IntegerField(read_only=True, required=False)
    creater = serializers.CharField(read_only=True, required=False)
    create_time = serializers.DateTimeField(read_only=True, format='%Y-%m-%d %H:%M', required=False)
    update_time = serializers.DateTimeField(read_only=True, format='%Y-%m-%d %H:%M', required=False)
    

    def get_container(self, obj):
        """ 动态序列化关联的主单数据 """
        from .serializers import ContainerListGetSerializer
        return ContainerListGetSerializer(obj.container).data

    def get_batch(self, obj):
        """ 动态序列化关联的批次数据 """
        from bound.serializers import BoundBatchGetSerializer
        return BoundBatchGetSerializer(obj.batch).data

    class Meta:
        # 指定模型和排除字段
        model = ContainerDetailModel
        exclude = ['id', 'is_delete', ]
        read_only_fields = ['id']
    
class ContainerDetailPostSerializer(serializers.ModelSerializer):
    # 定义明细单列表的序列化器，用于创建操作，允许部分字段写入
    month = serializers.IntegerField(read_only=False, required=False, validators=[datasolve.data_validate])
    container = serializers.PrimaryKeyRelatedField(queryset=ContainerListModel.objects.all(),
    help_text='关联的主单',
    error_messages = {
        'null': '请选择关联的主单',
        'does_not_exist': '关联的主单不存在',
        'incorrect_type': '关联的主单格式错误'
    },
    required=False, validators=[datasolve.data_validate])
    batch = serializers.PrimaryKeyRelatedField(queryset=BoundBatchModel.objects.all(),
    help_text='关联的批次',
    error_messages = {
        
        'does_not_exist': '关联的批次不存在',
        'incorrect_type': '关联的批次格式错误'
    },
    required=False, validators=[datasolve.data_validate])
    goods_code = serializers.CharField(read_only=False, required=True, validators=[datasolve.data_validate])
    goods_desc = serializers.CharField(read_only=False, required=True, validators=[datasolve.data_validate])
    goods_qty = serializers.DecimalField(read_only=False, required=True, max_digits=10, decimal_places=3,validators=[datasolve.data_validate])
    goods_weight = serializers.DecimalField(read_only=False, required=True, max_digits=10, decimal_places=2, validators=[datasolve.data_validate])
    status = serializers.IntegerField(read_only=False, required=False, validators=[datasolve.data_validate])
    creater = serializers.CharField(read_only=False, required=False, validators=[datasolve.data_validate])
    create_time = serializers.DateTimeField(read_only=False, format='%Y-%m-%d %H:%M', required=False, validators=[datasolve.data_validate])
    update_time = serializers.DateTimeField(read_only=False, format='%Y-%m-%d %H:%M', required=False, validators=[datasolve.data_validate])

    class Meta:
        # 指定模型和排除字段
        model = ContainerDetailModel
        fields= '__all__'
        read_only_fields = ['id']

class ContainerOperationGetSerializer(serializers.ModelSerializer):
    # 定义操作记录的序列化器，用于获取操作，字段只读
    month = serializers.IntegerField(read_only=True, required=False)
    container = serializers.SerializerMethodField()
    operation_type = serializers.CharField(read_only=True, required=False)

    batch = serializers.SerializerMethodField()
    goods_code = serializers.CharField(read_only=True, required=False)
    goods_desc = serializers.CharField(read_only=True, required=False)
    goods_qty = serializers.DecimalField(read_only=False, required=False, max_digits=10, decimal_places=3)
    goods_weight = serializers.DecimalField(read_only=True, required=False, max_digits=10, decimal_places=2)

    operator = serializers.CharField(read_only=True, required=False)
    timestamp = serializers.DateTimeField(read_only=True, format='%Y-%m-%d %H:%M', required=False)
    from_location = serializers.CharField(read_only=True, required=False)
    to_location = serializers.CharField(read_only=True, required=False)
    memo = serializers.CharField(read_only=True, required=False)
    def get_container(self, obj):
        """ 动态序列化关联的主单数据 """
        from .serializers import ContainerListGetSerializer
        return ContainerListGetSerializer(obj.container).data

    def get_batch(self, obj):
        """ 动态序列化关联的批次数据 """
        from bound.serializers import BoundBatchGetSerializer
        return BoundBatchGetSerializer(obj.batch).data

    class Meta:
        # 指定模型和排除字段
        model = ContainerOperationModel
        fields= '__all__'
        read_only_fields = ['id']

class ContainerOperationPostSerializer(serializers.ModelSerializer):
    # 定义操作记录的序列化器，用于创建操作，允许部分字段写入
    month = serializers.IntegerField(read_only=False, required=False, validators=[datasolve.data_validate])
    container = serializers.PrimaryKeyRelatedField(queryset=ContainerListModel.objects.all(),
    help_text='关联的主单',
    error_messages = {
        'null': '请选择关联的主单',
        'does_not_exist': '关联的主单不存在',
        'incorrect_type': '关联的主单格式错误'
    },
    required=True, validators=[datasolve.data_validate])
    operation_type = serializers.CharField(read_only=False, required=True, validators=[datasolve.data_validate])

    batch = serializers.PrimaryKeyRelatedField(queryset=BoundBatchModel.objects.all(),
    help_text='关联的批次',
    error_messages = {
        'null': '请选择关联的批次',
        'does_not_exist': '关联的批次不存在',
        'incorrect_type': '关联的批次格式错误'
    },
    required=False, validators=[datasolve.data_validate])
    goods_code = serializers.CharField(read_only=False, required=True, validators=[datasolve.data_validate])
    goods_desc = serializers.CharField(read_only=False, required=True, validators=[datasolve.data_validate])
    goods_qty = serializers.DecimalField(read_only=False, required=True, max_digits=10, decimal_places=3,validators=[datasolve.data_validate])
    goods_weight = serializers.DecimalField(read_only=False, required=True, max_digits=10, decimal_places=2, validators=[datasolve.data_validate])

    operator = serializers.CharField(read_only=False, required=True, validators=[datasolve.data_validate])
    timestamp = serializers.DateTimeField(read_only=False, format='%Y-%m-%d %H:%M', required=True, validators=[datasolve.data_validate])
    from_location = serializers.CharField(read_only=False, required=True, validators=[datasolve.data_validate])
    to_location = serializers.CharField(read_only=False, required=True, validators=[datasolve.data_validate])
    memo = serializers.CharField(read_only=False, required=False, validators=[datasolve.data_validate])

    class Meta:
        # 指定模型和排除字段
        model = ContainerOperationModel
        fields= '__all__'
        read_only_fields = ['id']

class TaskGetSerializer(serializers.ModelSerializer):
    # 定义任务记录的序列化器，用于获取操作，字段只读
    task_wcs = serializers.SerializerMethodField()
    container_detail = serializers.SerializerMethodField()
    batch_detail = serializers.SerializerMethodField()


    def get_task_wcs(self, obj):
        """ 动态序列化关联的WCS任务数据 """
        from .models import ContainerWCSModel
        return ContainerWCSModel.objects.filter(id=obj.task_wcs_id).first().to_dict()

    def get_container_detail(self, obj):
        """ 动态序列化关联的主单数据 """
        from .serializers import ContainerDetailGetSerializer
        return ContainerDetailGetSerializer(obj.container_detail).data
    def get_batch_detail(self, obj):
        """ 动态序列化关联的批次数据 """
        from bound.serializers import BoundDetailGetSerializer
        return BoundDetailGetSerializer(obj.batch_detail).data

    class Meta:
        # 指定模型和排除字段
        model = TaskModel
        fields= '__all__'
        read_only_fields = ['id']

class TaskPostSerializer(serializers.ModelSerializer):
    # 定义任务记录的序列化器，用于获取操作，字段只读
    task_wcs = serializers.PrimaryKeyRelatedField(queryset=ContainerWCSModel.objects.all(),
    help_text='关联的WCS任务',
    error_messages = {
        'null': '请选择关联的WCS任务',
        'does_not_exist': '关联的WCS任务不存在',
        'incorrect_type': '关联的WCS任务格式错误'
    },
    required=False, validators=[datasolve.data_validate])
    bound_detail = serializers.PrimaryKeyRelatedField(queryset=BoundDetailModel.objects.all(),
    help_text='关联的明细单',
    error_messages = {
        'null': '请选择关联的明细单',
        'does_not_exist': '关联的明细单不存在',
        'incorrect_type': '关联的明细单格式错误'
    },
    required=False, validators=[datasolve.data_validate])
    class Meta:
        # 指定模型和排除字段
        model = TaskModel
        fields= '__all__'
        read_only_fields = ['id']
        
# serializers.py
class OutBoundDetailSerializer(serializers.ModelSerializer):
    """列表用简略序列化器"""

    class Meta:
        model = out_batch_detail
        fields = ['id', 'out_bound', 'container', 'working']

class OutBoundFullDetailSerializer(serializers.ModelSerializer):
    container_code = serializers.CharField(source='container.container_code', read_only=True)
    batch = serializers.CharField(source='container_detail.batch.bound_number', read_only=True)
    goods_code = serializers.CharField(source='container_detail.goods_code', read_only=True)
    goods_desc = serializers.CharField(source='container_detail.goods_desc', read_only=True)
    goods_qty = serializers.DecimalField(source='container_detail.goods_qty', read_only=True,max_digits=10, decimal_places=3)
    class Meta:
        model = out_batch_detail
        fields = '__all__'
        read_only_fields = ['id', 'out_bound', 'container', 'container_detail', 'working']