udi-wms-java/src/main/java/com/glxp/api/service/inout/IoSplitCodeService.java

package com.glxp.api.service.inout;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.constant.Constant;
import com.glxp.api.dao.inout.IoSplitCodeMapper;
import com.glxp.api.entity.basic.SysWorkplacePutRel;
import com.glxp.api.entity.basic.UdiRelevanceEntity;
import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.inout.IoSplitCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoInv;
import com.glxp.api.exception.JsonException;
import com.glxp.api.req.basic.FilterUdiRelRequest;
import com.glxp.api.req.collect.AddInvDesDetaiRequest;
import com.glxp.api.req.collect.CollectOrderRequest;
import com.glxp.api.req.inout.IoSplitCodeRequest;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.collect.*;
import com.glxp.api.service.thrsys.SysWorkplacePutRelService;
import com.glxp.api.util.GennerOrderUtils;
import com.glxp.api.util.IntUtil;
import com.glxp.api.util.OrderNoTypeBean;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 拆零码明细
 */
@Service
public class IoSplitCodeService extends ServiceImpl<IoSplitCodeMapper, IoSplitCodeEntity> {

    @Resource
    IoSplitCodeMapper splitCodeMapper;
    @Resource
    IoSplitFifoCodeService splitFifoCodeService;
    @Resource
    IoCollectOrderBizService collectOrderBizService;
    @Resource
    IoCollectOrderCodeAutoService collectOrderCodeAutoService;
    @Resource
    IoSplitDesOrderService splitDesOrderService;
    @Resource
    IoSplitDesOrderDetailService splitDesOrderDetailService;
    @Resource
    GennerOrderUtils gennerOrderUtils;

    @Resource
    UdiRelevanceService udiRelevanceService;
    @Resource
    IoCollectOrderCodeManService collectOrderCodeManService;
    @Resource
    IoSplitCodeService splitCodeService;
    @Resource
    IoCollectOrderBizBackupService ioCollectOrderBizBackupService;
    @Resource
    IoSplitFifoInvService splitFifoInvService;

    @Resource
    IoCollectLedGroupService ioCollectLedGroupService;


    @Resource
    SysWorkplacePutRelService workplacePutRelService;

    public List<IoSplitCodeEntity> filterList(IoSplitCodeRequest splitCodeRequest) {
        if (splitCodeRequest == null) {
            return Collections.emptyList();
        }
        if (splitCodeRequest.getPage() != null) {
            int offset = (splitCodeRequest.getPage() - 1) * splitCodeRequest.getLimit();
            PageHelper.offsetPage(offset, splitCodeRequest.getLimit());
        }
        return super.baseMapper.filterList(splitCodeRequest);

    }

    public List<IoSplitCodeEntity> findSplitCodes(Long relId, String batchNo, Long workPlaceCode) {
        List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(new LambdaQueryWrapper<IoSplitCodeEntity>()
                .eq(IoSplitCodeEntity::getRelId, relId)
                .eq(StrUtil.isNotEmpty(batchNo), IoSplitCodeEntity::getBatchNo, batchNo)
                .eq(workPlaceCode != null, IoSplitCodeEntity::getWorkPlaceCode, workPlaceCode)
                .gt(IoSplitCodeEntity::getRemainCount, 0)
                .in(IoSplitCodeEntity::getStatus, 1, 2).orderByAsc(IoSplitCodeEntity::getInBactchNo));
        return ioSplitCodeEntities;
    }

    public IoSplitCodeEntity findByCode(String code, Long workPlaceCode) {
        if (workPlaceCode == null) {
            return null;
        }
        List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(new LambdaQueryWrapper<IoSplitCodeEntity>()
                .eq(IoSplitCodeEntity::getCode, code)
                .eq(workPlaceCode != null, IoSplitCodeEntity::getWorkPlaceCode, workPlaceCode)
                .in(IoSplitCodeEntity::getStatus, 1, 2).orderByAsc(IoSplitCodeEntity::getInBactchNo));
        if (CollUtil.isNotEmpty(ioSplitCodeEntities))
            return ioSplitCodeEntities.get(0);
        return null;
    }

    public IoSplitCodeEntity findByCode(String code) {
        return splitCodeMapper.selectOne(new LambdaQueryWrapper<IoSplitCodeEntity>()
                .eq(IoSplitCodeEntity::getCode, code).last("limit 1"));
    }

    public void splitRemove(IoCollectOrderBiz collectOrderBiz, IoCollectOrder collectOrder, Long putWorkPlaceCode, Boolean isAuto) {
        //1.按照先进先出原则，查询拆零表，获取拆零表ID
        List<IoSplitCodeEntity> ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);

        //2.如果拆零表为空，则自动从预出库队列中获拉取数据
        if (CollUtil.isEmpty(ioSplitCodeEntities)) {
            addFifoCode(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), IntUtil.value(collectOrderBiz.getUnTagCount()), putWorkPlaceCode);
            ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);
        }
        //3.如果拆零表不为空，则开始扣除数量
        int count = 0;
        int unCount = 0;  //剩余未扣减数量
        unCount = IntUtil.value(collectOrderBiz.getUnTagCount());
        for (IoSplitCodeEntity ioSplitCodeEntity : ioSplitCodeEntities) {
            count = IntUtil.value(ioSplitCodeEntity.getRemainCount()) - unCount;
            collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
                    .codeIdFk(ioSplitCodeEntity.getId())
                    .udiCode(ioSplitCodeEntity.getCode())
                    .orderIdFk(collectOrder.getBillNo())
                    .batchNo(ioSplitCodeEntity.getBatchNo())
                    .productDate(ioSplitCodeEntity.getProduceDate())
                    .expireDate(ioSplitCodeEntity.getExpireDate())
                    .serialNo(ioSplitCodeEntity.getSerialNo())
                    .relId(collectOrderBiz.getRelId())
                    .bizIdFk(collectOrderBiz.getId())
                    .fifoSplit(ioSplitCodeEntity.getFifoSplit())
                    .createTime(new Date())
                    .updateTime(new Date())
                    .build());
            if (count > 0) {
                ioSplitCodeEntity.setRemainCount(count);
                unCount = 0;
                splitCodeMapper.updateById(ioSplitCodeEntity);
                break;
            } else if (count == 0) {
                ioSplitCodeEntity.setRemainCount(0);
                unCount = 0;
            } else {
                ioSplitCodeEntity.setRemainCount(0);
                unCount = -count;
            }
            splitCodeMapper.updateById(ioSplitCodeEntity);
        }

        if (unCount > 0) {
            //4.拆零表数量不足，则从预出库队列中获取数据
            Integer fifoCount = addFifoCode(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), unCount, putWorkPlaceCode);
            if (fifoCount == 0) {
                //预出库队列数量不足
                collectOrderBiz.setTagStatus(2);
                collectOrderBiz.setTagMsg("预出库队列码数量不足，赋码失败！");
                if (isAuto)
                    throw new JsonException(500, "提交失败，工位库存数量不足！");
                else return;

            } else {
                //再次执行赋码
                ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);
                for (IoSplitCodeEntity ioSplitCodeEntity : ioSplitCodeEntities) {
                    if (IntUtil.value(ioSplitCodeEntity.getRemainCount()) > 0) {
                        count = IntUtil.value(ioSplitCodeEntity.getRemainCount()) - unCount;
                        collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
                                .codeIdFk(ioSplitCodeEntity.getId())
                                .udiCode(ioSplitCodeEntity.getCode())
                                .orderIdFk(collectOrder.getBillNo())
                                .batchNo(ioSplitCodeEntity.getBatchNo())
                                .productDate(ioSplitCodeEntity.getProduceDate())
                                .expireDate(ioSplitCodeEntity.getExpireDate())
                                .serialNo(ioSplitCodeEntity.getSerialNo())
                                .relId(collectOrderBiz.getRelId())
                                .bizIdFk(collectOrderBiz.getId())
                                .fifoSplit(ioSplitCodeEntity.getFifoSplit())
                                .createTime(new Date())
                                .updateTime(new Date())
                                .build());
                        if (count > 0) {
                            ioSplitCodeEntity.setRemainCount(count);
                            splitCodeMapper.updateById(ioSplitCodeEntity);
                            break;
                        } else if (count == 0) {
                            ioSplitCodeEntity.setRemainCount(0);
                            splitCodeMapper.updateById(ioSplitCodeEntity);
                        } else {
                            ioSplitCodeEntity.setRemainCount(0);
                            splitCodeMapper.updateById(ioSplitCodeEntity);
                            unCount = -count;
                        }
                    }
                }
                if (unCount > 0) {
                    collectOrderBiz.setTagStatus(2);
                    collectOrderBiz.setTagMsg("预出库队列码数量不足，赋码失败！");
                    if (isAuto)
                        throw new JsonException(500, "提交失败，工位库存数量不足！");
                    else return;
                } else {
                    collectOrderBiz.setTagStatus(3);
                    collectOrderBiz.setTagMsg("赋码完成！");
                }
            }
        } else {
            collectOrderBiz.setTagStatus(3);
            collectOrderBiz.setTagMsg("赋码完成！");
        }
        collectOrderBiz.setUnTagCount(unCount);
        collectOrderBizService.updateById(collectOrderBiz);
    }


    @Transactional(rollbackFor = Exception.class)
    public void finishAutoTagCode(IoCollectOrder collectOrder, Boolean isAuto, String queueCode) {

        SysWorkplacePutRel sysWorkplacePutRel = workplacePutRelService.findPutWorkPlace(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
        Long putWorkPlaceCode = null;
        if (sysWorkplacePutRel != null)
            putWorkPlaceCode = sysWorkplacePutRel.getWorkPlaceCode();
        List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());

        //如果手动扫码判断该码是否在队列里，如果已在队列，则队列里剔除
        List<IoCollectOrderCodeMan> collectOrderCodeMEN = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
        if (CollUtil.isNotEmpty(collectOrderCodeMEN)) {
            for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodeMEN) {
                IoSplitFifoCodeEntity splitFifoCodeEntity = splitFifoCodeService.findByCode(collectOrderCodeMan.getUdiCode(), putWorkPlaceCode);
                if (splitFifoCodeEntity != null) {
                    collectOrderCodeMan.setRemoveFlag(true);
                    if (IntUtil.value(splitFifoCodeEntity.getScanCount()) - IntUtil.value(collectOrderCodeMan.getScanCount()) <= 0) {
                        splitFifoCodeService.removeById(splitFifoCodeEntity.getId());
                        IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
                        if (splitFifoInv != null) {
                            splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
                            int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
                            splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
                            splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInvService.updateById(splitFifoInv);
                        }

                    } else {
                        //队列码数量大于扫码数量更新数量（一般指无序列号）
//                        UdiRelevanceEntity udiRelevanceEntity = udiRelevanceService.selectById(collectOrderCodeMan.getRelId());
                        FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
                        filterUdiRelRequest.setId(collectOrderCodeMan.getRelId());
                        filterUdiRelRequest.setPackLevel("1");
                        UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectOneUdi(filterUdiRelRequest);
                        int removeCount = IntUtil.value(collectOrderCodeMan.getScanCount()) * udiRelevanceResponse.getBhxjsl();
                        splitFifoCodeService.updateById(IoSplitFifoCodeEntity.builder()
                                .id(splitFifoCodeEntity.getId())
                                .scanCount(IntUtil.value(splitFifoCodeEntity.getScanCount()) - IntUtil.value(collectOrderCodeMan.getScanCount()))
                                .totalCount(IntUtil.value(splitFifoCodeEntity.getTotalCount()) - removeCount)
                                .build());

                        IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
                        if (splitFifoInv != null) {
                            splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + removeCount);
                            int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - removeCount;
                            splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
                            splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInvService.updateById(splitFifoInv);
                        }
                    }
                }

                //判断拆零表里是否存在，如果存在则剔除
                IoSplitCodeEntity splitCodeEntity = splitCodeService.findByCode(collectOrderCodeMan.getUdiCode(), putWorkPlaceCode);
                if (splitCodeEntity != null && IntUtil.value(splitCodeEntity.getRemainCount()) > 0) {
                    if (IntUtil.value(splitCodeEntity.getRemainCount()) > IntUtil.value(collectOrderCodeMan.getScanActCount())) {
                        splitCodeEntity.setRemainCount(IntUtil.value(splitCodeEntity.getRemainCount()) - IntUtil.value(collectOrderCodeMan.getScanActCount()));
                    } else {
                        splitCodeEntity.setRemainCount(0);
                    }
                    collectOrderCodeMan.setSplitFlag(true);
                    splitCodeService.updateById(splitCodeEntity);
                }

            }
        }
        for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
//            UdiRelevanceEntity udiRelevanceEntity = udiRelevanceService.selectById(collectOrderBiz.getRelId());
            FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
            filterUdiRelRequest.setId(collectOrderBiz.getRelId());
            filterUdiRelRequest.setPackLevel("1");
            //todo  后面可以 没有搜索到层级为1的
            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectOneUdi(filterUdiRelRequest);
            //去除掉已经手动扫码的数据，找出需要自动扫码的明细，执行上述的拆零或整取
            int unTagCount = collectOrderBiz.getCount() - IntUtil.value(collectOrderBiz.getScanActCount());
            if (unTagCount > 0) {
                collectOrderBiz.setUnTagCount(unTagCount);
            } else {
                collectOrderBiz.setTagStatus(3);
                //手动扫码时涉及到拆零时，把拆零剩余数量插入至拆零表里
                if (unTagCount < 0) {
                    List<IoCollectOrderCodeMan> newList = filterCode(collectOrderCodeMEN, collectOrderBiz, udiRelevanceResponse);
                    if (CollUtil.isNotEmpty(newList)) {
                        for (IoCollectOrderCodeMan item : newList) {
                            if (IntUtil.value(item.getSplitFlag())) {
                                IoSplitCodeEntity splitCodeEntity = splitCodeService.findByCode(item.getUdiCode(), putWorkPlaceCode);
                                splitCodeEntity.setRemainCount(-unTagCount);
                                splitCodeService.updateById(splitCodeEntity);
                            } else {
                                IoSplitCodeEntity ioSplitCodeEntity = IoSplitCodeEntity.builder().code(item.getUdiCode())
                                        .errUdiCode(item.getUdiCode())
                                        .orderId(item.getOrderIdFk())
                                        .action(collectOrder.getBusType())
                                        .relId(item.getRelId())
                                        .nameCode(item.getNameCode())
                                        .batchNo(item.getBatchNo())
                                        .produceDate(item.getProductDate())
                                        .expireDate(item.getExpireDate())
                                        .serialNo(item.getSerialNo())
                                        .scanCount(item.getScanCount())
                                        .totalCount(item.getScanCount())
                                        .workPlaceCode(putWorkPlaceCode)
                                        .status(2)
                                        .fifoSplit(1)
                                        .createTime(new Date()).updateTime(new Date())
                                        .remainCount(item.getRemainCount()).build();
                                this.decorateUnpackExpireTime(ioSplitCodeEntity);
                                splitCodeService.save(ioSplitCodeEntity);
                            }

                        }
                    }
                }
                continue;
            }
            int quotient = 0;
            int remainder = 0;
            if (IntUtil.value(udiRelevanceResponse.getBhxjsl()) != 0) {
                quotient = collectOrderBiz.getUnTagCount() / IntUtil.value(udiRelevanceResponse.getBhxjsl());
                remainder = collectOrderBiz.getUnTagCount() % IntUtil.value(udiRelevanceResponse.getBhxjsl());
            }
            //2.如果整盒，从工位队列扣除   默认最后一个追溯码拆零
            if (quotient > 0) {
                List<IoSplitFifoCodeEntity> ioSplitFifoCodeEntities = splitFifoCodeService.findByRelId(putWorkPlaceCode, collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), queueCode);
                if (ioSplitFifoCodeEntities.size() < quotient) {
                    if (isAuto)
                        throw new JsonException(500, "提交失败，工位库存数量不足！");
//                    else return;
                }
                if (ioSplitFifoCodeEntities.size() > 0) {
                    for (int i = 0; i < quotient; i++) {
                        IoSplitFifoCodeEntity splitFifoCodeEntity = ioSplitFifoCodeEntities.get(i);
                        collectOrderBiz.setUnTagCount(IntUtil.value(collectOrderBiz.getUnTagCount()) - IntUtil.value(udiRelevanceResponse.getBhxjsl()));
                        collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
                                .codeIdFk(splitFifoCodeEntity.getId())
                                .udiCode(splitFifoCodeEntity.getCode())
                                .orderIdFk(collectOrder.getBillNo())
                                .batchNo(splitFifoCodeEntity.getBatchNo())
                                .productDate(splitFifoCodeEntity.getProduceDate())
                                .expireDate(splitFifoCodeEntity.getExpireDate())
                                .serialNo(splitFifoCodeEntity.getSerialNo())
                                .relId(collectOrderBiz.getRelId())
                                .bizIdFk(collectOrderBiz.getId())
                                .fifoSplit(splitFifoCodeEntity.getFifoSplit())
                                .createTime(new Date())
                                .updateTime(new Date())
                                .build());
                        splitFifoCodeService.removeById(splitFifoCodeEntity.getId());
                        IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
                        if (splitFifoInv != null) {
                            splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
                            int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
                            splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
                            splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInvService.updateById(splitFifoInv);
                        }

                    }
                }

            }
            //.如果拆零，拆零表扣除
            if (remainder > 0) {
                splitRemove(collectOrderBiz, collectOrder, putWorkPlaceCode, isAuto);
            }

        }
        ArrayList<IoCollectOrderBizBackup> ioCollectOrderBizBackups = new ArrayList<>();
        for (IoCollectOrderBiz ioCollectOrderBiz : collectOrderBizs) {
            IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
            BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
            ioCollectOrderBizBackups.add(ioCollectOrderBizBackup);
        }
        ioCollectOrderBizBackupService.saveBatch(ioCollectOrderBizBackups);
    }


    @Resource
    IoCollectOrderService collectOrderService;

    @Transactional(rollbackFor = Exception.class)
    public void confirmBizAutiTagCode(IoCollectOrderBiz collectOrderBiz, String queueCode) {

        IoCollectOrder collectOrder = collectOrderService.getByBillNo(collectOrderBiz.getOrderIdFk());
        SysWorkplacePutRel sysWorkplacePutRel = workplacePutRelService.findPutWorkPlace(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
        Long putWorkPlaceCode = null;
        if (sysWorkplacePutRel != null)
            putWorkPlaceCode = sysWorkplacePutRel.getWorkPlaceCode();
        FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
        filterUdiRelRequest.setId(collectOrderBiz.getRelId());
        filterUdiRelRequest.setPackLevel("1");
        //todo  后面可以 没有搜索到层级为1的
        UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectOneUdi(filterUdiRelRequest);
        //去除掉已经手动扫码的数据，找出需要自动扫码的明细，执行上述的拆零或整取
        int unTagCount = collectOrderBiz.getCount() - IntUtil.value(collectOrderBiz.getScanActCount());
        if (unTagCount > 0) {
            collectOrderBiz.setUnTagCount(unTagCount);
        }

        int quotient = collectOrderBiz.getUnTagCount() / IntUtil.value(udiRelevanceResponse.getBhxjsl());
        int remainder = collectOrderBiz.getUnTagCount() % IntUtil.value(udiRelevanceResponse.getBhxjsl());
        //2.如果整盒，从工位队列扣除   默认最后一个追溯码拆零
        if (quotient > 0) {
            List<IoSplitFifoCodeEntity> ioSplitFifoCodeEntities = splitFifoCodeService.findByRelId(putWorkPlaceCode, collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), queueCode);
            if (ioSplitFifoCodeEntities.size() < quotient) {
                throw new JsonException(500, "确认失败，工位库存数量不足！");
            }
            for (int i = 0; i < quotient; i++) {
                IoSplitFifoCodeEntity splitFifoCodeEntity = ioSplitFifoCodeEntities.get(i);
                collectOrderBiz.setUnTagCount(IntUtil.value(collectOrderBiz.getUnTagCount()) - IntUtil.value(udiRelevanceResponse.getBhxjsl()));
                collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
                        .codeIdFk(splitFifoCodeEntity.getId())
                        .udiCode(splitFifoCodeEntity.getCode())
                        .orderIdFk(collectOrder.getBillNo())
                        .batchNo(splitFifoCodeEntity.getBatchNo())
                        .productDate(splitFifoCodeEntity.getProduceDate())
                        .expireDate(splitFifoCodeEntity.getExpireDate())
                        .serialNo(splitFifoCodeEntity.getSerialNo())
                        .relId(collectOrderBiz.getRelId())
                        .bizIdFk(collectOrderBiz.getId())
                        .fifoSplit(splitFifoCodeEntity.getFifoSplit())
                        .createTime(new Date())
                        .updateTime(new Date())
                        .build());
                splitFifoCodeService.removeById(splitFifoCodeEntity.getId());
                IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
                if (splitFifoInv != null) {
                    splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
                    int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
                    splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
                    splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                    splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                    splitFifoInvService.updateById(splitFifoInv);
                }
            }
        }
        //.如果拆零，拆零表扣除
        if (remainder > 0) {
            splitRemove(collectOrderBiz, collectOrder, putWorkPlaceCode, false);
        }
        if (collectOrderBiz.getTagStatus() == 2) {
            throw new JsonException(500, "确认失败，工位库存数量不足！");
        } else {
            collectOrderBiz.setGetConfirm(true);
            collectOrderBizService.updateById(collectOrderBiz);
        }

    }


    @Resource
    IoSplitFifoInvRelService splitFifoInvRelService;

    public List<Long> findInvIdFk(IoCollectOrder collectOrder) {
        List<IoSplitFifoInvRel> ioSplitFifoInvRels = splitFifoInvRelService.findInvIdFk(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
        if (CollUtil.isNotEmpty(ioSplitFifoInvRels)) {
            return ioSplitFifoInvRels.stream()
                    .map(IoSplitFifoInvRel::getInvIdFk)
                    .collect(Collectors.toList());
        } else
            return null;
    }

    public List<IoCollectOrderCodeMan> filterCode(List<IoCollectOrderCodeMan> collectOrderCodes, IoCollectOrderBiz collectOrderBiz, UdiRelevanceResponse udiRelevanceResponse) {
        int unTagCount = IntUtil.value(collectOrderBiz.getScanActCount()) - collectOrderBiz.getCount();
        List<IoCollectOrderCodeMan> newList = new ArrayList<IoCollectOrderCodeMan>();
        int count = 0;
        boolean first = true;
        for (IoCollectOrderCodeMan collectOrderCode : collectOrderCodes) {
            if (collectOrderCode.getBizIdFk().equals(collectOrderBiz.getId())) {
                if (IntUtil.value(collectOrderCode.getIsSplitCode())) {
                    if (first) {
                        int remainder = unTagCount % IntUtil.value(udiRelevanceResponse.getBhxjsl());
                        collectOrderCode.setRemainCount(remainder);
                        first = false;
                    } else {
                        collectOrderCode.setRemainCount(collectOrderCode.getScanActCount());
                    }
                    newList.add(collectOrderCode);
                } else {
                    count = count + collectOrderCode.getScanActCount();
                    if (!IntUtil.value(collectOrderCode.getRemoveFlag())) {
                        if (count > collectOrderBiz.getCount()) {
                            if (first) {
                                int remainder = unTagCount % IntUtil.value(udiRelevanceResponse.getBhxjsl());
                                collectOrderCode.setRemainCount(remainder);
                                first = false;
                            } else {
                                collectOrderCode.setRemainCount(collectOrderCode.getScanActCount());
                            }
                            newList.add(collectOrderCode);
                        }
                    }
                }

            }
        }
        return newList;

    }


    /**
     * 单据预赋码
     *
     * @param collectOrder
     */
    public void preAutoTagCode(IoCollectOrder collectOrder, String queueCode) {
        Long putWorkPlaceCode = null;
        //获取上货工位
        SysWorkplacePutRel sysWorkplacePutRel = workplacePutRelService.findPutWorkPlace(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
        if (sysWorkplacePutRel != null)
            putWorkPlaceCode = sysWorkplacePutRel.getWorkPlaceCode();

        List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
        for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
            List<IoSplitFifoCodeEntity> splitFifoCodeEntities =
                    splitFifoCodeService.findByRelId(putWorkPlaceCode,
                            collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), queueCode);
            int total = splitFifoCodeEntities.stream()
                    .mapToInt(IoSplitFifoCodeEntity::getTotalCount)
                    .sum();
            collectOrderBiz.setTempWorkPlaceCount(total);
            List<IoSplitCodeEntity> splitCodeEntities = splitCodeService.findSplitCodes(collectOrderBiz.getRelId()
                    , collectOrderBiz.getBatchNo(), putWorkPlaceCode);
            int splitTotal = splitCodeEntities.stream()
                    .mapToInt(IoSplitCodeEntity::getRemainCount)
                    .sum();
            collectOrderBiz.setTempSplitCount(splitTotal);
            total = total + splitTotal;
            if (total >= IntUtil.value(collectOrderBiz.getCount())) {
                collectOrderBiz.setAutoTagStatus(2);
            } else if (total > 0) {
                collectOrderBiz.setAutoTagStatus(3);
            } else
                collectOrderBiz.setAutoTagStatus(1);
        }
        ThreadUtil.execAsync(() -> {
                    ioCollectLedGroupService.openLed(collectOrderBizs);
                }
        );

        collectOrderBizService.updateBatchById(collectOrderBizs);
    }


    /**
     * 拆零单据撤回，则将拆零表剩余数量加回预出库队列
     *
     * @param collectOrder
     */
    public void backSplit(IoCollectOrder collectOrder) {
        List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
        for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
            List<IoSplitCodeEntity> ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), collectOrder.getWorkPlaceCode());
            if (CollUtil.isNotEmpty(ioSplitCodeEntities)) {
                IoSplitCodeEntity splitCodeEntity = ioSplitCodeEntities.get(0);
                splitCodeEntity.setRemainCount(IntUtil.value(splitCodeEntity.getRemainCount()) + (IntUtil.value(collectOrderBiz.getCount()) - IntUtil.value(collectOrderBiz.getUnTagCount())));
                splitCodeMapper.updateById(splitCodeEntity);
            }
        }
    }


    /**
     * 从预出库队列里面取出数据，添加至拆零表
     */
    public Integer addFifoCode(Long relId, String batchNo, Integer needCount, Long putWorkPlaceCode) {

        List<IoSplitFifoCodeEntity> splitFifoCodeEntities = splitFifoCodeService
                .list(new LambdaQueryWrapper<IoSplitFifoCodeEntity>()
                        .eq(IoSplitFifoCodeEntity::getRelId, relId)
                        .eq(StrUtil.isNotEmpty(batchNo), IoSplitFifoCodeEntity::getBatchNo, batchNo)
                        .eq(putWorkPlaceCode != null, IoSplitFifoCodeEntity::getWorkPlaceCode, putWorkPlaceCode)
                        .orderByAsc(IoSplitFifoCodeEntity::getInBactchNo)
                );
        Integer count = 0;
        List<IoSplitCodeEntity> addSplitCodeEntities = new ArrayList<>();
        List<Long> removeIds = new ArrayList<>();
        for (IoSplitFifoCodeEntity splitFifoCodeEntity : splitFifoCodeEntities) {
            IoSplitCodeEntity splitCodeEntity = new IoSplitCodeEntity();
            BeanUtils.copyProperties(splitFifoCodeEntity, splitCodeEntity);

            count = IntUtil.value(splitFifoCodeEntity.getTotalCount()) + count;
            splitCodeEntity.setRemainCount(splitCodeEntity.getTotalCount());

            splitCodeEntity.setStatus(1);
            splitCodeEntity.setFifoSplit(splitFifoCodeEntity.getFifoSplit());
            splitCodeEntity.setId(null);
            this.decorateUnpackExpireTime(splitCodeEntity);
            addSplitCodeEntities.add(splitCodeEntity);
            removeIds.add(splitFifoCodeEntity.getId());
            IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
            if (splitFifoInv != null) {
                splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
                int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
                splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
                splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                splitFifoInvService.updateById(splitFifoInv);
            }
            if (count >= needCount) {
                break;
            }
        }
        if (removeIds.size() > 0) {
            splitFifoCodeService.removeByIds(removeIds);
        }
        if (addSplitCodeEntities.size() > 0) {
            splitCodeMapper.insertBatch(addSplitCodeEntities);
        }
        return count;

    }


    public int checkStatus(List<IoCollectOrderBiz> list) {
        boolean hasTwo = false;
        boolean hasOne = false;
        boolean hasNone = true;
        for (IoCollectOrderBiz di : list) {
            int tagStatus = di.getTagStatus();
            if (tagStatus == 2) {
                hasTwo = true;
            } else if (tagStatus == 1) {
                hasOne = true;
            } else if (tagStatus != 3) {
                throw new IllegalArgumentException("Invalid tagStatus value: " + tagStatus);
            }
        }
        for (IoCollectOrderBiz di : list) {
            if (IntUtil.value(di.getCount()) != IntUtil.value(di.getUnTagCount())) {
                hasNone = false;
                break;
            }
        }
        if (hasNone) {
            return 1;
        }
        if (hasTwo) {
            return 2;
        } else if (hasOne) {
            return 1;
        } else {
            return 3;
        }
    }


    //包装拆包失效时间
    void decorateUnpackExpireTime(IoSplitCodeEntity ioSplitCodeEntity) {
        Long relId = ioSplitCodeEntity.getRelId();
        UdiRelevanceEntity relevanceEntity = udiRelevanceService.getById(relId);
        int n = IntUtil.value(relevanceEntity.getUnpackUseTime());
        // 获取当前时间
        Calendar calendar = Calendar.getInstance();
        Date unpackTime = calendar.getTime();
        // 加上n小时
        calendar.add(Calendar.HOUR_OF_DAY, n);
        // 转换为Date对象
        Date unpackExpireTime = calendar.getTime();
        ioSplitCodeEntity.setUnpackTime(unpackTime);
        ioSplitCodeEntity.setUnpackExpireTime(unpackExpireTime);
    }

    /**
     * 扫描拆包过期进行处理损耗出库
     */
    public void asyncUnpackExpireTask() {
        LambdaQueryWrapper<IoSplitCodeEntity> lqw = new LambdaQueryWrapper<>();
        Date now = new Date();
        lqw.lt(IoSplitCodeEntity::getUnpackExpireTime, now);

        List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(lqw);
        if (CollUtil.isNotEmpty(ioSplitCodeEntities)) {
            //进行损耗出库
            IoSplitDesOrder collectOrder;
            List<IoSplitDesOrderDetail> splitDesOrderDetails = new ArrayList<>();
            List<Long> removeByIds = new ArrayList<>();
            collectOrder = IoSplitDesOrder.builder()
                    .id(IdUtil.getSnowflakeNextId())
                    .billNo(gennerOrderUtils.createWdOrderNo(new OrderNoTypeBean(Constant.SPLIT_DES_ORDER, "yyyyMMdd")))
                    .busType(null)
                    .workPlaceCode(null)
                    .createTime(new Date())
                    .billTime(new Date())
                    .remark(null)
                    .status(2)
                    .createUser("1")
                    .updateTime(new Date())
                    .updateUser("1")
                    .build();
            splitDesOrderService.save(collectOrder);

            ioSplitCodeEntities.forEach(splitCodeEntity -> {
                //损耗详细表
                IoSplitDesOrderDetail splitDesOrderDetail = IoSplitDesOrderDetail.builder()
                        .id(IdUtil.getSnowflakeNextId())
                        .workPlaceCode(collectOrder.getWorkPlaceCode())
                        .orderIdFk(collectOrder.getBillNo())
                        .relId(splitCodeEntity.getRelId())
                        .batchNo(splitCodeEntity.getBatchNo())
                        .produceDate(splitCodeEntity.getProduceDate())
                        .expireDate(splitCodeEntity.getExpireDate())
                        .supId(splitCodeEntity.getSupId())
                        .count(splitCodeEntity.getRemainCount())
                        .reCount(splitCodeEntity.getRemainCount())
                        .createTime(new Date())
                        .updateTime(new Date())
                        .remark("").build();
                splitDesOrderDetails.add(splitDesOrderDetail);
                removeByIds.add(splitCodeEntity.getId());
            });

            if (removeByIds.size() > 0) {
                this.removeByIds(removeByIds);
            }
            if (splitDesOrderDetails.size() > 0) {
                splitDesOrderDetailService.saveBatch(splitDesOrderDetails);
            }
        }
    }
}