1.空托盘悬挑库位没有空库位时，找第八层库位

zwl

5 天以前 f9a2a3435ff836a855eb54f7d1268d8bbc391a53

1.空托盘悬挑库位没有空库位时，找第八层库位

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

@@ -97,7 +97,7 @@
    @TableField("loc_type")
    private String locType;

    @ApiModelProperty(value= "高低类型{0:未知,1:低库位,2:高库位}")
    @ApiModelProperty(value= "高低类型{0:未知,1:低库位,2:高库位,3:空托盘兜底库位}")
    @TableField("loc_type1")
    private Short locType1;


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

@@ -880,7 +880,7 @@
    public String emptyPlateIn(Integer devpNo, Long userId) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        // 检索库位；人工空托盘入库固定传 staDescId=10，实际找位规则集中在 CommonService。
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();


 src/main/java/com/zy/common/model/LocTypeDto.java

@@ -13,7 +13,7 @@
@Data
public class LocTypeDto {

    // 高低类型{0:未知,1:低库位,2:高库位}
    // 高低类型{0:未知,1:低库位,2:高库位,3:空托盘兜底库位}
    private Short locType1;

    // 宽窄类型{0:未知,1:窄库位,2:宽库位}

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

@@ -168,7 +168,10 @@
    }

    /**
     * 检索库位号
     * 入库找库位统一入口。
     *
     * 空托盘入库也从这里进入，先由 {@link #normalizeLocTypeDto(Integer, FindLocNoAttributeVo, LocTypeDto)}
     * 统一识别空托盘和整理库位规格，再按 row_lastno_type 分流到不同库型的找位实现。
     *
     * @param staDescId            路径ID
     * @param sourceStaNo          源站
@@ -281,8 +284,8 @@
     * 统一整理入库规格，避免不同入口传入的 locType 不一致。
     *
     * 空托盘的库位策略有两段：
     * 1. 首轮只限制 loc_type2=1，表示优先找窄库位。
     * 2. loc_type1 高度信息必须保留，后续再按低位向高位兼容。
     * 1. 先限制 loc_type2=1，表示优先找窄库位，并保留 loc_type1 高度兼容。
     * 2. 窄库位没有结果后，把 loc_type1 改为 3 再找库位。
     *
     * 非空托盘只保留 loc_type1，满托找位不再使用 loc_type2/loc_type3 过滤。
     */
@@ -313,11 +316,10 @@
    }

    /**
     * 空托盘固定按 4 段式找位：
     * 空托盘固定按窄库位优先找位：
     * 1. 严格高度 + narrow
     * 2. 向上兼容高度 + narrow
     * 3. 严格高度 + open
     * 4. 向上兼容高度 + open
     * 3. loc_type1=3 + open
     */
    private List<LocTypeDto> buildEmptyPalletSearchLocTypes(LocTypeDto locTypeDto) {
        List<LocTypeDto> searchLocTypes = new ArrayList<LocTypeDto>();
@@ -336,19 +338,23 @@
            searchLocTypes.add(narrowCompatibleLocType);
        }

        LocTypeDto openStrictLocType = copyLocTypeDto(baseLocTypeDto);
        openStrictLocType.setLocType2((short) 0);
        searchLocTypes.add(openStrictLocType);

        LocTypeDto openCompatibleLocType = buildUpwardCompatibleLocTypeDto(openStrictLocType);
        if (openCompatibleLocType != null) {
            openCompatibleLocType.setLocType2((short) 0);
            searchLocTypes.add(openCompatibleLocType);
        }
        LocTypeDto emptyPalletFallbackLocType = copyLocTypeDto(baseLocTypeDto);
        emptyPalletFallbackLocType.setLocType1((short) 3);
        emptyPalletFallbackLocType.setLocType2((short) 0);
        searchLocTypes.add(emptyPalletFallbackLocType);
        return searchLocTypes;
    }

    /**
     * 给空托盘找位阶段生成日志标识，便于排查到底卡在窄库位、高度兼容还是 loc_type1=3 兜底阶段。
     */
    private String buildEmptyPalletStageCode(LocTypeDto baseLocTypeDto, LocTypeDto stageLocTypeDto) {
        boolean emptyPalletType3Fallback = stageLocTypeDto != null
                && stageLocTypeDto.getLocType1() != null
                && stageLocTypeDto.getLocType1() == 3;
        if (emptyPalletType3Fallback) {
            return "empty-pallet-locType1-3";
        }
        boolean compatibleHeight = baseLocTypeDto != null
                && baseLocTypeDto.getLocType1() != null
                && stageLocTypeDto != null
@@ -373,6 +379,9 @@

    /**
     * 把 locType 条件追加到库位查询条件里。
     *
     * 空托盘会显式传 loc_type2：第一轮 loc_type2=1 优先窄库位，兜底阶段 loc_type2=0 表示不再限制宽窄。
     * 满托盘整理后没有 loc_type2/loc_type3，此处会排除 loc_type2=1，避免满托占用空托盘窄库位。
     */
    private Wrapper<LocMast> applyLocTypeFilters(Wrapper<LocMast> wrapper, LocTypeDto locTypeDto, boolean includeLocType1) {
        if (wrapper == null || locTypeDto == null) {
@@ -993,7 +1002,12 @@
    }

    /**
     * 按第一优先池 -> 第二优先池的顺序查找可用库位。
     * run2 站点优先池找位入口。
     *
     * 空托盘规则：
     * 1. 先找站点第一优先池，再找第二优先池；第二池会排除第一池已配置的堆垛机。
     * 2. 每个优先池内先找窄库位，再做高度向上兼容，最后把 loc_type1 改为 3 兜底。
     * 3. 只有命中库位的池会推进自己的 currentNo 游标，未命中的池不改变轮询状态。
     */
    private LocMast findRun2PriorityLocInPools(BasDevp station, RowLastno rowLastno, RowLastnoType rowLastnoType,
                                                Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo,
@@ -1033,6 +1047,13 @@

    /**
     * 在单个优先池内按轮转顺序找位。
     *
     * 池内规则：
     * 1. 从 currentNo 的下一台堆垛机开始轮转，保证同一优先池内均分。
     * 2. 跳过不可入、故障或源站到目标堆垛机无入库路径的堆垛机。
     * 3. 每台堆垛机内部交给 {@link #findConfiguredEmptyLocForCrn(RowLastno, RowLastnoType, Integer, Integer, LocTypeDto, FindLocNoAttributeVo, boolean)}
     *    按深浅排画像选择第一个可分配库位。
     * 4. 命中后回写该优先池游标，并把目标站写入 startupDto。
     */
    private LocMast findRun2PriorityLocInPool(RowLastno rowLastno, RowLastnoType rowLastnoType, BasDevp station,
                                              List<Integer> crnNos, Integer currentCrnNo, int poolNo, LocTypeDto locTypeDto,
@@ -1079,7 +1100,10 @@
    }

    /**
     * 在单个优先池内先按当前规格找位，失败后再做一次 locType1 向上兼容。
     * 普通托盘的优先池规格兼容入口。
     *
     * 空托盘不走这个方法，因为空托盘已经在 {@link #buildEmptyPalletSearchLocTypes(LocTypeDto)}
     * 中固定展开了“窄库位优先 + 高度向上兼容 + loc_type1=3 兜底”的顺序。
     */
    private LocMast findRun2PriorityLocInPoolWithCompatibility(RowLastno rowLastno, RowLastnoType rowLastnoType,
                                                                BasDevp station, List<Integer> crnNos, Integer currentCrnNo,
@@ -1323,10 +1347,13 @@
    }

    /**
     * 空托盘 run2 专用搜索链路。
     * 保留的空托盘 run2 按库区轮询搜索链路。
     *
     * 当前 getLocNoRun2 的空托盘实际入口走 {@link #findRun2PriorityLocInPools(BasDevp, RowLastno, RowLastnoType, Integer, Integer, FindLocNoAttributeVo, LocTypeDto, StartupDto, boolean)}
     * 的站点优先池规则；如果后续需要恢复“当前库区 -> 其它库区”的兜底，可以从这里接回。
     *
     * 执行顺序：
     * 1. 先按固定规格阶段构造 4 段式 locType 回退顺序。
     * 1. 先按固定规格阶段构造“窄库位优先 + loc_type1=3 兜底”的 locType 回退顺序。
     * 2. 每个规格阶段都按“当前库区 -> 其它库区”的顺序搜索。
     * 3. 每个库区内部都按该库区自己的 rowLastno/currentRow 做轮询均分。
     *
@@ -1347,6 +1374,12 @@
        return null;
    }

    /**
     * 保留链路：在某个空托盘规格阶段内按库区顺序搜索。
     *
     * 库区顺序由 {@link #buildAreaSearchOrder(List, Integer)} 生成：站点绑定库区优先，其次接口请求库区，
     * 最后补齐 1/2/3 全库区。每个库区使用自己的 row_lastno 游标，并且跨库区时不强制 sta_desc 路径校验。
     */
    private Run2AreaSearchResult findEmptyPalletRun2AreaLoc(RowLastno defaultRowLastno, Integer staDescId, Integer sourceStaNo,
                                                            StartupDto startupDto, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto,
                                                            String stageCode) {
@@ -2096,6 +2129,11 @@

    /**
     * 在一对浅排/深排之间选择真正可投放的目标库位。
     *
     * 双伸位规则：
     * 1. 浅位和深位同列同层都为空时，优先返回深位，避免浅位先占住后挡住深位。
     * 2. 深位已有货时，允许返回对应浅位。
     * 3. 深位为空但规格不匹配时，不把浅位作为可投放结果，继续找下一组同列同层位置。
     */
    private LocMast findPairAssignableLoc(RowLastno rowLastno, RowLastnoType rowLastnoType, Integer crnNo,
                                          Integer shallowRow, Integer deepRow, LocTypeDto locTypeDto) {
@@ -2129,6 +2167,12 @@

    /**
     * 按某台堆垛机的深浅排画像搜索第一个可分配空库位。
     *
     * 这是空托盘最终落库位的核心选择方法：
     * 1. 先读取堆垛机深浅库位规则画像，得到该堆垛机本次应扫描的排顺序。
     * 2. 双伸堆垛机先尝试同货优先规则，再按浅排/深排成对判断可投放位置。
     * 3. 单伸堆垛机直接按排内排序后的空库位返回第一个匹配项。
     * 4. 排内排序会继续受频次、前几列策略和 locType 过滤影响。
     */
    private LocMast findConfiguredEmptyLocForCrn(RowLastno rowLastno, RowLastnoType rowLastnoType, Integer crnNo,
                                                  Integer preferredNearRow, LocTypeDto locTypeDto) {
@@ -2653,8 +2697,8 @@
     * 当前方法只保留“组织流程”和“统一收口”的职责，具体策略拆成独立方法：
     * 1. 先按站点第一优先池找位，再找第二优先池。
     * 2. 池内按 current_no 轮转，从下一台堆垛机开始平均分配。
     * 3. 空托盘先按 loc_type2=1 搜索，同池无结果再允许其它库位。
     * 4. 低库位可向上兼容，兼容重试仍保持两层优先池顺序。
     * 3. 空托盘由 matnr=emptyPallet 或 staDescId=10 识别，先找窄库位，失败后用 loc_type1=3 兜底。
     * 4. 普通托盘只做 loc_type1 向上兼容，并排除空托盘专用窄库位。
     */
    @Transactional
    public StartupDto getLocNoRun2(Integer whsType, Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, Integer moveCrnNo, LocTypeDto locTypeDto, List<Integer> recommendRows, int times) {

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

@@ -142,6 +142,7 @@
            sourceStaNoEntity.setLocType1((short) (param.getLocType1()!=1?2:1));
            LocTypeDto locTypeDto = new LocTypeDto(sourceStaNoEntity);
            if (waitPakins.get(0).getMatnr().equals("emptyPallet")) {
                // 空托盘由组托档 matnr=emptyPallet 标识；后续 CommonService 会按窄库位优先、locType1=3 兜底规则找库位。
                locTypeDto.setLocType2((short) 1);
            }

@@ -183,6 +184,7 @@
        }
        sourceStaNo.setLocType1(param.getLocType1());
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        // AGV 空托盘直入库固定走 staDescId=10，最终由 CommonService.getLocNo 统一执行找位规则。
        param.setIoType(10);
        StartupDto dto = null;
        switch (param.getIoType()) {
@@ -430,7 +432,7 @@
    public StartupDto startupFullPutStoreAgv(Integer devpNo, String barcode, LocTypeDto locTypeDto, Integer outArea, Integer staDescId) {
        // 源站点状态检测
//        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        // 检索库位；staDescId=10 时按空托盘入口识别，进入 CommonService 的优先池 + locType1=3 兜底找位规则。
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();
        findLocNoAttributeVo.setOutArea(outArea);
//        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo(waitPakins.get(0));
@@ -464,7 +466,7 @@
        try {
            // 源站点状态检测
            BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
            // 检索库位
            // 检索库位；如果组托档是 emptyPallet，即使 staDescId=1，也会在 CommonService 内切换为空托盘找位规则。
            FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo(waitPakins.get(0));
            // IoT 指定了目标库位时优先尝试该库位；不可用时再退回现有自动找位规则。
            StartupDto dto = buildPreferredStartupDto(devpNo, extractPreferredInboundLoc(waitPakins));
@@ -604,7 +606,7 @@
public StartupDto emptyPlateIn(Integer devpNo, LocTypeDto locTypeDto, String barcode) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        // 检索库位；旧空托盘入库入口固定传 staDescId=10，仍复用 CommonService 的统一空托盘找位规则。
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();

        StartupDto dto = commonService.getLocNo(10, devpNo, findLocNoAttributeVo, locTypeDto);

 src/test/java/com/zy/common/service/CommonServiceLocTypeStrategyTest.java

@@ -142,7 +142,7 @@

    @Test
    @SuppressWarnings("unchecked")
    void buildEmptyPalletSearchLocTypes_forLowLoc_returnsConfiguredFallbackOrder() {
    void buildEmptyPalletSearchLocTypes_forLowLoc_fallsBackToLocType1ThreeAfterNarrowLocs() {
        LocTypeDto locTypeDto = new LocTypeDto();
        locTypeDto.setLocType1((short) 1);
        locTypeDto.setLocType2((short) 1);
@@ -151,15 +151,13 @@
        List<LocTypeDto> stages = ReflectionTestUtils.invokeMethod(
                commonService, "buildEmptyPalletSearchLocTypes", locTypeDto);

        assertEquals(4, stages.size());
        assertEquals(3, stages.size());
        assertEquals(Short.valueOf((short) 1), stages.get(0).getLocType1());
        assertEquals(Short.valueOf((short) 1), stages.get(0).getLocType2());
        assertEquals(Short.valueOf((short) 2), stages.get(1).getLocType1());
        assertEquals(Short.valueOf((short) 1), stages.get(1).getLocType2());
        assertEquals(Short.valueOf((short) 1), stages.get(2).getLocType1());
        assertEquals(Short.valueOf((short) 3), stages.get(2).getLocType1());
        assertEquals(Short.valueOf((short) 0), stages.get(2).getLocType2());
        assertEquals(Short.valueOf((short) 2), stages.get(3).getLocType1());
        assertEquals(Short.valueOf((short) 0), stages.get(3).getLocType2());
        assertEquals(Short.valueOf((short) 2), stages.get(3).getLocType3());
        assertEquals(Short.valueOf((short) 2), stages.get(2).getLocType3());
    }
}