#退库优化/自动跨巷道移库V1

lty

4 天以前 b7d562f09526fc5d1fddc3a692f47aeb3ac956f6

#退库优化/自动跨巷道移库V1

 src/main/java/com/zy/api/service/impl/WcsApiServiceImpl.java

@@ -156,7 +156,7 @@
            throw new CoolException("未指定回库类型！！");
        }
        LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no",mast.getLocNo()));
        if(mast.getCrnNo() != locMast.getCrnNo()){ //若源库位不在本巷道
        if((mast.getCrnNo() != locMast.getCrnNo()) && mast.getIsSuplus()!=0){ //若源库位不在本巷道/空板直接回本巷道
            return workService.backLocOperationV2(mast.getWrkNo() + "", mast.getAppeUser());
        }

@@ -705,9 +705,7 @@
                //到达目的地
                //如果出库任务是跨区则需要生成新的入库任务入库
                if(!Cools.isEmpty(mast.getLocNo())  ){
                    if(!mast.getStaNo().equals("1070")){  //如果如果不是出库到1070的则自动生成跨库
                        mast.setOnlineYn("N");//等待生成跨区入库任务
                    }
                    mast.setOnlineYn("N");//等待生成跨区入库任务
                }
                mast.setWrkSts(14L);
                if(Cools.isEmpty(mast.getStaNo())){

 src/main/java/com/zy/asrs/controller/OpenController.java

@@ -11,6 +11,8 @@
import com.zy.asrs.entity.param.*;
import com.zy.asrs.mapper.ReportQueryMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.task.core.ReturnT;
import com.zy.asrs.task.handler.AutoEmptyOutHandler;
import com.zy.common.model.DetlDto;
import com.zy.common.web.BaseController;
import lombok.extern.slf4j.Slf4j;
@@ -50,6 +52,8 @@
    private WaitPakinService waitPakinService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private AutoEmptyOutHandler autoEmptyOutHandler;

    @PostMapping("/order/matSync/default/v2")
//    @AppAuth(memo = "商品信息同步接口")
@@ -181,6 +185,23 @@
        return R.ok().add(openService.queryStock());
    }

    @PostMapping("/task/autoEmptyOut/run/v1")
    public synchronized R runAutoEmptyOut(@RequestHeader(required = false) String appkey,
                                          @RequestParam(required = false) Integer crnNo,
                                          @RequestParam(required = false) Integer max,
                                          @RequestParam(required = false) Long userId,
                                          HttpServletRequest request) {
        // auth(appkey, null, request);
        ReturnT<String> res = autoEmptyOutHandler.moveOldestInventory(crnNo, max, userId);
        if (res == null) {
            return R.error("执行失败").add(null);
        }
        if (res.isSuccess()) {
            return R.ok().add(res);
        }
        return R.error(res.getMsg()).add(res);
    }

    private void auth(String appkey, Object obj, HttpServletRequest request) {
        log.info("{}接口被访问；appkey:{}；请求数据：{}", "open/sensorType/list/auth/v1", appkey, JSON.toJSONString(obj));
        request.setAttribute("cache", obj);

 src/main/java/com/zy/asrs/entity/ErpToken.java

@@ -1,8 +1,8 @@
package com.zy.asrs.entity;

import com.baomidou.mybatisplus.annotations.IdType;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.enums.IdType;
import com.core.common.Cools;
import java.text.SimpleDateFormat;
import java.util.Date;

 src/main/java/com/zy/asrs/service/impl/WorkServiceImpl.java

@@ -27,6 +27,7 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import javax.annotation.Resource;
import java.util.*;
@@ -44,6 +45,7 @@
    private static final int DEFAULT_WORK_NO_TYPE = 0;
    // 库位排号分配默认类别
    private static final int DEFAULT_ROW_NO_TYPE = 1;
    private static final String BACK_LOC_OPERATION_V2_SCENE = "跨巷道回库出库";

    @Autowired
    private MatService matService;
@@ -1586,111 +1588,136 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R backLocOperationV2(String workNo, Long userId) {
        WrkMast wrkMast = wrkMastService.selectById(workNo);
        if (Cools.isEmpty(wrkMast)) {
            return R.error(workNo+"工作档不存在");
        }
        if (wrkMast.getWrkSts() != 15) {
            return R.error("当前任务状态不能执行此操作！");
        }

        Integer ioType = 101;
        Integer wokNo;

        if (Objects.isNull(wrkMast.getIsSuplus())) {
            return R.error("回库类型不能为空！！");
        }

        wokNo = commonService.getWorkNo(0);
        LocMast locMast1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", wrkMast.getLocNo()));

        // 获取目标站
        Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                .eq("type_no", ioType)
                .eq("stn_no", 1070) // 1070
                .eq("crn_no", locMast1.getCrnNo()); // 堆垛机号
        StaDesc staDesc = staDescService.selectOne(wrapper);
        if (Cools.isEmpty(staDesc)) {
            return R.error("出库路径不存在");
        }

        int count = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("barcode", wrkMast.getBarcode()));
        if (count >= 2) {
            return R.error("任务档已生成，不可以重复生成相同的子任务！！");
        }

        WrkDetl detl = wrkDetlService.selectOne(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
        LocDetl locDetl = new LocDetl();
        BeanUtils.copyProperties(detl, locDetl);
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo(locDetl);

        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(staDesc.getCrnStn(), false);
        sourceStaNo.setLocType1((short) 1);
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        String locNo = wrkMast.getSourceLocNo();

        if(Cools.isEmpty(locNo)) {
            return R.error("没有空库位");
        }

        Date now = new Date();
        // 堆垛机站点(目标站)
        Integer staNo = staDesc.getCrnStn();
        WrkMast mast = new WrkMast();
        BeanUtils.copyProperties(wrkMast, mast);
        mast.setWrkNo(wokNo);
        // 更新工作档数据状态
        mast.setIoType(ioType); // 110先出库到1070
        mast.setWrkSts(11L); // 生成出库id
        mast.setSourceStaNo(String.valueOf(staDesc.getCrnStn())); // 源站
        mast.setStaNo(String.valueOf(staDesc.getStnNo())); // 目标站
        mast.setSourceLocNo(wrkMast.getLocNo()); //出库位
        mast.setLocNo(locNo); // 目标库位 = 出库时的源库位，用于判断巷道
        mast.setOnlineYn(null);
        mast.setModiTime(now);
        mast.setWrkCode(null);
        mast.setPacked(workNo);
        mast.setModiUser(userId);
        if (!wrkMastService.insert(mast)) {
            return R.error("更新工作档数据状态失败");
        }
        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
        if (Cools.isEmpty(wrkDetls)) {
            return R.error("数据错误，任务档明细不存在 ！！");
        }

        LocAroundBind aroundBind = locAroundBindService.selectOne(new EntityWrapper<LocAroundBind>().eq("b_loc_no", mast.getSourceLocNo()));
        if (!Objects.isNull(aroundBind)) {
            aroundBind.setLocType(LocStsType.LOC_STS_TYPE_R.type);
            if (!locAroundBindService.updateById(aroundBind)) {
                return R.error("工位状态修改失败！！");
        final String scene = BACK_LOC_OPERATION_V2_SCENE;
        String locNo = null;
        String sourceLocNo = null;
        String barcode = null;
        Integer sourceStaNo = null;
        Integer staNo = null;
        try {
            WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", workNo));
            if (Cools.isEmpty(wrkMast)) {
                return R.error(workNo + "工作档不存在");
            }
        }


        wrkDetls.forEach(wrkDetl -> {
            WrkDetl wrkDetl1 = new WrkDetl();
            BeanUtils.copyProperties(wrkDetl, wrkDetl1);
            wrkDetl1.setAnfme(wrkDetl.getStockQty() - wrkDetl.getAnfme());
            wrkDetl1.setWrkNo(wokNo);
            if (!wrkDetlService.insert(wrkDetl1)) {
                throw new CoolException("任务档明细保存失败！！");
            if (!Objects.equals(wrkMast.getWrkSts(), 15L)) {
                return R.error("当前任务状态不能执行此操作！");
            }
        });
            if (Objects.isNull(wrkMast.getIsSuplus())) {
                return R.error("回库类型不能为空！！");
            }

        //修改作业库位状态
        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
        locMast.setLocSts("R");
        locMast.setModiTime(now);
        locMast.setModiUser(userId);
        if (!locMastService.updateById(locMast)) {
            return R.error("修改库位状态失败");
            barcode = wrkMast.getBarcode();
            sourceLocNo = wrkMast.getLocNo();

            LocMast sourceLoc = locMastService.selectById(sourceLocNo);
            if (Cools.isEmpty(sourceLoc)) {
                return R.error("作业库位不存在");
            }

            List<Integer> outStaNos = staDescService.queryOutStaNosByLocNo(sourceLocNo, 101);
            if (Cools.isEmpty(outStaNos)) {
                return R.error("出库路径不存在");
            }
            sourceStaNo = outStaNos.get(0);

            LocTypeDto locTypeDto = new LocTypeDto();
            locTypeDto.setLocType1((short) 1);
            StartupDto dto = commonService.getLocNoV2(1, sourceStaNo, wrkMast, locTypeDto);
            if (Cools.isEmpty(dto) || Cools.isEmpty(dto.getLocNo())) {
                throw new CoolException("没有找到库位");
            }

            locNo = dto.getLocNo();
            List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
            if (Cools.isEmpty(wrkDetls)) {
                throw new CoolException("工作明细不存在");
            }
            List<Integer> inStaNos = staDescService.queryOutStaNosByLocNo(locNo, 1);
            if (Cools.isEmpty(inStaNos)) {
                throw new CoolException("入库路径不存在");
            }
            staNo = inStaNos.get(0);


            int count = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("barcode", barcode));
            if (count >= 2) {
                return R.error("任务档已生成，不可以重复生成相同的子任务！！");
            }

            WrkDetl detl = wrkDetlService.selectOne(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
            if (Cools.isEmpty(detl)) {
                return R.error("数据错误，任务档明细不存在 ！！");
            }

            LocDetl locDetl = new LocDetl();
            BeanUtils.copyProperties(detl, locDetl);
            new FindLocNoAttributeVo(locDetl);

            int newWorkNo = dto.getWorkNo();
            Date now = new Date();

            WrkMast mast = new WrkMast();
            BeanUtils.copyProperties(wrkMast, mast);
            mast.setWrkNo(newWorkNo);
            mast.setIoType(101);
            mast.setWrkSts(11L);
            mast.setSourceStaNo(String.valueOf(sourceStaNo));
            mast.setStaNo(String.valueOf(staNo));
            mast.setSourceLocNo(sourceLocNo);
            mast.setLocNo(locNo);
            mast.setOnlineYn("N");
            mast.setModiTime(now);
            mast.setWrkCode(null);
            mast.setPacked(workNo);
            mast.setModiUser(userId);
            if (!wrkMastService.insert(mast)) {
                return R.error("更新工作档数据状态失败");
            }

            LocAroundBind aroundBind = locAroundBindService.selectOne(new EntityWrapper<LocAroundBind>().eq("b_loc_no", mast.getSourceLocNo()));
            if (!Objects.isNull(aroundBind)) {
                aroundBind.setLocType(LocStsType.LOC_STS_TYPE_R.type);
                if (!locAroundBindService.updateById(aroundBind)) {
                    return R.error("工位状态修改失败！！");
                }
            }

            for (WrkDetl wrkDetl : wrkDetls) {
                WrkDetl wrkDetl1 = new WrkDetl();
                BeanUtils.copyProperties(wrkDetl, wrkDetl1);
                wrkDetl1.setAnfme(wrkDetl.getStockQty() - wrkDetl.getAnfme());
                wrkDetl1.setWrkNo(newWorkNo);
                if (!wrkDetlService.insert(wrkDetl1)) {
                    throw new CoolException("任务档明细保存失败！！");
                }
            }

            LocMast locMast1 = locMastService.selectById(sourceLocNo);
            locMast1.setLocSts("R");
            locMast1.setModiTime(now);
            locMast1.setModiUser(userId);
            LocMast locMast2 = locMastService.selectById(locNo);
            locMast2.setLocSts("S");
            locMast2.setModiTime(now);
            locMast2.setModiUser(userId);
            if (!locMastService.updateById(locMast1)) {
                return R.error("修改出库库位状态失败");
            }
            if (!locMastService.updateById(locMast2)) {
                return R.error("修改入库库位状态失败");
            }

            if (Cools.isEmpty(mast)) {
                return R.error("没有生成任务");
            }
            return R.ok("生成回库任务成功！！");
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            String reason = Cools.isEmpty(e.getMessage()) ? e.getClass().getSimpleName() : e.getMessage();
            log.error("{}失败[workNo={}, barcode={}, sourceLocNo={}, locNo={}, sourceStaNo={}, staNo={}, userId={}]，原因: {}",
                    scene, workNo, barcode, sourceLocNo, locNo, sourceStaNo, staNo, userId, reason, e);
            return R.error(reason);
        }
        if (Cools.isEmpty(mast)) {
            return R.error("没有生成任务");
        }
        return R.ok("生成回库任务成功！！");
    }



 src/main/java/com/zy/asrs/task/handler/AutoEmptyOutHandler.java

@@ -5,15 +5,18 @@
import com.core.common.Cools;
import com.zy.asrs.entity.LocDetl;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.WrkDetl;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.entity.param.EmptyPlateOutParam;
import com.zy.asrs.entity.param.StockOutParam;
import com.zy.asrs.mapper.LocDetlMapper;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.StaDescService;
import com.zy.asrs.service.WorkService;
import com.zy.asrs.service.WrkDetlService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.task.AbstractHandler;
import com.zy.asrs.task.core.ReturnT;
import com.zy.common.service.CommonService;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
@@ -22,6 +25,7 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.Date;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@@ -39,6 +43,212 @@
    private WorkService workService;
    @Autowired
    private LocDetlMapper locDetlMapper;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private StaDescService staDescService;

    @Transactional
    public ReturnT<String> moveOldestInventory(Integer crnNo, Integer max, Long userId) {
        try {
            Long operatorUserId = userId == null ? 1L : userId;
            Integer threshold = max;
            if (threshold == null) {
                Config config = configService.selectConfigByCode("EmptyMax");
                if (Cools.isEmpty(config)) {
                    threshold = 10;
                } else {
                    threshold = Integer.valueOf(config.getValue());
                }
            }

            Config configInventory = configService.selectConfigByCode("InventoryAutoOut");
            if (Cools.isEmpty(configInventory) || "false".equalsIgnoreCase(configInventory.getValue())) {
                return new ReturnT<>(ReturnT.SUCCESS_CODE, "InventoryAutoOut=false");
            }

            List<Integer> crnNos = new ArrayList<>();
            if (crnNo == null) {
                for (int i = 1; i < 5; i++) {
                    crnNos.add(i);
                }
            } else {
                crnNos.add(crnNo);
            }

            List<String> moved = new ArrayList<>();
            for (Integer currentCrnNo : crnNos) {
                if (currentCrnNo == null) {
                    continue;
                }
                List<WrkMast> wrkMastList = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                        .eq("crn_no", currentCrnNo)
                        .eq("io_type", 110));
                if (!wrkMastList.isEmpty()) {
                    continue;
                }

                Integer emptyLocCount = locMastService.selectCount(new EntityWrapper<LocMast>()
                        .eq("crn_no", currentCrnNo)
                        .eq("loc_sts", "O")
                        .eq("frozen", 0)
                        .eq("deleted", 0)
                        .eq("whs_type", 1));
                if (emptyLocCount == null || emptyLocCount >= threshold) {
                    continue;
                }

                String moveResult = moveOldestInventoryInner(currentCrnNo, operatorUserId);
                if (!Cools.isEmpty(moveResult)) {
                    moved.add(moveResult);
                }
            }

            ReturnT<String> res = new ReturnT<>(ReturnT.SUCCESS_CODE, "OK");
            if (!moved.isEmpty()) {
                res.setContent(String.join(";", moved));
            }
            return res;
        } catch (Exception e) {
            log.error("fail", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return new ReturnT<>(ReturnT.FAIL_CODE, e.getMessage());
        }
    }

    private String moveOldestInventoryInner(Integer crnNo, Long userId) {
        LocDetl oldest = locDetlMapper.selectOldestLocDetl(crnNo);
        if (Cools.isEmpty(oldest) || Cools.isEmpty(oldest.getLocNo())) {
            return null;
        }

        LocMast sourceLoc = locMastService.selectById(oldest.getLocNo());
        if (Cools.isEmpty(sourceLoc) || Cools.isEmpty(sourceLoc.getBarcode())) {
            return null;
        }

        Integer runningCount = wrkMastService.selectCount(new EntityWrapper<WrkMast>()
                .eq("barcode", sourceLoc.getBarcode())
                .in("wrk_sts", Arrays.asList(2L, 3L, 4L, 11L, 12L)));
        if (runningCount != null && runningCount > 0) {
            return null;
        }

        Integer targetCrnNo = null;
        Integer targetEmptyCount = null;
        for (int candidate = 1; candidate < 5; candidate++) {
            if (candidate == crnNo) {
                continue;
            }
            Integer candidateEmpty = locMastService.selectCount(new EntityWrapper<LocMast>()
                    .eq("crn_no", candidate)
                    .eq("loc_sts", "O")
                    .eq("frozen", 0)
                    .eq("deleted", 0)
                    .eq("whs_type", 1));
            if (candidateEmpty == null || candidateEmpty <= 0) {
                continue;
            }
            if (targetCrnNo == null || candidateEmpty > targetEmptyCount) {
                targetCrnNo = candidate;
                targetEmptyCount = candidateEmpty;
            }
        }
        if (targetCrnNo == null) {
            return null;
        }

        LocMast targetLoc = locMastService.selectOne(new EntityWrapper<LocMast>()
                .eq("crn_no", targetCrnNo)
                .eq("loc_sts", "O")
                .eq("frozen", 0)
                .eq("deleted", 0)
                .eq("whs_type", 1)
                .orderBy("lev1,bay1"));
        if (Cools.isEmpty(targetLoc)) {
            return null;
        }

        List<Integer> sourceStaNos = staDescService.queryOutStaNosByLocNo(sourceLoc.getLocNo(), 101);
        if (Cools.isEmpty(sourceStaNos)) {
            return null;
        }
        Integer sourceStaNo = sourceStaNos.get(0);

        List<Integer> targetStaNos = staDescService.queryOutStaNosByLocNo(targetLoc.getLocNo(), 1);
        if (Cools.isEmpty(targetStaNos)) {
            return null;
        }
        Integer targetStaNo = targetStaNos.get(0);

        List<LocDetl> sourceDetls = locDetlMapper.selectList(new EntityWrapper<LocDetl>().eq("loc_no", sourceLoc.getLocNo()));
        if (Cools.isEmpty(sourceDetls)) {
            return null;
        }

        Date now = new Date();
        Integer workNo = commonService.getWorkNo(0);
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(11L);
        wrkMast.setIoType(101);
        wrkMast.setIoPri(10D);
        wrkMast.setCrnNo(sourceLoc.getCrnNo());
        wrkMast.setSourceLocNo(sourceLoc.getLocNo());
        wrkMast.setLocNo(targetLoc.getLocNo());
        wrkMast.setBarcode(sourceLoc.getBarcode());
        wrkMast.setSourceStaNo(String.valueOf(sourceStaNo));
        wrkMast.setStaNo(String.valueOf(targetStaNo));
        wrkMast.setFullPlt("Y");
        wrkMast.setPicking("N");
        wrkMast.setExitMk("Y");
        wrkMast.setEmptyMk("N");
        wrkMast.setLinkMis("N");
        wrkMast.setPacked(null);
        wrkMast.setOnlineYn("N");
        wrkMast.setOveMk("N");
        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        if (!wrkMastService.insert(wrkMast)) {
            throw new RuntimeException("自动跨巷道移库生成任务失败，workNo=" + workNo + ", sourceLocNo=" + sourceLoc.getLocNo());
        }

        for (LocDetl sourceDetl : sourceDetls) {
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(sourceDetl);
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setIoTime(now);
            wrkDetl.setAnfme(sourceDetl.getAnfme());
            wrkDetl.setAppeTime(now);
            wrkDetl.setAppeUser(userId);
            wrkDetl.setModiTime(now);
            wrkDetl.setModiUser(userId);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new RuntimeException("自动跨巷道移库生成任务明细失败，workNo=" + workNo + ", sourceLocNo=" + sourceLoc.getLocNo());
            }
        }

        sourceLoc.setLocSts("R");
        sourceLoc.setModiUser(userId);
        sourceLoc.setModiTime(now);
        if (!locMastService.updateById(sourceLoc)) {
            throw new RuntimeException("自动跨巷道移库更新源库位失败，workNo=" + workNo + ", sourceLocNo=" + sourceLoc.getLocNo());
        }

        targetLoc.setLocSts("S");
        targetLoc.setModiUser(userId);
        targetLoc.setModiTime(now);
        if (!locMastService.updateById(targetLoc)) {
            throw new RuntimeException("自动跨巷道移库更新目标库位失败，workNo=" + workNo + ", targetLocNo=" + targetLoc.getLocNo());
        }

        return "workNo=" + workNo + ",sourceLocNo=" + sourceLoc.getLocNo() + ",targetLocNo=" + targetLoc.getLocNo();
    }
    @Transactional
    public ReturnT<String> start() {
        try {
@@ -77,29 +287,10 @@
                ).getRecords();
                if (Cools.isEmpty(locMastDList)) {
                    Config configInventory = configService.selectConfigByCode("InventoryAutoOut");
                    if (Cools.isEmpty(configInventory) || configInventory.getValue().equals("false")) {
                    if (Cools.isEmpty(configInventory) || "false".equalsIgnoreCase(configInventory.getValue())) {
                        continue;
                    }
                    LocDetl oldest = locDetlMapper.selectOldestLocDetl(crnNo);
                    if (Cools.isEmpty(oldest) || Cools.isEmpty(oldest.getLocNo()) || Cools.isEmpty(oldest.getMatnr()) || Cools.isEmpty(oldest.getAnfme())) {
                        continue;
                    }
                    StockOutParam stockOutParam = new StockOutParam();
                    stockOutParam.setOutSite(1070);
                    StockOutParam.LocDetl outDetl = new StockOutParam.LocDetl();
                    outDetl.setLocNo(oldest.getLocNo());
                    outDetl.setMatnr(oldest.getMatnr());
                    outDetl.setBatch(oldest.getBatch());
                    outDetl.setBrand(oldest.getBrand());
                    outDetl.setStandby1(oldest.getStandby1());
                    outDetl.setStandby2(oldest.getStandby2());
                    outDetl.setStandby3(oldest.getStandby3());
                    outDetl.setBoxType1(oldest.getBoxType1());
                    outDetl.setBoxType2(oldest.getBoxType2());
                    outDetl.setBoxType3(oldest.getBoxType3());
                    outDetl.setCount(oldest.getAnfme());
                    stockOutParam.setLocDetls(Arrays.asList(outDetl));
                    workService.startupFullTakeStore(stockOutParam, 1L);
                    moveOldestInventoryInner(crnNo, 1L);
                    continue;
                }


 src/main/java/com/zy/asrs/task/handler/WorkMastHandler.java

@@ -194,13 +194,6 @@
                            }
                        }
                    }
                    if(wrkMast.getSourceStaNo().equals("1070")){
                        WrkMast wrkMastOld = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode",wrkMast.getBarcode()).eq("loc_no",wrkMast.getSourceLocNo()));
                        wrkMastOld.setOveMk("Y");
                        if(!wrkMastService.updateById(wrkMastOld)){
                            return FAIL.setMsg("出库回库 ===>> 原任务完成失败; [workNo=" + wrkMastOld.getWrkNo() + "],[locNo=" + wrkMastOld.getLocNo() + "]");
                        }
                    }
                    // 修改库位状态 S ====>> F
                    if (locMast.getLocSts().equals("S")) {
                        locMast.setLocSts("F");
@@ -457,6 +450,14 @@
//                    }
                    movLoc(wrkMast);
                    break;
                case 2:WrkMast wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode",wrkMast.getBarcode()).eq("io_type",101));
                if(!Cools.isEmpty(wrkMast1)) {
                    wrkMast1.setOveMk("Y");
                }
                if(!wrkMastService.updateById(wrkMast1)) {
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    return FAIL.setMsg("更新退库跨区域完成状态失败; [workNo=" + wrkMast1.getWrkNo());
                }break;
                default:
                    break;
            }
@@ -607,19 +608,36 @@
                            throw new CoolException("工位状态修改失败！！");
                        }
                    } else {
                        if(!Objects.isNull(wrkMast.getPacked())){ //不是本巷道的出库至1070，之前的跨巷道出库进行完结操作
                            WrkMast wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no",wrkMast.getPacked()));
                            if(!Objects.isNull(wrkMast1)) {
                                wrkMast1.setOveMk("Y");
                                wrkMastService.updateById(wrkMast1);
                        if(!Objects.isNull(wrkMast.getPacked()) || !Objects.isNull(wrkMast.getExitMk())){ //标记
                            if(!Objects.isNull(wrkMast.getPacked())){
                                WrkMast wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no",wrkMast.getPacked()));
                                if(!Objects.isNull(wrkMast1)) {
                                    wrkMast1.setOveMk("Y");
                                    wrkMastService.updateById(wrkMast1);
                                }
                            }
                            LocAroundBind bLocNo = locAroundBindService.selectOne(new EntityWrapper<LocAroundBind>().eq("b_loc_no", wrkMast.getSourceLocNo()));
                            if (Objects.isNull(bLocNo)) {
                                throw new CoolException("数据错误， 目标工位不存在！！");
                            movLoc(wrkMast);
                            LocMast locMastTarget = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no",wrkMast.getLocNo()));
                            // 修改库位状态 S ====>> F
                            if (locMastTarget.getLocSts().equals("S")) {
                                locMastTarget.setLocSts("F");
                                locMastTarget.setBarcode(wrkMast.getBarcode());
                                locMastTarget.setIoTime(now);
                                locMastTarget.setModiTime(now);
                                if (!locMastService.updateById(locMastTarget)) {
                                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                    return FAIL.setMsg("退库跨区域入库 ===>> 修改库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                                }
                            }
                            bLocNo.setLocType(LocStsType.LOC_STS_TYPE_O.type);
                            if (!locAroundBindService.updateById(bLocNo)) {
                                throw new CoolException("工位状态修改失败！！");
                            if(!Objects.isNull(wrkMast.getPacked())){
                                LocAroundBind bLocNo = locAroundBindService.selectOne(new EntityWrapper<LocAroundBind>().eq("b_loc_no", wrkMast.getSourceLocNo()));
                                if (Objects.isNull(bLocNo)) {
                                    throw new CoolException("数据错误， 目标工位不存在！！");
                                }
                                bLocNo.setLocType(LocStsType.LOC_STS_TYPE_O.type);
                                if (!locAroundBindService.updateById(bLocNo)) {
                                    throw new CoolException("工位状态修改失败！！");
                                }
                            }
                        }
//                    // 出库确认信号位

 src/main/java/com/zy/common/service/CommonService.java

@@ -162,7 +162,7 @@
    @Transactional
    public StartupDto getLocNoV2(Integer staDescId, Integer sourceStaNo, WrkMast wrkMast, LocTypeDto locTypeDto) {
        try {
            Integer whsType = Utils.GetWhsType(sourceStaNo);
            Integer whsType = 1;
            RowLastno rowLastno = rowLastnoService.selectById(whsType);
            RowLastnoType rowLastnoType = rowLastnoTypeService.selectById(rowLastno.getTypeId());
            /**
@@ -424,16 +424,6 @@
        Integer chosenCrnNo = null;
        Integer chosenCount = null;
        for (int candidate : candidates) {
            if (!basCrnpService.checkSiteError(candidate, true)) {
                continue;
            }
            StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                    .eq("type_no", staDescId)
                    .eq("stn_no", sourceStaNo)
                    .eq("crn_no", candidate));
            if (Cools.isEmpty(staDesc)) {
                continue;
            }
            //判断该巷道是否存在空位
            LocMast candidateLoc = locMastService.selectOne(new EntityWrapper<LocMast>()
                    .eq("crn_no", candidate)
@@ -457,24 +447,17 @@
                chosenCount = count;
            }
        }
        StaDesc staDesc = null;
        LocMast locMast = null;
        if (chosenCrnNo != null) {
            staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                    .eq("type_no", staDescId)
                    .eq("stn_no", sourceStaNo)
                    .eq("crn_no", chosenCrnNo));
            if (!Cools.isEmpty(staDesc)) {
                locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                        .eq("crn_no", chosenCrnNo)
                        .eq("loc_sts", "O")
                        .eq("frozen", 0)
                        .eq("deleted", 0)
                        .eq("whs_type", 1)
                        .orderBy("lev1,bay1"));
            }
            locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                    .eq("crn_no", chosenCrnNo)
                    .eq("loc_sts", "O")
                    .eq("frozen", 0)
                    .eq("deleted", 0)
                    .eq("whs_type", 1)
                    .orderBy("lev1,bay1"));
        }
        if (Cools.isEmpty(staDesc) || Cools.isEmpty(locMast)) {
        if (Cools.isEmpty(locMast)) {
            List<LocMast> anyLocs = locMastService.selectList(new EntityWrapper<LocMast>()
                    .eq("loc_sts", "O")
                    .eq("frozen", 0)
@@ -489,23 +472,13 @@
                    if (!basCrnpService.checkSiteError(anyLoc.getCrnNo(), true)) {
                        continue;
                    }
                    StaDesc anyStaDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                            .eq("type_no", staDescId)
                            .eq("stn_no", sourceStaNo)
                            .eq("crn_no", anyLoc.getCrnNo()));
                    if (Cools.isEmpty(anyStaDesc)) {
                        continue;
                    }
                    chosenCrnNo = anyLoc.getCrnNo();
                    staDesc = anyStaDesc;
                    locMast = anyLoc;
                    break;
                }
            }
        }
        if (Cools.isEmpty(staDesc)) {
            throw new CoolException("入库路径不存在");
        }

        if (Cools.isEmpty(locMast)) {
            throw new CoolException("没有空库位");
        }
@@ -513,9 +486,7 @@
        int workNo = getWorkNo(0);
        startupDto.setWorkNo(workNo);
        startupDto.setCrnNo(chosenCrnNo);
        startupDto.setSourceStaNo(sourceStaNo);
        startupDto.setLocNo(locNo);
        startupDto.setStaNo(staDesc.getCrnStn());
        return startupDto;
    }