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

zwl

昨天 5d480903c47b8966a086fc6c9bb26151f695570a

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

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

@@ -15,9 +15,11 @@

    private static final long serialVersionUID = 1L;

    @JSONField(serialize = false)
    @ApiModelProperty("order no")
    private String orderNo;

    @JSONField(serialize = false)
    @ApiModelProperty("pause reason")
    private Integer reason;


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

@@ -5,6 +5,8 @@
import com.zy.api.controller.params.StopOutTaskParams;
import com.zy.api.controller.params.WorkTaskParams;

import java.util.HashMap;
import java.util.List;
import java.util.Set;

public interface WcsApiService {
@@ -32,6 +34,6 @@
     * @param params
     * @return
     */
    R pauseOutTasks(StopOutTaskParams params);
    R pauseOutTasks(List<HashMap<String,Object>> params);

}

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

@@ -24,11 +24,7 @@
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@@ -211,8 +207,8 @@
        return ioType != null && (ioType == 101 || ioType == 103 || ioType == 104 || ioType == 107 || ioType == 110);
    }
    @Override
    public R pauseOutTasks(StopOutTaskParams params) {
        if (params == null || params.getTasks() == null || params.getTasks().isEmpty()) {
    public R pauseOutTasks(List<HashMap<String,Object>> params) {
        if (params == null || params.size() == 0) {
            return R.ok("无任务需要取消");
        }
        if (!Boolean.parseBoolean(String.valueOf(switchValue))) {
@@ -236,18 +232,7 @@
                String msg = jsonObject.getString("msg");
                throw new CoolException(Cools.isEmpty(msg) ? "WCS取消出库任务失败" : msg);
            }
            JSONObject data = jsonObject.getJSONObject("data");
            List<String> successList = data == null || data.getJSONArray("successList") == null
                    ? Collections.emptyList()
                    : data.getJSONArray("successList").toJavaList(String.class);
            List<String> failList = data == null || data.getJSONArray("failList") == null
                    ? Collections.emptyList()
                    : data.getJSONArray("failList").toJavaList(String.class);
            R result = R.ok(Cools.isEmpty(jsonObject.getString("msg")) ? "操作成功" : jsonObject.getString("msg"));
            result.put("data", data);
            result.put("successList", successList);
            result.put("failList", failList);
            return result;
            return R.ok(Cools.isEmpty(jsonObject.getString("msg")) ? "操作成功" : jsonObject.getString("msg"));
        } catch (IOException e) {
            throw new CoolException("调用WCS取消出库任务失败: " + e.getMessage());
        }

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

@@ -17,7 +17,6 @@
import com.zy.common.model.DetlDto;
import com.zy.common.model.LocDetlDto;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.utils.Synchro;
import com.zy.common.web.BaseController;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -425,7 +424,8 @@
     */
    @PostMapping("/comb/auth")
    public synchronized R comb(@RequestBody ArrayList<MesToCombParam> param){
        List<MesToCombReturnParam> errorComb = Lists.newArrayList();
        List<MesToCombParam> errorComb = Lists.newArrayList();
        List<MesToCombParam> validComb = Lists.newArrayList();
        for (MesToCombParam mesToCombParam : param) {
//            if (mesToCombParam.getPalletId().length() != 8) {
//                return R.error(mesToCombParam.getPalletId()+"-该托盘码不为8位");
@@ -438,18 +438,18 @@
            int countWrk = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet", mesToCombParam.getPalletId()));
//        int countwait = waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet",param.getPalletId()));
            if (countLoc > 0 || countWrk > 0) {
                MesToCombReturnParam mesToCombReturnParam = new MesToCombReturnParam();
                Synchro.Copy(mesToCombParam, mesToCombReturnParam);
                errorComb.add(mesToCombReturnParam);
                errorComb.add(mesToCombParam);
//                return R.error(mesToCombParam.getPalletId()+"-工作档/库存条码数据已存在");
                continue;
            }
            // 判断是否有相同条码的数据
            if (waitPakinService.selectCount(new EntityWrapper<WaitPakin>().
                    eq("zpallet", mesToCombParam.getPalletId()).eq("io_status", "N")) > 0) {
                waitPakinService.delete(new EntityWrapper<WaitPakin>().eq("zpallet", mesToCombParam.getPalletId()));
            }
            validComb.add(mesToCombParam);
        }
        for (MesToCombParam mesToCombParam : param) {
        for (MesToCombParam mesToCombParam : validComb) {
            openService.mesToComb(mesToCombParam);
        }
        // TODO:待测试
@@ -466,20 +466,19 @@

    @PostMapping("/outOrder")
    public synchronized R outOrder (@RequestBody ArrayList<OutTaskParam> params){
        List<OutTaskReturnParam> errorOutOrders = Lists.newArrayList();
        List<OutTaskParam> errorOutOrders = Lists.newArrayList();
        List<OutTaskParam> validOutOrders = Lists.newArrayList();
        for (OutTaskParam outTaskParam : params) {
            // TODO:待測試，校驗庫存信息，不存在則返回
            int countLoc = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet", outTaskParam.getPalletId()));
            if (countLoc == 0){
                OutTaskReturnParam outTaskReturnParam = new OutTaskReturnParam();
                Synchro.Copy(outTaskParam, outTaskReturnParam);
                errorOutOrders.add(outTaskReturnParam);

                params.remove(outTaskParam);
                errorOutOrders.add(outTaskParam);
                continue;
            }
            validOutOrders.add(outTaskParam);
        }

        for (OutTaskParam outTaskParam : params) {
        for (OutTaskParam outTaskParam : validOutOrders) {
            R r = openService.outOrder(outTaskParam);
            if (!r.get("code").equals(200)){
                return r;

 src/main/java/com/zy/asrs/entity/param/OpenOrderPakoutPauseParam.java

@@ -8,5 +8,5 @@
    private String orderId;

    //执行任务，1 出库；2 暂停；暂停指剩余未操作托盘不再执行出库；
    private Integer reason;
    private Integer execute;
}

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

@@ -377,12 +377,12 @@
        if (param == null || Cools.isEmpty(param.getOrderId())) {
            throw new CoolException("orderNo不能为空");
        }
        if (param.getReason() == null) {
        if (param.getExecute() == null) {
            throw new CoolException("reason不能为空");
        }

        List<WrkMast> activeTasks = findActiveOutboundTasks(param.getOrderId());
        if (Objects.equals(param.getReason(), 1)) {
        if (Objects.equals(param.getExecute(), 1)) {
            // ERP确认立即执行，仅处理待下发的出库任务。
            List<WrkMast> pendingTasks = activeTasks.stream()
                    .filter(wrkMast -> wrkMast != null && Objects.equals(wrkMast.getWrkSts(), 11L))
@@ -415,94 +415,30 @@
            result.put("confirmedCount", confirmedCount);
            return R.ok(confirmedCount == 0 ? "任务已确认执行" : "ERP确认执行出库成功").add(result);
        }
        if (Objects.equals(param.getReason(), 2)) {
            // ERP请求取消任务：未下发任务直接本地取消，已下发任务交给WCS判定可取消清单。
        if (Objects.equals(param.getExecute(), 2)) {
            // ERP请求取消任务：直接收集任务号，按 taskList 格式发送给 WCS。
            Map<String, Object> result = new HashMap<>();
            result.put("orderNo", param.getOrderId());
            result.put("reason", param.getReason());
            result.put("execute", param.getExecute());
            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);
            }

            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());

            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);

            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);
            List<HashMap<String,Object>> taskList = new ArrayList<>();
            for (WrkMast wrkMast : activeTasks) {
                HashMap<String,Object> hashMap = new HashMap<>();
                hashMap.put("taskNo", wrkMast.getWrkNo());
                taskList.add(hashMap);
                        }
                    }
                }
                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);
            wcsApiService.pauseOutTasks(taskList);
            return R.ok("取消任务已发送至WCS").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不能为空");
        }
        if (param.getExecute() == null) {
            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.setOrderId(param.getOrderId());
            pauseParam.setReason(2);
            return pakoutOrderPause(pauseParam);
        }
        throw new CoolException("execute仅支持1或2");
        return null;
    }

    private List<WrkMast> findActiveOutboundTasks(String orderNo) {
@@ -631,14 +567,7 @@
        return orderDetl.getMatnr() + "|batch=" + (orderDetl.getBatch() == null ? "" : orderDetl.getBatch()) + "|lack=" + lackQty;
    }

    private boolean needNotifyWcsStop(WrkMast wrkMast) {
        return wrkMast != null
                && wrkMast.getWrkSts() != null
                && wrkMast.getWrkSts() >= 12L
                && wrkMast.getWrkSts() < 14L;
    }

    private StopOutTaskParams buildStopOutTaskParams(OpenOrderPakoutPauseParam param, List<WrkMast> wrkMasts) {
    private StopOutTaskParams buildStopOutTaskParams(List<WrkMast> wrkMasts) {
        StopOutTaskParams stopParams = new StopOutTaskParams();
        // WCS取消接口仅接收 taskList.taskNo。
        for (WrkMast wrkMast : wrkMasts) {
@@ -647,50 +576,6 @@
            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