fix bug

Author: xlorne

springboot-starter-flow/src/main/java/com/codingapi/springboot/flow/service/FlowNextNodeService.java

@@ -2,18 +2,22 @@
 
 import com.codingapi.springboot.flow.bind.BindDataSnapshot;
 import com.codingapi.springboot.flow.bind.IBindData;
+import com.codingapi.springboot.flow.content.FlowContent;
 import com.codingapi.springboot.flow.domain.FlowNode;
+import com.codingapi.springboot.flow.domain.FlowRelation;
 import com.codingapi.springboot.flow.domain.FlowWork;
 import com.codingapi.springboot.flow.domain.Opinion;
 import com.codingapi.springboot.flow.em.FlowSourceDirection;
-import com.codingapi.springboot.flow.event.FlowApprovalEvent;
+import com.codingapi.springboot.flow.error.ErrorResult;
+import com.codingapi.springboot.flow.error.NodeResult;
+import com.codingapi.springboot.flow.error.OperatorResult;
 import com.codingapi.springboot.flow.record.FlowRecord;
 import com.codingapi.springboot.flow.repository.FlowBindDataRepository;
 import com.codingapi.springboot.flow.repository.FlowOperatorRepository;
 import com.codingapi.springboot.flow.user.IFlowOperator;
-import com.codingapi.springboot.framework.event.EventPusher;
 import lombok.Getter;
 
+import java.util.ArrayList;
 import java.util.List;
 
 class FlowNodeService {
@@ -40,6 +44,8 @@ class FlowNodeService {
     private List<FlowRecord> childrenRecords;
     @Getter
     private List<FlowRecord> historyRecords;
+    @Getter
+    private IFlowOperator createOperator;
 
     @Getter
     private BindDataSnapshot snapshot;
@@ -131,7 +137,7 @@ public boolean hasCurrentFlowIsFinish() {
 
 
     /**
-     *  完成所有流程
+     * 完成所有流程
      */
     public void finishFlow() {
         flowRecord.finish();
@@ -209,7 +215,7 @@ public void loadChildrenRecords() {
 
 
     /**
-     *  校验是否后续没有审批记录
+     * 校验是否后续没有审批记录
      */
     public void verifyChildrenRecordsIsEmpty() {
         if (!childrenRecords.isEmpty()) {
@@ -218,7 +224,7 @@ public void verifyChildrenRecordsIsEmpty() {
     }
 
     /**
-     *  校验流程的审批方向
+     * 校验流程的审批方向
      */
     public void verifyFlowSourceDirection() {
         if (flowSourceDirection == null) {
@@ -230,36 +236,139 @@ public void verifyFlowSourceDirection() {
     }
 
 
-    public void createNextRecord(){
+    /**
+     * 加载流程发起者
+     */
+    public void loadCreateOperator() {
+        createOperator = flowOperatorRepository.getFlowOperatorById(flowRecord.getCreateOperatorId());
+    }
 
-        IFlowOperator createOperator = flowOperatorRepository.getFlowOperatorById(flowRecord.getCreateOperatorId());
-        if(flowSourceDirection == FlowSourceDirection.PASS){
-            FlowRecordService flowRecordService = new FlowRecordService(flowOperatorRepository, processId, createOperator, currentOperator, snapshot, opinion, flowWork, flowSourceDirection, historyRecords);
-            FlowNode nextNode = flowRecordService.matcherPassNextNode(flowNode);
-            if (nextNode == null) {
-                throw new IllegalArgumentException("next node not found");
+
+    /**
+     * 获取下一个节点
+     *
+     * @return 下一个节点
+     */
+    public FlowNode matcherNextNode(boolean back) {
+        List<FlowRelation> relations = flowWork.getRelations().stream()
+                .filter(relation -> relation.sourceMatcher(flowNode.getCode()))
+                .filter(relation -> relation.isBack() == back)
+                .sorted((o1, o2) -> (o2.getOrder() - o1.getOrder()))
+                .toList();
+        if (relations.isEmpty()) {
+            throw new IllegalArgumentException("relation not found");
+        }
+        FlowContent flowContent = new FlowContent(flowWork, flowNode, createOperator, currentOperator, snapshot.toBindData(), opinion, historyRecords);
+        List<FlowNode> flowNodes = new ArrayList<>();
+        for (FlowRelation flowRelation : relations) {
+            FlowNode node = flowRelation.trigger(flowContent);
+            if (node != null) {
+                flowNodes.add(node);
             }
-            List<FlowRecord> records = flowRecordService.createRecord(preId, nextNode);
-            flowRecordService2.flowRecordRepository.save(records);
+        }
+        if (flowNodes.isEmpty()) {
+            throw new IllegalArgumentException("next node not found");
+        }
+        return flowNodes.get(0);
+    }
 
-            for (FlowRecord record : records) {
-                IFlowOperator pushOperator = flowOperatorRepository.getFlowOperatorById(record.getCurrentOperatorId());
-                EventPusher.push(new FlowApprovalEvent(FlowApprovalEvent.STATE_TODO, record, pushOperator,flowWork));
+    /**
+     * 异常匹配
+     *
+     * @param currentNode     当前节点
+     * @param currentOperator 当前操作者
+     * @return 流程记录
+     */
+    private List<FlowRecord> errMatcher(FlowNode currentNode, IFlowOperator currentOperator) {
+        if (currentNode.hasErrTrigger()) {
+            FlowContent flowContent = new FlowContent(flowWork, currentNode, createOperator, currentOperator, snapshot.toBindData(), opinion, historyRecords);
+            ErrorResult errorResult = currentNode.errMatcher(flowContent);
+            if (errorResult == null) {
+                throw new IllegalArgumentException("errMatcher match error.");
+            }
+
+            // 匹配操作者
+            if (errorResult.isOperator()) {
+                List<FlowRecord> recordList = new ArrayList<>();
+                List<Long> operatorIds = ((OperatorResult) errorResult).getOperatorIds();
+                List<? extends IFlowOperator> operators = flowOperatorRepository.findByIds(operatorIds);
+                for (IFlowOperator operator : operators) {
+                    FlowContent content = new FlowContent(flowWork, currentNode, createOperator, operator, snapshot.toBindData(), opinion, historyRecords);
+                    String recordTitle = currentNode.generateTitle(content);
+                    FlowRecord record = currentNode.createRecord(flowWork.getId(), processId, preId, recordTitle, createOperator, operator, snapshot);
+                    recordList.add(record);
+                }
+                return recordList;
+            }
+            // 匹配节点
+            if (errorResult.isNode()) {
+                String nodeCode = ((NodeResult) errorResult).getNode();
+                FlowNode node = flowWork.getNodeByCode(nodeCode);
+                if (node == null) {
+                    throw new IllegalArgumentException("node not found.");
+                }
+                List<FlowRecord> recordList = new ArrayList<>();
+                FlowContent content = new FlowContent(flowWork, node, createOperator, currentOperator, snapshot.toBindData(), opinion, historyRecords);
+                List<? extends IFlowOperator> matcherOperators = node.loadFlowNodeOperator(content, flowOperatorRepository);
+                if (!matcherOperators.isEmpty()) {
+                    for (IFlowOperator matcherOperator : matcherOperators) {
+                        String recordTitle = node.generateTitle(content);
+                        FlowRecord record = node.createRecord(flowWork.getId(), processId, preId, recordTitle, createOperator, matcherOperator, snapshot);
+                        recordList.add(record);
+                    }
+                }
+                return recordList;
+            }
+            throw new IllegalArgumentException("errMatcher not match.");
+        }
+        throw new IllegalArgumentException("operator not match.");
+    }
+
+
+    /**
+     * 创建流程记录
+     *
+     * @param currentNode 当前节点
+     * @return 流程记录
+     */
+    public List<FlowRecord> createRecord(FlowNode currentNode, IFlowOperator currentOperator) {
+        FlowContent flowContent = new FlowContent(flowWork, currentNode, createOperator, currentOperator, snapshot.toBindData(), opinion, historyRecords);
+        long workId = flowWork.getId();
+        List<? extends IFlowOperator> operators = currentNode.loadFlowNodeOperator(flowContent, flowOperatorRepository);
+        if (operators.isEmpty()) {
+            List<FlowRecord> errorRecordList = this.errMatcher(currentNode, currentOperator);
+            if (errorRecordList.isEmpty()) {
+                throw new IllegalArgumentException("operator not match.");
             }
+            return errorRecordList;
+        } else {
+            String recordTitle = currentNode.generateTitle(flowContent);
+            List<FlowRecord> recordList = new ArrayList<>();
+            for (IFlowOperator operator : operators) {
+                FlowRecord record = currentNode.createRecord(workId, processId, preId, recordTitle, createOperator, operator, snapshot);
+                recordList.add(record);
+            }
+            return recordList;
         }
+    }
 
 
-        if(flowSourceDirection == FlowSourceDirection.REJECT){
+    private List<FlowRecord> createPassRecord() {
+        if (flowSourceDirection == FlowSourceDirection.PASS) {
+            FlowNode nextNode = this.matcherNextNode(false);
+            return this.createRecord(nextNode, currentOperator);
+        }
+        return null;
+    }
 
+    private List<FlowRecord> createCustomBackRecord() {
+        if (flowSourceDirection == FlowSourceDirection.REJECT) {
             // 设置了退回流程
-            if(flowWork.hasBackRelation()){
-
-                FlowRecordService flowRecordService = new FlowRecordService(flowOperatorRepository, processId, createOperator, currentOperator, snapshot, opinion, flowWork, flowSourceDirection, historyRecords);
-                FlowNode nextNode = flowRecordService.matcherBackNextNode(flowNode);
+            if (flowWork.hasBackRelation()) {
+                FlowNode nextNode = this.matcherNextNode(true);
                 if (nextNode == null) {
                     throw new IllegalArgumentException("next node not found");
                 }
-
                 IFlowOperator flowOperator = currentOperator;
                 if (nextNode.isAnyOperatorMatcher()) {
                     // 如果是任意人员操作时则需要指定为当时审批人员为当前审批人员
@@ -269,16 +378,15 @@ public void createNextRecord(){
                     }
                     flowOperator = flowOperatorRepository.getFlowOperatorById(preFlowRecord.getCurrentOperatorId());
                 }
-                flowRecordService.changeCurrentOperator(flowOperator);
-                List<FlowRecord> records = flowRecordService.createRecord(preId, nextNode);
-                flowRecordService2.flowRecordRepository.save(records);
-
-                for (FlowRecord record : records) {
-                    IFlowOperator pushOperator = flowOperatorRepository.getFlowOperatorById(record.getCurrentOperatorId());
-                    EventPusher.push(new FlowApprovalEvent(FlowApprovalEvent.STATE_TODO, record, pushOperator,flowWork));
-                }
-            }else{
+                return this.createRecord(nextNode, flowOperator);
+            }
+        }
+        return null;
+    }
 
+    private List<FlowRecord> createDefaultBackRecord() {
+        if (flowSourceDirection == FlowSourceDirection.REJECT) {
+            if (!flowWork.hasBackRelation()) {
                 IFlowOperator flowOperator;
                 // 拒绝时，默认返回上一个节点
                 FlowRecord preRecord = flowRecordService2.flowRecordRepository.getFlowRecordById(flowRecord.getPreId());
@@ -287,36 +395,45 @@ public void createNextRecord(){
                     // 继续寻找上一个节点
                     preRecord = flowRecordService2.flowRecordRepository.getFlowRecordById(preRecord.getPreId());
                 }
-
                 // 获取上一个节点的审批者，继续将审批者设置为当前审批者
                 flowOperator = flowOperatorRepository.getFlowOperatorById(preRecord.getCurrentOperatorId());
-
-                FlowRecordService flowRecordService = new FlowRecordService(flowOperatorRepository, processId, createOperator, flowOperator, snapshot, opinion, flowWork, flowSourceDirection, historyRecords);
                 FlowNode nextNode = flowWork.getNodeByCode(preRecord.getNodeCode());
                 if (nextNode == null) {
                     throw new IllegalArgumentException("next node not found");
                 }
-                List<FlowRecord> records = flowRecordService.createRecord(preId, nextNode);
-
-                flowRecordService2.flowRecordRepository.save(records);
-
-                for (FlowRecord record : records) {
-                    IFlowOperator pushOperator = flowOperatorRepository.getFlowOperatorById(record.getCurrentOperatorId());
-                    EventPusher.push(new FlowApprovalEvent(FlowApprovalEvent.STATE_TODO, record, pushOperator,flowWork));
-                }
-
+                return this.createRecord(nextNode, flowOperator);
             }
-
         }
+        return null;
+    }
 
+    private boolean isDefaultBackRecord() {
+        return flowSourceDirection == FlowSourceDirection.REJECT && !flowWork.hasBackRelation();
+    }
 
-        int eventState = flowSourceDirection== FlowSourceDirection.PASS ? FlowApprovalEvent.STATE_PASS : FlowApprovalEvent.STATE_REJECT;
-        EventPusher.push(new FlowApprovalEvent(eventState, flowRecord, currentOperator,flowWork));
+    private boolean isPassBackRecord() {
+        return flowSourceDirection == FlowSourceDirection.PASS;
+    }
 
+    private boolean isCustomBackRecord() {
+        return flowSourceDirection == FlowSourceDirection.REJECT && flowWork.hasBackRelation();
+    }
 
 
+    public List<FlowRecord> createNextRecord() {
+        this.loadCreateOperator();
+        List<FlowRecord> records = null;
+        if (isDefaultBackRecord()) {
+            records = this.createDefaultBackRecord();
+        }
+        if (isCustomBackRecord()) {
+            records = this.createCustomBackRecord();
+        }
+        if (isPassBackRecord()) {
+            records = this.createPassRecord();
+        }
+        return records;
     }
 
 
-
 }