流程状态为审批中，但是节点状态为已同意

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

@@ -38,16 +38,13 @@ import com.srm.bpm.logic.dto.UserInfoDTO;
 import com.srm.bpm.logic.dto.UserOrgDTO;
 import com.srm.bpm.logic.dto.UserPositionDTO;
 import com.srm.bpm.logic.error.BillCode;
-import com.srm.bpm.logic.service.BillBpmnLogic;
-import com.srm.bpm.logic.service.BillItemLogic;
-import com.srm.bpm.logic.service.CallBackLogic;
-import com.srm.bpm.logic.service.FlowMsgLogic;
-import com.srm.bpm.logic.service.UserCenterlogic;
+import com.srm.bpm.logic.service.*;
 import com.srm.bpm.logic.vo.FormPermissionVO;
 import com.srm.bpm.logic.constant.FormConst;
 import com.srm.common.data.exception.RbException;
 import com.srm.common.util.datetime.DateTimeUtil;
 
+import com.srm.config.SpringContextHolder;
 import org.activiti.bpmn.model.BpmnModel;
 import org.activiti.bpmn.model.FlowElement;
 import org.activiti.bpmn.model.FlowNode;
@@ -484,7 +481,7 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
 //        if (task == null) {
 //            throw new RbException(BillCode.TASK_NOT_FOUND);
 //        }
-        Map<String, Object> variables = Maps.newHashMap();
+        /*Map<String, Object> variables = Maps.newHashMap();
         variables.put(BpmnConst.VAR_OPINION, opinion);
         variables.put(BpmnConst.VAR_APPROVER_EMPLOYEE, userCode);
         variables.put(BpmnConst.VAR_ACTION, BillAction.agree.name());
@@ -493,10 +490,265 @@ public class BillBpmnLogicImpl implements BillBpmnLogic {
         variables.put(BpmnConst.VAR_LAST_TASK_ID, lastTaskId);
         variables.put(BpmnConst.VAR_AGREE_DATA, JSON.parseObject(formData, Map.class));
         taskService.complete(taskId, variables);
-        return true;
+        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());
+                // 检查归档条件并触发回调
+                checkAndTriggerArchiveCallback(bill, taskId);
+                // 检查流程是否应该结束
+                checkAndCompleteBillIfNeeded(bill);
+                return true;
+            } else {
+                log.warn("Activiti任务不存在，可能已经被删除。taskId: {}, billId: {}，跳过完成操作。业务数据已更新。",
+                        taskId, bill != null ? bill.getId() : null);
+                // 检查归档条件并触发回调
+                checkAndTriggerArchiveCallback(bill, taskId);
+                // 检查流程是否应该结束
+                checkAndCompleteBillIfNeeded(bill);
+                return true; // 业务数据已更新，返回成功
+            }
+        }
+
+        Map<String, Object> variables = Maps.newHashMap();
+        variables.put(BpmnConst.VAR_OPINION, opinion);
+        variables.put(BpmnConst.VAR_APPROVER_EMPLOYEE, userCode);
+        variables.put(BpmnConst.VAR_ACTION, BillAction.agree.name());
+        variables.put(BpmnConst.VAR_NEXT_APPROVER, nextApprover);
+        variables.put(BpmnConst.VAR_LAST_NODE_KEY, lastTaskNodeId);
+        variables.put(BpmnConst.VAR_LAST_TASK_ID, lastTaskId);
+        // 安全处理 formData，避免空值或 null 导致解析失败
+        if (!Strings.isNullOrEmpty(formData) && !"null".equals(formData) && !"{}".equals(formData)) {
+            try {
+                variables.put(BpmnConst.VAR_AGREE_DATA, JSON.parseObject(formData, Map.class));
+            } catch (Exception e) {
+                log.warn("解析 formData 失败，使用空 Map。billId: {}, taskId: {}, formData: {}", 
+                        bill != null ? bill.getId() : null, taskId, formData);
+                variables.put(BpmnConst.VAR_AGREE_DATA, Maps.newHashMap());
+            }
+        } else {
+            variables.put(BpmnConst.VAR_AGREE_DATA, Maps.newHashMap());
+        }
+
+        try {
+            taskService.complete(taskId, variables);
+
+            // 任务完成后，先检查归档条件并触发回调
+            checkAndTriggerArchiveCallback(bill, taskId);
+
+            // 任务完成后，立即检查流程是否结束，如果结束则触发回调
+            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)) {
+                        // 检查历史流程实例是否已结束
+                        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);
+                            triggerBillCompleteCallback(bill);
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            // 如果流程未结束，检查是否应该结束（用于处理没有Activiti任务但业务任务已完成的情况）
+            checkAndCompleteBillIfNeeded(bill);
+            return true;
+        } catch (org.activiti.engine.ActivitiObjectNotFoundException e) {
+            log.warn("完成Activiti任务时发生异常，任务可能已被删除。taskId: {}, billId: {}, 错误: {}",
+                    taskId, bill != null ? bill.getId() : null, e.getMessage());
+            // 检查归档条件并触发回调
+            checkAndTriggerArchiveCallback(bill, taskId);
+            // 业务数据已更新，检查流程是否应该结束
+            checkAndCompleteBillIfNeeded(bill);
+            return true;
+        }
+
     }
 
     /**
+     * 检查归档条件并触发回调
+     * 如果 toa_bill 的 status 为 1（审批中）且 bill_task 的最后一个节点审批状态为 2（已同意），则触发回调
+     *
+     * @param bill 审批单实体
+     * @param taskId 任务ID
+     */
+    private void checkAndTriggerArchiveCallback(ToaBillEntity bill, String taskId) {
+        if (bill == null || bill.getId() == null) {
+            return;
+        }
+
+        try {
+            // 重新查询最新的bill数据，确保使用最新状态
+            final ToaBillEntity latestBill = billService.getById(bill.getId());
+            if (latestBill == null) {
+                return;
+            }
+
+            // 检查 toa_bill 的 status 是否为 1（审批中）
+            if (latestBill.getStatus() != BillStatus.APPROVAL.getStatus()) {
+                return;
+            }
+
+            // 查找最后一个节点的 bill_task，按 sort 降序排列取第一个
+            final List<BillTaskEntity> billTasks = billTaskService.list(
+                    com.baomidou.mybatisplus.core.toolkit.Wrappers.lambdaQuery(BillTaskEntity.class)
+                            .eq(BillTaskEntity::getBillId, latestBill.getId())
+                            .eq(BillTaskEntity::getIsDeleted, 0)
+                            .orderByDesc(BillTaskEntity::getSort)
+                            .last("LIMIT 1")
+            );
+
+            if (CollectionUtil.isEmpty(billTasks)) {
+                return;
+            }
+
+            final BillTaskEntity lastTask = billTasks.get(0);
+
+            // 检查最后一个节点的审批状态是否为 2（已同意）
+            if (lastTask.getNodeStatus() == BillTaskStatus.AGREE.getStatus()) {
+                // 检查最后一个任务是否是归档节点
+                final Long processId = latestBill.getProcessId();
+                if (processId != null && !Strings.isNullOrEmpty(lastTask.getTaskNodeKey())) {
+                    final Optional<ProcessNodeExtendEntity> nodeExtendOpt = nodeExtendService
+                            .findByNodeIdAndProcessId(processId, lastTask.getTaskNodeKey());
+
+                    if (nodeExtendOpt.isPresent()) {
+                        final ProcessNodeExtendEntity nodeExtend = nodeExtendOpt.get();
+                        final String linkType = nodeExtend.getLinkType();
+
+                        // 如果是归档节点，触发回调
+                        if (NodeLinkType.archive.name().equals(linkType)) {
+                            log.info("检测到归档节点且满足条件：toa_bill status=1（审批中），最后一个节点 status=2（已同意）。触发回调。billId: {}, taskId: {}, lastTaskNodeKey: {}",
+                                    latestBill.getId(), taskId, lastTask.getTaskNodeKey());
+                            triggerBillCompleteCallback(latestBill);
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            log.error("检查归档条件并触发回调时发生异常。billId: {}, taskId: {}, 错误: {}",
+                    bill != null ? bill.getId() : null, taskId, e.getMessage(), e);
+        }
+    }
+
+    /**
+     * 触发审批单完成逻辑和回调
+     *
+     * @param bill 审批单实体
+     */
+    private void triggerBillCompleteCallback(ToaBillEntity bill) {
+        if (bill == null || bill.getId() == null) {
+            return;
+        }
+
+        try {
+            log.info("触发审批单完成逻辑和回调。billId: {}", bill.getId());
+            final BillLogic billLogic = SpringContextHolder.getBean(BillLogic.class);
+            // 重新查询最新的bill数据，确保使用最新状态
+            final ToaBillEntity latestBill = billService.getById(bill.getId());
+            if (latestBill != null && latestBill.getStatus() != BillStatus.COMPLETE.getStatus()) {
+                billLogic.complete(latestBill, BillAction.agree.name());
+                log.info("已成功触发审批单完成逻辑和回调。billId: {}", bill.getId());
+            } else if (latestBill != null && latestBill.getStatus() == BillStatus.COMPLETE.getStatus()) {
+                log.debug("审批单已完成，无需再次触发。billId: {}", bill.getId());
+            }
+        } catch (Exception e) {
+            log.error("触发审批单完成逻辑和回调时发生异常。billId: {}, 错误: {}", bill.getId(), e.getMessage(), e);
+        }
+    }
+
+    /**
+     * 检查审批单是否应该完成，如果是最后一个节点且没有待审批任务，则完成审批单
+     * 
+     * @param bill 审批单实体
+     */
+    public void checkAndCompleteBillIfNeeded(ToaBillEntity bill) {
+        if (bill == null || bill.getId() == 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::getNodeStatus, BillTaskStatus.APPROVAL.getStatus())
+                            .eq(BillTaskEntity::getIsDeleted, 0)
+            );
+            
+            // 如果没有待审批任务，说明所有任务都已完成
+            if (CollectionUtil.isEmpty(approvalTasks)) {
+                // 检查流程实例状态
+                final String processInstanceId = bill.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)
+                                .singleResult();
+                        
+                        if (historicProcessInstance != null && historicProcessInstance.getEndTime() != null) {
+                            // 流程已结束
+                            log.info("流程实例已结束，但审批单状态未更新。billId: {}, processInstanceId: {}", bill.getId(), processInstanceId);
+                            shouldComplete = true;
+                        } else {
+                            // 流程实例不存在或未结束，但也没有待办任务和待审批任务，应该完成
+                            log.info("没有待办任务和待审批任务，流程应该结束。billId: {}, processInstanceId: {}", bill.getId(), processInstanceId);
+                            shouldComplete = true;
+                        }
+                    }
+                } else {
+                    // 流程实例ID为空，但所有bill_task都已完成，应该完成审批单
+                    log.info("流程实例ID为空，但所有任务都已完成，应该完成审批单。billId: {}", bill.getId());
+                    shouldComplete = true;
+                }
+                
+                if (shouldComplete && bill.getStatus() != BillStatus.COMPLETE.getStatus()) {
+                    // 审批单状态不是完成，需要触发完成逻辑和回调
+                    log.info("检测到流程应该结束，但审批单状态未更新。手动触发审批单完成逻辑和回调。billId: {}, 当前状态: {}", 
+                            bill.getId(), bill.getStatus());
+                    triggerBillCompleteCallback(bill);
+                }
+            }
+        } catch (Exception e) {
+            log.error("检查审批单完成状态时发生异常。billId: {}, 错误: {}", bill.getId(), e.getMessage(), e);
+        }
+    }
+    
+    /**
      * 审批拒绝接口
      *
      * @param taskId   审批任务

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

@@ -179,11 +179,65 @@ public class BillNextNodeLogicImpl implements BillNextNodeLogic {
         // 构建流程变量
         final BpmnBillContext bpmnBillContext = billBpmnLogic.createBpmnContext(employeeId, billDataValue);
         final String nodeKey = billTask.getTaskNodeKey();
-        final Task task = taskService.createTaskQuery().taskDefinitionKey(nodeKey).processInstanceId(processInstanceId).singleResult();
+/*        final Task task = taskService.createTaskQuery().taskDefinitionKey(nodeKey).processInstanceId(processInstanceId).singleResult();
         final BpmnModel bpmnModel = repositoryService.getBpmnModel(task.getProcessDefinitionId());
         final List<Process> processes = bpmnModel.getProcesses();
         final Process process = processes.get(0);
+        final FlowElement flowElement = process.getFlowElement(nodeKey);*/
+        if (Strings.isNullOrEmpty(nodeKey)) {
+            log.error("任务节点标识为空，billTaskId: {}", billTask.getId());
+            return Pair.of(0, StrUtil.EMPTY);
+        }
+
+        // 先尝试从运行时任务获取流程定义ID
+        String processDefinitionId = null;
+        final Task task = taskService.createTaskQuery().taskDefinitionKey(nodeKey).processInstanceId(processInstanceId).singleResult();
+        if (task != null) {
+            processDefinitionId = task.getProcessDefinitionId();
+            log.debug("从运行时任务获取流程定义ID: {}", processDefinitionId);
+        } else {
+            log.warn("未找到对应的Activiti运行时任务，taskId: {}, nodeKey: {}, processInstanceId: {}，尝试从流程定义获取", taskId, nodeKey, processInstanceId);
+            // 如果任务不存在，从流程定义获取
+            if (!Strings.isNullOrEmpty(processDetailDTO.getFlowId())) {
+                final ProcessDefinition processDefinition = findLastVersionByFlowId(processDetailDTO.getFlowId());
+                if (processDefinition != null) {
+                    processDefinitionId = processDefinition.getId();
+                    log.debug("从流程定义获取流程定义ID: {}", processDefinitionId);
+                } else {
+                    log.error("未找到流程定义，flowId: {}", processDetailDTO.getFlowId());
+                    return Pair.of(0, StrUtil.EMPTY);
+                }
+            } else {
+                log.error("流程FlowId为空，无法获取流程定义");
+                return Pair.of(0, StrUtil.EMPTY);
+            }
+        }
+
+        if (Strings.isNullOrEmpty(processDefinitionId)) {
+            log.error("流程定义ID为空，无法获取BPMN模型");
+            return Pair.of(0, StrUtil.EMPTY);
+        }
+
+        final BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
+        if (bpmnModel == null) {
+            log.error("未找到对应的BPMN模型，processDefinitionId: {}", processDefinitionId);
+            return Pair.of(0, StrUtil.EMPTY);
+        }
+        final List<Process> processes = bpmnModel.getProcesses();
+        if (CollectionUtil.isEmpty(processes)) {
+            log.error("BPMN模型中未找到流程定义，processDefinitionId: {}", processDefinitionId);
+            return Pair.of(0, StrUtil.EMPTY);
+        }
+        final Process process = processes.get(0);
+        if (process == null) {
+            log.error("流程定义对象为空，processDefinitionId: {}", processDefinitionId);
+            return Pair.of(0, StrUtil.EMPTY);
+        }
         final FlowElement flowElement = process.getFlowElement(nodeKey);
+        if (flowElement == null) {
+            log.error("未找到对应的流程节点，nodeKey: {}, processDefinitionId: {}", nodeKey, processDefinitionId);
+            return Pair.of(0, StrUtil.EMPTY);
+        }
         return getCorrespondConnection(flowElement, formDataMap, bpmnBillContext);
     }