修改流程的审批同意接口

bpm-client-http/src/main/java/com/srm/bpm/facde/oa/WebServiceRequestInfo.java

@@ -3,17 +3,17 @@ package com.srm.bpm.facde.oa;
 public class WebServiceRequestInfo {
 
 
-     //正式
+/*     //正式
     public static final String oaRequestAddress = "http://172.16.0.36"; //正式环境
 // public static final String oaRequestAddress = "http://172.16.0.37:8081"; //测试环境
 
-    public static final String oaEtenAddress="http://uoa.jqh.cc:20600";
+    public static final String oaEtenAddress="http://uoa.jqh.cc:20600";*/
 
-/*    //测试
+    //测试
 //public static final String oaRequestAddress = "http://172.16.0.36"; //E8正式环境
 public static final String oaRequestAddress = "http://172.16.1.36"; //E8假环境
 // public static final String oaRequestAddress = "http://172.16.0.37:8081"; //（失效）测试环境
 
 //public static final String oaEtenAddress="http://uoa.jqh.cc:20600";//E10正式环境
-public static final String oaEtenAddress="http://172.16.0.59:20666/";//E10测试环境*/
+public static final String oaEtenAddress="http://172.16.0.59:20666/";//E10测试环境
 }

bpm-core/src/main/java/com/srm/bpm/logic/service/impl/BillBpmnLogicImpl.java

@@ -28,6 +28,7 @@ import com.srm.bpm.logic.constant.BillAction;
 import com.srm.bpm.logic.constant.BillStatus;
 import com.srm.bpm.logic.constant.BillTaskStatus;
 import com.srm.bpm.logic.constant.BpmnConst;
+import com.srm.bpm.logic.constant.Const;
 import com.srm.bpm.logic.constant.NodeLinkType;
 import com.srm.bpm.logic.constant.StringPool;
 import com.srm.bpm.logic.context.BillDataContext;
@@ -206,10 +207,10 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
         variables.put(BpmnConst.VAR_FORM_DATA, formDataParam);
         variables.put(BpmnConst.VAR_BILL_CONTEXT, varDataContext);
         variables.put(BpmnConst.VAR_APPLY_PROCESS, processDetail.getId());
-        variables.put(BpmnConst.VAR_APPLY_EMPLOYEE, authenticatedUserId);
-        variables.put(BpmnConst.VAR_APPROVER_EMPLOYEE, authenticatedUserId);
+        variables.put(BpmnConst.VAR_APPLY_EMPLOYEE, authenticatedUserId);//申请人
+        variables.put(BpmnConst.VAR_APPROVER_EMPLOYEE, authenticatedUserId);//审批人
         variables.put(BpmnConst.VAR_ACTION, BillAction.submit.name());
-        variables.put(BpmnConst.VAR_NEXT_APPROVER, nextApprover);
+        variables.put(BpmnConst.VAR_NEXT_APPROVER, nextApprover);//下一个审批人
         variables.put(BpmnConst.VAR_AGREE_DATA, Maps.newHashMap());
         final ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery()
                 .processInstanceBusinessKey(businessKey).active();
@@ -494,33 +495,78 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
         taskService.complete(taskId, variables);
         return true;*/
 
-        // 先检查运行时任务是否存在
+        // 查询【当前流程】对应的【处理中】的【任务节点】信息
         final Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+
+        // 如果流程没有【处理中】的节点，就查询【已处理】的节点
         if (task == null) {
-            // 检查历史任务，看是否已经完成
             final org.activiti.engine.history.HistoricTaskInstance historicTask = historyService
                     .createHistoricTaskInstanceQuery()
                     .taskId(taskId)
                     .singleResult();
+
+            // 【已处理】节点不为空
             if (historicTask != null) {
-                log.warn("任务已经完成，跳过完成操作。taskId: {}, billId: {}, 完成时间: {}",
-                        taskId, bill != null ? bill.getId() : null, historicTask.getEndTime());
-                // 检查归档条件并触发回调
+
+                /*// 判断是否是自动审批
+                final boolean isAutoAgree = Const.AUTO_AGREE_OPTION.equals(opinion);
+
+                // 默认是最后一个节点
+                boolean isLastNode = true;
+                if (bill != null && bill.getId() != null) {
+                    final String processInstanceId = bill.getProcessInstanceId();
+                    if (!Strings.isNullOrEmpty(processInstanceId)) {
+
+                        // 查询该【流程实例】的活跃节点，
+                        // 【有活跃任务】 --> 不是最后一个节点
+                        // 【无活跃任务】 --> 是最后一个节点
+                        final List<Task> activeTasks = taskService.createTaskQuery()
+                                .processInstanceId(processInstanceId)
+                                .active()
+                                .list();
+                        isLastNode = CollectionUtil.isEmpty(activeTasks);
+                    }
+                }
+
+
+                log.warn("任务已经完成，跳过完成操作。taskId: {}, billId: {}, 完成时间: {}, isAutoAgree: {}, isLastNode: {}",
+                        taskId, bill != null ? bill.getId() : null, historicTask.getEndTime(), isAutoAgree, isLastNode);*/
+                
+                // 如果 toa_bill 的 status 为 1【审批中】，且 bill_task 的最后一个节点为【归档节点】，则触发回调
                 checkAndTriggerArchiveCallback(bill, taskId);
-                // 检查流程是否应该结束
+                
+                // 如果是自动审批且是最后一个节点，直接触发完成逻辑（重复触发了）
+                /*if (isAutoAgree && isLastNode) {
+                    log.info("任务已完成，自动审批最后一个节点，直接触发审批单完成逻辑和回调。billId: {}, taskId: {}",
+                            bill != null ? bill.getId() : null, taskId);
+                    triggerBillCompleteCallback(bill);
+                    return true;
+                }*/
+
+                // 如果没有【审批待办】了，但还不是【归档】状态，二次触发【回调】
                 checkAndCompleteBillIfNeeded(bill);
                 return true;
             } else {
-                log.warn("Activiti任务不存在，可能已经被删除。taskId: {}, billId: {}，跳过完成操作。业务数据已更新。",
-                        taskId, bill != null ? bill.getId() : null);
+                log.warn("Activiti任务不存在，可能已经被删除。taskId: {}, billId: {}，跳过完成操作。业务数据已更新。", taskId, bill != null ? bill.getId() : null);
+                
                 // 检查归档条件并触发回调
                 checkAndTriggerArchiveCallback(bill, taskId);
+                
+                /*// 如果是自动审批且是最后一个节点，直接触发完成逻辑
+                if (isAutoAgree && isLastNode) {
+                    log.info("任务不存在，自动审批最后一个节点，直接触发审批单完成逻辑和回调。billId: {}, taskId: {}",
+                            bill != null ? bill.getId() : null, taskId);
+                    triggerBillCompleteCallback(bill);
+                    return true;
+                }*/
+                
                 // 检查流程是否应该结束
                 checkAndCompleteBillIfNeeded(bill);
                 return true; // 业务数据已更新，返回成功
             }
         }
 
+        // 如果能查询到【当前流程】对应的【处理中】的【任务节点】信息
         Map<String, Object> variables = Maps.newHashMap();
         variables.put(BpmnConst.VAR_OPINION, opinion);
         variables.put(BpmnConst.VAR_APPROVER_EMPLOYEE, userCode);
@@ -542,33 +588,257 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
         }
 
         try {
+            // 判断是否是自动审批
+            final boolean isAutoAgree = Const.AUTO_AGREE_OPTION.equals(opinion);
+
+            // 设置task_bill表数据
             taskService.complete(taskId, variables);
 
-            // 任务完成后，先检查归档条件并触发回调
+            // 如果是自动审批，需要判断是否是最后一个节点
+            if (isAutoAgree) {
+                // 检查是否有下一个节点（通过检查运行时待办任务）
+                // taskService.complete() 会同步触发 CreateTaskListener，所以这里检查时下一个节点应该已经创建
+                boolean isLastNode = true;
+                if (bill != null && bill.getId() != null) {
+                    final String processInstanceId = bill.getProcessInstanceId();
+                    if (!Strings.isNullOrEmpty(processInstanceId)) {
+                        final List<Task> activeTasks = taskService.createTaskQuery()
+                                .processInstanceId(processInstanceId)
+                                .active()
+                                .list();
+                        isLastNode = CollectionUtil.isEmpty(activeTasks);
+                    }
+                }
+
+                // 当前节点是最后一个节点，执行检查和回调方法
+                if (isLastNode) {
+                    log.info("自动审批完成，当前节点是最后一个节点，执行检查和回调方法。billId: {}, taskId: {}", bill != null ? bill.getId() : null, taskId);
+
+                    // 如果 toa_bill 的 status 为 1【审批中】，且 bill_task 的最后一个节点为【归档节点】，则触发回调
+                    checkAndTriggerArchiveCallback(bill, taskId);
+                    
+                    /*// 再检查流程是否应该结束（无论是否是归档节点，都要检查）
+                    // 因为最后一个节点可能不是归档节点，但流程已经结束，需要完成审批单
+                    final String processInstanceId = bill != null ? bill.getProcessInstanceId() : null;
+                    boolean shouldTriggerComplete = false;
+                    
+                    if (!Strings.isNullOrEmpty(processInstanceId)) {
+                        // 检查是否有运行时待办任务
+                        final List<Task> activeTasks = taskService.createTaskQuery()
+                                .processInstanceId(processInstanceId)
+                                .active()
+                                .list();
+                        
+                        if (CollectionUtil.isEmpty(activeTasks)) {
+                            // 没有运行时待办任务，检查历史流程实例是否已结束
+                            final org.activiti.engine.history.HistoricProcessInstance historicProcessInstance = historyService
+                                    .createHistoricProcessInstanceQuery()
+                                    .processInstanceId(processInstanceId)
+                                    .singleResult();
+                            
+                            if (historicProcessInstance != null && historicProcessInstance.getEndTime() != null) {
+                                // 流程已结束，立即触发完成逻辑和回调
+                                log.info("自动审批完成，最后一个节点，流程已结束（历史流程实例已结束）。立即触发审批单完成逻辑和回调。billId: {}, taskId: {}",
+                                        bill != null ? bill.getId() : null, taskId);
+                                shouldTriggerComplete = true;
+                            } else {
+                                // 流程实例可能还没有完全结束（endTime 可能还是 null），但没有运行时待办任务
+                                // 说明流程实际上已经结束，只是 Activiti 还没有更新历史流程实例
+                                // 此时也应该触发完成逻辑
+                                log.info("自动审批完成，最后一个节点，没有运行时待办任务，流程应该已结束（即使历史流程实例 endTime 为 null）。立即触发审批单完成逻辑和回调。billId: {}, taskId: {}",
+                                        bill != null ? bill.getId() : null, taskId);
+                                shouldTriggerComplete = true;
+                            }
+                        }
+                    } else {
+                        // 流程实例ID为空，但所有任务都已完成，应该完成审批单
+                        log.info("自动审批完成，最后一个节点，流程实例ID为空，但所有任务都已完成。立即触发审批单完成逻辑和回调。billId: {}, taskId: {}",
+                                bill != null ? bill.getId() : null, taskId);
+                        shouldTriggerComplete = true;
+                    }
+                    
+                    if (shouldTriggerComplete) {
+                        // 触发完成逻辑和回调
+                        triggerBillCompleteCallback(bill);
+                        return true;
+                    }*/
+                    
+                    // 如果流程实例还没有结束，检查是否应该结束（兜底机制）
+                    checkAndCompleteBillIfNeeded(bill);
+                    return true;
+                }/*else {
+                    // todo 如果是自动审批节点，但不是最后一个节点，则需要处理完当前节点，再新建下一个节点
+                    // 下一个节点的自动审批会在 saveBillApprover() 中递归处理
+                    log.info("自动审批完成，当前节点不是最后一个节点，等待下一个节点处理。billId: {}, taskId: {}", bill != null ? bill.getId() : null, taskId);
+                    return true;
+                }*/
+
+            }
+
+            // 【手动审批】 || 【自动审批】但不是【最后一个节点】：任务完成后，先检查归档条件并触发回调
             checkAndTriggerArchiveCallback(bill, taskId);
 
-            // 任务完成后，立即检查流程是否结束，如果结束则触发回调
+            // 手动审批场景：判断下一个节点是否是自动审批节点
+            // 步骤一：先完成本节点审批事件，生成下一个节点的审批信息（已完成，通过 taskService.complete()）
+            // 步骤二：判断下一个节点是否是自动审批节点，如果是，则自动调用审批通过的方法
             if (bill != null && bill.getId() != null) {
                 final String processInstanceId = bill.getProcessInstanceId();
                 if (!Strings.isNullOrEmpty(processInstanceId)) {
-                    // 先检查运行时流程实例是否还有待办任务
+                    // 检查是否有下一个节点
                     final List<Task> activeTasks = taskService.createTaskQuery()
                             .processInstanceId(processInstanceId)
                             .active()
                             .list();
 
-                    // 如果没有待办任务，检查流程是否已结束
-                    if (CollectionUtil.isEmpty(activeTasks)) {
+
+                    // 有下一个节点
+                    if (CollectionUtil.isNotEmpty(activeTasks)) {
+                        final Task nextTask = activeTasks.get(0);
+                        final String nextTaskNodeId = nextTask.getTaskDefinitionKey();
+                        final Long processId = bill.getProcessId();
+                        
+                        if (processId != null && !Strings.isNullOrEmpty(nextTaskNodeId)) {
+                            // 获取下一个节点的配置
+                            final Optional<ProcessNodeExtendEntity> nextNodeExtendOpt = nodeExtendService
+                                    .findByNodeIdAndProcessId(processId, nextTaskNodeId);
+                            
+                            if (nextNodeExtendOpt.isPresent()) {
+                                final ProcessNodeExtendEntity nextNodeExtend = nextNodeExtendOpt.get();
+                                final String nextNodeAutoAgree = nextNodeExtend.getAutoAgree();
+                                
+                                // 判断下一个节点是否配置了自动审批
+                                if (!Strings.isNullOrEmpty(nextNodeAutoAgree)) {
+                                    // 下一个节点是自动审批节点，需要检查是否满足自动审批条件
+                                    // 这里需要查询下一个节点的 bill_task，检查是否满足自动审批条件
+                                    final List<BillTaskEntity> nextNodeTasks = billTaskService.list(
+                                            com.baomidou.mybatisplus.core.toolkit.Wrappers.lambdaQuery(BillTaskEntity.class)
+                                                    .eq(BillTaskEntity::getBillId, bill.getId())
+                                                    .eq(BillTaskEntity::getTaskId, nextTask.getId())
+                                                    .eq(BillTaskEntity::getIsDeleted, 0)
+                                    );
+                                    
+                                    if (CollectionUtil.isNotEmpty(nextNodeTasks)) {
+                                        // 检查下一个节点的任务是否满足自动审批条件
+                                        final BillTaskLogic billTaskLogic = SpringContextHolder.getBean(BillTaskLogic.class);
+                                        
+                                        // 获取上一个节点的任务ID（用于判断是否是同一个处理人）
+                                        // 使用当前完成的 taskId 作为 lastTaskId
+                                        final String nextNodeLastTaskId = taskId;
+                                        
+                                        // 检查是否满足自动审批条件
+                                        final BillTaskEntity autoAgreeTask = billTaskLogic.autoAgree(
+                                                nextNodeExtend, nextNodeTasks, nextNodeLastTaskId, bill.getId());
+
+                                        // 有下一个节点，且下一个节点满足自动审批条件，自动调用审批通过的方法
+                                        if (autoAgreeTask != null) {
+                                            log.info("手动审批完成，下一个节点是自动审批节点且满足条件，自动调用审批通过的方法。billId: {}, nextTaskId: {}, nextNodeKey: {}",
+                                                    bill.getId(), nextTask.getId(), nextTaskNodeId);
+                                            
+                                            // 会签判断
+                                            final BillLogic billLogic = SpringContextHolder.getBean(BillLogic.class);
+                                            final boolean goFlag = billLogic.agreeIsGoOn(autoAgreeTask);
+                                            if (goFlag) {
+                                                // 自动审批下一个节点
+                                                // 使用当前完成的 taskId 作为 lastTaskId
+                                                this.complete(bill, nextTask.getId(), Const.AUTO_AGREE_OPTION, 
+                                                        autoAgreeTask.getUserCode(), "", "", 
+                                                        nextTaskNodeId, nextNodeLastTaskId);
+                                                
+                                                // 删除待审批的信息
+                                                billTaskService.deleteApproval(bill.getId(), nextTask.getId(), 
+                                                        BillTaskStatus.APPROVAL.getStatus());
+                                            }
+                                            /*else {
+                                                //todo 转办操作
+                                                transfer(billTasks, billId);
+                                                final List<BillTaskEntity> approvingByBillAndTaskId = this.billTaskService.findApprovingByBillAndTaskId(billId, taskId);
+                                                msgLogic.sendMsg(approvingByBillAndTaskId);
+                                                return approvingByBillAndTaskId;
+                                            }*/
+                                        }else {
+                                            /*//todo 转办操作
+                                            transfer(billTasks, billId);
+                                            final List<BillTaskEntity> approvingByBillAndTaskId = this.billTaskService.findApprovingByBillAndTaskId(billId, taskId);
+                                            msgLogic.sendMsg(approvingByBillAndTaskId);
+                                            return approvingByBillAndTaskId;*/
+                                        }
+                                    }
+                                }else {
+                                    // 下一个节点是手动审批节点
+                                    log.info("手动审批完成，下一个节点是手动审批节点，等待审批人处理。billId: {}, nextTaskId: {}, nextNodeKey: {}", bill.getId(), nextTask.getId(), nextTaskNodeId);
+
+                                    // 查询下一个节点的 bill_task 记录
+                                    final List<BillTaskEntity> nextNodeTasks = billTaskService.list(
+                                            com.baomidou.mybatisplus.core.toolkit.Wrappers.lambdaQuery(BillTaskEntity.class)
+                                                    .eq(BillTaskEntity::getBillId, bill.getId())
+                                                    .eq(BillTaskEntity::getTaskId, nextTask.getId())
+                                                    .eq(BillTaskEntity::getIsDeleted, 0)
+                                    );
+
+                                    if (CollectionUtil.isNotEmpty(nextNodeTasks)) {
+                                        // 使用当前完成的 taskId 作为 lastTaskId
+                                        final String nextNodeLastTaskId = taskId;
+
+                                        // 检查并更新 lastTaskId，确保正确关联到当前完成的节点
+                                        boolean needUpdate = false;
+                                        for (BillTaskEntity nextNodeTask : nextNodeTasks) {
+                                            // 如果 lastTaskId 不正确，需要更新
+                                            if (!Objects.equals(nextNodeTask.getLastTaskId(), nextNodeLastTaskId)) {
+                                                nextNodeTask.setLastTaskId(nextNodeLastTaskId);
+                                                nextNodeTask.setLastNodeKey(lastTaskNodeId); // 同时更新 lastNodeKey
+                                                needUpdate = true;
+                                            }
+                                        }
+
+                                        if (needUpdate) {
+                                            log.info("手动审批完成，更新下一个手动审批节点的 lastTaskId。billId: {}, nextTaskId: {}, lastTaskId: {} -> {}",
+                                                    bill.getId(), nextTask.getId(), nextNodeTasks.get(0).getLastTaskId(), nextNodeLastTaskId);
+                                            billTaskService.updateBatchById(nextNodeTasks);
+                                        } else {
+                                            log.info("手动审批完成，下一个手动审批节点的 lastTaskId 已正确关联。billId: {}, nextTaskId: {}, lastTaskId: {}",
+                                                    bill.getId(), nextTask.getId(), nextNodeLastTaskId);
+                                        }
+                                    } else {
+                                        log.warn("手动审批完成，下一个节点是手动审批节点，但未找到对应的 bill_task 记录。billId: {}, nextTaskId: {}, nextNodeKey: {}",
+                                                bill.getId(), nextTask.getId(), nextTaskNodeId);
+                                    }
+                                }
+
+                            }
+                        }
+                    } else {
+                        // 没有下一个节点，当前节点是最后一个节点了（【手动审批】）
+
                         // 检查历史流程实例是否已结束
                         final org.activiti.engine.history.HistoricProcessInstance historicProcessInstance = historyService
                                 .createHistoricProcessInstanceQuery()
                                 .processInstanceId(processInstanceId)
                                 .singleResult();
 
+                        // 流程正常已结束，立即触发完成逻辑和回调
                         if (historicProcessInstance != null && historicProcessInstance.getEndTime() != null) {
-                            // 流程已结束，立即触发完成逻辑和回调
-                            log.info("任务完成后，检测到流程已结束（没有待办任务且历史流程实例已结束）。立即触发审批单完成逻辑和回调。billId: {}, taskId: {}",
-                                    bill.getId(), taskId);
+                            log.info("任务完成后，检测到流程已结束（没有待办任务且历史流程实例已结束）。立即触发审批单完成逻辑和回调。billId: {}, taskId: {}", bill.getId(), taskId);
+
+                            // 如果 toa_bill 的 status 为 1【审批中】，且 bill_task 的最后一个节点为【归档节点】，则触发回调
+                            checkAndTriggerArchiveCallback(bill, taskId);
+                            triggerBillCompleteCallback(bill);
+                            return true;
+
+                        }else if(historicProcessInstance != null && historicProcessInstance.getEndTime() == null) {
+                            // 流程实例可能还没有完全结束（endTime 可能还是 null），但没有运行时待办任务
+                            // 说明流程实际上已经结束，只是 Activiti 还没有更新历史流程实例
+                            // 此时也应该触发完成逻辑
+                            log.info("自动审批完成，最后一个节点，没有运行时待办任务，流程应该已结束（即使历史流程实例 endTime 为 null）。立即触发审批单完成逻辑和回调。billId: {}, taskId: {}",
+                                    bill != null ? bill.getId() : null, taskId);
+                            checkAndTriggerArchiveCallback(bill, taskId);
+                            triggerBillCompleteCallback(bill);
+                            return true;
+
+                        }else if(historicProcessInstance == null){
+                            // 流程实例ID为空，但所有任务都已完成，应该完成审批单
+                            log.info("手动审批完成，最后一个节点，流程实例ID为空，但所有任务都已完成。立即触发审批单完成逻辑和回调。billId: {}, taskId: {}", bill != null ? bill.getId() : null, taskId);
+                            // 如果 toa_bill 的 status 为 1【审批中】，且 bill_task 的最后一个节点为【归档节点】，则触发回调
+                            checkAndTriggerArchiveCallback(bill, taskId);
                             triggerBillCompleteCallback(bill);
                             return true;
                         }
@@ -576,7 +846,7 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
                 }
             }
 
-            // 如果流程未结束，检查是否应该结束（用于处理没有Activiti任务但业务任务已完成的情况）
+            // 如果流程未结束，检查是否应该结束（用于处理没有Activiti任务但业务任务已完成的情况）【二次确认归档】
             checkAndCompleteBillIfNeeded(bill);
             return true;
         } catch (org.activiti.engine.ActivitiObjectNotFoundException e) {
@@ -593,7 +863,7 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
 
     /**
      * 检查归档条件并触发回调
-     * 如果 toa_bill 的 status 为 1（审批中）且 bill_task 的最后一个节点审批状态为 2（已同意），则触发回调
+     * 如果 toa_bill 的 status 为 1【审批中】，且 bill_task 的最后一个节点为【归档节点】，则触发回调
      *
      * @param bill 审批单实体
      * @param taskId 任务ID
@@ -658,6 +928,8 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
                 // 检查最后一个任务是否是归档节点
                 final Long processId = latestBill.getProcessId();
                 if (processId != null && !Strings.isNullOrEmpty(lastTask.getTaskNodeKey())) {
+
+                    // 查询【当前节点】的【流程节点配置表元数据】
                     final Optional<ProcessNodeExtendEntity> nodeExtendOpt = nodeExtendService
                             .findByNodeIdAndProcessId(processId, lastTask.getTaskNodeKey());
 
@@ -713,7 +985,10 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
     }
 
     /**
-     * 检查审批单是否应该完成，如果是最后一个节点且没有待审批任务，则完成审批单
+     * 如果没有【审批待办】了，但还不是【归档】状态，触发【回调】
+     *  有流程实例，且是最后一个节点就要归档（如果有流程实例，但不是最后一个节点，目前不管。）
+     *  不能查到流程实例，也要归档（可能最后一个节点当时没有【归档】就结束任务了，重新触发【归档】）
+     *
      * 
      * @param bill 审批单实体
      */
@@ -721,31 +996,42 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
         if (bill == null || bill.getId() == null) {
             return;
         }
+
+        final ToaBillEntity latestBill = billService.getById(bill.getId());
+        if (latestBill == null) {
+            return;
+        }
         
         try {
             // 先检查是否有待审批的bill_task
             final List<BillTaskEntity> approvalTasks = billTaskService.list(
                     com.baomidou.mybatisplus.core.toolkit.Wrappers.lambdaQuery(BillTaskEntity.class)
-                            .eq(BillTaskEntity::getBillId, bill.getId())
+                            .eq(BillTaskEntity::getBillId, latestBill.getId())
                             .eq(BillTaskEntity::getNodeStatus, BillTaskStatus.APPROVAL.getStatus())
                             .eq(BillTaskEntity::getIsDeleted, 0)
             );
             
-            // 如果没有待审批任务，说明所有任务都已完成
-            if (CollectionUtil.isEmpty(approvalTasks)) {
+            // 如果没有待审批任务，但是流程不是【归档】状态，需要触发回调
+            if (CollectionUtil.isEmpty(approvalTasks) && latestBill.getStatus() != BillStatus.COMPLETE.getStatus()) {
+
                 // 检查流程实例状态
-                final String processInstanceId = bill.getProcessInstanceId();
+                final String processInstanceId = latestBill.getProcessInstanceId();
                 boolean shouldComplete = false;
-                
+
                 if (!Strings.isNullOrEmpty(processInstanceId)) {
-                    // 检查运行时流程实例是否还有待办任务
+
+                    // 查询该【流程实例】的活跃节点，
+                    // 【有活跃任务】 --> 不是最后一个节点
+                    // 【无活跃任务】 --> 是最后一个节点
                     final List<Task> activeTasks = taskService.createTaskQuery()
                             .processInstanceId(processInstanceId)
                             .active()
                             .list();
-                    
+
+                    // 所有任务都完成了，且现在是最后一个节点了
                     if (CollectionUtil.isEmpty(activeTasks)) {
-                        // 没有运行时待办任务，检查历史流程实例是否已结束
+
+                        // 如果流程没有【处理中】的节点，就查询【已处理】的节点
                         final org.activiti.engine.history.HistoricProcessInstance historicProcessInstance = historyService
                                 .createHistoricProcessInstanceQuery()
                                 .processInstanceId(processInstanceId)
@@ -753,29 +1039,28 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
                         
                         if (historicProcessInstance != null && historicProcessInstance.getEndTime() != null) {
                             // 流程已结束
-                            log.info("流程实例已结束，但审批单状态未更新。billId: {}, processInstanceId: {}", bill.getId(), processInstanceId);
+                            log.info("流程实例已结束，但审批单状态未更新。billId: {}, processInstanceId: {}", latestBill.getId(), processInstanceId);
                             shouldComplete = true;
                         } else {
                             // 流程实例不存在或未结束，但也没有待办任务和待审批任务，应该完成
-                            log.info("没有待办任务和待审批任务，流程应该结束。billId: {}, processInstanceId: {}", bill.getId(), processInstanceId);
+                            log.info("没有待办任务和待审批任务，流程应该结束。billId: {}, processInstanceId: {}", latestBill.getId(), processInstanceId);
                             shouldComplete = true;
                         }
                     }
                 } else {
-                    // 流程实例ID为空，但所有bill_task都已完成，应该完成审批单
-                    log.info("流程实例ID为空，但所有任务都已完成，应该完成审批单。billId: {}", bill.getId());
+                    // 流程实例ID为空，但是没有待办任务了，也应该要归档
+                    log.info("流程实例ID为空，但所有任务都已完成，应该完成审批单。billId: {}", latestBill.getId());
                     shouldComplete = true;
                 }
                 
-                if (shouldComplete && bill.getStatus() != BillStatus.COMPLETE.getStatus()) {
+                if (shouldComplete) {
                     // 审批单状态不是完成，需要触发完成逻辑和回调
-                    log.info("检测到流程应该结束，但审批单状态未更新。手动触发审批单完成逻辑和回调。billId: {}, 当前状态: {}", 
-                            bill.getId(), bill.getStatus());
-                    triggerBillCompleteCallback(bill);
+                    log.info("检测到流程应该结束，但审批单状态未更新。手动触发审批单完成逻辑和回调。billId: {}, 当前状态: {}", latestBill.getId(), latestBill.getStatus());
+                    triggerBillCompleteCallback(latestBill);//调用归档接口
                 }
             }
         } catch (Exception e) {
-            log.error("检查审批单完成状态时发生异常。billId: {}, 错误: {}", bill.getId(), e.getMessage(), e);
+            log.error("检查审批单完成状态时发生异常。billId: {}, 错误: {}", latestBill.getId(), e.getMessage(), e);
             // 设置事务回滚，确保异常不会导致事务提交
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             throw new RuntimeException("检查审批单完成状态时发生异常: " + e.getMessage(), e);

bpm-core/src/main/java/com/srm/bpm/logic/service/impl/BillTaskLogicImpl.java

@@ -292,20 +292,33 @@ public class BillTaskLogicImpl implements BillTaskLogic {
                     }
                 }
                 if (CollectionUtil.isNotEmpty(billTasks)) {
+                    // 先保存节点任务到数据库，确保节点任务已经被创建
                     this.billTaskService.saveBatch(billTasks, 300);
+                    
+                    // 检查是否需要自动审批
                     final BillTaskEntity billTaskEntity = autoAgree(nodeExtend, billTasks, lastTaskId, billId);
                     if (!Objects.isNull(billTaskEntity)) {
                         //需要增加会签判断
                         final boolean goFlag = billLogic.agreeIsGoOn(billTaskEntity);
                         if (goFlag) {
-                            this.billBpmnLogic.complete(billService.getById(billId), billTaskEntity.getTaskId(), Const.AUTO_AGREE_OPTION, billTaskEntity.getUserCode(), "", "", billTaskEntity.getTaskNodeKey(), billTaskEntity.getTaskId());
-
-                            //todo 修改后
-                            // this.billBpmnLogic.complete(billService.getById(billId), billTaskEntity.getTaskId(), Const.AUTO_AGREE_OPTION, billTaskEntity.getUserCode(), "", "", billTaskEntity.getTaskNodeKey(), billTaskEntity.getLastTaskId());
+                            // 自动审批场景：
+                            // 步骤一：先完成本节点审批事件，生成下一个节点的审批信息
+                            // 步骤二：然后在 complete() 中判断是否是最后一个节点，如果不是，继续递归处理
+                            log.info("节点满足自动审批条件，执行自动审批。billId: {}, taskId: {}, nodeKey: {}", 
+                                    billId, billTaskEntity.getTaskId(), billTaskEntity.getTaskNodeKey());
+                            
+                            // 执行自动审批，这会触发下一个节点的创建
+                            // 使用 lastTaskId 作为参数，确保能正确关联上一个节点
+                            this.billBpmnLogic.complete(billService.getById(billId), billTaskEntity.getTaskId(), 
+                                    Const.AUTO_AGREE_OPTION, billTaskEntity.getUserCode(), "", "", 
+                                    billTaskEntity.getTaskNodeKey(), billTaskEntity.getLastTaskId());
 
                             //删除待审批的信息
-                            this.billTaskService.deleteApproval(billId, billTaskEntity.getTaskId(), BillTaskStatus.APPROVAL.getStatus());
+                            this.billTaskService.deleteApproval(billId, billTaskEntity.getTaskId(), 
+                                    BillTaskStatus.APPROVAL.getStatus());
                             
+                            // 返回已创建的节点任务列表（即使已经自动审批，也要返回，确保节点信息被记录）
+                            return billTasks;
                         } else {
                             //转办操作
                             transfer(billTasks, billId);