factory/apps/inm/serializers.py

from rest_framework import serializers
from rest_framework.exceptions import ValidationError

from apps.mtm.serializers import MaterialSerializer
from apps.pum.models import PuOrder
from apps.sam.models import Order
from apps.system.models import Dept, User
from apps.utils.constants import EXCLUDE_FIELDS_BASE, EXCLUDE_FIELDS_DEPT, EXCLUDE_FIELDS
from apps.utils.serializers import CustomModelSerializer

from .models import MIO, MaterialBatch, MIOItem, WareHouse


class WareHourseSerializer(CustomModelSerializer):
    class Meta:
        model = WareHouse
        fields = '__all__'
        read_only_fields = EXCLUDE_FIELDS_DEPT


class MaterialBatchSerializer(CustomModelSerializer):
    warehouse_name = serializers.CharField(
        source='warehouse.name', read_only=True)
    material_name = serializers.CharField(
        source='material.name', read_only=True)

    class Meta:
        model = MaterialBatch
        fields = '__all__'
        read_only_fields = EXCLUDE_FIELDS_BASE


class MIOListSerializer(CustomModelSerializer):
    create_by_name = serializers.CharField(
        source='create_by.name', read_only=True)
    submit_user_name = serializers.CharField(
        source='submit_user.name', read_only=True)
    do_user_name = serializers.CharField(
        source='do_user.name', read_only=True)
    belong_dept_name = serializers.CharField(
        source='belong_dept.name', read_only=True)
    supllier_name = serializers.CharField(
        source='supplier.name', read_only=True)
    customer_name = serializers.CharField(
        source='customer.name', read_only=True)
    order_number = serializers.CharField(source='order.number', read_only=True)
    pu_order_number = serializers.CharField(
        source='pu_order.name', read_only=True)

    class Meta:
        model = MIO
        fields = '__all__'
        read_only_fields = EXCLUDE_FIELDS + \
            ['state', 'submit_time', 'submit_user']

    # def validate(self, attrs):
    #     if 'pu_order' in attrs and attrs['pu_order']:
    #         attrs['supplier'] = attrs['pu_order'].supplier
    #         if attrs['pu_order'].belong_dept:
    #             attrs['belong_dept'] = attrs['pu_order'].belong_dept
    #     elif 'order' in attrs and attrs['order']:
    #         attrs['customer'] = attrs['order'].customer
    #     return super().validate(attrs)

    # def create(self, validated_data):
    #     type = validated_data['type']
    #     if type == MIO.MIO_TYPE_PUR_IN:
    #         pu_order = validated_data.get('pu_order', None)
    #         if pu_order and pu_order.state in [PuOrder.PUORDER_SUBMITED, PuOrder.PUORDER_SHIP]:
    #             pass
    #         else:
    #             raise ValidationError('该采购订单不可选')
    #     return super().create(validated_data)

    # def update(self, instance, validated_data):
    #     validated_data.pop('type')
    #     return super().update(instance, validated_data)


class MIOItemSerializer(CustomModelSerializer):
    warehouse_name = serializers.CharField(source='warehouse', read_only=True)
    material_ = MaterialSerializer(source='material', read_only=True)

    class Meta:
        model = MIOItem
        fields = '__all__'

    def create(self, validated_data):
        mio = validated_data['mio']
        if mio.state != MIO.MIO_CREATE:
            raise ValidationError('出入库记录非创建中不可新增')
        return super().create(validated_data)


class MIODoSerializer(CustomModelSerializer):
    belong_dept = serializers.PrimaryKeyRelatedField(
        label="车间", queryset=Dept.objects.all(), required=True)
    do_user = serializers.PrimaryKeyRelatedField(
        label="执行人", queryset=User.objects.all(), required=True)

    class Meta:
        model = MIO
        fields = ['id', 'number', 'note', 'do_user',
                  'belong_dept', 'type', 'inout_date']

    def create(self, validated_data):
        if validated_data['type'] not in [MIO.MIO_TYPE_DO_OUT, MIO.MIO_TYPE_DO_IN]:
            raise ValidationError('出入库类型错误')
        return super().create(validated_data)

    def update(self, instance, validated_data):
        validated_data.pop('type')
        return super().update(instance, validated_data)


class MIOSaleSerializer(CustomModelSerializer):
    order = serializers.PrimaryKeyRelatedField(
        label="订单", queryset=Order.objects.all(), required=True)

    class Meta:
        model = MIO
        fields = ['id', 'number', 'note', 'order', 'inout_date']

    def create(self, validated_data):
        validated_data['type'] = MIO.MIO_TYPE_SALE_OUT
        order = validated_data['order']
        validated_data['customer'] = order.customer
        if order.belong_dept:
            validated_data['belong_dept'] = order.belong_dept
        return super().create(validated_data)


class MIOPurSerializer(CustomModelSerializer):
    pu_order = serializers.PrimaryKeyRelatedField(
        label="采购订单", queryset=PuOrder.objects.all(), required=True)

    class Meta:
        model = MIO
        fields = ['id', 'number', 'note', 'pu_order', 'inout_date']

    def create(self, validated_data):
        validated_data['type'] = MIO.MIO_TYPE_PUR_IN
        pu_order = validated_data['pu_order']
        validated_data['supplier'] = pu_order.supplier
        if pu_order.belong_dept:
            validated_data['belong_dept'] = pu_order.belong_dept
        return super().create(validated_data)


class MIOOtherSerializer(CustomModelSerializer):

    class Meta:
        model = MIO
        fields = ['id', 'number', 'note', 'supplier',
                  'customer', 'type', 'inout_date']

    def create(self, validated_data):
        if validated_data['type'] not in [MIO.MIO_TYPE_OTHER_OUT, MIO.MIO_TYPE_OTHER_IN]:
            raise ValidationError('出入库类型错误')
        return super().create(validated_data)

    def update(self, instance, validated_data):
        validated_data.pop('type')
        return super().update(instance, validated_data)