fix(dms): 修复工作流启动和推进的相关问题

- 润滑工单和保养工单的工作流启动逻辑优化
- 增加对已启动工作流的处理逻辑
- 修复工作流任务完成和推进的问题
- 优化设备 ID 类型，改为 Long 类型
- 新增润滑标准编码字段
- 保养标准编号相关接口定义更新

ruoyi-modules/hwmom-dms/src/main/java/org/dromara/dms/domain/mobile/DeviceBeen.java

@@ -23,7 +23,7 @@ public class DeviceBeen {
      * 设备ID，映射到数据库的 machine_id 字段
      */
     @TableId("machine_id")
-    private int deviceId;
+    private Long deviceId;
     
     /**
      * 设备编码，映射到数据库的 machine_code 字段

ruoyi-modules/hwmom-dms/src/main/java/org/dromara/dms/domain/mobile/DmsBillsLubeInstanceMobile.java

@@ -66,7 +66,7 @@ public class DmsBillsLubeInstanceMobile implements Serializable {
      */
     @ExcelProperty(value = "润滑级别", converter = ExcelDictConvert.class)
     @ExcelDictFormat(dictType = "lube_level")
-    private String lubeLevel;
+    private Long lubeLevel;
 
 //    /**
 //     * 计划润滑开始时间
@@ -97,7 +97,7 @@ public class DmsBillsLubeInstanceMobile implements Serializable {
      */
     @ExcelProperty(value = "润滑状态", converter = ExcelDictConvert.class)
     @ExcelDictFormat(dictType = "lube_status")
-    private String lubeStatus;
+    private Long lubeStatus;
 
     /**
      * 激活标识（1是 0否）

ruoyi-modules/hwmom-dms/src/main/java/org/dromara/dms/domain/mobile/DmsInspectInstanceDetailMobile.java

@@ -49,10 +49,10 @@ public class DmsInspectInstanceDetailMobile implements Serializable {
     private Long realLineStep;
 
     /**
-     * 设备ID - 映射machineId字段，PDA端期望int类型
+     * 设备ID - 映射machineId字段，与PDA端DeviceInspectionDetail保持一致
      */
     @ExcelProperty(value = "设备ID")
-    private int deviceId;
+    private Long deviceId;
 
     /**
      * 巡检状态（1待巡检 2巡检中 3已完成）

ruoyi-modules/hwmom-dms/src/main/java/org/dromara/dms/domain/mobile/LubricationDetail.java

@@ -90,4 +90,9 @@ public class LubricationDetail {
      */
     private String lubeOperationDescription;
 
+    /**
+     * 润滑标准编码
+     */
+    private String lubeStandardCode;
+
 }

ruoyi-modules/hwmom-dms/src/main/java/org/dromara/dms/domain/vo/DmsBillsInspectInstanceVo.java

@@ -2,6 +2,7 @@ package org.dromara.dms.domain.vo;
 
 import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
 import com.alibaba.excel.annotation.ExcelProperty;
+import com.baomidou.mybatisplus.annotation.TableField;
 import io.github.linpeilie.annotations.AutoMapper;
 import lombok.Data;
 import org.dromara.common.excel.annotation.ExcelDictFormat;

ruoyi-modules/hwmom-dms/src/main/java/org/dromara/dms/service/impl/DmsBillsInspectInstanceServiceImpl.java

@@ -223,6 +223,27 @@ public class DmsBillsInspectInstanceServiceImpl implements IDmsBillsInspectInsta
         if (count==0||count==1){
             // 如果没有未完成的检查实例，设置状态为3
             dmsBillsInspectInstance.setInspectStatus("3");
+            
+            // 【参考润滑工单】工作流完成处理
+            Long inspectInstanceId = dmsInspectInstanceDetail.getInspectInstanceId();
+            String businessId = inspectInstanceId.toString();
+            Long currentActiveTaskId = remoteWorkflowService.getCurrentActiveTaskId(businessId);
+            
+            if (currentActiveTaskId != null) {
+                // 【关键】设置消息类型为非null的List（避免原始错误）
+                List<String> messageTypes = new ArrayList<>();
+                messageTypes.add("system"); // 系统消息
+                
+                // 【工作流推进】完成当前活跃任务
+                boolean taskCompleted = remoteWorkflowService.completeTaskIgnoreAuth(currentActiveTaskId, "巡检工单完成，自动推进");
+                if (!taskCompleted) {
+                    log.error("巡检工作流完成失败，当前活跃任务ID: {}", currentActiveTaskId);
+                } else {
+                    log.info("巡检工单 {} 工作流完成成功，任务ID: {}", inspectInstanceId, currentActiveTaskId);
+                }
+            } else {
+                log.warn("巡检工单 {} 无法获取当前活跃任务ID，工作流可能已完成或异常", inspectInstanceId);
+            }
         }else{
             // 如果有未完成的检查实例，设置状态为2
             dmsBillsInspectInstance.setInspectStatus("2");
@@ -299,9 +320,9 @@ public class DmsBillsInspectInstanceServiceImpl implements IDmsBillsInspectInsta
             List<DmsInspectInstanceDetailVo> inspectInstanceDetails = dmsInspectInstanceDetailMapper.selectDmsInspectInstanceDetailJoinList(queryInspectInstanceDetail);
             // 设置巡检实例详情列表到newestBillsInspectInstance对象中
             newestBillsInspectInstance.setDmsInspectInstanceDetailList(inspectInstanceDetails);
+            // 设置新的巡检编码为计划巡检编码
+            newestBillsInspectInstance.setBillsInspectCode(newestBillsInspectInstance.getPlanInspectCode());
         }
-        // 设置新的巡检编码为计划巡检编码
-        newestBillsInspectInstance.setBillsInspectCode(newestBillsInspectInstance.getPlanInspectCode());
         // 返回最新的未完成巡检工单
         return newestBillsInspectInstance;
     }

ruoyi-modules/hwmom-dms/src/main/java/org/dromara/dms/service/impl/DmsBillsLubeInstanceServiceImpl.java

@@ -335,39 +335,83 @@ public class DmsBillsLubeInstanceServiceImpl implements IDmsBillsLubeInstanceSer
             updateInstance.setLubeStatus(DmsConstants.DMS_BILLS_LUBE_INSTANCE_STATUS_LUBING);
             updateInstance.setRealBeginTime(currentDate);
 
-            // 【工作流启动】创建远程启动流程对象
+            // 【关键修复】检查工作流是否已经启动
-            RemoteStartProcess startProcess = new RemoteStartProcess();
+            if(StringUtils.isNull(dmsBillsLubeInstance.getWfDefinitionId()))
-            // 设置润滑工作流程代码
+            {
-            startProcess.setFlowCode(DmsConstants.DMS_BILLS_LUBE_INSTANCE_WF_CODE);
+                // 【工作流启动】创建远程启动流程对象
-            // 获取业务ID（润滑实例ID）
+                RemoteStartProcess startProcess = new RemoteStartProcess();
-            String businessId = dmsBillsLubeInstance.getLubeInstanceId().toString();
+                // 设置润滑工作流程代码
-            // 设置业务ID
+                startProcess.setFlowCode(DmsConstants.DMS_BILLS_LUBE_INSTANCE_WF_CODE);
-            startProcess.setBusinessId(businessId);
+                // 获取业务ID（润滑实例ID）
-            // 启动工作流程
+                String businessId = dmsBillsLubeInstance.getLubeInstanceId().toString();
-            RemoteStartProcessReturn remoteStartProcessReturn = remoteWorkflowService.startWorkFlow(startProcess);
+                // 设置业务ID
-            // 获取任务ID
+                startProcess.setBusinessId(businessId);
-            Long taskId = remoteStartProcessReturn.getTaskId();
+                // 启动工作流程
-            // 如果任务ID为空，抛出流程启动失败异常
+                RemoteStartProcessReturn remoteStartProcessReturn = remoteWorkflowService.startWorkFlow(startProcess);
-            if (StringUtils.isNull(taskId)) {
+                
-                throw new ServiceException("润滑工作流启动失败");
+                // 【关键修复】获取流程实例ID和任务ID
+                Long processInstanceId = remoteStartProcessReturn.getProcessInstanceId();
+                Long taskId = remoteStartProcessReturn.getTaskId();
+                
+                // 如果流程实例ID为空，抛出流程启动失败异常
+                if (StringUtils.isNull(processInstanceId)) {
+                    throw new ServiceException("润滑工作流启动失败");
+                } else {
+                    // 【关键修复】存储流程实例ID到wfDefinitionId
+                    updateInstance.setWfDefinitionId(processInstanceId);
+                    
+                    // 【异步线程上下文传递】解决Sa-Token在异步线程中丢失的问题
+                    // 1. 【捕获Token】: 在主线程中获取当前用户的Token
+                    final String tokenValue = StpUtil.getTokenValue();
+                    // 2. 【异步更新工作流】: 使用TtlRunnable包装异步任务，确保ThreadLocal变量传递
+                    CompletableFuture.runAsync(TtlRunnable.get(() -> {
+                        try {
+                            // 3. 【设置上下文】: 在异步线程中恢复Token上下文
+                            StpUtil.setTokenValue(tokenValue);
+                            // 4. 【执行业务】: 更新润滑工单的工作流信息并推进工作流
+                            updateLubeWorkFlow(updateInstance, taskId);
+                        } catch (Exception e) {
+                            // 【错误处理】记录异常但不影响主流程
+                            log.error("异步更新润滑工作流失败，getBillsLubeCode: {}, 错误: {}",
+                                dmsBillsLubeInstance.getBillsLubeCode(), e.getMessage(), e);
+                            // 可以考虑记录到失败表，后续补偿处理
+                        }
+                    }));
+                }
             } else {
-                // 【异步线程上下文传递】解决Sa-Token在异步线程中丢失的问题
+                // 【关键修复】工作流已启动，根据流程实例ID查询当前活跃任务
-                // 1. 【捕获Token】: 在主线程中获取当前用户的Token
+                Long processInstanceId = dmsBillsLubeInstance.getWfDefinitionId();
-                final String tokenValue = StpUtil.getTokenValue();
+                log.info("润滑工单 {} 工作流已启动，流程实例ID: {}，查询当前活跃任务", 
-                // 2. 【异步更新工作流】: 使用TtlRunnable包装异步任务，确保ThreadLocal变量传递
+                    dmsBillsLubeInstance.getLubeInstanceId(), processInstanceId);
-                CompletableFuture.runAsync(TtlRunnable.get(() -> {
+                
-                    try {
+                // 根据流程实例ID获取当前活跃任务ID
-                        // 3. 【设置上下文】: 在异步线程中恢复Token上下文
+                Long currentActiveTaskId = remoteWorkflowService.getCurrentTaskIdByInstanceId(processInstanceId);
-                        StpUtil.setTokenValue(tokenValue);
+                
-                        // 4. 【执行业务】: 更新润滑工单的工作流信息
+                if (currentActiveTaskId != null) {
-                        updateLubeWorkFlow(updateInstance, taskId);
+                    log.info("润滑工单 {} 找到当前活跃任务ID: {}", 
-                    } catch (Exception e) {
+                        dmsBillsLubeInstance.getLubeInstanceId(), currentActiveTaskId);
-                        // 【错误处理】记录异常但不影响主流程
+                    
-                        log.error("异步更新润滑工作流失败，getBillsLubeCode: {}, 错误: {}",
+                    // 直接推进工作流
-                            dmsBillsLubeInstance.getBillsLubeCode(), e.getMessage(), e);
+                    RemoteCompleteTask remoteCompleteTask = new RemoteCompleteTask();
-                        // 可以考虑记录到失败表，后续补偿处理
+                    remoteCompleteTask.setTaskId(currentActiveTaskId);
+                    remoteCompleteTask.setMessage("润滑开始，推进工作流");
+                    // 设置消息类型为非null的List
+                    List<String> messageTypes = new ArrayList<>();
+                    messageTypes.add("user"); // 用户操作
+                    remoteCompleteTask.setMessageType(messageTypes);
+                    
+                    boolean taskCompleted = remoteWorkflowService.completeTask(remoteCompleteTask);
+                    if (!taskCompleted) {
+                        log.error("润滑工作流推进失败，任务ID: {}", currentActiveTaskId);
+                    } else {
+                        log.info("润滑工单 {} 工作流推进成功", dmsBillsLubeInstance.getLubeInstanceId());
                     }
-                }));
+                } else {
+                    log.warn("润滑工单 {} 无法获取当前活跃任务，流程可能已完成", dmsBillsLubeInstance.getLubeInstanceId());
+                }
+                
+                // 更新润滑工单状态
+                this.updateByBo(updateInstance);
             }
 
             // 更新润滑工单明细状态
@@ -440,10 +484,14 @@ public class DmsBillsLubeInstanceServiceImpl implements IDmsBillsLubeInstanceSer
             updateInstance.setRealEndTime(currentDate);
 
             // 【工作流完成】完成润滑工作流
-            Long taskId = dmsBillsLubeInstance.getWfDefinitionId();
+            // 【关键修复】不再使用存储的wfDefinitionId（那是第一个已完成的任务ID）
-            if (taskId != null) {
+            // 而是根据业务ID动态获取当前活跃的任务ID
+            String businessId = lubeInstanceId.toString();
+            Long currentActiveTaskId = remoteWorkflowService.getCurrentActiveTaskId(businessId);
+            
+            if (currentActiveTaskId != null) {
                 RemoteCompleteTask remoteCompleteTask = new RemoteCompleteTask();
-                remoteCompleteTask.setTaskId(taskId);
+                remoteCompleteTask.setTaskId(currentActiveTaskId); // 使用当前活跃任务ID
                 remoteCompleteTask.setMessage("润滑工单完成，自动推进");
                 // 【关键】设置消息类型为非null的List（避免原始错误）
                 List<String> messageTypes = new ArrayList<>();
@@ -452,8 +500,12 @@ public class DmsBillsLubeInstanceServiceImpl implements IDmsBillsLubeInstanceSer
                 // 完成工作流任务
                 boolean taskCompleted = remoteWorkflowService.completeTask(remoteCompleteTask);
                 if (!taskCompleted) {
-                    log.error("润滑工作流完成失败，taskId: {}", taskId);
+                    log.error("润滑工作流完成失败，当前活跃任务ID: {}", currentActiveTaskId);
+                } else {
+                    log.info("润滑工单 {} 工作流完成成功，任务ID: {}", lubeInstanceId, currentActiveTaskId);
                 }
+            } else {
+                log.warn("润滑工单 {} 无法获取当前活跃任务ID，工作流可能已完成或异常", lubeInstanceId);
             }
 
             // 更新润滑工单状态
@@ -494,16 +546,15 @@ public class DmsBillsLubeInstanceServiceImpl implements IDmsBillsLubeInstanceSer
     }
 
     /**
-     * 【异步工作流更新方法】更新润滑工单的工作流信息
+     * 【异步工作流更新方法】更新润滑工单的工作流信息并推进工作流
      *
-     * @param updateInstance 润滑工单更新对象
+     * @param updateInstance 润滑工单更新对象（已包含流程实例ID）
-     * @param taskId 工作流任务ID
+     * @param taskId 工作流任务ID（用于推进工作流）
      * @return 更新是否成功
      */
     private Boolean updateLubeWorkFlow(DmsBillsLubeInstanceBo updateInstance, Long taskId) {
-        // 【设置工作流任务ID】将工作流任务ID设置到润滑工单中
+        // 【关键修复】不再设置工作流ID，因为流程实例ID已经在主方法中设置
-        updateInstance.setWfDefinitionId(taskId);
+        // 【更新润滑工单信息】保存工作流相关信息（包含流程实例ID）
-        // 【更新润滑工单信息】保存工作流相关信息
         DmsBillsLubeInstanceVo dmsBillsLubeInstanceVo = this.updateByBo(updateInstance);
         if (ObjectUtils.isEmpty(dmsBillsLubeInstanceVo)){
             // 【更新失败处理】润滑工单更新失败，记录错误并返回false

ruoyi-modules/hwmom-dms/src/main/java/org/dromara/dms/service/impl/DmsBillsMaintInstanceServiceImpl.java

@@ -322,46 +322,104 @@ public class DmsBillsMaintInstanceServiceImpl implements IDmsBillsMaintInstanceS
             dmsBillsMaintInstance.setMaintStatus(DmsConstants.DMS_BILLS_MAINT_INSTANCE_STATUS_MAINTING);
             // 设置实际开始保养时间为当前时间
             dmsBillsMaintInstance.setRealBeginTime(currentDate);
-            // FIXME:工作流相关
+            
-            // 创建远程启动流程对象
+            // 【关键修复】检查工作流是否已经启动 - 先重新查询最新数据
-            RemoteStartProcess startProcess = new RemoteStartProcess();
+            // 重新查询保养实例，确保获取到最新的工作流ID（避免使用缓存中的旧数据）
-            // 设置流程代码
+            DmsBillsMaintInstance latestInstance = baseMapper.selectById(dmsBillsMaintInstance.getMaintInstanceId());
-            startProcess.setFlowCode(DmsConstants.DMS_BILLS_MAINT_INSTANCE_WF_CODE);
+            
-            // 获取业务ID（保养实例ID）
+            if (latestInstance != null && latestInstance.getWfDefinitionId() == null) {
-            String businessId = dmsBillsMaintInstance.getMaintInstanceId().toString();
+                // 【工作流启动】创建远程启动流程对象
-            // 设置业务ID
+                RemoteStartProcess startProcess = new RemoteStartProcess();
-            startProcess.setBusinessId(businessId);
+                // 设置流程代码
-            // 启动工作流程
+                startProcess.setFlowCode(DmsConstants.DMS_BILLS_MAINT_INSTANCE_WF_CODE);
-            RemoteStartProcessReturn remoteStartProcessReturn = remoteWorkflowService.startWorkFlow(startProcess);
+                // 获取业务ID（保养实例ID）
-            // 获取任务ID
+                String businessId = dmsBillsMaintInstance.getMaintInstanceId().toString();
-            Long taskId = remoteStartProcessReturn.getTaskId();
+                // 设置业务ID
-            // 如果任务ID为空，抛出流程启动失败异常
+                startProcess.setBusinessId(businessId);
-            if (StringUtils.isNull(taskId)) {
+                
-                throw new ServiceException("流程启动失败");
+                try {
-            }else{
+                    // 启动工作流程
-                // ** 异步线程上下文传递【核心问题】 **
+                    RemoteStartProcessReturn remoteStartProcessReturn = remoteWorkflowService.startWorkFlow(startProcess);
-                // 在主线程中，用户的登录信息(Token)是存放在一个叫 ThreadLocal 的"线程口袋"里的。
+                
-                // 当我们使用 CompletableFuture.runAsync() 开启一个异步线程（子线程）时，
+                // 【关键修复】获取流程实例ID和任务ID
-                // 这个"口袋"里的东西默认是不会被带到子线程去的。
+                Long processInstanceId = remoteStartProcessReturn.getProcessInstanceId();
-                //
+                Long taskId = remoteStartProcessReturn.getTaskId();
-                // ** 【解决方案】 **
+                
-                // 1. 【捕获Token】: 在主线程里，我们先用 StpUtil.getTokenValue() 把Token拿出来，存好。
+                // 如果流程实例ID为空，抛出流程启动失败异常
-                final String tokenValue = StpUtil.getTokenValue();
+                if (processInstanceId == null) {
-                // 2. 【传递与恢复】: 使用 TtlRunnable (TransmittableThreadLocal Runnable) 包装我们的异步任务。
+                    throw new ServiceException("保养工作流启动失败");
-                //    它就像一个特殊的"接力棒"，能在线程切换时把主线程"口袋"里的东西（包括Token）传递给子线程。
+                } else {
-                CompletableFuture.runAsync(TtlRunnable.get(() -> {
+                    // 【关键修复】存储流程实例ID到wfDefinitionId
-                    try {
+                    dmsBillsMaintInstance.setWfDefinitionId(processInstanceId);
-                        // 3. 【设置上下文】: 在子线程任务开始时，立刻用 StpUtil.setTokenValue() 把传递过来的Token放进子线程自己的"口袋"。
+                    
-                        StpUtil.setTokenValue(tokenValue);
+                    // ** 异步线程上下文传递【核心问题】 **
-                        // 4. 【执行业务】: 现在子线程就像登录过一样，可以带着Token去调用其他需要权限的服务了。
+                    // 1. 【捕获Token】: 在主线程里，我们先用 StpUtil.getTokenValue() 把Token拿出来，存好。
-                        updateWorkFlow(dmsBillsMaintInstance, taskId);
+                    final String tokenValue = StpUtil.getTokenValue();
-                    } catch (Exception e) {
+                    // 2. 【传递与恢复】: 使用 TtlRunnable 包装我们的异步任务。
-                        // 简单记录错误，不影响主流程
+                    CompletableFuture.runAsync(TtlRunnable.get(() -> {
-                        log.error("异步更新保养工作流失败，getBillsMaintCode: {}, 错误: {}",
+                        try {
-                            dmsBillsMaintInstance.getBillsMaintCode(), e.getMessage(), e);
+                            // 3. 【设置上下文】: 在子线程任务开始时，立刻用 StpUtil.setTokenValue() 把传递过来的Token放进子线程自己的"口袋"。
-                        // 可以考虑记录到失败表，后续补偿处理
+                            StpUtil.setTokenValue(tokenValue);
+                            // 4. 【执行业务】: 现在子线程就像登录过一样，可以带着Token去调用其他需要权限的服务了。
+                            updateWorkFlow(dmsBillsMaintInstance, taskId);
+                        } catch (Exception e) {
+                            // 简单记录错误，不影响主流程
+                            log.error("异步更新保养工作流失败，getBillsMaintCode: {}, 错误: {}",
+                                dmsBillsMaintInstance.getBillsMaintCode(), e.getMessage(), e);
+                            // 可以考虑记录到失败表，后续补偿处理
+                        }
+                    }));
+                }
+                } catch (Exception e) {
+                    // 【关键修复】捕获工作流启动异常，避免重复启动导致的错误
+                    if (e.getMessage() != null && e.getMessage().contains("该单据已提交过申请")) {
+                        log.warn("保养工单 {} 工作流已存在，跳过启动: {}", dmsBillsMaintInstance.getMaintInstanceId(), e.getMessage());
+                        // 重新查询获取工作流ID
+                        DmsBillsMaintInstance updatedInstance = baseMapper.selectById(dmsBillsMaintInstance.getMaintInstanceId());
+                        if (updatedInstance != null && updatedInstance.getWfDefinitionId() != null) {
+                            dmsBillsMaintInstance.setWfDefinitionId(updatedInstance.getWfDefinitionId());
+                        }
+                    } else {
+                        log.error("保养工单 {} 工作流启动失败: {}", dmsBillsMaintInstance.getMaintInstanceId(), e.getMessage());
+                        throw new ServiceException("保养工作流启动失败: " + e.getMessage());
                     }
-                }));
+                }
+            } else if (latestInstance != null) {
+                // 【关键修复】工作流已启动，根据流程实例ID查询当前活跃任务
+                // 使用最新查询到的工作流ID
+                Long processInstanceId = latestInstance.getWfDefinitionId();
+                dmsBillsMaintInstance.setWfDefinitionId(processInstanceId); // 同步更新到当前对象
+                
+                log.info("保养工单 {} 工作流已启动，流程实例ID: {}，查询当前活跃任务", 
+                    dmsBillsMaintInstance.getMaintInstanceId(), processInstanceId);
+                
+                // 根据流程实例ID获取当前活跃任务ID
+                Long currentActiveTaskId = remoteWorkflowService.getCurrentTaskIdByInstanceId(processInstanceId);
+                
+                if (currentActiveTaskId != null) {
+                    log.info("保养工单 {} 找到当前活跃任务ID: {}", 
+                        dmsBillsMaintInstance.getMaintInstanceId(), currentActiveTaskId);
+                    
+                    // 直接推进工作流
+                    RemoteCompleteTask remoteCompleteTask = new RemoteCompleteTask();
+                    remoteCompleteTask.setTaskId(currentActiveTaskId);
+                    remoteCompleteTask.setMessage("保养开始，推进工作流");
+                    // 设置消息类型为非null的List
+                    List<String> messageTypes = new ArrayList<>();
+                    messageTypes.add("user"); // 用户操作
+                    remoteCompleteTask.setMessageType(messageTypes);
+                    
+                    boolean taskCompleted = remoteWorkflowService.completeTask(remoteCompleteTask);
+                    if (!taskCompleted) {
+                        log.error("保养工作流推进失败，任务ID: {}", currentActiveTaskId);
+                    } else {
+                        log.info("保养工单 {} 工作流推进成功", dmsBillsMaintInstance.getMaintInstanceId());
+                    }
+                } else {
+                    log.warn("保养工单 {} 无法获取当前活跃任务，流程可能已完成", dmsBillsMaintInstance.getMaintInstanceId());
+                }
+            } else {
+                log.error("保养工单 {} 不存在，无法处理工作流", dmsBillsMaintInstance.getMaintInstanceId());
             }
 
             // 设置保养明细的实际开始时间为当前时间
@@ -409,23 +467,35 @@ public class DmsBillsMaintInstanceServiceImpl implements IDmsBillsMaintInstanceS
         return dmsBillsMaintDetail;
     }
 
+    /**
+     * 【异步工作流更新方法】更新保养工单的工作流信息并推进工作流
+     *
+     * @param dmsBillsMaintInstance 保养工单实例（已包含流程实例ID）
+     * @param taskId 工作流任务ID（用于推进工作流）
+     * @return 更新是否成功
+     */
     private Boolean updateWorkFlow(DmsBillsMaintInstance dmsBillsMaintInstance, Long taskId){
-        // 设置工作流定义ID
+        // 【关键修复】不再设置工作流ID，因为流程实例ID已经在主方法中设置
-        dmsBillsMaintInstance.setWfDefinitionId(taskId);
+        // 【更新保养工单信息】保存实际开始时间
-        // 重新设置实际开始时间为当前时间（可能已变化）
         dmsBillsMaintInstance.setRealBeginTime(new Date());
-        // FIXME:完成第一步，待测试待完善
+        int updateResult = baseMapper.updateById(dmsBillsMaintInstance);
-        // 创建远程完成任务对象
+        if (updateResult <= 0) {
+            log.error("保养工单工作流信息更新失败，maintInstanceId: {}", dmsBillsMaintInstance.getMaintInstanceId());
+            return false;
+        }
+        
+        // 【自动推进工作流】完成第一步任务，推进到下一步
         RemoteCompleteTask remoteCompleteTask = new RemoteCompleteTask();
         // 设置任务ID
         remoteCompleteTask.setTaskId(taskId);
-        // 设置完成后的消息
+        // 设置完成消息
-        remoteCompleteTask.setMessage("自动推进");
+        remoteCompleteTask.setMessage("保养工单启动，自动推进");
-        // 关键：设置messageType为非null的List（解决原始错误）
+        // 【关键】设置消息类型为非null的List（避免原始错误）
         List<String> messageTypes = new ArrayList<>();
         messageTypes.add("system"); // 系统消息
         remoteCompleteTask.setMessageType(messageTypes);
-        // 完成该任务
+
+        // 【执行任务完成】推进工作流到下一步
         boolean b = remoteWorkflowService.completeTask(remoteCompleteTask);
         if (!b){
             return false;
@@ -489,14 +559,30 @@ public class DmsBillsMaintInstanceServiceImpl implements IDmsBillsMaintInstanceS
             // 设置实际结束时间为当前时间
             dmsBillsMaintInstance.setRealEndTime(currentDate);
 
-            //FIXME:工作流相关
+            // 【工作流完成】完成保养工作流
-            RemoteCompleteTask remoteCompleteTask = new RemoteCompleteTask();
+            // 【关键修复】不再使用存储的wfDefinitionId（那是流程实例ID）
-            remoteCompleteTask.setTaskId(dmsBillsMaintInstance.getWfDefinitionId());
+            // 而是根据业务ID动态获取当前活跃的任务ID
-            remoteCompleteTask.setMessage("自动推进");
+            String businessId = maintInstanceId.toString();
-            List<String> messageTypes = new ArrayList<>() ;
+            Long currentActiveTaskId = remoteWorkflowService.getCurrentActiveTaskId(businessId);
-            messageTypes.add("system");
+            
-            remoteCompleteTask.setMessageType(messageTypes);
+            if (currentActiveTaskId != null) {
-            remoteWorkflowService.completeTask(remoteCompleteTask);
+                RemoteCompleteTask remoteCompleteTask = new RemoteCompleteTask();
+                remoteCompleteTask.setTaskId(currentActiveTaskId); // 使用当前活跃任务ID
+                remoteCompleteTask.setMessage("保养工单完成，自动推进");
+                // 【关键】设置消息类型为非null的List（避免原始错误）
+                List<String> messageTypes = new ArrayList<>();
+                messageTypes.add("system"); // 系统消息
+                remoteCompleteTask.setMessageType(messageTypes);
+                // 完成工作流任务
+                boolean taskCompleted = remoteWorkflowService.completeTask(remoteCompleteTask);
+                if (!taskCompleted) {
+                    log.error("保养工作流完成失败，当前活跃任务ID: {}", currentActiveTaskId);
+                } else {
+                    log.info("保养工单 {} 工作流完成成功，任务ID: {}", maintInstanceId, currentActiveTaskId);
+                }
+            } else {
+                log.warn("保养工单 {} 无法获取当前活跃任务ID，工作流可能已完成或异常", maintInstanceId);
+            }
 
             // 更新保养实例信息
             baseMapper.updateById(dmsBillsMaintInstance);