erp下发停止出库任务，wms取消wcs任务

zwl

昨天 1b31d14e361c01fcd4e5c2dcfe0b6fb3a63c92fc

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

@@ -374,77 +374,135 @@
    @Override
    @Transactional
    public R pakoutOrderPause(OpenOrderPakoutPauseParam param) {
        if (param == null || Cools.isEmpty(param.getOrderNo())) {
            throw new CoolException("orderNo is empty");
        if (param == null || Cools.isEmpty(param.getOrderId())) {
            throw new CoolException("orderNo不能为空");
        }
        Order order = orderService.selectByNo(param.getOrderNo());
        if (order == null) {
            order = OrderInAndOutUtil.selectByNo(Boolean.FALSE, param.getOrderNo());
        }
        if (order == null) {
            throw new CoolException("order not found: " + param.getOrderNo());
        if (param.getReason() == null) {
            throw new CoolException("reason不能为空");
        }

        List<WrkMast> activeTasks = findActiveOutboundTasks(param.getOrderNo());
        if (activeTasks.isEmpty()) {
            return R.ok("no active out tasks");
        }

        Date now = new Date();
        int pausedCount = 0;
        List<WrkMast> issuedTasks = new ArrayList<>();
        for (WrkMast wrkMast : activeTasks) {
            if (wrkMast == null || "Y".equalsIgnoreCase(wrkMast.getPauseMk())) {
                continue;
        List<WrkMast> activeTasks = findActiveOutboundTasks(param.getOrderId());
        if (Objects.equals(param.getReason(), 1)) {
            // ERP确认立即执行，仅处理待下发的出库任务。
            List<WrkMast> pendingTasks = activeTasks.stream()
                    .filter(wrkMast -> wrkMast != null && Objects.equals(wrkMast.getWrkSts(), 11L))
                    .collect(Collectors.toList());
            Map<String, Object> result = new HashMap<>();
            result.put("orderNo", param.getOrderId());
            result.put("taskCount", pendingTasks.size());
            if (pendingTasks.isEmpty()) {
                result.put("confirmedCount", 0);
                return R.ok("无有效出库任务").add(result);
            }
            wrkMast.setPauseMk("Y");
            wrkMast.setUpdMk(needNotifyWcsStop(wrkMast) ? "WCS_STOP_REQUESTED" : "WMS_PAUSED");
            wrkMast.setManuType("ERP_PAUSE");
            wrkMast.setModiTime(now);
            wrkMast.setModiUser(9527L);
            if (!wrkMastService.updateById(wrkMast)) {
                throw new CoolException("pause out task failed: " + wrkMast.getWrkNo());

            Date now = new Date();
            int confirmedCount = 0;
            for (WrkMast wrkMast : pendingTasks) {
                if (wrkMast == null || "Y".equalsIgnoreCase(wrkMast.getPdcType())) {
                    continue;
                }
                wrkMast.setPdcType("Y");
//            wrkMast.setUpdMk("ERP_CONFIRMED");
//            wrkMast.setManuType("ERP_CONFIRM_OUT");
                wrkMast.setModiTime(now);
                wrkMast.setModiUser(9527L);
                if (!wrkMastService.updateById(wrkMast)) {
                    throw new CoolException("确认执行出库任务失败: " + wrkMast.getWrkNo());
                }
                confirmedCount++;
            }
            pausedCount++;
            if (needNotifyWcsStop(wrkMast)) {
                issuedTasks.add(wrkMast);

            result.put("confirmedCount", confirmedCount);
            return R.ok(confirmedCount == 0 ? "任务已确认执行" : "ERP确认执行出库成功").add(result);
        }
        if (Objects.equals(param.getReason(), 2)) {
            // ERP请求取消任务：未下发任务直接本地取消，已下发任务交给WCS判定可取消清单。
            Map<String, Object> result = new HashMap<>();
            result.put("orderNo", param.getOrderId());
            result.put("reason", param.getReason());
            result.put("taskCount", activeTasks.size());
            if (activeTasks.isEmpty()) {
                result.put("successList", Collections.emptyList());
                result.put("failList", Collections.emptyList());
                result.put("cancelledCount", 0);
                return R.ok("无有效出库任务").add(result);
            }
        }

        if (pausedCount == 0) {
            return R.ok("tasks already paused");
        }
            Map<String, WrkMast> taskIndex = activeTasks.stream()
                    .filter(wrkMast -> wrkMast != null && wrkMast.getWrkNo() != null)
                    .collect(Collectors.toMap(
                            wrkMast -> String.valueOf(wrkMast.getWrkNo()),
                            wrkMast -> wrkMast,
                            (left, right) -> left,
                            LinkedHashMap::new
                    ));
            List<WrkMast> directCancelTasks = activeTasks.stream()
                    .filter(wrkMast -> wrkMast != null && !needNotifyWcsStop(wrkMast))
                    .collect(Collectors.toList());
            List<WrkMast> wcsCancelTasks = activeTasks.stream()
                    .filter(this::needNotifyWcsStop)
                    .collect(Collectors.toList());

        if (!issuedTasks.isEmpty()) {
            wcsApiService.pauseOutTasks(buildStopOutTaskParams(param, issuedTasks));
        }
            LinkedHashSet<String> successTaskNos = new LinkedHashSet<>();
            LinkedHashSet<String> failTaskNos = new LinkedHashSet<>();
            cancelOutboundTasks(directCancelTasks.stream()
                    .map(WrkMast::getWrkNo)
                    .filter(Objects::nonNull)
                    .map(String::valueOf)
                    .collect(Collectors.toList()), taskIndex, successTaskNos);

        Map<String, Object> result = new HashMap<>();
        result.put("orderNo", param.getOrderNo());
        result.put("pausedCount", pausedCount);
        result.put("wcsStopCount", issuedTasks.size());
        return R.ok("pause out success").add(result);
            List<String> wcsSuccessList = Collections.emptyList();
            List<String> wcsFailList = Collections.emptyList();
            if (!wcsCancelTasks.isEmpty()) {
                R wcsResult = wcsApiService.pauseOutTasks(buildStopOutTaskParams(param, wcsCancelTasks));
                wcsSuccessList = extractTaskNoList(wcsResult, "successList");
                wcsFailList = extractTaskNoList(wcsResult, "failList");
                cancelOutboundTasks(wcsSuccessList, taskIndex, successTaskNos);

                LinkedHashSet<String> wcsFailTaskNos = new LinkedHashSet<>(wcsFailList);
                if (wcsFailTaskNos.isEmpty()) {
                    for (WrkMast wrkMast : wcsCancelTasks) {
                        String taskNo = String.valueOf(wrkMast.getWrkNo());
                        if (!successTaskNos.contains(taskNo)) {
                            wcsFailTaskNos.add(taskNo);
                        }
                    }
                }
                failTaskNos.addAll(wcsFailTaskNos);
                wcsFailList = new ArrayList<>(wcsFailTaskNos);
            }

            result.put("wcsTaskCount", wcsCancelTasks.size());
            result.put("wcsSuccessList", wcsSuccessList);
            result.put("wcsFailList", wcsFailList);
            result.put("successList", new ArrayList<>(successTaskNos));
            result.put("failList", new ArrayList<>(failTaskNos));
            result.put("cancelledCount", successTaskNos.size());
            result.put("failCount", failTaskNos.size());
            return R.ok(successTaskNos.isEmpty() ? "没有可取消任务" : "取消出库任务成功").add(result);
        }
        throw new CoolException("reason仅支持1或2");
    }

    @Override
    @Transactional
    public R pakoutOrderExecute(OpenOrderPakoutExecuteParam param) {
        if (param == null || Cools.isEmpty(param.getOrderId())) {
            throw new CoolException("orderId is empty");
            throw new CoolException("orderId不能为空");
        }
        if (param.getExecute() == null) {
            throw new CoolException("execute is empty");
            throw new CoolException("execute不能为空");
        }
        if (Objects.equals(param.getExecute(), 1)) {
            return createPakoutTasks(param.getOrderId());
        }
        if (Objects.equals(param.getExecute(), 2)) {
            OpenOrderPakoutPauseParam pauseParam = new OpenOrderPakoutPauseParam();
            pauseParam.setOrderNo(param.getOrderId());
            pauseParam.setReason("OPEN_API_PAUSE");
            pauseParam.setOrderId(param.getOrderId());
            pauseParam.setReason(2);
            return pakoutOrderPause(pauseParam);
        }
        throw new CoolException("execute only supports 1 or 2");
        throw new CoolException("execute仅支持1或2");
    }

    private List<WrkMast> findActiveOutboundTasks(String orderNo) {
@@ -461,8 +519,8 @@
        }
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                .in("wrk_no", wrkNos)
                .in("io_type", Arrays.asList(101, 103, 107, 108, 110))
                .lt("wrk_sts", 14L));
                .in("io_type", Arrays.asList(101, 103, 104, 107, 108, 110))
                .in("wrk_sts", Arrays.asList(11L, 12L, 13L)));
        if (wrkMasts == null || wrkMasts.isEmpty()) {
            return Collections.emptyList();
        }
@@ -582,18 +640,57 @@

    private StopOutTaskParams buildStopOutTaskParams(OpenOrderPakoutPauseParam param, List<WrkMast> wrkMasts) {
        StopOutTaskParams stopParams = new StopOutTaskParams();
        stopParams.setOrderNo(param.getOrderNo());
        stopParams.setReason(param.getReason());
        // WCS取消接口仅接收 taskList.taskNo。
        for (WrkMast wrkMast : wrkMasts) {
            StopOutTaskParams.TaskItem item = new StopOutTaskParams.TaskItem();
            item.setTaskNo(String.valueOf(wrkMast.getWrkNo()));
            if (wrkMast.getStaNo() != null) {
                item.setStaNo(String.valueOf(wrkMast.getStaNo()));
            }
            item.setLocNo(wrkMast.getSourceLocNo());
            stopParams.getTasks().add(item);
        }
        return stopParams;
    }

    private List<String> extractTaskNoList(R result, String key) {
        if (result == null) {
            return Collections.emptyList();
        }
        List<String> taskNos = toTaskNoList(result.get(key));
        if (!taskNos.isEmpty()) {
            return taskNos;
        }
        Object data = result.get("data");
        if (data instanceof Map) {
            return toTaskNoList(((Map<?, ?>) data).get(key));
        }
        if (data instanceof JSONObject) {
            return toTaskNoList(((JSONObject) data).get(key));
        }
        return Collections.emptyList();
    }

    private List<String> toTaskNoList(Object value) {
        if (value == null) {
            return Collections.emptyList();
        }
        if (value instanceof Collection) {
            List<String> taskNos = new ArrayList<>();
            for (Object item : (Collection<?>) value) {
                if (item != null) {
                    taskNos.add(String.valueOf(item));
                }
            }
            return taskNos;
        }
        return JSON.parseArray(JSON.toJSONString(value), String.class);
    }

    private void cancelOutboundTasks(List<String> taskNos, Map<String, WrkMast> taskIndex, Set<String> successTaskNos) {
        for (String taskNo : taskNos) {
            if (Cools.isEmpty(taskNo) || successTaskNos.contains(taskNo) || !taskIndex.containsKey(taskNo)) {
                continue;
            }
            workService.cancelWrkMast(taskNo, 9527L);
            successTaskNos.add(taskNo);
        }
    }

    @Override
@@ -1276,7 +1373,7 @@

            if (param.getFull() == 1) {
                //满托盘
                mat = matService.selectByMatnr(param.getMatnr());
                mat = matService.selectByMatnr("emptyPallet");
            } else if (param.getFull() == 0) {
                //空托盘
                mat = matService.selectByMatnr("emptyPallet");
@@ -1285,6 +1382,7 @@

        WaitPakin waitPakin = new WaitPakin();
        waitPakin.sync(mat);
//        waitPakin.setMatnr(param.getMatnr());
        waitPakin.setBatch(String.valueOf(param.getBatchId()));
        waitPakin.setZpallet(param.getPalletId());   // 托盘码

@@ -1335,6 +1433,7 @@
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("N");
        wrkMast.setPdcType("N");
        wrkMast.setUserNo(param.getOrderId());//订单号
        wrkMast.setPltType(param.getSeq());//出库顺序，从1开始
        wrkMast.setTakeNone("0");  //0非自动