1.针对7.3接口文档，新增了几个字段需要加入到组托档中，不额外加字段 2.针对7.11接口文档，对outOrder方法进行重写，batchSeq在w...

zwl

1 天以前 1443d5a84a4df99d9a86ac04c904554e91ae8271

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

@@ -45,6 +45,10 @@
    private static final Long WCS_SYNC_USER = 9999L;
    private static final String YES = "Y";
    private static final String NO = "N";
    private static final long OUT_LOCK_REPORT_PENDING_WRK_STS = 13L;
    private static final long OUT_LOCK_REPORT_SUCCESS_WRK_STS = 21L;
    private static final long OUT_LOCK_REPORT_FAIL_WRK_STS = 22L;
    private static final String OUT_LOCK_REPORT_PENDING_FLAG = "P";

    /** 同一 WCS 路径、同一单号下一组下发的任务条数上限 */
    private static final int WCS_PUB_BATCH_SIZE = 20;
@@ -302,7 +306,7 @@
    }

    /**
     * 出库：仅当单号、序号均有效时做跳号校验；单号空或序号无效仍下发。入库/移库不处理。
     * 出库：仅当单号、批次、序号均有效时做批次内跳号校验；无效时仍下发。入库/移库不处理。
     */
    private List<WorkTaskParams> filterOutboundByContiguousPlt(List<WorkTaskParams> accepted, Map<String, WrkMast> wrkMastMap, List<String> skipMsgs) {
        Map<String, Integer> reachCache = new HashMap<>();
@@ -314,12 +318,14 @@
            }
            WrkMast w = wrkMastMap.get(p.getTaskNo());
            String userNo = sortUserNoForPub(p, w);
            String batchGroup = sortBatchGroupForPub(p, w);
            Integer plt = sortPltForPub(p, w);
            if (Cools.isEmpty(userNo) || plt == null || plt <= 0) {
                kept.add(p);
                continue;
            }
            int maxReach = reachCache.computeIfAbsent(userNo, wrkMastService::outboundSeqMaxContiguousPlt);
            String cacheKey = buildOutboundBatchCacheKey(userNo, batchGroup);
            int maxReach = reachCache.computeIfAbsent(cacheKey, key -> wrkMastService.outboundSeqMaxContiguousPlt(userNo, batchGroup));
            if (plt > maxReach) {
                skipMsgs.add(buildTaskMsg(p, "出库序号跳号，跳过"));
                continue;
@@ -363,7 +369,7 @@
    }

    /**
     * 同单下一组：优先 WCS queryTask；失败或无数据则主表已非 11 或已进历史表。
     * 同单同批下一组：优先 WCS queryTask；失败或无数据则主表已非 11 或已进历史表。
     */
    private boolean sameOrderNextChunkAllowed(List<WorkTaskParams> lastSentChunk) {
        if (lastSentChunk == null || lastSentChunk.isEmpty()) {
@@ -426,7 +432,7 @@
    }

    /**
     * 出库每组下发前：本组有有效最小序号且&gt;1 时，只校验「最小序号-1」一档；序号全无则跳过本条件。
     * 出库每组下发前：本组有有效最小序号且&gt;1 时，只校验「同单同批的最小序号-1」一档；序号全无则跳过本条件。
     */
    private boolean outboundChunkPredecessorPltReady(List<WorkTaskParams> chunk, Map<String, WrkMast> wrkMastMap) {
        if (chunk == null || chunk.isEmpty()) {
@@ -438,6 +444,7 @@
        }
        WrkMast headMast = wrkMastMap.get(head.getTaskNo());
        String userNo = sortUserNoForPub(head, headMast);
        String batchGroup = sortBatchGroupForPub(head, headMast);
        if (Cools.isEmpty(userNo)) {
            return true;
        }
@@ -454,14 +461,20 @@
        if (minPlt == Integer.MAX_VALUE || minPlt <= 1) {
            return true;
        }
        return outboundPltSlotReleasedInWms(userNo, minPlt - 1);
        return outboundPltSlotReleasedInWms(userNo, batchGroup, minPlt - 1);
    }

    private boolean outboundPltSlotReleasedInWms(String userNo, int pltType) {
        List<WrkMast> rows = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                .eq("user_no", userNo)
                .eq("io_type", 101)
                .eq("plt_type", pltType));
    private boolean outboundPltSlotReleasedInWms(String userNo, String batchSeq, int pltType) {
        EntityWrapper<WrkMast> mastWrapper = new EntityWrapper<>();
        mastWrapper.eq("user_no", userNo);
        mastWrapper.eq("io_type", 101);
        mastWrapper.eq("plt_type", pltType);
        if (batchSeq == null) {
            mastWrapper.isNull("batch_seq");
        } else {
            mastWrapper.eq("batch_seq", batchSeq);
        }
        List<WrkMast> rows = wrkMastService.selectList(mastWrapper);
        if (rows != null && !rows.isEmpty()) {
            for (WrkMast m : rows) {
                if (m != null && m.getWrkSts() != null && Objects.equals(m.getWrkSts(), 11L)) {
@@ -470,10 +483,16 @@
            }
            return true;
        }
        int logCnt = wrkMastLogService.selectCount(new EntityWrapper<WrkMastLog>()
                .eq("user_no", userNo)
                .eq("io_type", 101)
                .eq("plt_type", pltType));
        EntityWrapper<WrkMastLog> logWrapper = new EntityWrapper<>();
        logWrapper.eq("user_no", userNo);
        logWrapper.eq("io_type", 101);
        logWrapper.eq("plt_type", pltType);
        if (batchSeq == null) {
            logWrapper.isNull("batch_seq");
        } else {
            logWrapper.eq("batch_seq", batchSeq);
        }
        int logCnt = wrkMastLogService.selectCount(logWrapper);
        return logCnt > 0;
    }

@@ -502,6 +521,7 @@
        return Comparator
                .comparing((WorkTaskParams p) -> Optional.ofNullable(p.getType()).orElse(""), String.CASE_INSENSITIVE_ORDER)
                .thenComparing(p -> sortUserNoForPub(p, wrkMastMap.get(p.getTaskNo())), Comparator.nullsLast(String::compareTo))
                .thenComparing(p -> sortBatchGroupForPub(p, wrkMastMap.get(p.getTaskNo())), Comparator.nullsLast(String::compareTo))
                .thenComparing(p -> sortPltForPub(p, wrkMastMap.get(p.getTaskNo())), Comparator.nullsLast(Integer::compareTo));
    }

@@ -518,6 +538,19 @@
            return wrkMast.getPltType();
        }
        return p.getBatchSeq();
    }

    private static String sortBatchGroupForPub(WorkTaskParams p, WrkMast wrkMast) {
        if (wrkMast != null) {
            return wrkMast.getBatchSeq();
        }
        return null;
    }

    private static String buildOutboundBatchCacheKey(String userNo, String batchSeq) {
        String safeUserNo = Cools.isEmpty(userNo) ? "_NO_USER_" : userNo;
        String safeBatchSeq = Cools.isEmpty(batchSeq) ? "_NO_BATCH_" : batchSeq;
        return safeUserNo + "#" + safeBatchSeq;
    }

    /**
@@ -544,13 +577,26 @@
        }


        if (params.getNotifyType().equals("task")) {
        if (isOutboundCrnTaskRun(params)) {
            // WCS出库任务开始：堆垛机开始执行出库任务，工作状态 12 -> 13。
            if (isOutboundTask(mast) && Objects.equals(mast.getWrkSts(), 12L)) {
                mast.setWrkSts(OUT_LOCK_REPORT_PENDING_WRK_STS);
                mast.setExpTime(0D);
                mast.setLogMk(OUT_LOCK_REPORT_PENDING_FLAG);
                mast.setLogErrMemo(null);
                mast.setLogErrTime(null);
                mast.setModiTime(new Date());
                if (!wrkMastService.updateById(mast)) {
                    throw new CoolException("任务状态修改失败！！");
                }
            }
        } else if (params.getNotifyType().equals("task")) {
            //任务
            if (params.getMsgType().equals("task_complete")) {

                if (mast.getIoType() == 1 || mast.getIoType() == 2 ||mast.getIoType() == 10) {
                    mast.setWrkSts(4L);
                } else if ((mast.getIoType() == 101||mast.getIoType()==110) && mast.getWrkSts()<14) {
                } else if (isOutboundTask(mast) && canMarkOutboundTaskComplete(mast)) {
                    mast.setWrkSts(14L);
                    if(Cools.isEmpty(mast.getStaNo())){
                        mast.setOveMk("Y");
@@ -581,6 +627,25 @@

        }
        return R.ok();
    }

    private boolean isOutboundCrnTaskRun(ReceviceTaskParams params) {
        return params != null
                && "Crn".equalsIgnoreCase(params.getNotifyType())
                && "crn_out_task_run".equalsIgnoreCase(params.getMsgType());
    }

    private boolean isOutboundTask(WrkMast mast) {
        return mast != null && mast.getIoType() != null && (mast.getIoType() == 101 || mast.getIoType() == 110);
    }

    private boolean canMarkOutboundTaskComplete(WrkMast mast) {
        if (mast == null || mast.getWrkSts() == null) {
            return false;
        }
        return mast.getWrkSts() < 14
                || mast.getWrkSts().equals(OUT_LOCK_REPORT_SUCCESS_WRK_STS)
                || mast.getWrkSts().equals(OUT_LOCK_REPORT_FAIL_WRK_STS);
    }

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

    /**
@@ -1048,10 +1115,12 @@
        if (!Cools.isEmpty(params.getStaNo())) {
            task.put("staNo", params.getStaNo());
        }
        if (!Cools.isEmpty(params.getBatch())) {
        boolean includeOutBatch = !"out".equalsIgnoreCase(params.getType())
                || (params.getBatchSeq() != null && params.getBatchSeq() > 0);
        if (includeOutBatch && !Cools.isEmpty(params.getBatch())) {
            task.put("batch", params.getBatch());
        }
        if (!Objects.isNull(params.getBatchSeq())) {
        if (includeOutBatch && !Objects.isNull(params.getBatchSeq())) {
            task.put("batchSeq", params.getBatchSeq());
        }
        return task;