修复调用导入工程失败 重复保存；修复分批出片逻辑

huang

16 小时以前 04914a9997afbbead6f8adbb9d9c40e05b2edbd1

 mes-processes/mes-plcSend/src/main/java/com/mes/interaction/vehicle/handler/LoadVehicleLogicHandler.java

@@ -223,7 +223,7 @@
                    result = handleSetOnlineState(deviceConfig, params, logicParams);
                    break;
                case "checkMesConfirm":
                    result = checkMesConfirm(deviceConfig, logicParams);
                    result = checkMesConfirm(deviceConfig, params, logicParams);
                    break;
                case "markBroken":
                    result = handleMarkBroken(deviceConfig, params, logicParams);
@@ -1331,10 +1331,22 @@
            MesTaskInfo existingTask = currentTasks.get(deviceId);
            if (existingTask != null) {
                log.debug("设备已有任务在执行中，跳过检查MES任务: deviceId={}", deviceId);
                // 仍然返回当前任务的玻璃列表，供任务引擎记录/对账本批次
                List<String> batchIds = new ArrayList<>();
                if (existingTask.glasses != null) {
                    for (GlassTaskInfo g : existingTask.glasses) {
                        if (g != null && g.glassId != null && !g.glassId.isEmpty()) {
                            batchIds.add(g.glassId);
                        }
                    }
                }
                return DevicePlcVO.OperationResult.builder()
                        .success(true)
                        .message("任务执行中，无需重复检查MES任务")
                        .data(Collections.singletonMap("waiting", false))
                        .data(new HashMap<String, Object>() {{
                            put("waiting", false);
                            put("batchGlassIds", batchIds);
                        }})
                        .build();
            }
            
@@ -1357,6 +1369,7 @@
                waitData.put("completed", false);
                waitData.put("waiting", true);
                waitData.put("waitingReason", "mesSend=0");
                waitData.put("batchGlassIds", new ArrayList<>());
                return DevicePlcVO.OperationResult.builder()
                        .success(true)
                        .message("等待MES发送请求（mesSend=0）")
@@ -1500,6 +1513,39 @@
            }
            
            currentTasks.put(deviceId, taskInfo);

            // 如果有多设备任务上下文，则记录本次MES下发的玻璃ID列表到上下文，供分批校验使用
            if (params != null) {
                Object ctxObj = params.get("_taskContext");
                if (ctxObj instanceof com.mes.task.model.TaskExecutionContext) {
                    com.mes.task.model.TaskExecutionContext ctx = (com.mes.task.model.TaskExecutionContext) ctxObj;
                    List<String> batchIds = new ArrayList<>();
                    for (GlassTaskInfo g : glasses) {
                        if (g != null && g.glassId != null && !g.glassId.isEmpty()) {
                            batchIds.add(g.glassId);
                        }
                    }
                    // 1. 记录当前批次的玻璃ID
                    ctx.getSharedData().put("currentMesBatchGlassIds", batchIds);
                    log.info("记录本次MES批次玻璃列表: deviceId={}, batchIds={}", deviceId, batchIds);
                    
                    // 2. 初始化总待出片玻璃列表（仅第一次初始化，从任务参数获取）
                    if (!ctx.getSharedData().containsKey("initialGlassIds")) {
                        // 从任务参数中获取总待出片玻璃ID（核心：总列表来自任务参数，而非MES批次）
                        List<String> taskGlassIds = ctx.getParameters().getGlassIds();
                        if (taskGlassIds != null && !taskGlassIds.isEmpty()) {
                            ctx.getSharedData().put("initialGlassIds", new ArrayList<>(taskGlassIds));
                            // 初始化已出片列表为空
                            if (!ctx.getSharedData().containsKey("outboundGlassIds")) {
                                ctx.getSharedData().put("outboundGlassIds", new ArrayList<>());
                            }
                            log.info("初始化总待出片玻璃列表: deviceId={}, taskGlassIds={}", deviceId, taskGlassIds);
                        } else {
                            log.warn("任务参数中未找到总待出片玻璃ID列表: deviceId={}", deviceId);
                        }
                    }
                }
            }
            
            // 清空plcRequest（表示已接收任务）
            Map<String, Object> payload = new HashMap<>();
@@ -1537,6 +1583,14 @@
            Map<String, Object> successData = new HashMap<>();
            successData.put("waiting", false);
            successData.put("taskStarted", true);
            // 将本次MES下发的玻璃ID列表通过返回值带回（任务引擎不再依赖_taskContext写入）
            List<String> batchIdsForReturn = new ArrayList<>();
            for (GlassTaskInfo g : glasses) {
                if (g != null && g.glassId != null && !g.glassId.isEmpty()) {
                    batchIdsForReturn.add(g.glassId);
                }
            }
            successData.put("batchGlassIds", batchIdsForReturn);
            
            return DevicePlcVO.OperationResult.builder()
                    .success(true)
@@ -2040,6 +2094,7 @@
     * 返回OperationResult.data中的 completed 标志表示是否已确认完成
     */
    public DevicePlcVO.OperationResult checkMesConfirm(DeviceConfig deviceConfig,
                                                       Map<String, Object> params,
                                                       Map<String, Object> logicParams) {
        if (plcDynamicDataService == null || s7SerializerProvider == null) {
            return DevicePlcVO.OperationResult.builder()
@@ -2062,8 +2117,11 @@
        if (taskInfo == null) {
            log.info("检查MES确认时未找到任务记录，尝试补偿检查MES任务: deviceId={}", deviceId);
            try {
                // 关键：补偿检查时也要透传params（包含_taskContext），
                // 否则handleCheckMesTask无法把本批次玻璃ID写入currentMesBatchGlassIds，任务引擎无法累加完成进度
                Map<String, Object> checkParams = params != null ? params : Collections.emptyMap();
                DevicePlcVO.OperationResult checkResult =
                        handleCheckMesTask(deviceConfig, Collections.emptyMap(), logicParams);
                        handleCheckMesTask(deviceConfig, checkParams, logicParams);
                if (Boolean.TRUE.equals(checkResult.getSuccess())) {
                    taskInfo = currentTasks.get(deviceId);
                    if (taskInfo != null) {
@@ -2149,12 +2207,14 @@
            data.put("completed", completed);

            if (completed) {
                // MES已确认，清空state和汇报字
                // MES已确认：本次交互完成（不在设备侧判断“是否还有更多玻璃”，由任务引擎统一编排）
                clearTaskStates(deviceConfig, serializer);

                // 记录已完成的任务签名，避免MES未复位时被重复拉起
                lastCompletedMesRecords.put(deviceId,
                        new CompletedMesRecord(taskInfo.mesSignature, System.currentTimeMillis()));
                if (taskInfo != null && taskInfo.mesSignature != null) {
                    lastCompletedMesRecords.put(deviceId,
                            new CompletedMesRecord(taskInfo.mesSignature, System.currentTimeMillis()));
                }

                // 任务完成，恢复为空闲状态
                statusManager.updateVehicleStatus(
@@ -2173,10 +2233,10 @@
                plcDynamicDataService.writePlcData(deviceConfig, payload, serializer);

                log.info("MES任务已确认完成: deviceId={}", deviceConfig.getDeviceId());
                String taskType = taskInfo.isOutbound ? "出片" : "进片";
                String taskType = (taskInfo != null && taskInfo.isOutbound) ? "出片" : "进片";
                return DevicePlcVO.OperationResult.builder()
                        .success(true)
                        .message(String.format("%s任务完成：MES已确认（mesConfirm=1），已清空state和汇报字，大车空闲（plcRequest=1），可以等待下次任务", taskType))
                        .message(String.format("%s任务交互完成：MES已确认（mesConfirm=1），已清空state和汇报字，大车空闲（plcRequest=1）", taskType))
                        .data(data)
                        .build();
            }