入库找库位逻辑

Junjie

2023-05-25 eb9e30160e01dbf905d5514c3b6a07f5d12023ff

入库找库位逻辑

 src/main/java/com/zy/asrs/mapper/LocDetlMapper.java

@@ -30,7 +30,7 @@
    @Update("update asr_loc_detl set loc_no = #{newLocNo}, modi_time=getDate() where loc_no = #{oldLocNo}")
    int updateLocNo(String newLocNo, String oldLocNo);

    List<String> selectSameDetl(@Param("matnr") String matnr, @Param("start") Integer start, @Param("end") Integer end);
    List<String> selectSameDetl(@Param("matnr") String matnr);

    @Select("SELECT ld.loc_no FROM asr_loc_detl ld LEFT JOIN asr_loc_mast lm ON ld.loc_no = lm.loc_no WHERE (1 = 1 AND ld.matnr = #{matnr} AND (lm.row1 >= #{start} AND lm.row1 <= #{end})  AND lm.loc_sts = 'F' AND DateDiff(dd, lm.modi_time, getdate()) = 0) ORDER BY lm.modi_time ASC")
    List<String> selectSameDetlToday(@Param("matnr") String matnr, @Param("start") Integer start, @Param("end") Integer end);

 src/main/java/com/zy/asrs/mapper/LocMastMapper.java

@@ -31,8 +31,20 @@
    @Select("select loc_no from asr_loc_mast where 1=1 and loc_sts = 'O' and crn_no = #{crnNo}")
    List<String> queryGroupEmptyStock(Integer crnNo);

    @Select("select count(*) as count from asr_loc_mast where 1=1 and loc_sts = 'O' and loc_type1 = #{locType1} and crn_no = #{crnNo}")
    Integer selectEmptyLocCount(@Param("locType1") Short locType1, @Param("crnNo") Integer crnNo);
    @Select("select count(*) as count from asr_loc_mast where 1=1 and loc_sts = 'O' and loc_type1 = #{locType1} and loc_type2 = #{locType2} and crn_no = #{crnNo}")
    Integer selectEmptyLocCount(@Param("locType1") Short locType1, @Param("locType2") Short locType2, @Param("crnNo") Integer crnNo);

    void updateLocSts(@Param("locNo") String locNo,@Param("locSts") String locSts);

    //找外侧空库位
    LocMast findOutMast(Short locType1, List<Integer> crnNos);

    //找单品类型，最内侧空库位
    LocMast findInEmptyLocMast(Short locType1, @Param("rows") List<Integer> rows);

    //在库位组中搜索可入的空库位
    LocMast findEmptyLocMastByLocNos(Short locType1, @Param("locNos") List<String> locNos);

    //搜索低频(混放区域)空库位
    LocMast findEmptyLowFrequencyLocMast(Short locType1);
}

 src/main/java/com/zy/asrs/service/LocDetlService.java

@@ -29,7 +29,7 @@
     * @param matnr 产品号
     * @return locNo 库位号
     */
    List<String> getSameDetl(String matnr, Integer start, Integer end);
    List<String> getSameDetl(String matnr);

    /**
     * 获取当天相同规格货物的深库位号

 src/main/java/com/zy/asrs/service/LocMastService.java

@@ -54,4 +54,16 @@
    void breakUp(String locNo, List<String> excludeLocNos);

    void updateLocSts(String locNo, String locSts);

    //找外侧空库位
    LocMast findOutMast(Short locType1, List<Integer> crnNos);

    //找单品类型，最内侧空库位
    LocMast findInEmptyLocMast(Short locType1, List<Integer> rows);

    //在库位组中搜索可入的空库位
    LocMast findEmptyLocMastByLocNos(Short locType1, List<String> locNos);

    //搜索低频(混放区域)空库位
    LocMast findEmptyLowFrequencyLocMast(Short locType1);
}

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

@@ -48,8 +48,8 @@
    }

    @Override
    public List<String> getSameDetl(String matnr, Integer start, Integer end) {
        return this.baseMapper.selectSameDetl(matnr, start, end);
    public List<String> getSameDetl(String matnr) {
        return this.baseMapper.selectSameDetl(matnr);
    }

    @Override

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

@@ -79,9 +79,10 @@
        if (locMast == null) {
            return false;
        }
        boolean res = this.baseMapper.selectEmptyLocCount(locMast.getLocType1(), locMast.getCrnNo()) > quaOfBlank;
        Integer nowQua = this.baseMapper.selectEmptyLocCount(locMast.getLocType1(), locMast.getLocType2(), locMast.getCrnNo());
        boolean res = nowQua > quaOfBlank;
        if (!res) {
            log.warn("{}号堆垛机库位不足，因滞留空库位{}个", locMast.getCrnNo(), quaOfBlank);
            log.warn("{}号堆垛机库位不足，因滞留空库位{}个,目前空库位{}个", locMast.getCrnNo(), quaOfBlank, nowQua);
        }
        return res;
    }
@@ -203,4 +204,23 @@
        this.baseMapper.updateLocSts(locNo,locSts);
    }

    @Override
    public LocMast findOutMast(Short locType1, List<Integer> crnNos) {
        return this.baseMapper.findOutMast(locType1, crnNos);
    }

    @Override
    public LocMast findInEmptyLocMast(Short locType1, List<Integer> rows) {
        return this.baseMapper.findInEmptyLocMast(locType1, rows);
    }

    @Override
    public LocMast findEmptyLocMastByLocNos(Short locType1, List<String> locNos) {
        return this.baseMapper.findEmptyLocMastByLocNos(locType1, locNos);
    }

    @Override
    public LocMast findEmptyLowFrequencyLocMast(Short locType1) {
        return this.baseMapper.findEmptyLowFrequencyLocMast(locType1);
    }
}

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

@@ -1,8 +1,6 @@
package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.BaseRes;
@@ -93,7 +91,7 @@
        // 检索库位
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        List<String> matnrs = param.getList().stream().map(FullStoreParam.MatCodeStore::getMatnr).distinct().collect(Collectors.toList());
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 1, param.getDevpNo(), matnrs, locTypeDto, 0);
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 1, param.getDevpNo(), matnrs, locTypeDto);
        // 生成工作号
        int workNo = dto.getWorkNo();
        // 生成工作档
@@ -474,7 +472,7 @@
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 10, devpNo, null, locTypeDto, 0);
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 10, devpNo, null, locTypeDto);
        int workNo = dto.getWorkNo();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();

 src/main/java/com/zy/asrs/utils/Utils.java

@@ -39,6 +39,13 @@
    }

    /**
     * 通过排列层拼接出库位号
     */
    public static String append(int row, int bay, int lev) {
        return zerofill(String.valueOf(row), 2) + zerofill(String.valueOf(bay), 3) + zerofill(String.valueOf(lev), 2);
    }

    /**
     * 判断是否为深库位
     */
    public static boolean isDeepLoc(SlaveProperties slaveProperties, String locNo){
@@ -146,6 +153,26 @@
    }

    /**
     * 通过库位号获取 列
     */
    public static int getBay(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(2, 5));
        }
        throw new RuntimeException("库位解析异常");
    }

    /**
     * 通过库位号获取 层
     */
    public static int getLev(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(5, 7));
        }
        throw new RuntimeException("库位解析异常");
    }

    /**
     * 当检索到双深库位的浅库位时，如果深库位无货，则放入对应的深库位
     */
    public static void toDeepIfEmptyByShallow(String shallowLoc) {
@@ -197,42 +224,6 @@
                throw new RuntimeException("库位解析异常");
        }
    }

    public static Integer getInnermostRow(String locNo){
        int row = getRow(locNo);
        switch (row) {
            case 1:
            case 2:
            case 3:
                return 1;
            case 4:
            case 5:
            case 6:
            case 7:
                return 7;
            case 8:
            case 9:
            case 10:
            case 11:
                return 8;
            case 12:
            case 13:
            case 14:
                return 14;
            case 15:
            case 16:
            case 17:
            case 18:
                return 15;
            case 19:
            case 20:
            case 21:
                return 21;
            default:
                throw new RuntimeException("库位解析异常");
        }
    }


    public static List<String> getGroupLoc(String locNo){
        int row = getRow(locNo);
@@ -532,7 +523,6 @@
                throw new RuntimeException("库位解析异常");
        }
    }


    public Map<Integer, List<Integer>> getRowSeqHasSortOfPakin(int start, int end) {
        Map<Integer, List<Integer>> result = new HashMap<>();

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

@@ -1,6 +1,5 @@
package com.zy.common.service;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Cools;
@@ -10,7 +9,6 @@
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.Shelves;
import com.zy.common.model.StartupDto;
import com.zy.common.properties.SlaveProperties;
import lombok.extern.slf4j.Slf4j;
@@ -100,11 +98,6 @@
        return workNo;
    }

    public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos, LocTypeDto locTypeDto, int times) {
        LocTypeDto oldLocType = locTypeDto.clone();
        return getLocNo(whsType, staDescId, sourceStaNo, matNos, locTypeDto, oldLocType, times);
    }

    /**
     * 检索库位号
     * @param whsType 类型 1:双深式货架
@@ -113,84 +106,105 @@
     * @param matNos 物料号集合
     * @return locNo 检索到的库位号
     */
    public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos, LocTypeDto locTypeDto, LocTypeDto oldLocType, int times) {
        StartupDto startupDto = new StartupDto();
    public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos, LocTypeDto locTypeDto) {
        int start;
        int end;
        Integer theCrnNo = null;
        Integer matType = null;//物料类型
        //根据入库站，决定搜索指定堆垛机
        ArrayList<Integer> crnNos = new ArrayList<>();
        //根据入库站，找到库位组最内侧排
        ArrayList<Integer> rows = new ArrayList<>();
        switch (sourceStaNo) {
            case 103:
            case 103://103入库站
                whsType = 1;
                start = 1;
                end = 14;
//                if (null != wrkMastService.selectPakoutOfStaNo(104)) {
//                    start = 8;
//                    theCrnNo = 2;
//                }
                end = 11;

                //103站分配1，2堆垛机
                crnNos.add(1);
                crnNos.add(2);

                //分配1，7，8排
                rows.add(1);
                rows.add(7);
                rows.add(8);
                break;
            case 203:
            case 203://203入库站
                whsType = 2;
                start = 8;
                start = 12;
                end = 21;
//                if (null != wrkMastService.selectPakoutOfStaNo(204)) {
//                    end = 14;
//                    theCrnNo = 2;
//                }

                //203站分配3，4堆垛机
                crnNos.add(3);
                crnNos.add(4);

                //分配14，15，21排
                rows.add(14);
                rows.add(15);
                rows.add(21);
                break;
            default:
                throw new CoolException("检索库位失败，请联系管理员");
        }
        // 生成工作号
        int workNo = getWorkNo(0);
        RowLastno rowLastno = rowLastnoService.selectById(whsType);
        if (Cools.isEmpty(rowLastno)) {
            throw new CoolException("数据异常，请联系管理员");
        }
        int curRow = rowLastno.getCurrentRow();  // 当前列
        int sRow = rowLastno.getsRow();          // 起始列
        int eRow = rowLastno.geteRow();          // 终止列
        int crn_qty = rowLastno.getCrnQty();     // 堆垛机数量（巷道数量）
        int rowCount = eRow - sRow + 1;          // 库排总数
        // 目标堆垛机号
        int crnNo = 0;
        // 目标库位
        LocMast locMast = null;

        boolean inoutEveryday = false;
        if (!Cools.isEmpty(matNos)) {
            for (String matNo : matNos) {
                Mat mat = matService.selectByMatnr(matNo);
                if (mat.getInoutEveryday() != null && mat.getInoutEveryday()) {
                    inoutEveryday = true;
                    break;
                if (matType == null) {
                    matType = mat.getMatType();
                }
                if (matType != mat.getMatType()) {
                    throw new CoolException("混放物料类型不一致");
            }
        }

        // 靠近摆放规则 --- 同天同规格物料
        if (!Cools.isEmpty(matNos) && matNos.size() == 1) {
            List<String> locNos = locDetlService.getSameDetl(matNos.get(0), start, end);
            for (String locNo : locNos) {
                List<String> groupLoc = Utils.getGroupLoc(locNo);
                LocMast locMast0 = locMastService.findOutMost(groupLoc);
                if (null != locMast0) {
                    // 浅库位符合尺寸检测
                    if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                        // 浅库位对应堆垛机必须可用且无异常
                        if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                            // 因库位移转、需预留空库位
                            if (locMastService.checkEmptyCount(locMast0, 10)) {
                                crnNo = locMast0.getCrnNo();
                                locMast = locMast0;
                                break;
                            }
                        }
                    }
                }
            if (matNos.size() > 1 && matType == 1) {
                //物料为单品类型，且物料种类超过1(实际为高频混放)，则禁止入库
                throw new CoolException("物料类型和实际种类不一致");
            }
        }

        // 靠近摆放规则 --- 空托
        locMast = getLocNoStep1(staDescId, locTypeDto, start, end);
        if (locMast != null) {
            //找到库位，返回dto
            return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
        }

        if (matType != null) {
            if (matType == 1) {//单品类型入库
                locMast = getLocNoStep2(locTypeDto, matNos, rows);
                if (locMast != null) {
                    //找到库位，返回dto
                    return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
                }
            } else if (matType == 2) {//高频类型入最外侧库位
                locMast = getLocNoStep3(locTypeDto, crnNos);
                if (locMast != null) {
                    //找到库位，返回dto
                    return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
                }
            } else if (matType == 3) {//低频混放类型
                locMast = getLocNoStep4(locTypeDto);
                if (locMast != null) {
                    //找到库位，返回dto
                    return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
                }
            }
        }

        throw new CoolException("检索库位失败，请联系管理员");
    }

    // 靠近摆放规则 --- 空托
    private LocMast getLocNoStep1(Integer staDescId, LocTypeDto locTypeDto,int start,int end) {
        LocMast locMast = null;
        if (staDescId == 10) {
            List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
                    .eq("loc_sts", "D").ge("row1", start).le("row1", end));
@@ -205,7 +219,6 @@
                            if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                                // 因库位移转、需预留空库位
                                if (locMastService.checkEmptyCount(locMast0, 10)) {
                                    crnNo = locMast0.getCrnNo();
                                    locMast = locMast0;
                                    break;
                                }
@@ -216,23 +229,24 @@
            }
        }

        // 库区锁定
        if (Cools.isEmpty(locMast)) {
            LocRule locRule = locRuleService.find(Cools.isEmpty(matNos) ? null : matNos.get(0), null, start, end);
            if (!Cools.isEmpty(locRule)) {
                List<LocMast> locMasts = locMastService.queryFreeLocMast2(locTypeDto.getLocType1()
                        , locRule.getRowBeg(), locRule.getRowEnd(), locRule.getBayBeg(), locRule.getBayEnd(), locRule.getLevBeg(), locRule.getLevEnd());
                for (LocMast one : locMasts) {
                    List<String> groupLoc = Utils.getGroupLoc(one.getLocNo());
                    LocMast locMast0 = locMastService.findOutMost(groupLoc);
        return locMast;
    }

    //单品类型入库
    private LocMast getLocNoStep2(LocTypeDto locTypeDto, List<String> matNos, List<Integer> rows) {
        LocMast locMast = null;
        //找内侧空库位(非最外侧库位)
        List<String> locNos = locDetlService.getSameDetl(matNos.get(0));
        for (String locNo : locNos) {
            List<String> groupLoc = Utils.getGroupLoc(locNo);
            LocMast locMast0 = locMastService.findEmptyLocMastByLocNos(locTypeDto.getLocType1(), groupLoc);
                    if (null != locMast0) {
                        // 浅库位符合尺寸检测
                        if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                            // 浅库位对应堆垛机必须可用且无异常
                            if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                    if (true || basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                                // 因库位移转、需预留空库位
                                if (locMastService.checkEmptyCount(locMast0, 10)) {
                                    crnNo = locMast0.getCrnNo();
                                    locMast = locMast0;
                                    break;
                                }
@@ -240,93 +254,66 @@
                        }
                    }
                }
            }

        //未找到巷道，找一条新的空巷道
        if (locMast == null) {
            locMast = locMastService.findInEmptyLocMast(locTypeDto.getLocType1(), rows);//找一条新的空巷道
        }

        // 如果没有相近物料，则按规则轮询货架
        int currentRow = 1;
        if (null == locMast) {
            Shelves shelves = new Shelves(rowCount, crn_qty);
            for (int i = 0; i < shelves.group; i ++) {
                if (i > 0) {
                    curRow = currentRow;
        return locMast;
                }
                curRow = shelves.start(curRow);
                if (curRow < 0) {
                    throw new CoolException("检索库位失败，请联系管理员");

    //高频类型入最外侧库位
    private LocMast getLocNoStep3(LocTypeDto locTypeDto, List<Integer> crnNos) {
        LocMast locMast = null;
        //找最外侧空库位
        LocMast locMast0 = locMastService.findOutMast(locTypeDto.getLocType1(), crnNos);
        if (locMast0 != null) {
            // 浅库位符合尺寸检测
            if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                // 浅库位对应堆垛机必须可用且无异常
                if (true||basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                    // 因库位移转、需预留空库位
                    if (locMastService.checkEmptyCount(locMast0, 10)) {
                        locMast = locMast0;
                }
                currentRow = curRow;
                int crnNo1 = shelves.get(curRow);
                if (whsType == 1) {
                    switch (curRow) {
                        case 1:
                            curRow = 1;
                            if (null != theCrnNo) {
                                curRow = 8;
                                crnNo1 = crnNo1 + 1;
                            }
                            break;
                        case 2:
                            curRow = 7;
                            if (null != theCrnNo) {
                                curRow = 14;
                                crnNo1 = crnNo1 + 1;
                            }
                            break;
                        case 3:
                            curRow = 8;
                            break;
                        case 4:
                            curRow = 14;
                            break;
                        default:
                            throw new CoolException("检索库位失败，请联系管理员");
                    }
                } else {
                    switch (curRow) {
                        case 1:
                            curRow = 8;
                            break;
                        case 2:
                            curRow = 14;
                            break;
                        case 3:
                            curRow = 15;
                            if (null != theCrnNo) {
                                curRow = 8;
                                crnNo1 = crnNo1 - 1;
                            }
                            break;
                        case 4:
                            curRow = 21;
                            if (null != theCrnNo) {
                                curRow = 14;
                                crnNo1 = crnNo1 - 1;
                            }
                            break;
                        default:
                            throw new CoolException("检索库位失败，请联系管理员");
                    }
                    crnNo1 = crnNo1 + 1;
                }
                if (basCrnpService.checkSiteError(crnNo1, true)) {
                    crnNo = crnNo1;
                    break;
                }
            }
        }

        if (crnNo == 0) {
            throw new CoolException("没有可用的堆垛机");
        return locMast;
        }

    //低频类型，直接找混放区域
    private LocMast getLocNoStep4(LocTypeDto locTypeDto) {
        LocMast locMast = null;
        LocMast locMast0 = locMastService.findEmptyLowFrequencyLocMast(locTypeDto.getLocType1());
        if (locMast0 != null) {
            // 浅库位符合尺寸检测
            if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                // 浅库位对应堆垛机必须可用且无异常
                if (true||basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                    // 因库位移转、需预留空库位
                    if (locMastService.checkEmptyCount(locMast0, 10)) {
                        locMast = locMast0;
                    }
                }
            }
        }

        return locMast;
    }

    //返回dto
    private StartupDto getLocNoFinalStep(Integer staDescId, Integer sourceStaNo, LocMast locMast) {
        // 获取目标站
        Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                .eq("type_no", staDescId)
                .eq("stn_no", sourceStaNo)
                .eq("crn_no", crnNo);
                .eq("crn_no", locMast.getCrnNo());
        StaDesc staDesc = staDescService.selectOne(wrapper);
        if (Cools.isEmpty(staDesc)) {
            log.error("入库路径不存在, staDescId={}, sourceStaNo={}, crnNo={}", staDescId, sourceStaNo, crnNo);
            log.error("入库路径不存在, staDescId={}, sourceStaNo={}, crnNo={}", staDescId, sourceStaNo, locMast.getCrnNo());
            throw new CoolException("入库路径不存在");
        }

@@ -336,162 +323,15 @@
            throw new CoolException("目标站"+staDesc.getCrnStn()+"不可用");
        }

        // 更新库位排号
        rowLastno.setCurrentRow(currentRow);
        rowLastnoService.updateById(rowLastno);

        // 开始查找库位 ==============================>>

        // 1.当检索库排为浅库位排时，优先寻找当前库排的深库位排
        // 高低频管控、库位组全部为O
        if (locMast == null) {
            List<Integer> rows = Utils.getGroupLoc(curRow);
            List<LocMast> locMasts = locMastService.queryFreeLocMast0(rows, rows.size(), locTypeDto.getLocType1(), inoutEveryday);
            if (!Cools.isEmpty(locMasts)) {
                Integer innermostRow = Utils.getInnermostRow(locMasts.get(0).getLocNo());
                for (LocMast one : locMasts) {
                    if (one.getRow1().equals(innermostRow)) {
                        locMast = one;
                        break;
                    }
                }
            }

            // 因库位移转、需预留空库位
            if (!locMastService.checkEmptyCount(locMast, 10)) { locMast = null; }
        }

        // 2.1 高低频管控、库位组无需全部为O，找到库位对应深库位不能为P R
        if (Cools.isEmpty(locMast)) {
            int sign = curRow;
            while (sign != 0 && Cools.isEmpty(locMast)) {
                List<LocMast> locMasts = locMastService.queryFreeLocMastEnd1(sign, locTypeDto.getLocType1(), inoutEveryday);
                for (LocMast loc : locMasts) {
                    // 同库位组对应其钱库位是否为 O.空库位
                    boolean success = true;
                    // 浅库位
                    List<String> outerLocList = Utils.getGroupOuterLoc(loc.getLocNo());
                    for (String outerLocNo : outerLocList) {
                        LocMast outerLoc = locMastService.selectById(outerLocNo);
                        if (Cools.isEmpty(outerLoc)) {
                            continue;
                        }
                        if (!outerLoc.getLocSts().equals("O")) {
                            success = false; break;
                        }
                    }
                    // 深库位判断
                    List<String> insideLocList = Utils.getGroupInsideLoc(loc.getLocNo());
                    for (String insideLocNo : insideLocList) {
                        LocMast insideLoc = locMastService.selectById(insideLocNo);
                        if (Cools.isEmpty(insideLoc)) {
                            continue;
                        }
                        if (insideLoc.getLocSts().equals("R")
                                || insideLoc.getLocSts().equals("P")
                                || insideLoc.getLocSts().equals("Q")
                                || insideLoc.getLocSts().equals("S")) {
                            success = false; break;
                        }
                    }
                    // 因库位移转、需预留空库位
                    if (!locMastService.checkEmptyCount(loc, 10)) {
                        success = false;
                    }
                    if (success) {
                        locMast = loc;
                        break;
                    }
                }
                sign = getCurRow(sign);
            }
        }

        // 2.无库位时，无视区域锁定，重新查找库位
        if (Cools.isEmpty(locMast)) {
            int sign = curRow;
            while (sign != 0 && Cools.isEmpty(locMast)) {
                List<LocMast> locMasts = locMastService.queryFreeLocMastEnd(sign, locTypeDto.getLocType1());
                for (LocMast loc : locMasts) {
                    // 同库位组对应其钱库位是否为 O.空库位
                    boolean success = true;
                    // 浅库位
                    List<String> outerLocList = Utils.getGroupOuterLoc(loc.getLocNo());
                    for (String outerLocNo : outerLocList) {
                        LocMast outerLoc = locMastService.selectById(outerLocNo);
                        if (Cools.isEmpty(outerLoc)) {
                            continue;
                        }
                        if (!outerLoc.getLocSts().equals("O")) {
                            success = false; break;
                        }
                    }
                    // 深库位
                    List<String> insideLocList = Utils.getGroupInsideLoc(loc.getLocNo());
                    for (String insideLocNo : insideLocList) {
                        LocMast insideLoc = locMastService.selectById(insideLocNo);
                        if (Cools.isEmpty(insideLoc)) {
                            continue;
                        }
                        if (insideLoc.getLocSts().equals("R")
                                || insideLoc.getLocSts().equals("P")
                                || insideLoc.getLocSts().equals("Q")
                                || insideLoc.getLocSts().equals("S")) {
                            success = false; break;
                        }
                    }
                    // 因库位移转、需预留空库位
                    if (!locMastService.checkEmptyCount(loc, 10)) {
                        success = false;
                    }
                    if (success) {
                        locMast = loc;
                        break;
                    }
                }
                sign = getCurRow(sign);
            }
        }

        //2023-4-13 ADD， 找到的库位、以及其浅库位，如果在工作档有移库任务，则跳过
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                .eq("io_type", 11));
        for (WrkMast wrkMast : wrkMasts){
            if (wrkMast.getSourceLocNo().equals(locMast.getLocNo())){
                locMast = null;
                break;
            }
            List<String> outerLocList = Utils.getGroupOuterLoc(locMast.getLocNo());
            for (String outerLocNo : outerLocList) {
                if (locMast.getLocNo().equals(outerLocNo)){
                    locMast = null;
                    break;
                }
            }
        }

        // 3.库位当前所属尺寸无空库位时，调整尺寸参数，向上兼容检索库位
        if (Cools.isEmpty(locMast)) {
            // 当前巷道无空库位时，递归调整至下一巷道，检索全部巷道无果后，跳出递归
            if (times < rowCount) {
                times = times + 1;
                return getLocNo(whsType, staDescId, sourceStaNo, matNos, locTypeDto, oldLocType, times);
            } else {
                times = 0;
            }
            // 货物检索低库位仓失败，兼容高库位仓后继续执行
            if (locTypeDto.getLocType1() == 1) {
                locTypeDto.setLocType1((short) 2);
                return getLocNo(1, staDescId, sourceStaNo, matNos, locTypeDto, oldLocType, times);
            }
            log.error("系统没有空库位！！！ 尺寸规格： {}， 轮询次数：{}", JSON.toJSONString(locTypeDto), times);
            throw new CoolException("没有空库位");
        }
        String locNo = locMast.getLocNo();

        // 生成工作号
        int workNo = getWorkNo(0);

        // 返回dto
        StartupDto startupDto = new StartupDto();
        startupDto.setWorkNo(workNo);
        startupDto.setCrnNo(crnNo);
        startupDto.setCrnNo(locMast.getCrnNo());
        startupDto.setSourceStaNo(sourceStaNo);
        startupDto.setStaNo(staNo.getDevNo());
        startupDto.setLocNo(locNo);

 src/main/java/com/zy/common/web/WcsController.java

@@ -112,7 +112,7 @@
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        List<String> matNos = waitPakins.stream().map(WaitPakin::getMatnr).distinct().collect(Collectors.toList());
        StartupDto dto = commonService.getLocNo(1, 1, devpNo, matNos, locTypeDto,0);
        StartupDto dto = commonService.getLocNo(1, 1, devpNo, matNos, locTypeDto);
        int workNo = dto.getWorkNo();
        Date now = new Date();
        // 生成工作档
@@ -195,7 +195,7 @@
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        StartupDto dto = commonService.getLocNo(1, 10, devpNo, null, locTypeDto,0);
        StartupDto dto = commonService.getLocNo(1, 10, devpNo, null, locTypeDto);
        int workNo = dto.getWorkNo();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
@@ -258,7 +258,7 @@
        }
        // 检索库位
        List<String> matnrList = wrkDetls.stream().map(WrkDetl::getMatnr).distinct().collect(Collectors.toList());
        return commonService.getLocNo(1, ioType - 50, devpNo, matnrList, locTypeDto,0); // 库位号， 堆垛机，目标站
        return commonService.getLocNo(1, ioType - 50, devpNo, matnrList, locTypeDto); // 库位号， 堆垛机，目标站
    }

}

 src/main/resources/mapper/LocDetlMapper.xml

@@ -496,7 +496,7 @@
        ) dual on dual.loc_no = lm.loc_no
        WHERE 1 = 1
        AND ld.matnr = #{matnr}
        AND (lm.row1 >= #{start} AND lm.row1 &lt;= #{end})
        AND loc_type2 = 1
        AND (lm.loc_sts = 'F')
        AND dual.count = 1
        ORDER BY lm.modi_time ASC

 src/main/resources/mapper/LocMastMapper.xml

@@ -33,7 +33,6 @@
        <result column="inv_wh" property="invWh" />
        <result column="mk" property="mk" />
        <result column="barcode" property="barcode" />
        <result column="Pdc_type" property="PdcType" />
        <result column="ctn_no" property="ctnNo" />

    </resultMap>
@@ -284,4 +283,47 @@
        order by loc_sts desc ,lev1 asc,bay1 asc
    </select>

    <select id="findOutMast" resultMap="BaseResultMap">
        select top 1 * from asr_loc_mast
        where loc_type1 = #{locType1}
        and loc_type2 = 2
        and crn_no in
        <foreach item="item" collection="crnNos" index="index"  separator="," open="(" close=")">
            #{item}
        </foreach>
        and loc_sts = 'O'
        order by row1,bay1,lev1
    </select>

    <select id="findInEmptyLocMast" resultMap="BaseResultMap">
        select top 1 * from asr_loc_mast
        where loc_type2 = 1
        and loc_type1 = #{locType1}
        and row1 in
        <foreach item="item" collection="rows" index="index"  separator="," open="(" close=")">
            #{item}
        </foreach>
        and loc_sts = 'O'
        order by row1,bay1,lev1
    </select>

    <select id="findEmptyLocMastByLocNos" resultMap="BaseResultMap">
        select top 1 * from asr_loc_mast
        where loc_type2 = 1
        and loc_type1 = #{locType1}
        and loc_no in
        <foreach item="item" collection="locNos" index="index"  separator="," open="(" close=")">
            #{item}
        </foreach>
        and loc_sts = 'O'
        order by row1,bay1,lev1
    </select>

    <select id="findEmptyLowFrequencyLocMast" resultMap="BaseResultMap">
        select top 1 * from asr_loc_mast
        where loc_type2 = 3
        and loc_type1 = #{locType1}
        and loc_sts = 'O'
        order by row1,bay1,lev1
    </select>
</mapper>