575 lines
25 KiB
Python
575 lines
25 KiB
Python
from apps.utils.constants import EXCLUDE_FIELDS, EXCLUDE_FIELDS_BASE
|
|
from apps.utils.serializers import CustomModelSerializer
|
|
from rest_framework import serializers
|
|
from rest_framework.exceptions import ValidationError, ParseError
|
|
from datetime import datetime
|
|
|
|
from .models import SfLog, StLog, SfLogExp, WMaterial, Mlog, Handover, Mlogb, AttLog, OtherLog
|
|
from apps.system.models import Dept, User
|
|
from apps.system.serializers import UserSimpleSerializer
|
|
from apps.pm.models import Mtask
|
|
from apps.wpm.tasks import cal_enstat_when_pcoal_heat_change, cal_enstat_when_team_change, cal_exp_duration_sec
|
|
from apps.wpm.services import get_sflog, find_material_can_change
|
|
from apps.mtm.models import Mgroup, TeamMember, Shift, Material, Route
|
|
from apps.mtm.serializers import MaterialSimpleSerializer
|
|
from django.db import transaction
|
|
from django.utils import timezone
|
|
from django.core.cache import cache
|
|
from django.utils.timezone import localdate
|
|
from apps.qm.models import NotOkOption
|
|
|
|
|
|
class OtherLogSerializer(CustomModelSerializer):
|
|
class Meta:
|
|
model = OtherLog
|
|
fields = '__all__'
|
|
read_only_fields = EXCLUDE_FIELDS
|
|
|
|
|
|
class StLogSerializer(CustomModelSerializer):
|
|
mgroup_name = serializers.CharField(source='mgroup.name', read_only=True)
|
|
current_sflog = serializers.CharField(label='当前处理值班', write_only=True)
|
|
current_note = serializers.CharField(
|
|
label='值班处理备注', write_only=True, allow_blank=True)
|
|
|
|
class Meta:
|
|
model = StLog
|
|
fields = '__all__'
|
|
read_only_fields = EXCLUDE_FIELDS + \
|
|
['is_shutdown', 'sflog', 'duration']
|
|
|
|
def create(self, validated_data):
|
|
current_sflog_id = validated_data.pop('current_sflog')
|
|
current_note = validated_data.pop('current_note', '')
|
|
with transaction.atomic():
|
|
sflog = get_sflog(
|
|
validated_data['mgroup'], validated_data['start_time'])
|
|
if current_sflog_id != sflog.id:
|
|
raise ParseError('值班时间与发生时间不一致')
|
|
instance = super().create(validated_data)
|
|
instance.sflog = sflog
|
|
instance.save()
|
|
SfLogExp.objects.create(
|
|
sflog=sflog, stlog=instance, create_by=self.context['request'].user, note=current_note)
|
|
return instance
|
|
|
|
def update(self, instance, validated_data):
|
|
if instance.is_shutdown: # 停机不可编辑end_time
|
|
validated_data.pop('end_time', None)
|
|
if instance.end_time:
|
|
raise ParseError('该异常已结束无需编辑')
|
|
with transaction.atomic():
|
|
validated_data.pop('mgroup', None)
|
|
validated_data.pop('start_time', None)
|
|
end_time = validated_data.pop('end_time', None)
|
|
current_sflog = validated_data.pop('current_sflog')
|
|
current_note = validated_data.pop('current_note', '')
|
|
instance = super().update(instance, validated_data)
|
|
if end_time: # 需要把涉及到的sflog都拉入
|
|
cal_exp_duration_sec(instance.id)
|
|
try:
|
|
sflogexp = SfLogExp.objects.get(
|
|
stlog=instance.stlog, sflog=current_sflog)
|
|
sflogexp.note = current_note
|
|
sflogexp.save()
|
|
except SfLogExp.DoesNotExist:
|
|
raise ParseError('该异常无需本班填写')
|
|
return instance
|
|
|
|
def validate(self, attrs):
|
|
now = timezone.now()
|
|
start_time: datetime = attrs['start_time']
|
|
end_time: datetime = attrs.get('end_time', None)
|
|
if start_time > now:
|
|
raise ParseError('开始时间应为历史时间')
|
|
if end_time:
|
|
if end_time > now:
|
|
raise ParseError('开始时间应为历史时间')
|
|
if end_time > start_time:
|
|
attrs['duration_sec'] = (
|
|
end_time - start_time).total_seconds()
|
|
else:
|
|
raise ParseError('结束时间应大于开始时间')
|
|
return super().validate(attrs)
|
|
|
|
|
|
class SfLogSerializer(CustomModelSerializer):
|
|
mgroup_name = serializers.CharField(source='mgroup.name', read_only=True)
|
|
team_name = serializers.CharField(source='team.name', read_only=True)
|
|
shift_name = serializers.CharField(source='shift.name', read_only=True)
|
|
leader_name = serializers.CharField(source='leader.name', read_only=True)
|
|
|
|
class Meta:
|
|
model = SfLog
|
|
fields = '__all__'
|
|
read_only_fields = EXCLUDE_FIELDS + \
|
|
['mgroup', 'start_time', 'end_time', 'belong_dept']
|
|
extra_kwargs = {
|
|
'team': {'required': True},
|
|
'leader': {'required': True}
|
|
}
|
|
|
|
def update(self, instance, validated_data):
|
|
with transaction.atomic():
|
|
old_pcoal_heat = instance.pcoal_heat
|
|
old_team = instance.team
|
|
instance: SfLog = super().update(instance, validated_data)
|
|
new_pcoal_heat = instance.pcoal_heat
|
|
new_team = instance.team
|
|
mgroup: Mgroup = instance.mgroup
|
|
|
|
# 更新煤粉热值触发计算
|
|
if instance.mgroup == '回转窑' and instance.shift.name in ['早班', '白班']:
|
|
year_s, month_s, day_s = instance.get_ymd
|
|
if new_pcoal_heat: # 更新一下缓存
|
|
cache.set(f'pcoal_heat_{year_s}_{month_s}_{day_s}', new_pcoal_heat)
|
|
if new_pcoal_heat != old_pcoal_heat:
|
|
cal_enstat_when_pcoal_heat_change.delay(year_s, month_s, day_s)
|
|
|
|
# 更新班组触发计算
|
|
if new_team != old_team:
|
|
default_state = 'pending'
|
|
if timezone.now() > instance.end_time:
|
|
default_state = 'normal'
|
|
# 分配班组时创建人员到岗情况
|
|
for item in TeamMember.objects.filter(team=new_team, mgroup=instance.mgroup):
|
|
AttLog.objects.get_or_create(sflog=instance, user=item.user, defaults={
|
|
'sflog': instance, 'user': item.user, 'post': item.post, 'state': default_state, 'create_by': self.context['request'].user})
|
|
if mgroup.need_enm:
|
|
from apps.qm.tasks import cal_quastat_sflog
|
|
cal_enstat_when_team_change.delay(instance.id)
|
|
cal_quastat_sflog.delay(instance.id)
|
|
return instance
|
|
|
|
def to_representation(self, instance):
|
|
ret = super().to_representation(instance)
|
|
if "shut_sec" in ret:
|
|
ret["shut_hour"] = "{:.2f}".format(round(ret['shut_sec']/3600, 2))
|
|
return ret
|
|
# def to_internal_value(self, data):
|
|
# if hasattr(self.Meta, 'update_fields') and self.context['request'].method in ['PUT', 'PATCH']:
|
|
# u_fields = self.Meta.update_fields
|
|
# new_data = {key: data[key] for key in u_fields if key in data}
|
|
# return super().to_internal_value(new_data)
|
|
# return super().to_internal_value(data)
|
|
|
|
|
|
class SflogExpSerializer(CustomModelSerializer):
|
|
# mgroup = serializers.CharField(source='sflog.mgroup.id', read_only=True)
|
|
# mgroup_name = serializers.CharField(
|
|
# source='sflog.mgroup.name', read_only=True)
|
|
# stlog_ = StLogSerializer(source='stlog', read_only=True)
|
|
# happen_time = serializers.DateTimeField(required=True, label='发生时间')
|
|
# cate = serializers.CharField(required=True, label='原因类别')
|
|
sflog_ = SfLogSerializer(source='sflog', read_only=True)
|
|
stlog_ = StLogSerializer(source='stlog', read_only=True)
|
|
|
|
class Meta:
|
|
model = SfLogExp
|
|
fields = '__all__'
|
|
read_only_fields = EXCLUDE_FIELDS + ['sflog', 'stlog', 'duration']
|
|
|
|
|
|
class WMaterialSerializer(CustomModelSerializer):
|
|
material_ = MaterialSimpleSerializer(source='material', read_only=True)
|
|
material_name = serializers.StringRelatedField(
|
|
source='material', read_only=True)
|
|
mgroup_name = serializers.StringRelatedField(source='mgroup.name', read_only=True)
|
|
belong_dept_name = serializers.CharField(
|
|
source='belong_dept.name', read_only=True)
|
|
material_origin_name = serializers.StringRelatedField(source='material_origin', read_only=True)
|
|
notok_sign_name = serializers.SerializerMethodField()
|
|
|
|
def get_notok_sign_name(self, obj):
|
|
return getattr(NotOkOption, obj.notok_sign, NotOkOption.qt).label if obj.notok_sign else None
|
|
|
|
class Meta:
|
|
model = WMaterial
|
|
fields = '__all__'
|
|
|
|
|
|
class MlogbSerializer(CustomModelSerializer):
|
|
material_out_ = MaterialSimpleSerializer(
|
|
source='material_out', read_only=True)
|
|
material_out_name = serializers.StringRelatedField(
|
|
source='material_out', read_only=True)
|
|
|
|
class Meta:
|
|
model = Mlogb
|
|
fields = ['id', 'material_out', 'count_ok',
|
|
'material_out_', 'material_out_name']
|
|
extra_kwargs = {
|
|
'material_out': {'required': True, 'allow_null': False}}
|
|
|
|
class MlogbDetailSerializer(CustomModelSerializer):
|
|
material_out_name = serializers.StringRelatedField(
|
|
source='material_out', read_only=True)
|
|
material_in_name = serializers.StringRelatedField(source='material_in', read_only=True)
|
|
|
|
class Meta:
|
|
model = Mlogb
|
|
fields = '__all__'
|
|
|
|
class MlogSerializer(CustomModelSerializer):
|
|
supplier_name = serializers.CharField(source='supplier.name', read_only=True)
|
|
belong_dept = serializers.CharField(
|
|
source='mgroup.belong_dept.id', read_only=True)
|
|
belong_dept_name = serializers.CharField(
|
|
source='mgroup.belong_dept.name', read_only=True)
|
|
mgroup_name = serializers.CharField(
|
|
source='mgroup.name', read_only=True)
|
|
mtask_count = serializers.IntegerField(
|
|
source='mtask.count', read_only=True)
|
|
create_by_name = serializers.CharField(
|
|
source='create_by.name', read_only=True)
|
|
update_by_name = serializers.CharField(
|
|
source='update_by.name', read_only=True)
|
|
handovers = serializers.PrimaryKeyRelatedField(
|
|
source='handover_mlog', read_only=True, many=True)
|
|
material_out_ = MaterialSimpleSerializer(
|
|
source='material_out', read_only=True)
|
|
material_out_name = serializers.StringRelatedField(
|
|
source='material_out', read_only=True)
|
|
material_in_name = serializers.StringRelatedField(
|
|
source='material_in', read_only=True)
|
|
handle_user_name = serializers.CharField(
|
|
source='handle_user.name', read_only=True)
|
|
handle_user_2_name = serializers.CharField(
|
|
source='handle_user_2.name', read_only=True)
|
|
handle_leader_name = serializers.CharField(
|
|
source='handle_leader.name', read_only=True)
|
|
equipment_name = serializers.StringRelatedField(
|
|
source='equipment', read_only=True)
|
|
equipment_2_name = serializers.StringRelatedField(
|
|
source='equipment_2', read_only=True)
|
|
shift = serializers.PrimaryKeyRelatedField(
|
|
label='班次ID', queryset=Shift.objects.all(), required=True)
|
|
mgroup = serializers.PrimaryKeyRelatedField(
|
|
label='工段ID', queryset=Mgroup.objects.all(), required=True
|
|
)
|
|
material_out = serializers.PrimaryKeyRelatedField(
|
|
label='产物ID', queryset=Material.objects.all(), required=True
|
|
)
|
|
shift_name = serializers.CharField(source='shift.name', read_only=True)
|
|
mlogb = MlogbSerializer(
|
|
label='多产出件信息', many=True, required=False)
|
|
mlogb_full = MlogbDetailSerializer(
|
|
label='物料信息', many=True, read_only=True
|
|
)
|
|
handle_users_ = UserSimpleSerializer(
|
|
source='handle_users', many=True, read_only=True)
|
|
equipments_name = serializers.StringRelatedField(
|
|
source='equipments', read_only=True, many=True)
|
|
|
|
class Meta:
|
|
model = Mlog
|
|
fields = '__all__'
|
|
read_only_fields = EXCLUDE_FIELDS + \
|
|
['submit_time', 'submit_user', 'material_outs']
|
|
extra_kwargs = {
|
|
"batch": {"required": True}
|
|
}
|
|
|
|
def create(self, validated_data):
|
|
mtask: Mtask = validated_data.get('mtask', None)
|
|
if mtask:
|
|
validated_data['mgroup'] = mtask.mgroup
|
|
validated_data['material_in'] = mtask.material_in
|
|
material_out = mtask.material_out
|
|
validated_data['material_out'] = material_out
|
|
validated_data['handle_date'] = mtask.end_date
|
|
else:
|
|
mgroup = validated_data['mgroup']
|
|
material_out = validated_data['material_out']
|
|
if not (mgroup and material_out):
|
|
raise ValidationError('缺少工段或产物!')
|
|
with transaction.atomic():
|
|
mlogb = validated_data.pop('mlogb', [])
|
|
instance: Mlog = super().create(validated_data)
|
|
brotherId_should_list = material_out.brothers
|
|
if brotherId_should_list:
|
|
if mlogb:
|
|
for item in mlogb:
|
|
if item['material_out'].id in brotherId_should_list:
|
|
Mlogb.objects.create(
|
|
mlog=instance, batch=instance.batch, mtask=instance.mtask, material_out=item['material_out'], count_ok=item['count_ok'])
|
|
else:
|
|
raise ValidationError('缺少产出物信息')
|
|
return instance
|
|
|
|
def update(self, instance, validated_data):
|
|
validated_data.pop('mtask', None)
|
|
validated_data.pop('mgroup', None)
|
|
if instance.mtask:
|
|
validated_data.pop('handle_date', None)
|
|
# validated_data.pop('handle_user', None)
|
|
with transaction.atomic():
|
|
mlogb = validated_data.pop('mlogb', [])
|
|
instance = super().update(instance, validated_data)
|
|
if mlogb:
|
|
Mlogb.objects.filter(mlog=instance, material_out__isnull=False).update(count_ok=0)
|
|
for item in mlogb:
|
|
Mlogb.objects.filter(mlog=instance, material_out=item['material_out']).update(
|
|
count_ok=item['count_ok'])
|
|
return instance
|
|
|
|
def validate(self, attrs):
|
|
attrs['fill_way'] = Mlog.MLOG_ONETIME
|
|
attrs['mtype'] = Mlog.MTYPE_SELF # 默认为自生产
|
|
mtask = attrs.get('mtask', None)
|
|
count_notok = 0
|
|
for i in attrs:
|
|
if 'count_n_' in i:
|
|
count_notok = count_notok + attrs[i]
|
|
attrs['count_notok'] = count_notok
|
|
if attrs['count_real'] >= attrs['count_ok'] + attrs['count_notok']:
|
|
pass
|
|
else:
|
|
raise ValidationError('生产数量不能小于合格数量')
|
|
if mtask:
|
|
if mtask.start_date == mtask.end_date:
|
|
attrs['handle_date'] = mtask.start_date
|
|
else:
|
|
if attrs['handle_date'] >= mtask.start_date and attrs['handle_date'] <= mtask.end_date:
|
|
pass
|
|
else:
|
|
raise ValidationError('操作日期错误')
|
|
return attrs
|
|
|
|
|
|
class MlogInitSerializer(CustomModelSerializer):
|
|
class Meta:
|
|
model = Mlog
|
|
fields = ['id', 'work_start_time', 'mgroup', 'reminder_interval_list', 'route', 'equipment', 'handle_user', 'note', 'mtype', 'supplier']
|
|
extra_kwargs = {
|
|
'work_start_time': {'required': True},
|
|
'route':{'required': True},
|
|
'mgroup': {'required': True},
|
|
'mtype': {'required': True}
|
|
}
|
|
|
|
def validate(self, attrs):
|
|
mtype = attrs['mtype']
|
|
route: Route = attrs['route']
|
|
mgroup: Mgroup = attrs['mgroup']
|
|
if route.process != mgroup.process:
|
|
raise ValidationError('工序不匹配')
|
|
attrs['hour_work'] = route.hour_work
|
|
attrs['material_in'] = route.material_in
|
|
attrs['material_out'] = route.material_out
|
|
attrs['fill_way'] = Mlog.MLOG_STEP
|
|
if mtype == Mlog.MTYPE_OUT:
|
|
supplier = attrs.get('supplier', None)
|
|
if not supplier:
|
|
raise ValidationError('外协必须选择外协单位')
|
|
return attrs
|
|
|
|
class MlogChangeSerializer(CustomModelSerializer):
|
|
class Meta:
|
|
model = Mlog
|
|
fields = ['id', 'work_end_time', 'handle_user', 'note']
|
|
|
|
def validate(self, attrs):
|
|
if attrs.get('work_end_time', None):
|
|
attrs['handle_date'] = localdate(attrs['work_end_time'])
|
|
return attrs
|
|
|
|
|
|
class MlogbInSerializer(CustomModelSerializer):
|
|
class Meta:
|
|
model = Mlogb
|
|
fields = ['id', 'mlog', 'mtask', 'wm_in', 'count_use']
|
|
extra_kwargs = {'count_use': {'required': True}, 'mtask': {'required': True}, 'wm_in': {'required': True}}
|
|
|
|
def validate(self, attrs):
|
|
mlog: Mlog = attrs['mlog']
|
|
mtask: Mtask = attrs['mtask']
|
|
wm_in: WMaterial = attrs['wm_in']
|
|
if wm_in.state != WMaterial.WM_OK:
|
|
raise ValidationError('非合格品不可使用')
|
|
if mlog.route != mtask.route:
|
|
raise ValidationError('工序不匹配')
|
|
route = mlog.route
|
|
attrs['material_in'] = wm_in.material
|
|
attrs['batch'] = wm_in.batch
|
|
if route.batch_bind:
|
|
if not Mlogb.objects.filter(mtask__utask=mtask.utask, mlog__submit_time__isnull=False, material_out__isnull=False, batch=attrs['batch']).exists():
|
|
raise ValidationError('批次号不匹配')
|
|
return attrs
|
|
|
|
def create(self, validated_data):
|
|
mlog: Mlog = validated_data['mlog']
|
|
if Mlogb.objects.filter(mlog=mlog, mtask=validated_data['mtask'], wm_in=validated_data['wm_in']).exists():
|
|
raise ValidationError('该记录已存在')
|
|
if mlog.submit_time is not None:
|
|
raise ParseError('生产日志已提交不可编辑')
|
|
return super().create(validated_data)
|
|
|
|
def update(self, instance, validated_data):
|
|
mlog: Mlog = instance.mlog
|
|
if Mlogb.objects.filter(mlog=mlog, mtask=validated_data['mtask'], wm_in=validated_data['wm_in']).exclude(id=instance.id).exists():
|
|
raise ValidationError('该记录已存在')
|
|
if mlog.submit_time is not None:
|
|
raise ParseError('生产日志已提交不可编辑')
|
|
return super().update(instance, validated_data)
|
|
|
|
class MlogbInUpdateSerializer(CustomModelSerializer):
|
|
class Meta:
|
|
model = Mlogb
|
|
fields = ['id', 'count_use', 'count_break']
|
|
|
|
class MlogbOutUpdateSerializer(CustomModelSerializer):
|
|
class Meta:
|
|
model = Mlogb
|
|
fields = "__all__"
|
|
read_only_fields = EXCLUDE_FIELDS_BASE + ['mlog', 'mtask', 'wm_in', 'material_in', 'material_out', 'count_use', 'count_break']
|
|
|
|
def validate(self, attrs):
|
|
count_notok = 0
|
|
for i in attrs:
|
|
if 'count_n_' in i:
|
|
if not hasattr(Mlogb, i):
|
|
raise ValidationError(f'{i}不存在')
|
|
count_notok = count_notok + attrs[i]
|
|
attrs['count_notok'] = count_notok
|
|
if attrs['count_real'] >= attrs['count_ok'] + attrs['count_notok']:
|
|
pass
|
|
else:
|
|
raise ValidationError('生产数量不能小于合格数量')
|
|
return attrs
|
|
|
|
class MlogRevertSerializer(serializers.Serializer):
|
|
change_reason = serializers.CharField(label='撤回原因')
|
|
|
|
|
|
class MlogRelatedSerializer(serializers.Serializer):
|
|
mtask = serializers.PrimaryKeyRelatedField(
|
|
label='小任务ID', queryset=Mtask.objects.all())
|
|
|
|
|
|
class DeptBatchSerializer(serializers.Serializer):
|
|
belong_dept_name = serializers.CharField(label='车间名称')
|
|
|
|
|
|
class HandoverSerializer(CustomModelSerializer):
|
|
# wm = serializers.PrimaryKeyRelatedField(
|
|
# label='车间库存ID', queryset=WMaterial.objects.all())
|
|
# material = serializers.PrimaryKeyRelatedField(
|
|
# required=True, label='物料ID', queryset=Material.objects.all())
|
|
send_user_name = serializers.CharField(
|
|
source='send_user.name', read_only=True)
|
|
recive_user_name = serializers.CharField(
|
|
source='recive_user.name', read_only=True)
|
|
recive_dept_name = serializers.CharField(
|
|
source='recive_dept', read_only=True)
|
|
send_mgroup_name = serializers.CharField(source='send_mgroup.name', read_only=True)
|
|
recive_mgroup_name = serializers.CharField(source='recive_mgroup.name', read_only=True)
|
|
material_ = MaterialSimpleSerializer(source='material', read_only=True)
|
|
material_name = serializers.StringRelatedField(
|
|
source='material', read_only=True)
|
|
wm_notok_sign = serializers.CharField(source='wm.notok_sign', read_only=True)
|
|
|
|
def validate(self, attrs):
|
|
if 'type' not in attrs:
|
|
attrs['type'] = Handover.H_NORMAL
|
|
wm:WMaterial = attrs['wm']
|
|
material = wm.material
|
|
attrs['material'] = wm.material
|
|
attrs['batch'] = wm.batch
|
|
attrs['send_dept'] = wm.belong_dept
|
|
if attrs['wm'].mgroup:
|
|
attrs['send_mgroup'] = wm.mgroup
|
|
if material.process and material.process.into_wm_mgroup and 'recive_mgroup' not in attrs:
|
|
raise ValidationError('必须指定交接工段')
|
|
if 'recive_mgroup' in attrs and attrs['recive_mgroup']:
|
|
attrs['recive_dept'] = attrs['recive_mgroup'].belong_dept
|
|
if 'recive_dept' not in attrs and 'recive_mgroup' not in attrs:
|
|
raise ValidationError('收料车间和收料工段必须有一个')
|
|
if 'send_dept' not in attrs and 'send_mgroup' not in attrs:
|
|
raise ValidationError('送料车间和送料工段必须有一个')
|
|
if wm.notok_sign is not None and attrs['type'] in [Handover.H_NORMAL, Handover.H_TEST]:
|
|
raise ValidationError('物料不合格，不能进行正常/检验交接')
|
|
if wm.count_xtest is not None:
|
|
raise ValidationError('物料检验中，不能进行交接')
|
|
return attrs
|
|
|
|
class Meta:
|
|
model = Handover
|
|
fields = '__all__'
|
|
read_only_fields = EXCLUDE_FIELDS + ["mlog"]
|
|
extra_kwargs = {
|
|
"type": {"required": False},
|
|
"wm": {"required": True},
|
|
"send_dept": {"required": False},
|
|
"recive_mgroup": {"required": False},
|
|
"recive_dept": {"required": False},
|
|
"material": {"required": False},
|
|
"batch": {"required": False},
|
|
}
|
|
|
|
def create(self, validated_data):
|
|
type = validated_data['type']
|
|
if type == Handover.H_REPAIR:
|
|
recive_mgroup = validated_data.get("recive_mgroup", None)
|
|
if recive_mgroup is None:
|
|
raise ParseError('返工交接需指定工段')
|
|
validated_data['material_changed'] = find_material_can_change(validated_data['material'], recive_mgroup)
|
|
return super().create(validated_data)
|
|
|
|
class HandoverUpdateSerializer(CustomModelSerializer):
|
|
class Meta:
|
|
model = Handover
|
|
fields = ['id', 'send_date', 'send_user', 'count', 'count_eweight', 'recive_user']
|
|
|
|
|
|
class GenHandoverSerializer(serializers.Serializer):
|
|
mlogs = serializers.PrimaryKeyRelatedField(
|
|
label='mlog的ID列表', queryset=Mlog.objects.all(), many=True)
|
|
recive_dept = serializers.PrimaryKeyRelatedField(
|
|
label='交送车间', queryset=Dept.objects.all())
|
|
recive_user = serializers.PrimaryKeyRelatedField(
|
|
label='接收人', queryset=User.objects.all())
|
|
send_user = serializers.PrimaryKeyRelatedField(
|
|
label='交送人', queryset=User.objects.all())
|
|
send_date = serializers.DateField(label='交送日期')
|
|
|
|
|
|
class GenHandoverWmSerializer(serializers.Serializer):
|
|
wm = serializers.PrimaryKeyRelatedField(
|
|
label='车间物料ID', queryset=WMaterial.objects.all())
|
|
send_mgroup = serializers.PrimaryKeyRelatedField(
|
|
label='送料工段ID', queryset=Mgroup.objects.all())
|
|
recive_dept = serializers.PrimaryKeyRelatedField(
|
|
label='交送车间', queryset=Dept.objects.all())
|
|
recive_user = serializers.PrimaryKeyRelatedField(
|
|
label='接收人', queryset=User.objects.all())
|
|
send_user = serializers.PrimaryKeyRelatedField(
|
|
label='交送人', queryset=User.objects.all())
|
|
send_date = serializers.DateField(label='交送日期')
|
|
count = serializers.IntegerField(label='交送数量')
|
|
|
|
def validate(self, attrs):
|
|
if attrs['count'] <= 1:
|
|
raise ValidationError('交送数量必须大于1')
|
|
return attrs
|
|
|
|
|
|
class MlogAnaSerializer(serializers.Serializer):
|
|
belong_dept_name = serializers.CharField(label='车间名', required=False)
|
|
start_date = serializers.DateField(label='开始日期', required=True)
|
|
end_date = serializers.DateField(label='结束日期', required=True)
|
|
material_cate = serializers.CharField(label='物料系列', required=False)
|
|
|
|
|
|
class AttLogSerializer(CustomModelSerializer):
|
|
mgroup_name = serializers.CharField(
|
|
source='sflog.mgroup.name', read_only=True)
|
|
user_name = serializers.CharField(source='user.name', read_only=True)
|
|
post_name = serializers.CharField(source='post.name', read_only=True)
|
|
belong_dept_name = serializers.CharField(
|
|
source='sflog.mgroup.belong_dept.name', read_only=True)
|
|
|
|
class Meta:
|
|
model = AttLog
|
|
fields = '__all__'
|