fix #30

Author: xlorne

flow-engine-framework/src/main/java/com/codingapi/flow/context/RepositoryHolderContext.java

@@ -5,13 +5,16 @@
 import com.codingapi.flow.gateway.FlowOperatorGateway;
 import com.codingapi.flow.operator.IFlowOperator;
 import com.codingapi.flow.record.FlowRecord;
+import com.codingapi.flow.record.FlowTodoRecord;
+import com.codingapi.flow.record.FlowTodoMarge;
 import com.codingapi.flow.repository.*;
 import com.codingapi.flow.service.FlowService;
 import com.codingapi.flow.service.impl.FlowActionService;
 import com.codingapi.flow.service.impl.FlowDelayTriggerService;
 import com.codingapi.flow.session.FlowSession;
 import lombok.Getter;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class RepositoryHolderContext {
@@ -29,6 +32,10 @@ private RepositoryHolderContext() {
     @Getter
     private FlowRecordRepository flowRecordRepository;
     @Getter
+    private FlowTodoRecordRepository flowTodoRecordRepository;
+    @Getter
+    private FlowTodoMargeRepository flowTodoMargeRepository;
+    @Getter
     private FlowOperatorGateway flowOperatorGateway;
     @Getter
     private ParallelBranchRepository parallelBranchRepository;
@@ -45,6 +52,8 @@ public boolean isRegistered() {
                 && delayTaskRepository != null
                 && workflowBackupRepository != null
                 && flowRecordRepository != null
+                && flowTodoRecordRepository != null
+                && flowTodoMargeRepository != null
                 && flowOperatorGateway != null
                 && workflowRepository != null
                 && urgeIntervalRepository != null;
@@ -60,13 +69,17 @@ public void verify() {
     public void register(WorkflowRepository workflowRepository,
                          WorkflowBackupRepository workflowBackupRepository,
                          FlowRecordRepository flowRecordRepository,
+                         FlowTodoRecordRepository flowTodoRecordRepository,
+                         FlowTodoMargeRepository flowTodoMargeRepository,
                          FlowOperatorGateway flowOperatorGateway,
                          ParallelBranchRepository parallelBranchRepository,
                          DelayTaskRepository delayTaskRepository,
                          UrgeIntervalRepository urgeIntervalRepository) {
         this.workflowRepository = workflowRepository;
         this.workflowBackupRepository = workflowBackupRepository;
         this.flowRecordRepository = flowRecordRepository;
+        this.flowTodoRecordRepository = flowTodoRecordRepository;
+        this.flowTodoMargeRepository = flowTodoMargeRepository;
         this.flowOperatorGateway = flowOperatorGateway;
         this.parallelBranchRepository = parallelBranchRepository;
         this.delayTaskRepository = delayTaskRepository;
@@ -97,10 +110,7 @@ public FlowDelayTriggerService createDelayTriggerService(DelayTask task) {
      */
     public FlowActionService createFlowActionService(FlowSession flowSession) {
         this.verify();
-        return new FlowActionService(flowSession.toActionRequest(),
-                flowOperatorGateway,
-                flowRecordRepository,
-                workflowBackupRepository);
+        return new FlowActionService(flowSession.toActionRequest());
     }
 
 
@@ -114,6 +124,8 @@ public FlowService createFlowService() {
         return new FlowService(workflowRepository,
                 flowOperatorGateway,
                 flowRecordRepository,
+                flowTodoRecordRepository,
+                flowTodoMargeRepository,
                 workflowBackupRepository,
                 parallelBranchRepository,
                 delayTaskRepository,
@@ -142,12 +154,15 @@ public void deleteDelayTask(DelayTask delayTask) {
         delayTaskRepository.delete(delayTask);
     }
 
+
     public void saveRecords(List<FlowRecord> flowRecords) {
-        flowRecordRepository.saveAll(flowRecords);
+        FlowRecordRepositoryService flowRecordRepositoryService = new FlowRecordRepositoryService(flowRecords);
+        flowRecordRepositoryService.saveAll();
     }
 
     public void saveRecord(FlowRecord flowRecord) {
-        flowRecordRepository.save(flowRecord);
+        FlowRecordRepositoryService flowRecordRepositoryService = new FlowRecordRepositoryService(flowRecord);
+        flowRecordRepositoryService.saveAll();
     }
 
     public List<FlowRecord> findCurrentNodeRecords(long fromId, String nodeId) {
@@ -179,4 +194,109 @@ public List<DelayTask> findDelayTasks() {
     }
 
 
+    private static class FlowRecordRepositoryService {
+
+        private final List<FlowRecord> flowRecords;
+        private final FlowTodoRecordRepository flowTodoRecordRepository;
+        private final FlowTodoMargeRepository flowTodoMargeRepository;
+        private final FlowRecordRepository flowRecordRepository;
+
+
+        public FlowRecordRepositoryService(List<FlowRecord> flowRecords) {
+            this.flowTodoRecordRepository = RepositoryHolderContext.getInstance().getFlowTodoRecordRepository();
+            this.flowTodoMargeRepository = RepositoryHolderContext.getInstance().getFlowTodoMargeRepository();
+            this.flowRecordRepository = RepositoryHolderContext.getInstance().getFlowRecordRepository();
+            this.flowRecords = flowRecords;
+        }
+
+        public FlowRecordRepositoryService(FlowRecord flowRecord) {
+            this.flowTodoRecordRepository = RepositoryHolderContext.getInstance().getFlowTodoRecordRepository();
+            this.flowTodoMargeRepository = RepositoryHolderContext.getInstance().getFlowTodoMargeRepository();
+            this.flowRecordRepository = RepositoryHolderContext.getInstance().getFlowRecordRepository();
+            this.flowRecords = new ArrayList<>();
+            this.flowRecords.add(flowRecord);
+        }
+
+
+        private void saveTodoMargeRecords() {
+            List<FlowTodoRecord> flowTodoRecords = new ArrayList<>();
+            for (FlowRecord flowRecord : flowRecords) {
+                if (flowRecord.isTodo()) {
+                    FlowTodoRecord todoMargeRecord = null;
+                    if (flowRecord.isMergeable()) {
+                        todoMargeRecord = flowTodoRecordRepository.getByMageKey(flowRecord.getMergeKey());
+                        if (todoMargeRecord == null) {
+                            todoMargeRecord = new FlowTodoRecord(flowRecord);
+                        } else {
+                            todoMargeRecord.update(flowRecord);
+                            todoMargeRecord.addMargeCount();
+                        }
+                    } else {
+                        todoMargeRecord = new FlowTodoRecord(flowRecord);
+                    }
+                    flowTodoRecords.add(todoMargeRecord);
+                }
+            }
+            if (!flowTodoRecords.isEmpty()) {
+                flowTodoRecordRepository.saveAll(flowTodoRecords);
+            }
+
+            if (!flowTodoRecords.isEmpty()) {
+                List<FlowTodoMarge> relationList = new ArrayList<>();
+                for (FlowTodoRecord margeRecord : flowTodoRecords) {
+                    if(margeRecord.isMergeable()) {
+                        relationList.add(new FlowTodoMarge(margeRecord));
+                    }
+                }
+                flowTodoMargeRepository.saveAll(relationList);
+            }
+        }
+
+        private void saveRecords() {
+            if (!flowRecords.isEmpty()) {
+                flowRecordRepository.saveAll(flowRecords);
+            }
+        }
+
+
+        private void removeTodoMargeRecords() {
+            for (FlowRecord flowRecord : flowRecords) {
+                if (flowRecord.isDone()) {
+                    if (flowRecord.isMergeable()) {
+                        FlowTodoRecord todoMargeRecord = flowTodoRecordRepository.getByMageKey(flowRecord.getMergeKey());
+                        if(todoMargeRecord!=null) {
+                            List<FlowTodoMarge> margeRelations = flowTodoMargeRepository.findByTodoId(todoMargeRecord.getId());
+                            if(margeRelations!=null && !margeRelations.isEmpty()) {
+                                for (FlowTodoMarge margeRelation : margeRelations) {
+                                    if (margeRelation.isRecord(flowRecord.getId())) {
+                                        flowTodoMargeRepository.remove(margeRelation);
+                                        todoMargeRecord.divMargeCount();
+                                        if (todoMargeRecord.hasMargeCount()) {
+                                            flowTodoRecordRepository.save(todoMargeRecord);
+                                        } else {
+                                            flowTodoRecordRepository.remove(todoMargeRecord);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        FlowTodoRecord todoMargeRecord = flowTodoRecordRepository.getByMageKey(flowRecord.getMergeKey());
+                        if (todoMargeRecord != null) {
+                            flowTodoRecordRepository.remove(todoMargeRecord);
+                        }
+                    }
+                }
+            }
+        }
+
+        public void saveAll() {
+            this.saveRecords();
+            this.saveTodoMargeRecords();
+            this.removeTodoMargeRecords();
+        }
+
+
+    }
+
 }

flow-engine-framework/src/main/java/com/codingapi/flow/record/FlowRecord.java

@@ -190,7 +190,7 @@ public class FlowRecord {
     private long timeoutTime;
     /**
      * 是否可合并
-     * {@link FlowRecord#getMergeId()}
+     * {@link FlowRecord#getMergeKey()}
      */
     private boolean mergeable;
     /**
@@ -227,11 +227,11 @@ public class FlowRecord {
      * 数据合并的依据,当开启时值为固定值，否则为随机数据
      * 相同的 {@link FlowRecord#currentOperatorId} {@link FlowRecord#workBackupId} {@link FlowRecord#nodeId}字段的数据合并到一条记录上。
      */
-    public String getMergeId() {
+    public String getMergeKey() {
         if (mergeable) {
             return String.format("%s-%s-%s", currentOperatorId, workBackupId, nodeId);
         } else {
-            return RandomUtils.generateStringId();
+            return String.valueOf(id);
         }
     }
 
@@ -352,6 +352,13 @@ public boolean isTodo() {
         return recordState == SATE_RECORD_TODO && flowState == SATE_FLOW_RUNNING && !hidden && !revoked;
     }
 
+    /**
+     *  是否已办
+     */
+    public boolean isDone() {
+        return recordState == SATE_RECORD_DONE && !hidden && !revoked;
+    }
+
 
     /**
      * 判断是否已完成

flow-engine-framework/src/main/java/com/codingapi/flow/record/FlowTodoMarge.java

@@ -0,0 +1,40 @@
+package com.codingapi.flow.record;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ *  存储待办合并的记录，仅当开启流程记录合并时才会产生合并记录数据
+ * {@link FlowRecord#isMergeable()} 为true时才会产生
+ */
+@Getter
+@AllArgsConstructor
+public class FlowTodoMarge {
+
+    @Setter
+    private long id;
+    /**
+     * 待办id
+     */
+    private long todoId;
+    /**
+     * 待办记录id
+     */
+    private long recordId;
+    /**
+     * 创建时间
+     */
+    private long createTime;
+
+    public FlowTodoMarge(FlowTodoRecord margeRecord){
+        this.todoId = margeRecord.getId();
+        this.recordId = margeRecord.getRecordId();
+        this.createTime = margeRecord.getCreateTime();
+    }
+
+
+    public boolean isRecord(long recordId) {
+        return this.recordId == recordId;
+    }
+}