fix #123

Author: xlorne

springboot-starter-flow/src/main/java/com/codingapi/springboot/flow/em/FlowType.java

@@ -24,7 +24,11 @@ public enum FlowType {
     /**
      * 等待执行
      */
-    WAITING;
+    WAITING,
+    /**
+     * 删除
+     */
+    DELETE;
 
 
     public static FlowType parser(String type){

springboot-starter-flow/src/main/java/com/codingapi/springboot/flow/event/FlowApprovalEvent.java

@@ -38,6 +38,10 @@ public class FlowApprovalEvent implements ISyncEvent {
     public static final int STATE_SAVE = 10;
     // 删除
     public static final int STATE_DELETE = 11;
+    // 退回
+    public static final int STATE_BACK = 12;
+    // 作废
+    public static final int STATE_VOIDED = 13;
 
 
     private final int state;
@@ -110,4 +114,16 @@ public boolean isRecall() {
     public boolean isFinish() {
         return state == STATE_FINISH;
     }
+
+    public boolean isDelete() {
+        return state == STATE_DELETE;
+    }
+
+    public boolean isVoided() {
+        return state == STATE_VOIDED;
+    }
+
+    public boolean isBack() {
+        return state == STATE_BACK;
+    }
 }

springboot-starter-flow/src/main/java/com/codingapi/springboot/flow/record/FlowProcess.java

@@ -33,10 +33,24 @@ public class FlowProcess {
     private long createOperatorId;
 
 
+    /**
+     * 是否作废
+     */
+    private boolean voided;
+
+    /**
+     * 作废流程
+     */
+    public void voided(){
+        this.voided = true;
+    }
+
+
     public FlowProcess(long backupId, IFlowOperator createOperator) {
         this.processId = RandomGenerator.generateUUID();
         this.createTime = System.currentTimeMillis();
         this.backupId = backupId;
         this.createOperatorId = createOperator.getUserId();
+        this.voided = false;
     }
 }

springboot-starter-flow/src/main/java/com/codingapi/springboot/flow/record/FlowRecord.java

@@ -395,6 +395,13 @@ public void recall() {
         this.updateTime = System.currentTimeMillis();
     }
 
+    /**
+     * 删除流程
+     */
+    public void delete() {
+        this.flowType = FlowType.DELETE;
+        this.updateTime = System.currentTimeMillis();
+    }
 
     /**
      * 复制流程记录
@@ -430,6 +437,10 @@ public FlowRecord copy() {
         return record;
     }
 
+    public boolean isDelete() {
+        return this.flowType == FlowType.DELETE;
+    }
+
 
     /**
      * 是否超时

springboot-starter-flow/src/main/java/com/codingapi/springboot/flow/repository/FlowProcessRepository.java

@@ -10,9 +10,9 @@ public interface FlowProcessRepository {
 
     void save(FlowProcess flowProcess);
 
-
     FlowWork getFlowWorkByProcessId(String processId);
 
+    FlowProcess getFlowProcessByProcessId(String processId);
 
     void deleteByProcessId(String processId);
 

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

@@ -28,6 +28,8 @@ public class FlowService {
     private final FlowTransferService flowTransferService;
     private final FlowPostponedService flowPostponedService;
     private final FlowUrgeService flowUrgeService;
+    private final FlowVoidedService flowVoidedService;
+    private final FlowBackService flowBackService;
 
     private final FlowServiceRepositoryHolder flowServiceRepositoryHolder;
 
@@ -47,6 +49,8 @@ public FlowService(FlowWorkRepository flowWorkRepository,
         this.flowTransferService = new FlowTransferService(flowWorkRepository, flowRecordRepository, flowBindDataRepository, flowProcessRepository);
         this.flowPostponedService = new FlowPostponedService(flowWorkRepository, flowRecordRepository, flowProcessRepository);
         this.flowUrgeService = new FlowUrgeService(flowWorkRepository, flowRecordRepository, flowProcessRepository);
+        this.flowVoidedService = new FlowVoidedService(flowWorkRepository, flowRecordRepository, flowProcessRepository, flowBindDataRepository);
+        this.flowBackService = new FlowBackService(flowWorkRepository, flowRecordRepository, flowProcessRepository, flowBindDataRepository);
     }
 
     /**
@@ -287,4 +291,27 @@ public void recall(long recordId, IFlowOperator currentOperator) {
     public void remove(long recordId, IFlowOperator currentOperator) {
         flowRemoveService.remove(recordId, currentOperator);
     }
+
+
+    /**
+     * 作废流程
+     *
+     * @param processId       流程processId
+     * @param currentOperator 当前操作者
+     */
+    public void voided(String processId, IFlowOperator currentOperator) {
+        flowVoidedService.voided(processId, currentOperator);
+    }
+
+
+    /**
+     * 退回流程
+     *
+     * @param processId       流程processId
+     * @param backNodeCode    退回节点编码
+     * @param currentOperator 当前操作者
+     */
+    public void back(String processId, String backNodeCode, IFlowOperator currentOperator) {
+        flowBackService.back(processId, backNodeCode, currentOperator);
+    }
 }

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

@@ -0,0 +1,101 @@
+package com.codingapi.springboot.flow.service.impl;
+
+import com.codingapi.springboot.flow.bind.IBindData;
+import com.codingapi.springboot.flow.domain.FlowWork;
+import com.codingapi.springboot.flow.event.FlowApprovalEvent;
+import com.codingapi.springboot.flow.record.FlowProcess;
+import com.codingapi.springboot.flow.record.FlowRecord;
+import com.codingapi.springboot.flow.repository.FlowBindDataRepository;
+import com.codingapi.springboot.flow.repository.FlowProcessRepository;
+import com.codingapi.springboot.flow.repository.FlowRecordRepository;
+import com.codingapi.springboot.flow.repository.FlowWorkRepository;
+import com.codingapi.springboot.flow.user.IFlowOperator;
+import com.codingapi.springboot.framework.event.EventPusher;
+import lombok.AllArgsConstructor;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * 流程退回服务（流程管理员操作）
+ */
+@Transactional
+@AllArgsConstructor
+public class FlowBackService {
+
+    private final FlowWorkRepository flowWorkRepository;
+    private final FlowRecordRepository flowRecordRepository;
+    private final FlowProcessRepository flowProcessRepository;
+    private final FlowBindDataRepository flowBindDataRepository;
+
+
+    /**
+     * 退回流程
+     *
+     * @param processId       流程processId
+     * @param backNodeCode    退回节点编码
+     * @param currentOperator 当前操作者
+     */
+    public void back(String processId, String backNodeCode, IFlowOperator currentOperator) {
+        if (!currentOperator.isFlowManager()) {
+            throw new IllegalArgumentException("current operator not flow manager");
+        }
+
+        FlowProcess flowProcess = flowProcessRepository.getFlowProcessByProcessId(processId);
+        if (flowProcess.isVoided()) {
+            throw new IllegalArgumentException("flow process already voided");
+        }
+
+        List<FlowRecord> historyRecords = flowRecordRepository
+                .findFlowRecordByProcessId(processId)
+                .stream()
+                .sorted(Comparator.comparingLong(FlowRecord::getId))
+                .collect(Collectors.toList());
+
+        for (FlowRecord flowRecord : historyRecords) {
+            if (flowRecord.isFinish()) {
+                throw new IllegalArgumentException("flow record already finish");
+            }
+        }
+
+        if (historyRecords.isEmpty()) {
+            throw new IllegalArgumentException("flow record not found");
+        }
+
+        List<String> historyNodeCodes = historyRecords.stream()
+                .map(FlowRecord::getNodeCode)
+                .distinct()
+                .collect(Collectors.toList());
+
+        if (!historyNodeCodes.contains(backNodeCode)) {
+            throw new IllegalArgumentException("flow node code not found");
+        }
+
+        FlowRecord beginRecord = historyRecords.get(0);
+        for (FlowRecord flowRecord : historyRecords) {
+            if(flowRecord.getNodeCode().equals(backNodeCode)){
+                beginRecord = flowRecord;
+            }
+        }
+
+        for (FlowRecord flowRecord : historyRecords) {
+            if(flowRecord.getId()> beginRecord.getId() ){
+                flowRecord.delete();
+            }else {
+                if(flowRecord.getNodeCode().equals(beginRecord.getNodeCode())){
+                    flowRecord.recall();
+                }
+            }
+        }
+
+        flowRecordRepository.save(historyRecords);
+
+        FlowWork flowWork = flowWorkRepository.getFlowWorkByCode(beginRecord.getWorkCode());
+        IBindData bindData = flowBindDataRepository.getBindDataSnapshotById(beginRecord.getSnapshotId()).toBindData();
+
+        EventPusher.push(new FlowApprovalEvent(FlowApprovalEvent.STATE_BACK, beginRecord, currentOperator, flowWork, bindData), true);
+
+    }
+}

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

@@ -15,7 +15,7 @@
 import lombok.AllArgsConstructor;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.Collections;
+import java.util.ArrayList;
 import java.util.List;
 
 @Transactional
@@ -53,14 +53,17 @@ public void recall(long recordId, IFlowOperator currentOperator) {
         List<FlowRecord> childrenRecords = flowRecordRepository.findFlowRecordByPreId(recordId);
 
         BindDataSnapshot bindDataSnapshot = flowBindDataRepository.getBindDataSnapshotById(flowRecord.getSnapshotId());
+
         // 下一流程均为办理且未读
 
         // 如果是在开始节点撤销，则直接删除
         if (flowRecord.isStartRecord() && flowRecord.isTodo()) {
             if (!childrenRecords.isEmpty()) {
                 throw new IllegalArgumentException("flow record not recall");
             }
-            flowRecordRepository.delete(Collections.singletonList(flowRecord));
+            List<FlowRecord> flowRecords = new ArrayList<>();
+            flowRecords.add(flowRecord);
+            flowRecordRepository.delete(flowRecords);
         } else {
             // 如果是在中间节点撤销，则需要判断是否所有的子流程都是未读状态
             if (childrenRecords.isEmpty()) {
@@ -74,9 +77,11 @@ public void recall(long recordId, IFlowOperator currentOperator) {
             flowRecord.recall();
             flowRecordRepository.update(flowRecord);
 
-            flowRecordRepository.delete(childrenRecords);
+            for(FlowRecord childrenRecord : childrenRecords) {
+                childrenRecord.delete();
+            }
+            flowRecordRepository.save(childrenRecords);
         }
-
         IBindData bindData =  bindDataSnapshot.toBindData();
 
         EventPusher.push(new FlowApprovalEvent(FlowApprovalEvent.STATE_RECALL, flowRecord, currentOperator, flowWork, bindData), true);

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

@@ -5,6 +5,7 @@
 import com.codingapi.springboot.flow.domain.FlowNode;
 import com.codingapi.springboot.flow.domain.FlowWork;
 import com.codingapi.springboot.flow.event.FlowApprovalEvent;
+import com.codingapi.springboot.flow.record.FlowProcess;
 import com.codingapi.springboot.flow.record.FlowRecord;
 import com.codingapi.springboot.flow.repository.FlowBindDataRepository;
 import com.codingapi.springboot.flow.repository.FlowProcessRepository;
@@ -16,7 +17,6 @@
 import lombok.AllArgsConstructor;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.Collections;
 import java.util.List;
 
 @Transactional
@@ -54,12 +54,18 @@ public void remove(long recordId, IFlowOperator currentOperator) {
         if(!flowNode.isStartNode()){
             throw new IllegalArgumentException("flow record not remove");
         }
-
         BindDataSnapshot bindDataSnapshot = flowBindDataRepository.getBindDataSnapshotById(flowRecord.getSnapshotId());
         IBindData bindData =  bindDataSnapshot.toBindData();
 
-        flowProcessRepository.deleteByProcessId(flowRecord.getProcessId());
-        flowRecordRepository.deleteByProcessId(flowRecord.getProcessId());
+        FlowProcess flowProcess =  flowProcessRepository.getFlowProcessByProcessId(flowRecord.getProcessId());
+        flowProcess.voided();
+        flowProcessRepository.save(flowProcess);
+
+        List<FlowRecord> historyRecords = flowRecordRepository.findFlowRecordByProcessId(flowRecord.getProcessId());
+        for (FlowRecord record : historyRecords) {
+            record.delete();
+        }
+        flowRecordRepository.save(historyRecords);
 
         EventPusher.push(new FlowApprovalEvent(FlowApprovalEvent.STATE_DELETE, flowRecord, currentOperator, flowWork, bindData), true);
     }