1.wcs下发出库任务方式需更改，先采集数据再一次性下发：下发组batch和序号batch_seq 2.库位分配逻辑需优化，目前分配单个巷道 3.

zwl

21 小时以前 c9944fa15889ef97236960fcc9370a582cd86267

1.wcs下发出库任务方式需更改，先采集数据再一次性下发：下发组batch和序号batch_seq
2.库位分配逻辑需优化，目前分配单个巷道
3.

 src/main/java/com/zy/api/controller/params/WorkTaskParams.java

@@ -46,7 +46,7 @@
    private Integer isSuplus;

    @ApiModelProperty("组")
    private Integer batch;
    private String batch;

    @ApiModelProperty("序号")
    private Integer batchSeq;

 src/main/java/com/zy/api/service/WcsApiService.java

@@ -21,6 +21,15 @@
    R pubWrkToWcs(WorkTaskParams params);

    /**
     * 批量下发任务至WCS
     * @author Ryan
     * @date 2026/3/16 15:57
     * @param paramsList
     * @return com.core.common.R
     */
    R pubWrksToWcs(List<WorkTaskParams> paramsList);

    /**
     * 堆垛机任务完成状态上报
     * @author Ryan
     * @date 2026/1/10 16:29

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

@@ -75,37 +75,24 @@
     */
    @Override
    public R pubWrkToWcs(WorkTaskParams params) {
        if (Objects.isNull(params.getTaskNo())) {
            return R.error("任务号不能为空！！");
        if (params == null) {
            return R.error("参数不能为空！！");
        }
        if (Objects.isNull(params.getBarcode())) {
            return R.error("托盘码不能为空！！");
        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", params.getTaskNo()));
        String validateMsg = validatePubTask(params, wrkMast);
        if (!Cools.isEmpty(validateMsg)) {
            return R.error(validateMsg);
        }
        if (Objects.isNull(params.getLocNo())) {
            return R.error("目标库位不能为空！！");
        }
        String url = createInTask;
        if (!Objects.isNull(params.getType()) && params.getType().equals("out")) {
            url = getWcs_address;
        }else if (!Objects.isNull(params.getType()) && params.getType().equals("move")) {
            url = createLocMoveTask;
        }
        String url = resolveTaskPath(params);
        String response;
        R r = R.ok();
        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", params.getTaskNo()));
        if (!Objects.isNull(wrkMast) && "out".equalsIgnoreCase(params.getType())) {
            if ("Y".equalsIgnoreCase(wrkMast.getPauseMk())) {
                return R.error("task paused");
            }
            if (requiresOutboundErpConfirm(wrkMast) && !"Y".equalsIgnoreCase(wrkMast.getPdcType())) {
                return R.error("task not confirmed by erp");
            }
        }
        try {
            log.info("下发搬运任务给wcs="+JSON.toJSONString(params));
            response = new HttpHandler.Builder()
                    .setUri(wcs_address)
                    .setPath(url)
                    .setHttps(wcs_address != null && wcs_address.startsWith("https://"))
                    .setTimeout(10, TimeUnit.SECONDS)
                    .setJson(JSON.toJSONString(params))
                    .build()
                    .doPost();
@@ -114,21 +101,7 @@
            Integer code = jsonObject.getInteger("code");

            if (code==200) {
                if (!Objects.isNull(wrkMast)) {
                    if (wrkMast.getIoType()==1 || wrkMast.getIoType()==10) {
                        wrkMast.setWrkSts(2L);
                        wrkMast.setModiTime(new Date());
                        wrkMastService.updateById(wrkMast);
                    }else if(wrkMast.getIoType()==2){
                        wrkMast.setWrkSts(2L);
                        wrkMast.setModiTime(new Date());
                        wrkMastService.updateById(wrkMast);
                    }else if (wrkMast.getIoType()==101 || wrkMast.getIoType()==110) {
                        wrkMast.setWrkSts(12L);
                        wrkMast.setModiTime(new Date());
                        wrkMastService.updateById(wrkMast);
                    }
                }
                updateWrkMastAfterPublish(wrkMast);
                //TODO 上报是否成功
            }else {
                r =R.error();
@@ -137,6 +110,100 @@
            throw new RuntimeException(e);
        }
        return r;
    }

    @Override
    public R pubWrksToWcs(List<WorkTaskParams> paramsList) {
        if (paramsList == null || paramsList.isEmpty()) {
            return R.error("任务不能为空！！");
        }

        // 先一次性把本批任务对应的工作档捞出来，避免循环内重复查库。
        Map<String, WrkMast> wrkMastMap = getWrkMastMap(paramsList);
        Map<String, List<WorkTaskParams>> groupedTasks = new LinkedHashMap<>();
        List<String> skipMsgs = new ArrayList<>();

        for (WorkTaskParams params : paramsList) {
            if (params == null) {
                skipMsgs.add("任务不能为空！！");
                continue;
            }
            WrkMast wrkMast = wrkMastMap.get(params.getTaskNo());
            String validateMsg = validatePubTask(params, wrkMast);
            if (!Cools.isEmpty(validateMsg)) {
                skipMsgs.add(buildTaskMsg(params, validateMsg));
                continue;
            }

            // 分组主键 = 接口路径 + userNo。
            // 这样既能保证入库/出库/移库不会混发，也能保证相同 userNo 的任务会打包到同一次 WCS 请求中。
            String groupKey = buildBatchGroupKey(params, wrkMast);
            groupedTasks.computeIfAbsent(groupKey, key -> new ArrayList<>()).add(params);
        }

        if (groupedTasks.isEmpty()) {
            return R.error(skipMsgs.isEmpty() ? "无可下发任务" : skipMsgs.get(0)).add(skipMsgs);
        }

        int successCount = 0;
        List<String> failMsgs = new ArrayList<>();
        for (List<WorkTaskParams> group : groupedTasks.values()) {
            if (group == null || group.isEmpty()) {
                continue;
            }

            // 同一组内的任务类型一致，因此取第一条即可确定本组应该调用哪个 WCS 接口。
            String path = resolveTaskPath(group.get(0));
            Map<String, Object> payload = new HashMap<>();
            // WCS 批量下发报文统一使用 {"tasks":[...]} 结构。
            payload.put("tasks", buildTaskPayloads(group));
            String response = null;
            try {
                log.info("批量下发搬运任务给wcs={}", JSON.toJSONString(payload));
                response = new HttpHandler.Builder()
                        .setUri(wcs_address)
                        .setPath(path)
                        .setHttps(wcs_address != null && wcs_address.startsWith("https://"))
                        .setTimeout(10, TimeUnit.SECONDS)
                        .setJson(JSON.toJSONString(payload))
                        .build()
                        .doPost();
                JSONObject jsonObject = JSON.parseObject(response == null ? "{}" : response);
                log.info("批量下发任务给wcs的返回值={}", response);
                Integer code = jsonObject.getInteger("code");
                if (code != null && code == 200) {
                    successCount += group.size();
                    // 只有整组下发成功，才回写本地工作档状态，避免 WMS/WCS 状态分叉。
                    for (WorkTaskParams params : group) {
                        updateWrkMastAfterPublish(wrkMastMap.get(params.getTaskNo()));
                    }
                } else {
                    String msg = jsonObject.getString("msg");
                    failMsgs.add("path=" + path + ", msg=" + (Cools.isEmpty(msg) ? "WCS下发任务失败" : msg));
                    log.error("批量下发任务给wcs失败, path:{}, request:{}, response:{}", path, JSON.toJSONString(payload), response);
                }
            } catch (IOException e) {
                failMsgs.add("path=" + path + ", msg=" + e.getMessage());
                log.error("批量下发任务给wcs异常, path:{}, request:{}, response:{}", path, JSON.toJSONString(payload), response, e);
            }
        }

        Map<String, Object> result = new HashMap<>();
        result.put("successCount", successCount);
        result.put("skipCount", skipMsgs.size());
        result.put("failCount", failMsgs.size());
        if (!skipMsgs.isEmpty()) {
            result.put("skipMsgs", skipMsgs);
        }
        if (!failMsgs.isEmpty()) {
            result.put("failMsgs", failMsgs);
        }

        if (successCount == 0) {
            String msg = !failMsgs.isEmpty() ? failMsgs.get(0) : (skipMsgs.isEmpty() ? "WCS下发任务失败" : skipMsgs.get(0));
            return R.error(msg).add(result);
        }
        return R.ok(failMsgs.isEmpty() && skipMsgs.isEmpty() ? "操作成功" : "部分任务下发成功").add(result);
    }

    /**
@@ -206,6 +273,180 @@
        Integer ioType = wrkMast == null ? null : wrkMast.getIoType();
        return ioType != null && (ioType == 101 || ioType == 103 || ioType == 104 || ioType == 107 || ioType == 110);
    }

    /**
     * 校验单条任务是否满足下发前提。
     * <p>
     * 这里既校验接口必填项，也校验业务约束，例如：
     * 1. 出库任务是否被暂停；
     * 2. 需要 ERP 确认的出库任务是否已确认。
     */
    private String validatePubTask(WorkTaskParams params, WrkMast wrkMast) {
        if (params == null) {
            return "参数不能为空！！";
        }
        if (Cools.isEmpty(params.getTaskNo())) {
            return "任务号不能为空！！";
        }
        if (Cools.isEmpty(params.getBarcode())) {
            return "托盘码不能为空！！";
        }
        if (Cools.isEmpty(params.getLocNo())) {
            return "目标库位不能为空！！";
        }
        if (!Objects.isNull(wrkMast) && "out".equalsIgnoreCase(params.getType())) {
            if ("Y".equalsIgnoreCase(wrkMast.getPauseMk())) {
                return "task paused";
            }
            if (requiresOutboundErpConfirm(wrkMast) && !"Y".equalsIgnoreCase(wrkMast.getPdcType())) {
                return "task not confirmed by erp";
            }
        }
        return null;
    }

    /**
     * 按任务类型选择 WCS 接口地址。
     * in -> 入库接口
     * out -> 出库接口
     * move -> 移库接口
     */
    private String resolveTaskPath(WorkTaskParams params) {
        if (!Objects.isNull(params.getType()) && params.getType().equals("out")) {
            return getWcs_address;
        }
        if (!Objects.isNull(params.getType()) && params.getType().equals("move")) {
            return createLocMoveTask;
        }
        return createInTask;
    }

    /**
     * WCS 下发成功后推进本地工作档状态。
     * <p>
     * 这里只处理“已下发”这一层状态，不处理设备执行完成状态；
     * 设备执行完成依然以 WCS 回写为准。
     */
    private void updateWrkMastAfterPublish(WrkMast wrkMast) {
        if (Objects.isNull(wrkMast)) {
            return;
        }
        if (wrkMast.getIoType()==1 || wrkMast.getIoType()==10) {
            wrkMast.setWrkSts(2L);
            wrkMast.setModiTime(new Date());
            wrkMastService.updateById(wrkMast);
        }else if(wrkMast.getIoType()==2){
            wrkMast.setWrkSts(2L);
            wrkMast.setModiTime(new Date());
            wrkMastService.updateById(wrkMast);
        }else if (wrkMast.getIoType()==101 || wrkMast.getIoType()==110) {
            wrkMast.setWrkSts(12L);
            wrkMast.setModiTime(new Date());
            wrkMastService.updateById(wrkMast);
        }
    }

    /**
     * 把本次待下发的 taskNo 批量映射成工作档，供后续校验、按 userNo 分组、状态回写复用。
     */
    private Map<String, WrkMast> getWrkMastMap(List<WorkTaskParams> paramsList) {
        List<String> taskNos = paramsList.stream()
                .filter(Objects::nonNull)
                .map(WorkTaskParams::getTaskNo)
                .filter(taskNo -> !Cools.isEmpty(taskNo))
                .distinct()
                .collect(Collectors.toList());
        if (taskNos.isEmpty()) {
            return Collections.emptyMap();
        }
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_no", taskNos));
        if (wrkMasts == null || wrkMasts.isEmpty()) {
            return Collections.emptyMap();
        }
        return wrkMasts.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toMap(mast -> String.valueOf(mast.getWrkNo()), mast -> mast, (left, right) -> left, LinkedHashMap::new));
    }

    /**
     * 构造批量下发的分组键。
     * <p>
     * 分组规则：
     * 1. 先按接口路径区分，避免不同任务类型混用同一个 WCS 接口；
     * 2. 再按 userNo 区分，确保相同 userNo 的任务一起上报。
     * <p>
     * 正常情况下 userNo 取自 work_mast.user_no；
     * 如果当前没查到工作档，则回退到请求里的 batch 字段，保证兼容已有调用。
     */
    private String buildBatchGroupKey(WorkTaskParams params, WrkMast wrkMast) {
        String path = resolveTaskPath(params);
        String userNo = wrkMast == null ? null : wrkMast.getUserNo();
        if (Cools.isEmpty(userNo)) {
            userNo = params.getBatch();
        }
        if (Cools.isEmpty(userNo)) {
            userNo = "_NO_USER_";
        }
        return path + "#" + userNo;
    }

    /**
     * 将一组业务参数转换成 WCS 批量接口的 tasks 数组。
     */
    private List<Map<String, Object>> buildTaskPayloads(List<WorkTaskParams> tasks) {
        List<Map<String, Object>> payloads = new ArrayList<>();
        for (WorkTaskParams task : tasks) {
            payloads.add(buildTaskPayload(task));
        }
        return payloads;
    }

    /**
     * 组装单条任务的 WCS 请求体。
     * 只放当前任务类型实际需要的字段；空字段不透传，避免给 WCS 造成歧义。
     */
    private Map<String, Object> buildTaskPayload(WorkTaskParams params) {
        Map<String, Object> task = new LinkedHashMap<>();
        if (!Cools.isEmpty(params.getTaskNo())) {
            task.put("taskNo", params.getTaskNo());
        }
        if (!Cools.isEmpty(params.getLocNo())) {
            task.put("locNo", params.getLocNo());
        }
        if (!Cools.isEmpty(params.getSourceLocNo())) {
            task.put("sourceLocNo", params.getSourceLocNo());
        }
        if (!Cools.isEmpty(params.getSourceStaNo())) {
            task.put("sourceStaNo", params.getSourceStaNo());
        }
        if (!Cools.isEmpty(params.getBarcode())) {
            task.put("barcode", params.getBarcode());
        }
        if (!Objects.isNull(params.getTaskPri())) {
            task.put("taskPri", params.getTaskPri());
        }
        if (!Cools.isEmpty(params.getStaNo())) {
            task.put("staNo", params.getStaNo());
        }
        if (!Cools.isEmpty(params.getBatch())) {
            task.put("batch", params.getBatch());
        }
        if (!Objects.isNull(params.getBatchSeq())) {
            task.put("batchSeq", params.getBatchSeq());
        }
        return task;
    }

    /**
     * 构造跳过/失败信息时统一带上 taskNo，便于排查具体是哪一条工作档未被下发。
     */
    private String buildTaskMsg(WorkTaskParams params, String msg) {
        if (params == null || Cools.isEmpty(params.getTaskNo())) {
            return msg;
        }
        return "taskNo=" + params.getTaskNo() + ", msg=" + msg;
    }

    @Override
    public R pauseOutTasks(List<HashMap<String,Object>> params) {
        if (params == null || params.size() == 0) {

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

@@ -14,6 +14,8 @@
import com.zy.asrs.service.OpenService;
import com.zy.asrs.service.WaitPakinService;
import com.zy.asrs.service.WrkDetlService;
import com.zy.asrs.service.WrkMastLogService;
import com.zy.asrs.service.WrkMastService;
import com.zy.common.model.DetlDto;
import com.zy.common.model.LocDetlDto;
import com.zy.common.model.enums.WorkNoType;
@@ -49,6 +51,10 @@
    private WaitPakinService waitPakinService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkMastLogService wrkMastLogService;

//    @PostMapping("/order/matSync/default/v1")
////    @AppAuth(memo = "商品信息同步接口")
@@ -466,6 +472,35 @@

    @PostMapping("/outOrder")
    public synchronized R outOrder (@RequestBody ArrayList<OutTaskParam> params){
        if (Cools.isEmpty(params)) {
            return R.error("请求参数不能为空");
        }
        Set<String> orderIds = new LinkedHashSet<>();
        for (OutTaskParam outTaskParam : params) {
            if (Cools.isEmpty(outTaskParam) || Cools.isEmpty(outTaskParam.getOrderId())) {
                return R.error("出库单号不能为空");
            }
            orderIds.add(outTaskParam.getOrderId());
        }
        if (!orderIds.isEmpty()) {
            Set<String> existedOrderIds = new LinkedHashSet<>();
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("user_no", orderIds));
            for (WrkMast wrkMast : wrkMasts) {
                if (!Cools.isEmpty(wrkMast.getUserNo())) {
                    existedOrderIds.add(wrkMast.getUserNo());
                }
            }
            List<WrkMastLog> wrkMastLogs = wrkMastLogService.selectList(new EntityWrapper<WrkMastLog>().in("user_no", orderIds));
            for (WrkMastLog wrkMastLog : wrkMastLogs) {
                if (!Cools.isEmpty(wrkMastLog.getUserNo())) {
                    existedOrderIds.add(wrkMastLog.getUserNo());
                }
            }
            if (!existedOrderIds.isEmpty()) {
                return R.error("出库单号已存在任务档或任务历史档：" + String.join("，", existedOrderIds));
            }
        }

        List<OutTaskParam> errorOutOrders = Lists.newArrayList();
        List<OutTaskParam> validOutOrders = Lists.newArrayList();
        for (OutTaskParam outTaskParam : params) {

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

@@ -13,7 +13,7 @@

    RowLastno findBySection(Integer row);

    @Update("update asr_row_lastno set wrk_mk = 1 where whs_type = 1")
    @Update("update asr_row_lastno set crn_qty = 1 where whs_type = 2")
    void updateInitWrkMk();

    @Update("update asr_row_lastno set wrk_mk = 1 where whs_type = #{whs}")

 src/main/java/com/zy/asrs/task/WorkMastScheduler.java

@@ -17,6 +17,7 @@
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
@@ -57,35 +58,51 @@
    }

    /**
     * 任务自动下发
     * 任务自动下发。
     * <p>
     * 调度器只负责从工作档中挑出“当前允许下发”的任务，并将其转换成 WCS 接口需要的报文结构；
     * 真正的批量分组、调用 WCS、以及下发成功后的状态推进都放在 service 层统一处理。
     * <p>
     * 当前批量下发的归并维度是：
     * 1. WCS接口路径（入库/出库/移库不能混发）；
     * 2. work_mast.user_no（相同 userNo 的任务必须放到同一批次一起上报）。
     *
     * @author Ryan
     * @date 2026/1/10 14:42
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    private void autoPubTasks() {
        // 仅处理待下发/已生成下发号的工作档。
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", Arrays.asList(1L, 11L)));
        if (wrkMasts.isEmpty()) {
            return;
        }

        // 打散顺序，避免固定排序下同一批任务长期占用调度机会。
        Collections.shuffle(wrkMasts);
        List<WorkTaskParams> paramsList = new ArrayList<>();
        for (WrkMast wrkMast : wrkMasts) {
            // 出库类任务（ioType > 100）默认需要 ERP 确认；未确认的任务在这里直接跳过。
            if (wrkMast.getIoType()>100&& !wrkMast.getPdcType().equals("Y")) {
                continue;
            }

            // WMS 库位编码转换成 WCS 可识别的库位编码。
            String wcsSourceLocNo = Cools.isEmpty(wrkMast.getSourceLocNo()) ? "" : Utils.WMSLocToWCSLoc(wrkMast.getSourceLocNo());
            String wcsLocNo = Cools.isEmpty(wrkMast.getLocNo()) ? "" : Utils.WMSLocToWCSLoc(wrkMast.getLocNo());
            WorkTaskParams params = new WorkTaskParams();
            //出库和移库
            if(wrkMast.getIoType()==101&&!Cools.isEmpty(wrkMast.getStaNo())&& !wrkMast.getStaNo().equals("0")) {

            // 101: 出库。此处 batch 字段承载 userNo，后续 service 层会据此把相同 userNo 的任务并到一批。
            if(wrkMast.getIoType()==101) {
                params.setType("out")
                        .setTaskNo(wrkMast.getWrkNo()+"")
                        .setLocNo(wcsSourceLocNo)
                        .setStaNo(String.valueOf(wrkMast.getStaNo()))
                        .setTaskPri(wrkMast.getIoPri().intValue())
                        .setBatch(1)
                        .setBatch(wrkMast.getUserNo())
                        .setBatchSeq(wrkMast.getPltType())
                        .setBarcode(wrkMast.getBarcode());
            // 2: 入库。入库接口使用 sourceStaNo + 目标库位。
            }else if(wrkMast.getIoType()==2&& !Cools.isEmpty(wrkMast.getSourceStaNo())){
                params.setType("in")
                        .setTaskNo(wrkMast.getWrkNo()+"")
@@ -93,6 +110,7 @@
                        .setLocNo(wcsLocNo)
                        .setTaskPri(wrkMast.getIoPri().intValue())
                        .setBarcode(wrkMast.getBarcode());
            // 其余走移库接口，源库位和目标库位都需要带给 WCS。
            } else {
                params.setType("move")
                        .setTaskNo(wrkMast.getWrkNo()+"")
@@ -100,11 +118,17 @@
                        .setLocNo(wcsLocNo)
                        .setBarcode(wrkMast.getBarcode());
            }
            R r = wcsApiService.pubWrkToWcs(params);
            if (r.get("code").equals(200)){
                break;
            }
        };
            paramsList.add(params);
        }
        if (paramsList.isEmpty()) {
            return;
        }

        // service 层会继续按“接口路径 + userNo”分组后再批量上报。
        R r = wcsApiService.pubWrksToWcs(paramsList);
        if (!r.get("code").equals(200)) {
            log.warn("批量下发任务到WCS失败, result={}", r);
        }
    }

}

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

@@ -28,7 +28,19 @@
     **/
    public static boolean locMoveCheckLocTypeComplete(LocMast loc, LocTypeDto dto) {
        // 如果源库位是高库位，目标库位是低库位
        return dto.getLocType1().equals(loc.getLocType1());
        if (dto == null || loc == null) {
            return false;
        }
        if (dto.getLocType1() != null && dto.getLocType1() > 0 && !dto.getLocType1().equals(loc.getLocType1())) {
            return false;
        }
        if (dto.getLocType2() != null && dto.getLocType2() > 0 && !dto.getLocType2().equals(loc.getLocType2())) {
            return false;
        }
        if (dto.getLocType3() != null && dto.getLocType3() > 0 && !dto.getLocType3().equals(loc.getLocType3())) {
            return false;
        }
        return true;
    }

}

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

@@ -42,6 +42,23 @@
public class CommonService {
    private static final int MIN_SPARE_LOC_COUNT = 2;

    private static class Run2AreaSearchResult {
        private final LocMast locMast;
        private final RowLastno rowLastno;
        private final List<Integer> runnableCrnNos;

        /**
         * @param locMast 命中的空库位
         * @param rowLastno 命中库区对应的轮询游标记录
         * @param runnableCrnNos 当前库区可参与轮询的堆垛机顺序
         */
        private Run2AreaSearchResult(LocMast locMast, RowLastno rowLastno, List<Integer> runnableCrnNos) {
            this.locMast = locMast;
            this.rowLastno = rowLastno;
            this.runnableCrnNos = runnableCrnNos;
        }
    }

    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
@@ -138,6 +155,7 @@
    @Transactional
    public StartupDto getLocNo(Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto, List<Integer> recommendRows) {
        try {
            locTypeDto = normalizeLocTypeDto(staDescId, findLocNoAttributeVo, locTypeDto);
            Integer whsType = Utils.GetWhsType(sourceStaNo);
            RowLastno rowLastno = rowLastnoService.selectById(whsType);
            RowLastnoType rowLastnoType = rowLastnoTypeService.selectById(rowLastno.getTypeId());
@@ -169,6 +187,58 @@
            log.error("站点={} 查找库位异常", sourceStaNo, e);
            throw new CoolException("站点=" + sourceStaNo + " 查找库位失败");
        }
    }

    /**
     * 空托盘识别规则：
     * 1. 以组托档物料编码 matnr=emptyPallet 为主，不再依赖 ioType=10。
     * 2. 保留 staDescId=10 的兼容判断，避免旧链路还未切换时行为突变。
     */
    private boolean isEmptyPalletRequest(Integer staDescId, FindLocNoAttributeVo findLocNoAttributeVo) {
        if (findLocNoAttributeVo != null && "emptyPallet".equalsIgnoreCase(findLocNoAttributeVo.getMatnr())) {
            return true;
        }
        return staDescId != null && staDescId == 10;
    }

    /**
     * 统一整理入库规格，避免不同入口传入的 locType 不一致。
     *
     * 空托盘的库位策略有两段：
     * 1. 首轮只限制 loc_type2=1，表示优先找窄库位。
     * 2. 首轮不限制 loc_type1，高低位都允许参与搜索。
     *
     * 这样做的原因是现场口径已经改成“先找窄库位”，而不是“先找低位窄库位”。
     * 因此这里会主动清空 locType1，防止被站点默认值带成低位优先。
     */
    private LocTypeDto normalizeLocTypeDto(Integer staDescId, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto) {
        if (!isEmptyPalletRequest(staDescId, findLocNoAttributeVo)) {
            return locTypeDto;
        }
        if (findLocNoAttributeVo != null && Cools.isEmpty(findLocNoAttributeVo.getMatnr())) {
            findLocNoAttributeVo.setMatnr("emptyPallet");
        }
        LocTypeDto normalizedLocTypeDto = locTypeDto == null ? new LocTypeDto() : locTypeDto;
        // 空托盘首轮不限制高低位，只保留“窄库位优先”的约束。
        normalizedLocTypeDto.setLocType1(null);
        normalizedLocTypeDto.setLocType2((short) 1);
        return normalizedLocTypeDto;
    }

    private Wrapper<LocMast> applyLocTypeFilters(Wrapper<LocMast> wrapper, LocTypeDto locTypeDto, boolean includeLocType1) {
        if (wrapper == null || locTypeDto == null) {
            return wrapper;
        }
        if (includeLocType1 && locTypeDto.getLocType1() != null && locTypeDto.getLocType1() > 0) {
            wrapper.eq("loc_type1", locTypeDto.getLocType1());
        }
        if (locTypeDto.getLocType2() != null && locTypeDto.getLocType2() > 0) {
            wrapper.eq("loc_type2", locTypeDto.getLocType2());
        }
        if (locTypeDto.getLocType3() != null && locTypeDto.getLocType3() > 0) {
            wrapper.eq("loc_type3", locTypeDto.getLocType3());
        }
        return wrapper;
    }

    private Integer resolvePreferredArea(Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo) {
@@ -345,14 +415,14 @@
            if (row == null) {
                continue;
            }
            List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
            Wrapper<LocMast> wrapper = new EntityWrapper<LocMast>()
                    .eq("row1", row)
                    .ge("bay1", startBay)
                    .le("bay1", endBay)
                    .eq("loc_sts", "O")
                    .eq("loc_type1", locTypeDto.getLocType1())
                    .orderBy("lev1", true)
                    .orderBy("bay1", true));
                    .eq("loc_sts", "O");
            applyLocTypeFilters(wrapper, locTypeDto, true);
            wrapper.orderBy("lev1", true).orderBy("bay1", true);
            List<LocMast> locMasts = locMastService.selectList(wrapper);
            for (LocMast candidate : locMasts) {
                if (!VersionUtils.locMoveCheckLocTypeComplete(candidate, locTypeDto)) {
                    continue;
@@ -468,6 +538,268 @@
        return orderedCrnNos;
    }

    private Integer getCrnStartRow(RowLastno rowLastno, Integer crnNo) {
        if (rowLastno == null || crnNo == null) {
            return null;
        }
        Integer rowSpan = getCrnRowSpan(rowLastno.getTypeId());
        if (rowSpan == null || rowSpan <= 0) {
            return null;
        }
        int startCrnNo = rowLastno.getsCrnNo() == null ? 1 : rowLastno.getsCrnNo();
        int startRow = rowLastno.getsRow() == null ? 1 : rowLastno.getsRow();
        if (crnNo < startCrnNo) {
            return null;
        }
        return startRow + (crnNo - startCrnNo) * rowSpan;
    }

    /**
     * 判断某台堆垛机是否可以参与 run2 入库找位。
     *
     * routeRequired=true:
     * 普通入库必须同时满足设备可入、设备无故障、并且当前源站到该堆垛机存在有效目标站路径。
     *
     * routeRequired=false:
     * 空托盘跨库区找位时，只校验设备主档、故障和可入状态，不把 sta_desc 路径当成拦截条件。
     * 这样做是为了先满足“能找到库位”，目标站路径由后续主数据补齐。
     */
    private boolean canRun2CrnAcceptPakin(RowLastno rowLastno, Integer staDescId, Integer sourceStaNo, Integer crnNo) {
        return canRun2CrnAcceptPakin(rowLastno, staDescId, sourceStaNo, crnNo, true);
    }

    private boolean canRun2CrnAcceptPakin(RowLastno rowLastno, Integer staDescId, Integer sourceStaNo, Integer crnNo, boolean routeRequired) {
        if (crnNo == null) {
            return false;
        }
        BasCrnp basCrnp = basCrnpService.selectById(crnNo);
        if (Cools.isEmpty(basCrnp)) {
            return false;
        }
        if (!"Y".equals(basCrnp.getInEnable())) {
            return false;
        }
        if (basCrnp.getCrnSts() != null && basCrnp.getCrnSts() != 3) {
            return false;
        }
        if (basCrnp.getCrnErr() != null && basCrnp.getCrnErr() != 0) {
            return false;
        }
        if (!routeRequired) {
            return true;
        }
        if (!Utils.BooleanWhsTypeSta(rowLastno, staDescId)) {
            return true;
        }
        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                .eq("type_no", staDescId)
                .eq("stn_no", sourceStaNo)
                .eq("crn_no", crnNo));
        if (Cools.isEmpty(staDesc)) {
            return false;
        }
        BasDevp targetSta = basDevpService.selectById(staDesc.getCrnStn());
        return !Cools.isEmpty(targetSta) && "Y".equals(targetSta.getAutoing());
    }

    /**
     * 按既定轮询顺序过滤出真正可参与本次找位的堆垛机列表。
     */
    private List<Integer> getOrderedRunnableRun2CrnNos(RowLastno rowLastno, Integer staDescId, Integer sourceStaNo, List<Integer> orderedCrnNos) {
        return getOrderedRunnableRun2CrnNos(rowLastno, staDescId, sourceStaNo, orderedCrnNos, true);
    }

    private List<Integer> getOrderedRunnableRun2CrnNos(RowLastno rowLastno, Integer staDescId, Integer sourceStaNo, List<Integer> orderedCrnNos, boolean routeRequired) {
        List<Integer> runnableCrnNos = new ArrayList<>();
        if (Cools.isEmpty(orderedCrnNos)) {
            return runnableCrnNos;
        }
        for (Integer candidateCrnNo : orderedCrnNos) {
            if (canRun2CrnAcceptPakin(rowLastno, staDescId, sourceStaNo, candidateCrnNo, routeRequired)) {
                runnableCrnNos.add(candidateCrnNo);
            }
        }
        return runnableCrnNos;
    }

    /**
     * 根据本次命中的堆垛机，把轮询游标推进到下一台可参与轮询的堆垛机。
     */
    private int getNextRun2CurrentRow(RowLastno rowLastno, List<Integer> runnableCrnNos, Integer selectedCrnNo, int currentRow) {
        if (Cools.isEmpty(runnableCrnNos) || selectedCrnNo == null) {
            return getNextRun2CurrentRow(rowLastno, currentRow);
        }
        int index = runnableCrnNos.indexOf(selectedCrnNo);
        if (index < 0) {
            return getNextRun2CurrentRow(rowLastno, currentRow);
        }
        Integer nextCrnNo = runnableCrnNos.get((index + 1) % runnableCrnNos.size());
        Integer nextRow = getCrnStartRow(rowLastno, nextCrnNo);
        return nextRow == null ? getNextRun2CurrentRow(rowLastno, currentRow) : nextRow;
    }

    /**
     * 构造空托盘跨库区搜索顺序：
     * 先当前库区，再依次补足其它库区，避免重复。
     */
    private List<Integer> buildAreaSearchOrder(Integer preferredArea) {
        LinkedHashSet<Integer> areaOrder = new LinkedHashSet<>();
        if (preferredArea != null && preferredArea >= 1 && preferredArea <= 3) {
            areaOrder.add(preferredArea);
        }
        for (int area = 1; area <= 3; area++) {
            areaOrder.add(area);
        }
        return new ArrayList<>(areaOrder);
    }

    /**
     * 根据库区取该库区对应的轮询记录。
     * 当前库里 1/2/3 库区正好复用了 asr_row_lastno 的 whs_type 主键，因此这里直接按 area 取。
     * 如果缺主数据，就回退到当前源站所在仓的 rowLastno，避免直接空指针。
     */
    private RowLastno getAreaRowLastno(Integer area, RowLastno defaultRowLastno) {
        if (area != null && area > 0) {
            RowLastno areaRowLastno = rowLastnoService.selectById(area);
            if (!Cools.isEmpty(areaRowLastno)) {
                return areaRowLastno;
            }
        }
        return defaultRowLastno;
    }

    /**
     * 空托盘 run2 专用搜索链路。
     *
     * 执行顺序：
     * 1. 先按站点绑定库区找 loc_type2=1。
     * 2. 当前库区没有，再按其它库区继续找 loc_type2=1。
     * 3. 每个库区内部都按该库区自己的 rowLastno/currentRow 做轮询均分。
     *
     * 这里故意不复用普通 run2 的“推荐排 -> 当前库区排 -> 其它排”逻辑，
     * 因为空托盘的业务口径已经切换成“按库区找堆垛机”，不是按推荐排找巷道。
     */
    private Run2AreaSearchResult findEmptyPalletRun2AreaLoc(RowLastno defaultRowLastno, Integer staDescId, Integer sourceStaNo,
                                                            StartupDto startupDto, Integer preferredArea, LocTypeDto locTypeDto) {
        for (Integer area : buildAreaSearchOrder(preferredArea)) {
            RowLastno areaRowLastno = getAreaRowLastno(area, defaultRowLastno);
            if (Cools.isEmpty(areaRowLastno)) {
                continue;
            }
            RowLastnoType areaRowLastnoType = rowLastnoTypeService.selectById(areaRowLastno.getTypeId());
            if (Cools.isEmpty(areaRowLastnoType)) {
                continue;
            }
            Integer areaStartCrnNo = resolveRun2CrnNo(areaRowLastno);
            List<Integer> orderedAreaCrnNos = getOrderedCrnNos(areaRowLastno, areaStartCrnNo);
            // 空托盘跨库区时只筛设备主档和故障状态，不强依赖 sta_desc。
            List<Integer> runnableAreaCrnNos = getOrderedRunnableRun2CrnNos(areaRowLastno, staDescId, sourceStaNo, orderedAreaCrnNos, false);
            List<Integer> candidateCrnNos = Cools.isEmpty(runnableAreaCrnNos) ? orderedAreaCrnNos : runnableAreaCrnNos;
            if (Cools.isEmpty(candidateCrnNos)) {
                continue;
            }
            LocMast locMast = findRun2EmptyLocByCrnNos(areaRowLastno, areaRowLastnoType, candidateCrnNos, locTypeDto,
                    staDescId, sourceStaNo, startupDto, area, "empty-pallet-area-" + area, false);
            if (!Cools.isEmpty(locMast)) {
                return new Run2AreaSearchResult(locMast, areaRowLastno, candidateCrnNos);
            }
        }
        return null;
    }

    /**
     * 空托盘命中库位后，按命中库区回写该库区自己的轮询游标。
     * 这样 A/B/C 三个库区会分别维护各自的“下一台堆垛机”，不会互相覆盖。
     */
    private void advanceEmptyPalletRun2Cursor(Run2AreaSearchResult searchResult, LocMast locMast) {
        if (searchResult == null || searchResult.rowLastno == null || locMast == null) {
            return;
        }
        RowLastno updateRowLastno = searchResult.rowLastno;
        int updateCurRow = updateRowLastno.getCurrentRow() == null || updateRowLastno.getCurrentRow() == 0
                ? (updateRowLastno.getsRow() == null ? 1 : updateRowLastno.getsRow())
                : updateRowLastno.getCurrentRow();
        updateCurRow = getNextRun2CurrentRow(updateRowLastno, searchResult.runnableCrnNos, locMast.getCrnNo(), updateCurRow);
        updateRowLastno.setCurrentRow(updateCurRow);
        rowLastnoService.updateById(updateRowLastno);
    }

    /**
     * 普通 run2 的推荐排优先阶段。
     *
     * 推荐排只对普通物料生效，空托盘已经切换成“按库区轮询堆垛机”的规则，
     * 因此这里会直接跳过空托盘请求，避免 row 参数把空托盘重新带回旧逻辑。
     */
    private LocMast findRun2RecommendLoc(RowLastno rowLastno, RowLastnoType rowLastnoType, boolean emptyPalletRequest,
                                         List<Integer> recommendRows, LocTypeDto locTypeDto, Integer staDescId,
                                         Integer sourceStaNo, StartupDto startupDto, Integer preferredArea,
                                         List<Integer> triedCrnNos) {
        if (emptyPalletRequest) {
            return null;
        }
        List<Integer> recommendCrnNos = mapRowsToCrnNos(rowLastno, recommendRows);
        if (Cools.isEmpty(recommendCrnNos)) {
            return null;
        }
        LocMast locMast = findRun2EmptyLocByCrnNos(rowLastno, rowLastnoType, recommendCrnNos, locTypeDto,
                staDescId, sourceStaNo, startupDto, preferredArea, "recommend");
        triedCrnNos.addAll(recommendCrnNos);
        return locMast;
    }

    /**
     * 普通物料 run2 找位主流程。
     *
     * 执行顺序：
     * 1. 先看站点是否配置了“堆垛机 + 库位类型”优先级。
     * 2. 没配库区时，直接按当前 run2 轮询顺序找位。
     * 3. 配了库区时，先在当前库区找，再回退到其它库区。
     */
    private LocMast findNormalRun2Loc(RowLastno rowLastno, RowLastnoType rowLastnoType, Integer sourceStaNo,
                                      Integer staDescId, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto,
                                      StartupDto startupDto, Integer preferredArea, List<Integer> orderedCrnNos,
                                      List<Integer> triedCrnNos) {
        List<Map<String, Integer>> stationCrnLocTypes = Utils.getStationStorageAreaName(
                sourceStaNo,
                locTypeDto == null || locTypeDto.getLocType1() == null ? null : locTypeDto.getLocType1().intValue(),
                findLocNoAttributeVo == null ? null : findLocNoAttributeVo.getMatnr());
        if (!Cools.isEmpty(stationCrnLocTypes)) {
            return findRun2EmptyLocByCrnLocTypeEntries(rowLastno, rowLastnoType, stationCrnLocTypes,
                    locTypeDto, staDescId, sourceStaNo, startupDto, preferredArea, "station-priority");
        }
        if (preferredArea == null) {
            List<Integer> defaultCrnNos = new ArrayList<>(orderedCrnNos);
            defaultCrnNos.removeAll(triedCrnNos);
            return findRun2EmptyLocByCrnNos(rowLastno, rowLastnoType, defaultCrnNos, locTypeDto,
                    staDescId, sourceStaNo, startupDto, preferredArea, "default");
        }
        List<Integer> preferredCrnNos = filterCrnNosByRows(rowLastno, orderedCrnNos, getRun2AreaRows(preferredArea, rowLastno));
        preferredCrnNos.removeAll(triedCrnNos);
        LocMast locMast = findRun2EmptyLocByCrnNos(rowLastno, rowLastnoType, preferredCrnNos, locTypeDto,
                staDescId, sourceStaNo, startupDto, preferredArea, "preferred-area");
        if (!Cools.isEmpty(locMast)) {
            return locMast;
        }
        List<Integer> fallbackCrnNos = filterCrnNosByRows(rowLastno, orderedCrnNos, getRun2FallbackRows(rowLastno));
        fallbackCrnNos.removeAll(triedCrnNos);
        fallbackCrnNos.removeAll(preferredCrnNos);
        return findRun2EmptyLocByCrnNos(rowLastno, rowLastnoType, fallbackCrnNos, locTypeDto,
                staDescId, sourceStaNo, startupDto, preferredArea, "fallback-area");
    }

    /**
     * 普通物料命中库位后，沿用 run2 原有的全仓轮询游标推进方式。
     */
    private void advanceNormalRun2Cursor(RowLastno rowLastno, int curRow) {
        if (rowLastno == null) {
            return;
        }
        int updateCurRow = curRow == 0 ? (rowLastno.getsRow() == null ? 1 : rowLastno.getsRow()) : curRow;
        updateCurRow = getNextRun2CurrentRow(rowLastno, updateCurRow);
        rowLastno.setCurrentRow(updateCurRow);
        rowLastnoService.updateById(rowLastno);
    }

    private List<Integer> filterCrnNosByRows(RowLastno rowLastno, List<Integer> orderedCrnNos, List<Integer> rows) {
        if (Cools.isEmpty(rows)) {
            return new ArrayList<>(orderedCrnNos);
@@ -552,9 +884,26 @@
                JSON.toJSONString(locTypeDto));
    }

    /**
     * 按给定堆垛机顺序依次找空库位。
     *
     * 这里同时承担三类过滤：
     * 1. 设备侧过滤：堆垛机故障或不存在时直接跳过。
     * 2. 路径侧过滤：当前源站到该堆垛机目标站无路径时跳过。
     * 3. 库位侧过滤：无空库位或库位规格不匹配时跳过。
     *
     * 对空托盘来说，candidateCrnNos 由 run2 的轮询顺序生成，因此天然具备“均分到每个堆垛机”的效果。
     */
    private LocMast findRun2EmptyLocByCrnNos(RowLastno rowLastno, RowLastnoType rowLastnoType, List<Integer> candidateCrnNos,
                                             LocTypeDto locTypeDto, Integer staDescId, Integer sourceStaNo, StartupDto startupDto,
                                             Integer preferredArea, String stage) {
        return findRun2EmptyLocByCrnNos(rowLastno, rowLastnoType, candidateCrnNos, locTypeDto,
                staDescId, sourceStaNo, startupDto, preferredArea, stage, true);
    }

    private LocMast findRun2EmptyLocByCrnNos(RowLastno rowLastno, RowLastnoType rowLastnoType, List<Integer> candidateCrnNos,
                                             LocTypeDto locTypeDto, Integer staDescId, Integer sourceStaNo, StartupDto startupDto,
                                             Integer preferredArea, String stage, boolean routeRequired) {
        if (Cools.isEmpty(candidateCrnNos)) {
            log.warn("run2 skip empty candidate list. stage={}, sourceStaNo={}, preferredArea={}, spec={}",
                    stage, sourceStaNo, preferredArea, JSON.toJSONString(locTypeDto));
@@ -570,16 +919,15 @@
                continue;
            }
            Integer targetStaNo = resolveTargetStaNo(rowLastno, staDescId, sourceStaNo, candidateCrnNo);
            if (Utils.BooleanWhsTypeSta(rowLastno, staDescId) && targetStaNo == null) {
            if (routeRequired && Utils.BooleanWhsTypeSta(rowLastno, staDescId) && targetStaNo == null) {
                routeBlockedCrns.add(candidateCrnNo);
                continue;
            }
            Wrapper<LocMast> openWrapper = new EntityWrapper<LocMast>()
                    .eq("crn_no", candidateCrnNo)
                    .eq("loc_sts", "O")
                    .eq("loc_type1", locTypeDto.getLocType1())
                    .orderBy("lev1")
                    .orderBy("bay1");
                    .eq("loc_sts", "O");
            applyLocTypeFilters(openWrapper, locTypeDto, true);
            openWrapper.orderBy("lev1").orderBy("bay1");
            LocMast anyOpenLoc = locMastService.selectOne(openWrapper);
            if (Cools.isEmpty(anyOpenLoc)) {
                noEmptyCrns.add(candidateCrnNo);
@@ -587,13 +935,9 @@
            }
            Wrapper<LocMast> wrapper = new EntityWrapper<LocMast>()
                    .eq("crn_no", candidateCrnNo)
                    .eq("loc_sts", "O")
                    .eq("loc_type1", locTypeDto.getLocType1())
                    .orderBy("lev1")
                    .orderBy("bay1");
            if (locTypeDto != null && locTypeDto.getLocType1() != null) {
                wrapper.eq("loc_type1", locTypeDto.getLocType1());
            }
                    .eq("loc_sts", "O");
            applyLocTypeFilters(wrapper, locTypeDto, true);
            wrapper.orderBy("lev1").orderBy("bay1");
            LocMast candidateLoc = locMastService.selectOne(wrapper);
            if (Cools.isEmpty(candidateLoc) || (locTypeDto != null && !VersionUtils.locMoveCheckLocTypeComplete(candidateLoc, locTypeDto))) {
                locTypeBlockedCrns.add(candidateCrnNo);
@@ -716,6 +1060,7 @@
        if (candidateLocType1 != null) {
            wrapper.eq("loc_type1", candidateLocType1);
        }
        applyLocTypeFilters(wrapper, locTypeDto, false);
        // 单伸堆垛机按层、列递增顺序找第一个空库位。
        if (rowLastnoType != null && rowLastnoType.getType() != null && (rowLastnoType.getType() == 1 || rowLastnoType.getType() == 2)) {
            wrapper.orderBy("lev1", true).orderBy("bay1", true);
@@ -859,11 +1204,8 @@
        }
        Wrapper<LocMast> wrapper = new EntityWrapper<LocMast>()
                .in("row1", searchRows)
                .eq("loc_sts", "O")
                .eq("whs_type", rowLastnoType.getType().longValue());
        if (locTypeDto != null && locTypeDto.getLocType1() != null) {
            wrapper.eq("loc_type1", locTypeDto.getLocType1());
        }
                .eq("loc_sts", "O");
        applyLocTypeFilters(wrapper, locTypeDto, true);
        return locMastService.selectCount(wrapper);
    }

@@ -1054,6 +1396,44 @@
        compatibleLocTypeDto.setLocType3(locTypeDto.getLocType3());
        compatibleLocTypeDto.setSiteId(locTypeDto.getSiteId());
        return compatibleLocTypeDto;
    }

    /**
     * 空托盘兼容回退规则：
     * 当首轮 loc_type2=1 没有命中空库位时，允许退化到高位空库位 loc_type1=2。
     *
     * 注意这里不会继续保留 locType2=1。
     * 也就是说第二轮是“高位优先兜底”，而不是“高位窄库位兜底”。
     * 这是按照现场最新口径实现的：窄库位优先，窄库位没有时再找高位空库位。
     */
    private LocTypeDto buildEmptyPalletCompatibleLocTypeDto(LocTypeDto locTypeDto) {
        if (locTypeDto == null || locTypeDto.getLocType2() == null || locTypeDto.getLocType2() != 1) {
            return null;
        }
        LocTypeDto compatibleLocTypeDto = new LocTypeDto();
        compatibleLocTypeDto.setLocType1((short) 2);
        compatibleLocTypeDto.setLocType3(locTypeDto.getLocType3());
        compatibleLocTypeDto.setSiteId(locTypeDto.getSiteId());
        return compatibleLocTypeDto;
    }

    /**
     * 统一封装找库位失败后的兼容重试顺序。
     *
     * 空托盘：
     * 先按 loc_type2=1 查找，失败后退到 loc_type1=2。
     *
     * 非空托盘：
     * 维持原规则，低位失败后再向高位兼容。
     */
    private LocTypeDto buildRetryCompatibleLocTypeDto(Integer staDescId, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto) {
        if (isEmptyPalletRequest(staDescId, findLocNoAttributeVo)) {
            LocTypeDto emptyPalletCompatibleLocTypeDto = buildEmptyPalletCompatibleLocTypeDto(locTypeDto);
            if (emptyPalletCompatibleLocTypeDto != null) {
                return emptyPalletCompatibleLocTypeDto;
            }
        }
        return buildUpwardCompatibleLocTypeDto(locTypeDto);
    }


@@ -1261,9 +1641,9 @@
                times = times + 1;
                return getLocNoRun(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, locTypeDto, times);
            }
            LocTypeDto compatibleLocTypeDto = buildUpwardCompatibleLocTypeDto(locTypeDto);
            LocTypeDto compatibleLocTypeDto = buildRetryCompatibleLocTypeDto(staDescId, findLocNoAttributeVo, locTypeDto);
            if (compatibleLocTypeDto != null) {
                log.warn("locType1 upward compatibility retry. source={}, target={}", JSON.toJSONString(locTypeDto), JSON.toJSONString(compatibleLocTypeDto));
                log.warn("locType compatibility retry. source={}, target={}", JSON.toJSONString(locTypeDto), JSON.toJSONString(compatibleLocTypeDto));
                return getLocNoRun(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, compatibleLocTypeDto, 0);
            }
            log.error("No empty location found. spec={}, times={}", JSON.toJSONString(locTypeDto), times);
@@ -1285,6 +1665,14 @@
        return getLocNoRun2(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, locTypeDto, null, times);
    }

    /**
     * run2 入库找位主流程。
     *
     * 当前方法只保留“组织流程”和“统一收口”的职责，具体策略拆成独立方法：
     * 1. 普通物料：推荐排优先 -> 站点优先库区/堆垛机 -> 其它库区。
     * 2. 空托盘：优先库区 loc_type2=1 -> 其它库区 loc_type2=1 -> loc_type1=2 兼容。
     * 3. 命中库位后分别回写普通物料游标或空托盘库区游标。
     */
    public StartupDto getLocNoRun2(Integer whsType, Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, Integer moveCrnNo, LocTypeDto locTypeDto, List<Integer> recommendRows, int times) {

        int crnNo = 0;
@@ -1309,36 +1697,26 @@
        curRow = rowLastno.getCurrentRow();
        crnNo = resolveRun2CrnNo(rowLastno);
        Integer preferredArea = findLocNoAttributeVo.getOutArea();
        boolean emptyPalletRequest = isEmptyPalletRequest(staDescId, findLocNoAttributeVo);
        Run2AreaSearchResult emptyPalletAreaSearchResult = null;

        List<Integer> orderedCrnNos = getOrderedCrnNos(rowLastno, crnNo);
        List<Integer> triedCrnNos = new ArrayList<>();
        List<Integer> recommendCrnNos = mapRowsToCrnNos(rowLastno, recommendRows);
        if (!Cools.isEmpty(recommendCrnNos)) {
            locMast = findRun2EmptyLocByCrnNos(rowLastno, rowLastnoType, recommendCrnNos, locTypeDto, staDescId, sourceStaNo, startupDto, preferredArea, "recommend");
            triedCrnNos.addAll(recommendCrnNos);
        }
        locMast = findRun2RecommendLoc(rowLastno, rowLastnoType, emptyPalletRequest, recommendRows, locTypeDto,
                staDescId, sourceStaNo, startupDto, preferredArea, triedCrnNos);
        if (Cools.isEmpty(locMast)) {
            List<Map<String, Integer>> stationCrnLocTypes = Utils.getStationStorageAreaName(
                    sourceStaNo,
                    locTypeDto == null || locTypeDto.getLocType1() == null ? null : locTypeDto.getLocType1().intValue(),
                    findLocNoAttributeVo == null ? null : findLocNoAttributeVo.getMatnr());
            if (!Cools.isEmpty(stationCrnLocTypes)) {
                locMast = findRun2EmptyLocByCrnLocTypeEntries(rowLastno, rowLastnoType, stationCrnLocTypes,
                        locTypeDto, staDescId, sourceStaNo, startupDto, preferredArea, "station-priority");
            } else if (preferredArea == null) {
                List<Integer> defaultCrnNos = new ArrayList<>(orderedCrnNos);
                defaultCrnNos.removeAll(triedCrnNos);
                locMast = findRun2EmptyLocByCrnNos(rowLastno, rowLastnoType, defaultCrnNos, locTypeDto, staDescId, sourceStaNo, startupDto, preferredArea, "default");
            } else {
                List<Integer> preferredCrnNos = filterCrnNosByRows(rowLastno, orderedCrnNos, getRun2AreaRows(preferredArea, rowLastno));
                preferredCrnNos.removeAll(triedCrnNos);
                locMast = findRun2EmptyLocByCrnNos(rowLastno, rowLastnoType, preferredCrnNos, locTypeDto, staDescId, sourceStaNo, startupDto, preferredArea, "preferred-area");
                if (Cools.isEmpty(locMast)) {
                    List<Integer> fallbackCrnNos = filterCrnNosByRows(rowLastno, orderedCrnNos, getRun2FallbackRows(rowLastno));
                    fallbackCrnNos.removeAll(triedCrnNos);
                    fallbackCrnNos.removeAll(preferredCrnNos);
                    locMast = findRun2EmptyLocByCrnNos(rowLastno, rowLastnoType, fallbackCrnNos, locTypeDto, staDescId, sourceStaNo, startupDto, preferredArea, "fallback-area");
            if (emptyPalletRequest) {
                // 空托盘单独按库区轮询：
                // 1. 当前库区先找 loc_type2=1
                // 2. 当前库区没有，再找其他库区 loc_type2=1
                // 3. 全部 narrow 都没有时，再退到 loc_type1=2
                emptyPalletAreaSearchResult = findEmptyPalletRun2AreaLoc(rowLastno, staDescId, sourceStaNo, startupDto, preferredArea, locTypeDto);
                if (!Cools.isEmpty(emptyPalletAreaSearchResult)) {
                    locMast = emptyPalletAreaSearchResult.locMast;
                }
            } else {
                locMast = findNormalRun2Loc(rowLastno, rowLastnoType, sourceStaNo, staDescId, findLocNoAttributeVo,
                        locTypeDto, startupDto, preferredArea, orderedCrnNos, triedCrnNos);
            }
        }

@@ -1346,21 +1724,21 @@
            crnNo = locMast.getCrnNo();
            nearRow = locMast.getRow1();
        }
        if (curRow == 0) {
            curRow = rowLastno.getsRow() == null ? 1 : rowLastno.getsRow();
        if (emptyPalletRequest) {
            advanceEmptyPalletRun2Cursor(emptyPalletAreaSearchResult, locMast);
        } else {
            advanceNormalRun2Cursor(rowLastno, curRow);
        }
        curRow = getNextRun2CurrentRow(rowLastno, curRow);
        rowLastno.setCurrentRow(curRow);
        rowLastnoService.updateById(rowLastno);

        if (Cools.isEmpty(locMast) || !locMast.getLocSts().equals("O")) {
            if (times < rowCount * 2) {
            if (!emptyPalletRequest && times < rowCount * 2) {
                times = times + 1;
                return getLocNoRun2(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, locTypeDto, recommendRows, times);
            }
            LocTypeDto compatibleLocTypeDto = buildUpwardCompatibleLocTypeDto(locTypeDto);
            LocTypeDto compatibleLocTypeDto = buildRetryCompatibleLocTypeDto(staDescId, findLocNoAttributeVo, locTypeDto);
            if (compatibleLocTypeDto != null) {
                log.warn("locType1 upward compatibility retry. source={}, target={}", JSON.toJSONString(locTypeDto), JSON.toJSONString(compatibleLocTypeDto));
                // 第一轮全部堆垛机都没找到时，再进入规格兼容重试，不在单个堆垛机内局部退化。
                log.warn("locType compatibility retry. source={}, target={}", JSON.toJSONString(locTypeDto), JSON.toJSONString(compatibleLocTypeDto));
                return getLocNoRun2(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, compatibleLocTypeDto, recommendRows, 0);
            }
            log.error("No empty location found. spec={}, times={}, preferredArea={}, nearRow={}", JSON.toJSONString(locTypeDto), times, preferredArea, nearRow);
@@ -1821,9 +2199,9 @@
                times = times + 1;
                return getLocNoRun4(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, locTypeDto, times);
            }
            LocTypeDto compatibleLocTypeDto = buildUpwardCompatibleLocTypeDto(locTypeDto);
            LocTypeDto compatibleLocTypeDto = buildRetryCompatibleLocTypeDto(staDescId, findLocNoAttributeVo, locTypeDto);
            if (compatibleLocTypeDto != null) {
                log.warn("locType1 upward compatibility retry. source={}, target={}", JSON.toJSONString(locTypeDto), JSON.toJSONString(compatibleLocTypeDto));
                log.warn("locType compatibility retry. source={}, target={}", JSON.toJSONString(locTypeDto), JSON.toJSONString(compatibleLocTypeDto));
                return getLocNoRun4(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, compatibleLocTypeDto, 0);
            }
            log.error("No empty location found. spec={}, times={}", JSON.toJSONString(locTypeDto), times);
@@ -1968,9 +2346,9 @@
                times = times + 1;
                return getLocNoRun5(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, locTypeDto, recommendRows, times);
            }
            LocTypeDto compatibleLocTypeDto = buildUpwardCompatibleLocTypeDto(locTypeDto);
            LocTypeDto compatibleLocTypeDto = buildRetryCompatibleLocTypeDto(staDescId, findLocNoAttributeVo, locTypeDto);
            if (compatibleLocTypeDto != null) {
                log.warn("locType1 upward compatibility retry. source={}, target={}", JSON.toJSONString(locTypeDto), JSON.toJSONString(compatibleLocTypeDto));
                log.warn("locType compatibility retry. source={}, target={}", JSON.toJSONString(locTypeDto), JSON.toJSONString(compatibleLocTypeDto));
                return getLocNoRun5(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, compatibleLocTypeDto, recommendRows, 0);
            }
            log.error("No empty location found. spec={}, times={}", JSON.toJSONString(locTypeDto), times);

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

@@ -158,8 +158,10 @@
        StartupDto dto = null;
        switch (param.getIoType()) {
            case 1://满托盘入库
                dto = startupFullPutStoreAgv(param.getSourceStaNo(), param.getBarcode(), locTypeDto, param.getOutArea(), 1);
                break;
            case 10://空托盘入库
                dto = startupFullPutStoreAgv(param.getSourceStaNo(), param.getBarcode(), locTypeDto, param.getOutArea());
                dto = startupFullPutStoreAgv(param.getSourceStaNo(), param.getBarcode(), locTypeDto, param.getOutArea(), 10);
                break;
//                dto = emptyPlateIn(param.getSourceStaNo(), locTypeDto, param.getBarcode());
//                break;
@@ -396,14 +398,14 @@
     * 全板入库AGV
     */
    @Transactional
    public StartupDto startupFullPutStoreAgv(Integer devpNo, String barcode, LocTypeDto locTypeDto, Integer outArea) {
    public StartupDto startupFullPutStoreAgv(Integer devpNo, String barcode, LocTypeDto locTypeDto, Integer outArea, Integer staDescId) {
        // 源站点状态检测
//        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();
        findLocNoAttributeVo.setOutArea(outArea);
//        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo(waitPakins.get(0));
        StartupDto dto = commonService.getLocNo(1, devpNo, findLocNoAttributeVo, locTypeDto);
        StartupDto dto = commonService.getLocNo(staDescId, devpNo, findLocNoAttributeVo, locTypeDto);
        // 更新目标库位状态
        Date now = new Date();
        if (dto == null) {