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

package com.glxp.api.service.inout;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Assert;
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.dao.collect.IoCollectCodeBackMapper;
import com.glxp.api.dao.collect.IoCollectOrderBackupMapper;
import com.glxp.api.dao.inout.IoSplitFifoInvMapper;
import com.glxp.api.entity.basic.SysWorkplaceLayer;
import com.glxp.api.entity.basic.SysWorkplacePutRel;
import com.glxp.api.entity.basic.SysWorkplaceQueue;
import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.inout.*;
import com.glxp.api.exception.JsonException;
import com.glxp.api.req.basic.SysWorkplaceLayerRequest;
import com.glxp.api.req.inout.IoSplitCodeRequest;
import com.glxp.api.req.inout.IoSplitFifoInvRequest;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.res.inout.IoSplitInvResponse;
import com.glxp.api.service.basic.SysWorkplaceDocumentService;
import com.glxp.api.service.basic.SysWorkplaceLayerService;
import com.glxp.api.service.basic.SysWorkplaceQueueService;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.collect.IoCollectSetService;
import com.glxp.api.service.collect.IoSplitFifoInvRelService;
import com.glxp.api.service.thrsys.SysWorkplacePutRelService;
import com.glxp.api.util.IntUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class IoSplitFifoInvService extends ServiceImpl<IoSplitFifoInvMapper, IoSplitFifoInv> {

    @Resource
    IoSplitFifoCodeService splitFifoCodeService;
    @Resource
    SysWorkplaceDocumentService sysWorkplaceDocumentService;
    @Resource
    UdiRelevanceService udiRelevanceService;

    /**
     * 插入库存
     *
     * @param codeList
     */
    @Transactional(rollbackFor = Exception.class)
    public void insertInv(List<IoCodeEntity> codeList, IoOrderEntity orderEntity) {

        List<IoSplitFifoCodeEntity> splitCodeEntities = new ArrayList<>();
        if (CollUtil.isNotEmpty(codeList)) {
            long index = 1;
            for (IoCodeEntity codeEntity : codeList) {

                IoSplitFifoCodeEntity ioSplitFifoCodeEntity = null;
                if (StrUtil.isEmpty(codeEntity.getSerialNo())) {
                    ioSplitFifoCodeEntity = splitFifoCodeService.findByCode(codeEntity.getCode(), orderEntity.getWorkPlaceCode());
                }
                if (ioSplitFifoCodeEntity != null) {
                    ioSplitFifoCodeEntity.setScanCount(IntUtil.value(ioSplitFifoCodeEntity.getScanCount()) + IntUtil.value(codeEntity.getCount()));
                    ioSplitFifoCodeEntity.setTotalCount(ioSplitFifoCodeEntity.getTotalCount() + codeEntity.getReCount());
                    ioSplitFifoCodeEntity.setUpdateTime(new Date());
                    ioSplitFifoCodeEntity.setBusType(orderEntity.getSplitBusType());
                    ioSplitFifoCodeEntity.setWorkPlaceQueueCode(orderEntity.getWorkPlaceQueueCode());
                    splitFifoCodeService.updateById(ioSplitFifoCodeEntity);
                    IoSplitFifoInv splitFifoInv = findByFifoCode(ioSplitFifoCodeEntity);
                    if (splitFifoInv != null) {
                        splitFifoInv.setInCount(IntUtil.value(splitFifoInv.getInCount()) + IntUtil.value(codeEntity.getReCount()));
                        splitFifoInv.setInCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) + IntUtil.value(codeEntity.getCount()));
//                        splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(codeEntity.getReCount()));
                        splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                        splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
                        //入库 - 出库 - 锁定
                        splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()) - IntUtil.value(splitFifoInv.getLockCount()));
//                        splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) + IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()));
                        updateById(splitFifoInv);
                    }
                } else {
                    IoSplitFifoCodeEntity splitCodeEntity = new IoSplitFifoCodeEntity();
                    BeanUtils.copyProperties(codeEntity, splitCodeEntity);
                    splitCodeEntity.setInBactchNo(codeEntity.getInBatchNo());
                    splitCodeEntity.setScanCount(codeEntity.getCount());
                    splitCodeEntity.setTotalCount(IntUtil.value(splitCodeEntity.getTotalCount()) + codeEntity.getReCount());
                    if (StrUtil.isNotEmpty(codeEntity.getSupId()))
                        splitCodeEntity.setSupId(Long.parseLong(codeEntity.getSupId()));
                    splitCodeEntity.setWorkPlaceCode(orderEntity.getWorkPlaceCode());
                    splitCodeEntity.setWorkPlaceQueueCode(orderEntity.getWorkPlaceQueueCode());
                    splitCodeEntity.setFifoSplit(codeEntity.getFifoSplit());
                    UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByRelId(codeEntity.getRelId() + "");
                    if (udiRelevanceResponse != null) {
                        splitCodeEntity.setYbbm(udiRelevanceResponse.getYbbm());
                    }
                    splitCodeEntity.setBusType(orderEntity.getSplitBusType());
                    index++;
                    splitCodeEntity.setInBactchNo(System.currentTimeMillis() + index + "");
                    splitCodeEntity.setId(null);
                    splitCodeEntities.add(splitCodeEntity);
                }
            }
        }

        for (IoSplitFifoCodeEntity ioSplitFifoCodeEntity : splitCodeEntities) {
            IoSplitFifoInv splitFifoInv = findByFifoCode(ioSplitFifoCodeEntity);
            if (splitFifoInv != null) {
                splitFifoInv.setInCount(IntUtil.value(splitFifoInv.getInCount()) + IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()));
                splitFifoInv.setInCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) + IntUtil.value(ioSplitFifoCodeEntity.getScanCount()));
                splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
                splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getAvailableCount()) + IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()));
                updateById(splitFifoInv);
            } else {
                splitFifoInv = IoSplitFifoInv.builder()
                        .id(IdUtil.getSnowflakeNextId()).workPlaceCode(ioSplitFifoCodeEntity.getWorkPlaceCode())
                        .deptCode(ioSplitFifoCodeEntity.getDeptCode())
                        .invCode(ioSplitFifoCodeEntity.getInvCode())
                        .productType(ioSplitFifoCodeEntity.getProductType())
                        .fifoSplit(ioSplitFifoCodeEntity.getFifoSplit()).relId(ioSplitFifoCodeEntity.getRelId())
                        .inCodeCount(ioSplitFifoCodeEntity.getScanCount())
                        .batchNo(ioSplitFifoCodeEntity.getBatchNo())
                        .produceDate(ioSplitFifoCodeEntity.getProduceDate())
                        .expireDate(ioSplitFifoCodeEntity.getExpireDate())
                        .supId(ioSplitFifoCodeEntity.getSupId())
                        .inCount(ioSplitFifoCodeEntity.getTotalCount()).outCount(0)
                        .reCount(IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()))
                        .availableCount(IntUtil.value(ioSplitFifoCodeEntity.getTotalCount())).lockCount(0)
                        .createTime(new Date()).updateTime(new Date()).remark(null)
                        .enableRemind(false).invRemindCount(0)
                        .workPlaceQueueCode(orderEntity.getWorkPlaceQueueCode() == null ? setQueueCode(ioSplitFifoCodeEntity.getWorkPlaceCode(), orderEntity.getCreateUser(), ioSplitFifoCodeEntity.getRelId()) : orderEntity.getWorkPlaceQueueCode())
                        .build();
                splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
                save(splitFifoInv);
                //更新库存工位关联
                List<SysWorkplacePutRel> sysWorkplacePutRels = sysWorkplacePutRelService.selectByWorkPutCode(orderEntity.getWorkPlaceCode());
                if (CollUtil.isNotEmpty(sysWorkplacePutRels)) {
                    for (SysWorkplacePutRel sysWorkplacePutRel : sysWorkplacePutRels) {
                        IoSplitFifoInvRel splitFifoInvRel = new IoSplitFifoInvRel();
                        splitFifoInvRel.setInvIdFk(splitFifoInv.getId());
                        splitFifoInvRel.setPutWorkCode(orderEntity.getWorkPlaceCode());
                        splitFifoInvRel.setCollectWorkCode(sysWorkplacePutRel.getCollectWorkCode());
                        splitFifoInvRel.setBusType(sysWorkplacePutRel.getCollectBusType());
                        splitFifoInvRel.setCreateTime(new Date());
                        splitFifoInvRel.setUpdateTime(new Date());
                        splitFifoInvRelService.saveOrUpdate(splitFifoInvRel);
                    }
                }
            }
            ioSplitFifoCodeEntity.setInvIdFk(splitFifoInv.getId());
        }

        splitFifoCodeService.saveBatch(splitCodeEntities);
    }

    @Resource
    SysWorkplaceQueueService sysWorkplaceQueueService;

    @Resource
    SysWorkplaceLayerService sysWorkplaceLayerService;

    public String setQueueCode(Long workPlaceCode, String userId, Long relId) {
        List<SysWorkplaceQueue> queues = sysWorkplaceQueueService.list(new LambdaQueryWrapper<SysWorkplaceQueue>().eq(SysWorkplaceQueue::getWorkPlaceIdFk, workPlaceCode));
        if (queues.size() == 0) {
            throw new JsonException(500, "请增加取货槽");
        }

        //需要先判断 该产品是否已经有库存了 不然 工位有库存 在设置新的虚拟槽位 会显示同样产品 的多条数据但是 下面码明细一样
        List<IoSplitFifoInv> ioSplitFifoInvs = list(new LambdaQueryWrapper<IoSplitFifoInv>().eq(IoSplitFifoInv::getRelId, relId));
        if (ioSplitFifoInvs != null && ioSplitFifoInvs.size() > 0) {
            return ioSplitFifoInvs.get(0).getWorkPlaceQueueCode();
        }


        SysWorkplaceQueue workplaceQueue = queues.get(0);
        // 使用流来过滤掉匹配的元素
        List<SysWorkplaceQueue> filteredQueues = queues.stream()
                .filter(queue -> {
                    if (queue.getRelId() != null) {
                        return false;
                    }
                    List<IoSplitFifoInv> list = list(
                            new LambdaQueryWrapper<IoSplitFifoInv>()
                                    .eq(IoSplitFifoInv::getWorkPlaceQueueCode, queue.getCode())
                    );
                    return list == null || list.isEmpty();
                })
                .sorted((queue1, queue2) -> queue1.getCode().compareTo(queue2.getCode()))
                .collect(Collectors.toList());
        if (filteredQueues.size() > 0) {
            //还有剩余的槽位 可分配
            SysWorkplaceQueue sysWorkplaceQueue = filteredQueues.get(0);
            return sysWorkplaceQueue.getCode();
        } else {
            //增加一个槽位
            SysWorkplaceLayer layer = sysWorkplaceLayerService.getOne(new LambdaQueryWrapper<SysWorkplaceLayer>().eq(SysWorkplaceLayer::getCode, workplaceQueue.getLayerCode()));
            SysWorkplaceLayerRequest sysWorkplaceLayerRequest = new SysWorkplaceLayerRequest();
            sysWorkplaceLayerRequest.setFreightCode(workplaceQueue.getFreightCode());
            sysWorkplaceLayerRequest.setCode(workplaceQueue.getLayerCode());
            sysWorkplaceLayerRequest.setWorkPlaceIdFk(workPlaceCode);
            sysWorkplaceLayerRequest.setQueueNum(layer.getQueueNum() + 1);
            Boolean aBoolean = sysWorkplaceLayerService.addSysWorkplaceLayer(sysWorkplaceLayerRequest, Long.valueOf(userId));
            if (!aBoolean) {
                throw new JsonException(500, "虚拟槽位增加失败");
            }
        }
        return setQueueCode(workPlaceCode, userId, relId);
    }


    @Resource
    SysWorkplacePutRelService sysWorkplacePutRelService;
    @Resource
    IoSplitFifoInvRelService splitFifoInvRelService;
    @Resource
    IoCollectOrderBackupMapper collectOrderBackupMapper;
    @Resource
    IoCollectCodeBackMapper collectCodeBackMapper;
    @Resource
    IoCollectSetService collectSetService;

    /**
     * 移除库存
     */
    @Transactional(rollbackFor = Exception.class)
    public void removeInv(List<IoCodeEntity> codeList, IoOrderEntity orderEntity) {
        List<IoSplitFifoCodeEntity> splitCodeEntities = new ArrayList<>();
        IoCollectSet collectSet = collectSetService.getSet();
        if (CollUtil.isNotEmpty(codeList)) {
            for (IoCodeEntity codeEntity : codeList) {
                IoSplitFifoCodeEntity ioSplitFifoCodeEntity = splitFifoCodeService.findByCode(codeEntity.getCode(), orderEntity.getWorkPlaceCode());
                if (ioSplitFifoCodeEntity == null && IntUtil.value(collectSet.getConflictReturn())) {
                    ioSplitCodeService.workReturnReplace(codeEntity, orderEntity.getWorkPlaceCode());
                } else {
                    //退库扫码冲突判断
                    if (StrUtil.isEmpty(codeEntity.getSerialNo())) {
                        if (ioSplitFifoCodeEntity != null) {
                            ioSplitFifoCodeEntity.setScanCount(IntUtil.value(ioSplitFifoCodeEntity.getScanCount()) - IntUtil.value(codeEntity.getCount()));
                            ioSplitFifoCodeEntity.setTotalCount(IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()) - IntUtil.value(codeEntity.getReCount()));
                            ioSplitFifoCodeEntity.setUpdateTime(new Date());
                            splitFifoCodeService.updateById(ioSplitFifoCodeEntity);
                            IoSplitFifoInv splitFifoInv = findByFifoCode(ioSplitFifoCodeEntity);
                            if (splitFifoInv != null) {
                                splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(codeEntity.getReCount()));
                                splitFifoInv.setOutCodeCount(IntUtil.value(splitFifoInv.getOutCodeCount()) + IntUtil.value(codeEntity.getCount()));
                                splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(codeEntity.getReCount()));
                                splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
                                splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()) - IntUtil.value(splitFifoInv.getLockCount()));
                                updateById(splitFifoInv);
                            }
                            if (ioSplitFifoCodeEntity.getScanCount() == 0) {
                                splitFifoCodeService.removeById(ioSplitFifoCodeEntity);
                            }
                        }
                    } else {
                        if (ioSplitFifoCodeEntity != null) splitCodeEntities.add(ioSplitFifoCodeEntity);
                        splitFifoCodeService.removeBatchByIds(splitCodeEntities);
                        for (IoSplitFifoCodeEntity tempEntity : splitCodeEntities) {
                            IoSplitFifoInv splitFifoInv = findByFifoCode(tempEntity);
                            if (splitFifoInv != null) {
                                splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(tempEntity.getTotalCount()));
                                splitFifoInv.setOutCodeCount(IntUtil.value(splitFifoInv.getOutCodeCount()) + 1);
                                splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                                splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
                                splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()) - IntUtil.value(splitFifoInv.getLockCount()));
                                updateById(splitFifoInv);
                            }
                        }
                    }
                }

            }
        }


    }

    @Transactional(rollbackFor = Exception.class)
    public void removeByCodes(List<String> codes, Long workPlaceCode) {
        List<IoSplitFifoCodeEntity> splitCodeEntities = new ArrayList<>();
        for (String code : codes) {
            IoSplitFifoCodeEntity ioSplitFifoCodeEntity = splitFifoCodeService.findByCode(code, workPlaceCode);
            if (ioSplitFifoCodeEntity == null) {
                throw new JsonException(500, "工位队列不存在！");
            }
            splitCodeEntities.add(ioSplitFifoCodeEntity);
        }
        if (CollUtil.isNotEmpty(splitCodeEntities)) {
            splitFifoCodeService.removeBatchByIds(splitCodeEntities);
            for (IoSplitFifoCodeEntity ioSplitFifoCodeEntity : splitCodeEntities) {
                IoSplitFifoInv splitFifoInv = findByFifoCode(ioSplitFifoCodeEntity);
                if (splitFifoInv != null) {
                    splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()));
                    splitFifoInv.setOutCodeCount(IntUtil.value(splitFifoInv.getOutCodeCount()) + 1);
                    splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                    splitFifoInv.setReCodeCount(IntUtil.value(splitFifoInv.getInCodeCount()) - IntUtil.value(splitFifoInv.getOutCodeCount()));
                    splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()) - IntUtil.value(splitFifoInv.getLockCount()));
                    updateById(splitFifoInv);
                }
            }
        }

    }


    public IoSplitFifoInv findByFifoCode(IoSplitFifoCodeEntity ioSplitFifoCodeEntity) {
//        Boolean isOnlyInv = sysWorkplaceDocumentService.isOnlyInv(ioSplitFifoCodeEntity.getWorkPlaceCode(), ioSplitFifoCodeEntity.getBusType());
        IoSplitFifoInv splitFifoInv = getOne(new LambdaQueryWrapper<IoSplitFifoInv>().eq(IoSplitFifoInv::getRelId, ioSplitFifoCodeEntity.getRelId()).eq(IoSplitFifoInv::getWorkPlaceCode, ioSplitFifoCodeEntity.getWorkPlaceCode()).eq(StrUtil.isNotEmpty(ioSplitFifoCodeEntity.getBatchNo()), IoSplitFifoInv::getBatchNo, ioSplitFifoCodeEntity.getBatchNo()).eq(ioSplitFifoCodeEntity.getSupId() != null, IoSplitFifoInv::getSupId, ioSplitFifoCodeEntity.getSupId()).last("limit 1"));
//          .eq(StrUtil.isNotEmpty(ioSplitFifoCodeEntity.getBusType()) && isOnlyInv, IoSplitFifoInv::getBusType, ioSplitFifoCodeEntity.getBusType())
        return splitFifoInv;
    }

    /**
     * 库存查询
     * 若开启了库存预警，需要在库存上有一个状态显示预警状态   1:正常；2:低库存；3:负库存
     *
     * @param ioSplitFifoInvRequest
     * @return
     */
    public List<IoSplitInvResponse> filterList(IoSplitFifoInvRequest ioSplitFifoInvRequest) {
        if (ioSplitFifoInvRequest == null) {
            return Collections.emptyList();
        }
        if (ioSplitFifoInvRequest.getPage() != null) {
            int offset = (ioSplitFifoInvRequest.getPage() - 1) * ioSplitFifoInvRequest.getLimit();
            PageHelper.offsetPage(offset, ioSplitFifoInvRequest.getLimit());
        }
        List<IoSplitInvResponse> ioSplitInvResponses = this.baseMapper.filterList(ioSplitFifoInvRequest);
        if (CollUtil.isNotEmpty(ioSplitInvResponses)) {
            ioSplitInvResponses.forEach(t -> {
                if (IntUtil.value(t.getQueueEnableRemind())) {
                    int count = t.getReCount() - t.getQueueRemindCount();
                    if (count > 0) {
                        t.setRemindState(1);
                    } else {
                        t.setRemindState(2);
                    }
                } else {
                    t.setRemindState(1);
                }
            });
            return ioSplitInvResponses;
        } else {
            return Collections.emptyList();
        }
    }

    public List<IoSplitInvResponse> filterKcyjList(IoSplitFifoInvRequest ioSplitFifoInvRequest) {
        if (ioSplitFifoInvRequest == null) {
            return Collections.emptyList();
        }
        if (ioSplitFifoInvRequest.getPage() != null) {
            int offset = (ioSplitFifoInvRequest.getPage() - 1) * ioSplitFifoInvRequest.getLimit();
            PageHelper.offsetPage(offset, ioSplitFifoInvRequest.getLimit());
        }
        List<IoSplitInvResponse> ioSplitInvResponses = this.baseMapper.filterKcyjList(ioSplitFifoInvRequest);
        if (CollUtil.isNotEmpty(ioSplitInvResponses)) {
            ioSplitInvResponses.forEach(t -> {
                if (IntUtil.value(t.getQueueEnableRemind())) {
                    int count = IntUtil.value(t.getReCount()) - IntUtil.value(t.getQueueRemindCount());
                    if (count > 0) {
                        t.setRemindState(1);
                    } else {
                        t.setRemindState(2);
                    }
                } else {
                    t.setRemindState(0);
                }
                Integer suggestOutCount = t.getSuggestOutCount();
                if (suggestOutCount != null && suggestOutCount < 0) {
                    t.setSuggestOutCount(0);
                }
            });
            return ioSplitInvResponses;
        } else {
            return Collections.emptyList();
        }
    }

    /**
     * 库存预警设置
     *
     * @param ioSplitFifoInvRequest
     */
    @Transactional(rollbackFor = Exception.class)
    public void remindSet(IoSplitFifoInvRequest ioSplitFifoInvRequest) {
        Assert.notNull(ioSplitFifoInvRequest.getId(), "Id不能为空");
        IoSplitFifoInv old = this.getById(ioSplitFifoInvRequest.getId());
        Assert.notNull(old, "不存在该库存预警设置");
        this.lambdaUpdate().set(ioSplitFifoInvRequest.getEnableRemind() != null, IoSplitFifoInv::getEnableRemind, ioSplitFifoInvRequest.getEnableRemind() ? 1 : 0).set(ioSplitFifoInvRequest.getInvRemindCount() != null, IoSplitFifoInv::getInvRemindCount, ioSplitFifoInvRequest.getInvRemindCount()).set(IoSplitFifoInv::getUpdateTime, new Date()).eq(IoSplitFifoInv::getId, ioSplitFifoInvRequest.getId()).update();
    }


    @Resource
    IoSplitCodeService ioSplitCodeService;

    public List<IoSplitInvResponse> getStock(IoSplitFifoInvRequest ioSplitFifoInvRequest) {
        if (ioSplitFifoInvRequest == null) {
            return Collections.emptyList();
        }
        if (ioSplitFifoInvRequest.getPage() != null) {
            int offset = (ioSplitFifoInvRequest.getPage() - 1) * ioSplitFifoInvRequest.getLimit();
            PageHelper.offsetPage(offset, ioSplitFifoInvRequest.getLimit());
        }
        List<IoSplitInvResponse> ioSplitInvResponses = this.baseMapper.getStockList(ioSplitFifoInvRequest);
        for (IoSplitInvResponse ioSplitInvResponse : ioSplitInvResponses) {
            IoSplitCodeRequest ioSplitCodeRequest = new IoSplitCodeRequest();
            ioSplitCodeRequest.setRelId(ioSplitInvResponse.getRelId());
            List<IoSplitCodeEntity> ioSplitCodeEntities = ioSplitCodeService.filterList(ioSplitCodeRequest);
            if (ioSplitCodeEntities.size() > 0) {
                int totalRemainCount = ioSplitCodeEntities.stream()
                        .mapToInt(item -> item.getRemainCount())
                        .sum();
                ioSplitInvResponse.setSplitRemCount(totalRemainCount);
            }
        }
        ioSplitInvResponses.forEach(t -> {
            if (IntUtil.value(t.getQueueEnableRemind())) {
                int count = IntUtil.value(t.getRemCount()) - IntUtil.value(t.getQueueRemindCount());
                if (count > 0) {
                    t.setRemindState(1);
                } else {
                    t.setRemindState(2);
                }
            } else {
                t.setRemindState(0);
            }
            Integer suggestOutCount = t.getSuggestOutCount();
            if (suggestOutCount != null && suggestOutCount < 0) {
                t.setSuggestOutCount(0);
            }
        });
        return ioSplitInvResponses;
    }
}