feat(web): 适配flowable

gringotts-web/pom.xml

@@ -12,6 +12,11 @@
     <artifactId>gringotts-web</artifactId>
 
     <dependencies>
+        <dependency>
+            <groupId>com.lanyuanxiaoyao</groupId>
+            <artifactId>flowable</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
         <dependency>
             <groupId>com.eshore</groupId>
             <artifactId>gringotts-configuration</artifactId>
@@ -28,16 +33,6 @@
             <groupId>com.blinkfox</groupId>
             <artifactId>fenix-spring-boot-starter</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.dromara.warm</groupId>
-            <artifactId>warm-flow-jpa-sb-starter</artifactId>
-            <version>1.3.6</version>
-        </dependency>
-        <dependency>
-            <groupId>org.dromara.warm</groupId>
-            <artifactId>warm-flow-plugin-ui-sb-web</artifactId>
-            <version>1.3.6</version>
-        </dependency>
         <dependency>
             <groupId>org.hibernate</groupId>
             <artifactId>hibernate-jpamodelgen</artifactId>

gringotts-web/src/main/java/com/eshore/gringotts/web/WebApplication.java

@@ -4,14 +4,10 @@ import com.blinkfox.fenix.EnableFenix;
 import com.eshore.gringotts.web.domain.entity.User;
 import com.eshore.gringotts.web.domain.service.UserService;
 import com.ulisesbocchio.jasyptspringboot.annotation.EnableEncryptableProperties;
-import javax.annotation.Resource;
-import lombok.extern.slf4j.Slf4j;
-import org.dromara.warm.flow.core.service.DefService;
 import org.springframework.boot.ApplicationArguments;
 import org.springframework.boot.ApplicationRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.boot.autoconfigure.domain.EntityScan;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
@@ -25,12 +21,7 @@ import org.springframework.scheduling.annotation.EnableAsync;
  * @author lanyuanxiaoyao
  * @date 2024-11-14
  */
-@Slf4j
 @SpringBootApplication(scanBasePackages = {"com.eshore.gringotts"})
-@EntityScan({
-    "com.eshore.gringotts.web.domain.entity",
-    "org.dromara.warm.flow.orm.entity"
-})
 @EnableFenix
 @EnableJpaAuditing
 @EnableAsync
@@ -48,15 +39,10 @@ public class WebApplication implements ApplicationRunner {
     SpringApplication.run(WebApplication.class, args);
   }
 
-  @Resource
-  private DefService defService;
-
   @Override
   public void run(ApplicationArguments args) throws Exception {
     // 初始化系统管理员
     userService.initial();
-
-
   }
 
   @Bean

gringotts-web/src/main/java/com/eshore/gringotts/web/configuration/SaTokenConfiguration.java

@@ -30,8 +30,6 @@ public class SaTokenConfiguration implements WebMvcConfigurer {
                   .notMatch("/pages/**")
                   .notMatch("/user/**")
                   .notMatch("/upload/download/**")
-                  .notMatch("/warm-flow-ui/**")
-                  .notMatch("/warm-flow/**")
                   .check(r -> {
                     try {
                       StpUtil.checkLogin();

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/base/controller/CheckingController.java

@@ -1,34 +0,0 @@
-package com.eshore.gringotts.web.domain.base.controller;
-
-import com.eshore.gringotts.web.configuration.amis.AmisResponse;
-import com.eshore.gringotts.web.domain.base.entity.CheckingNeededEntity;
-import com.eshore.gringotts.web.domain.base.service.CheckingService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-
-/**
- * @author wn
- * @version 20241224
- */
-@Slf4j
-public abstract class CheckingController<ENTITY extends CheckingNeededEntity, SAVE_ITEM, LIST_ITEM, DETAIL_ITEM> extends SimpleControllerSupport<ENTITY, SAVE_ITEM, LIST_ITEM, DETAIL_ITEM> {
-  private final CheckingService<ENTITY> checkingService;
-
-  public CheckingController(CheckingService<ENTITY> service) {
-    super(service);
-    this.checkingService = service;
-  }
-
-  @GetMapping("/submit/{id}")
-  public AmisResponse<Object> submit(@PathVariable Long id) throws Exception {
-    checkingService.submit(id);
-    return AmisResponse.responseSuccess();
-  }
-
-  @GetMapping("/retract/{id}")
-  public AmisResponse<Object> retract(@PathVariable Long id) throws Exception {
-    checkingService.retract(id);
-    return AmisResponse.responseSuccess();
-  }
-}

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/base/entity/CheckingNeededEntity.java

@@ -1,6 +1,6 @@
 package com.eshore.gringotts.web.domain.base.entity;
 
-import com.eshore.gringotts.web.domain.entity.CheckOrder;
+import com.eshore.gringotts.web.domain.entity.order.CheckOrder;
 import javax.persistence.CascadeType;
 import javax.persistence.Column;
 import javax.persistence.EntityListeners;

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/base/service/CheckingService.java

@@ -2,7 +2,7 @@ package com.eshore.gringotts.web.domain.base.service;
 
 import com.eshore.gringotts.web.domain.base.entity.LogicDeleteEntity;
 import com.eshore.gringotts.web.domain.base.repository.SimpleRepository;
-import com.eshore.gringotts.web.domain.entity.CheckOrder;
+import com.eshore.gringotts.web.domain.entity.order.CheckOrder;
 import com.eshore.gringotts.web.domain.service.UserService;
 import javax.persistence.EntityManager;
 import org.eclipse.collections.api.map.ImmutableMap;

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/controller/AuthenticationController.java

@@ -1,6 +1,6 @@
 package com.eshore.gringotts.web.domain.controller;
 
-import com.eshore.gringotts.web.domain.base.controller.CheckingController;
+import com.eshore.gringotts.web.domain.base.controller.SimpleControllerSupport;
 import com.eshore.gringotts.web.domain.base.entity.FileInfo;
 import com.eshore.gringotts.web.domain.base.entity.SimpleListItem;
 import com.eshore.gringotts.web.domain.base.entity.SimpleSaveItem;
@@ -25,7 +25,7 @@ import org.springframework.web.bind.annotation.RestController;
 @Slf4j
 @RestController
 @RequestMapping("authentication")
-public class AuthenticationController extends CheckingController<Authentication, AuthenticationController.SaveItem, AuthenticationController.ListItem, AuthenticationController.DetailItem> {
+public class AuthenticationController extends SimpleControllerSupport<Authentication, AuthenticationController.SaveItem, AuthenticationController.ListItem, AuthenticationController.DetailItem> {
   private final DataResourceService dataResourceService;
   private final DataFileService dataFileService;
 

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/controller/CheckOrderController.java

@@ -3,9 +3,9 @@ package com.eshore.gringotts.web.domain.controller;
 import com.eshore.gringotts.web.configuration.amis.AmisResponse;
 import com.eshore.gringotts.web.domain.base.controller.ListController;
 import com.eshore.gringotts.web.domain.base.controller.query.Query;
-import com.eshore.gringotts.web.domain.entity.CheckOrder;
+import com.eshore.gringotts.web.domain.entity.order.CheckOrder;
+import com.eshore.gringotts.web.domain.entity.order.node.CheckOrderNode;
 import com.eshore.gringotts.web.domain.service.CheckOrderService;
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.time.LocalDateTime;
@@ -52,13 +52,25 @@ public class CheckOrderController implements ListController<CheckOrderController
     return AmisResponse.responseSuccess(checkOrderService.list().collect(this::toListItem));
   }
 
+  @GetMapping("/approve/{id}")
+  public AmisResponse<Object> approve(@PathVariable Long id) {
+    checkOrderService.approve(id);
+    return AmisResponse.responseSuccess();
+  }
+
+  @GetMapping("/reject/{id}")
+  public AmisResponse<Object> reject(@PathVariable Long id) {
+    checkOrderService.reject(id);
+    return AmisResponse.responseSuccess();
+  }
+
   @SneakyThrows
   private ListItem toListItem(CheckOrder order) {
     ListItem item = new ListItem();
     item.setCheckOrderId(order.getId());
     item.setDescription(order.getDescription());
-    item.setType(order.getType());
-    item.setParameters(mapper.readValue(order.getParameters(), new TypeReference<>() {}));
+    item.setCurrentNode(order.getCurrentNode());
+    item.setParameters(mapper.readValue(order.getContext(), new TypeReference<>() {}));
     item.setState(order.getState());
     item.setCreatedUsername(order.getCreatedUser().getUsername());
     item.setCreatedTime(order.getCreatedTime());
@@ -67,18 +79,11 @@ public class CheckOrderController implements ListController<CheckOrderController
     return item;
   }
 
-  @GetMapping("/operation/{id}/{operation}")
-  public AmisResponse<Object> operation(@PathVariable Long id, @PathVariable CheckOrder.Operation operation) throws JsonProcessingException {
-    log.info("id:{}, operation:{}", id, operation);
-    checkOrderService.operation(id, operation);
-    return AmisResponse.responseSuccess();
-  }
-
   @Data
   public static final class ListItem {
     private Long checkOrderId;
     private String description;
-    private CheckOrder.Type type;
+    private CheckOrderNode currentNode;
     private ImmutableMap<String, Object> parameters;
     private CheckOrder.State state;
     private LocalDateTime createdTime;

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/controller/ConfirmationController.java

@@ -1,6 +1,7 @@
 package com.eshore.gringotts.web.domain.controller;
 
-import com.eshore.gringotts.web.domain.base.controller.CheckingController;
+import com.eshore.gringotts.web.configuration.amis.AmisResponse;
+import com.eshore.gringotts.web.domain.base.controller.SimpleControllerSupport;
 import com.eshore.gringotts.web.domain.base.entity.FileInfo;
 import com.eshore.gringotts.web.domain.base.entity.SimpleListItem;
 import com.eshore.gringotts.web.domain.base.entity.SimpleSaveItem;
@@ -8,12 +9,15 @@ import com.eshore.gringotts.web.domain.entity.Confirmation;
 import com.eshore.gringotts.web.domain.service.ConfirmationService;
 import com.eshore.gringotts.web.domain.service.DataFileService;
 import com.eshore.gringotts.web.domain.service.DataResourceService;
+import com.fasterxml.jackson.core.JsonProcessingException;
 import java.time.LocalDateTime;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.collections.api.factory.Sets;
 import org.eclipse.collections.api.set.ImmutableSet;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -24,16 +28,24 @@ import org.springframework.web.bind.annotation.RestController;
 @Slf4j
 @RestController
 @RequestMapping("confirmation")
-public class ConfirmationController extends CheckingController<Confirmation, ConfirmationController.SaveItem, ConfirmationController.ListItem, ConfirmationController.DetailItem> {
+public class ConfirmationController extends SimpleControllerSupport<Confirmation, ConfirmationController.SaveItem, ConfirmationController.ListItem, ConfirmationController.DetailItem> {
+  private final ConfirmationService confirmationService;
   private final DataResourceService dataResourceService;
   private final DataFileService dataFileService;
 
   public ConfirmationController(ConfirmationService service, DataResourceService dataResourceService, DataFileService dataFileService) {
     super(service);
+    this.confirmationService = service;
     this.dataResourceService = dataResourceService;
     this.dataFileService = dataFileService;
   }
 
+  @GetMapping("submit/{id}")
+  public AmisResponse<Object> submit(@PathVariable Long id) throws JsonProcessingException {
+    confirmationService.submit(id);
+    return AmisResponse.responseSuccess();
+  }
+
   @Override
   protected Confirmation fromSaveItem(SaveItem item) throws Exception {
     Confirmation confirmation = new Confirmation();

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/controller/WareController.java

@@ -3,7 +3,7 @@ package com.eshore.gringotts.web.domain.controller;
 import cn.hutool.core.util.StrUtil;
 import com.eshore.gringotts.web.configuration.HostConfiguration;
 import com.eshore.gringotts.web.configuration.amis.AmisResponse;
-import com.eshore.gringotts.web.domain.base.controller.CheckingController;
+import com.eshore.gringotts.web.domain.base.controller.SimpleControllerSupport;
 import com.eshore.gringotts.web.domain.base.entity.SimpleListItem;
 import com.eshore.gringotts.web.domain.base.entity.SimpleSaveItem;
 import com.eshore.gringotts.web.domain.entity.Ware;
@@ -26,7 +26,7 @@ import org.springframework.web.bind.annotation.RestController;
 @Slf4j
 @RestController
 @RequestMapping("ware")
-public class WareController extends CheckingController<Ware, WareController.SaveItem, WareController.ListItem, WareController.DetailItem> {
+public class WareController extends SimpleControllerSupport<Ware, WareController.SaveItem, WareController.ListItem, WareController.DetailItem> {
   private final HostConfiguration hostConfiguration;
   private final WareService wareService;
   private final DataResourceService dataResourceService;

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/entity/order/CheckOrder.java

@@ -1,7 +1,9 @@
-package com.eshore.gringotts.web.domain.entity;
+package com.eshore.gringotts.web.domain.entity.order;
 
 import com.eshore.gringotts.core.Constants;
 import com.eshore.gringotts.web.domain.base.entity.SimpleEntity;
+import com.eshore.gringotts.web.domain.entity.order.node.CheckOrderNode;
+import java.util.List;
 import javax.persistence.Column;
 import javax.persistence.ConstraintMode;
 import javax.persistence.Entity;
@@ -13,6 +15,7 @@ import javax.persistence.ForeignKey;
 import javax.persistence.JoinColumn;
 import javax.persistence.NamedAttributeNode;
 import javax.persistence.NamedEntityGraph;
+import javax.persistence.OneToMany;
 import javax.persistence.OneToOne;
 import javax.persistence.Table;
 import lombok.Getter;
@@ -38,74 +41,34 @@ import org.springframework.data.jpa.domain.support.AuditingEntityListener;
     @NamedAttributeNode(value = "modifiedUser"),
 })
 @NamedEntityGraph(name = "check_order.detail", attributeNodes = {
+    @NamedAttributeNode(value = "nodes"),
     @NamedAttributeNode(value = "createdUser"),
     @NamedAttributeNode(value = "modifiedUser"),
 })
 @NoArgsConstructor
 public class CheckOrder extends SimpleEntity {
   @Column(nullable = false)
-  private String keyword;
+  private String name;
   @Column(nullable = false)
   private String description;
-  @Column(nullable = false)
-  @Enumerated(EnumType.STRING)
-  private Type type;
+
+  @OneToOne(fetch = FetchType.LAZY)
+  @JoinColumn(nullable = false, foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
+  @ToString.Exclude
+  private CheckOrderNode currentNode;
+  @OneToMany(fetch = FetchType.LAZY, mappedBy = "order")
+  @ToString.Exclude
+  private List<CheckOrderNode> nodes;
   /**
    * JSON 结构 Map<String, Object>
    */
   @Column(nullable = false)
-  private String parameters;
-
-  @Column(nullable = false)
-  @Enumerated(EnumType.STRING)
-  private Target target;
-  @Column(nullable = false)
-  private String targetClass;
-  @OneToOne(fetch = FetchType.LAZY)
-  @JoinColumn(foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
-  @ToString.Exclude
-  private User targetUser;
-  @Enumerated(EnumType.STRING)
-  private User.Role targetRole;
+  private String context = "{}";
 
   @Column(nullable = false)
   @Enumerated(EnumType.STRING)
   private State state = State.CHECKING;
 
-  public CheckOrder(
-      String keyword,
-      String description,
-      Type type,
-      String parameters,
-      String targetClass,
-      User targetUser
-  ) {
-    this.keyword = keyword;
-    this.description = description;
-    this.type = type;
-    this.parameters = parameters;
-    this.target = Target.USER;
-    this.targetClass = targetClass;
-    this.targetUser = targetUser;
-  }
-
-  public CheckOrder(
-      String keyword,
-      String description,
-      Type type,
-      String parameters,
-      String targetClass,
-      User.Role targetRole
-  ) {
-    this.keyword = keyword;
-    this.description = description;
-    this.type = type;
-    this.parameters = parameters;
-    this.target = Target.ROLE;
-    this.targetClass = targetClass;
-    this.targetRole = targetRole;
-  }
-
   public enum Operation {
     APPLY,
     REJECT,

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/entity/order/node/CheckOrderNode.java

@@ -0,0 +1,49 @@
+package com.eshore.gringotts.web.domain.entity.order.node;
+
+import com.eshore.gringotts.core.Constants;
+import com.eshore.gringotts.web.domain.base.entity.IdOnlyEntity;
+import com.eshore.gringotts.web.domain.entity.order.CheckOrder;
+import javax.persistence.Column;
+import javax.persistence.ConstraintMode;
+import javax.persistence.Entity;
+import javax.persistence.EntityListeners;
+import javax.persistence.FetchType;
+import javax.persistence.ForeignKey;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.Table;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicUpdate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+/**
+ * @author lanyuanxiaoyao
+ * @version 20241225
+ */
+@Getter
+@Setter
+@ToString
+@Entity
+@DynamicUpdate
+@EntityListeners(AuditingEntityListener.class)
+@Table(name = Constants.TABLE_PREFIX + "check_order_node")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+public abstract class CheckOrderNode extends IdOnlyEntity {
+  @Column(nullable = false)
+  private Integer sequence;
+  @ManyToOne(fetch = FetchType.LAZY)
+  @JoinColumn(nullable = false, foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
+  @ToString.Exclude
+  private CheckOrder order;
+
+  public abstract Type getCheckType();
+
+  public enum Type {
+    USER,
+    ROLE,
+  }
+}

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/entity/order/node/RoleCheckOrderNode.java

@@ -0,0 +1,38 @@
+package com.eshore.gringotts.web.domain.entity.order.node;
+
+import com.eshore.gringotts.core.Constants;
+import com.eshore.gringotts.web.domain.entity.User;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+/**
+ * 指定用户审核
+ *
+ * @author lanyuanxiaoyao
+ * @version 20241225
+ */
+@Getter
+@Setter
+@ToString
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = Constants.TABLE_PREFIX + "check_order_node_role")
+public class RoleCheckOrderNode extends CheckOrderNode {
+  @Column(nullable = false)
+  @Enumerated(EnumType.STRING)
+  private User.Role target;
+
+  @Override
+  public Type getCheckType() {
+    return Type.ROLE;
+  }
+}

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/entity/order/node/UserCheckOrderNode.java

@@ -0,0 +1,41 @@
+package com.eshore.gringotts.web.domain.entity.order.node;
+
+import com.eshore.gringotts.core.Constants;
+import com.eshore.gringotts.web.domain.entity.User;
+import javax.persistence.ConstraintMode;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ForeignKey;
+import javax.persistence.JoinColumn;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+/**
+ * 指定用户审核
+ *
+ * @author lanyuanxiaoyao
+ * @version 20241225
+ */
+@Getter
+@Setter
+@ToString
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = Constants.TABLE_PREFIX + "check_order_node_user")
+public class UserCheckOrderNode extends CheckOrderNode {
+  @OneToOne(fetch = FetchType.EAGER)
+  @JoinColumn(nullable = false, foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
+  @ToString.Exclude
+  private User target;
+
+  @Override
+  public Type getCheckType() {
+    return Type.USER;
+  }
+}

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/flowable/FlowDatabaseRepository.java

@@ -0,0 +1,126 @@
+package com.eshore.gringotts.web.domain.flowable;
+
+import com.eshore.gringotts.web.domain.entity.order.CheckOrder;
+import com.eshore.gringotts.web.domain.entity.order.node.CheckOrderNode;
+import com.eshore.gringotts.web.domain.entity.order.node.RoleCheckOrderNode;
+import com.eshore.gringotts.web.domain.entity.order.node.UserCheckOrderNode;
+import com.eshore.gringotts.web.domain.flowable.node.RoleCheckFlowNode;
+import com.eshore.gringotts.web.domain.flowable.node.UserCheckFlowNode;
+import com.eshore.gringotts.web.domain.repository.CheckOrderNodeRepository;
+import com.eshore.gringotts.web.domain.service.CheckOrderService;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.lanyuanxiaoyao.flowable.model.Flow;
+import com.lanyuanxiaoyao.flowable.model.FlowStatus;
+import com.lanyuanxiaoyao.flowable.node.FlowNode;
+import com.lanyuanxiaoyao.flowable.repository.FlowRepository;
+import java.util.stream.Collectors;
+import lombok.SneakyThrows;
+import org.eclipse.collections.api.factory.Lists;
+import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
+import org.springframework.stereotype.Service;
+
+/**
+ * @author lanyuanxiaoyao
+ * @version 20241225
+ */
+@Service
+public class FlowDatabaseRepository implements FlowRepository {
+  private final CheckOrderService checkOrderService;
+  private final CheckOrderNodeRepository checkOrderNodeRepository;
+  private final ObjectMapper mapper;
+
+  public FlowDatabaseRepository(CheckOrderService checkOrderService, CheckOrderNodeRepository checkOrderNodeRepository, Jackson2ObjectMapperBuilder builder) {
+    this.checkOrderService = checkOrderService;
+    this.checkOrderNodeRepository = checkOrderNodeRepository;
+    this.mapper = builder.build();
+  }
+
+  private FlowNode mapTo(CheckOrderNode source) {
+    switch (source.getCheckType()) {
+      case USER:
+        return new UserCheckFlowNode(source.getId().toString(), ((UserCheckOrderNode) source).getTarget());
+      case ROLE:
+        return new RoleCheckFlowNode(source.getId().toString(), ((RoleCheckOrderNode) source).getTarget());
+      default:
+        throw new IllegalArgumentException("Unsupported check type: " + source.getCheckType());
+    }
+  }
+
+  private CheckOrderNode mapTo(FlowNode source) {
+    return checkOrderNodeRepository.findById(Long.valueOf(source.getNodeId())).orElseThrow(() -> new RuntimeException(""));
+  }
+
+  private Flow mapTo(CheckOrder order) throws JsonProcessingException {
+    Flow flow = new Flow();
+    flow.setName(order.getName());
+    flow.setDescription(order.getDescription());
+    flow.setNodes(order.getNodes()
+        .stream()
+        .map(this::mapTo)
+        .collect(Collectors.toList())
+    );
+    flow.setCurrentNode(mapTo(order.getCurrentNode()).getNodeId());
+    switch (order.getState()) {
+      case CHECKING:
+        flow.setStatus(FlowStatus.PENDING);
+        break;
+      case RETRACT:
+        flow.setStatus(FlowStatus.REJECTED);
+        break;
+      case OVER:
+        flow.setStatus(FlowStatus.APPROVED);
+        break;
+    }
+    flow.setContextVariables(mapper.readValue(order.getContext(), new TypeReference<>() {}));
+    flow.setCreateTime(order.getCreatedTime());
+    flow.setUpdateTime(order.getModifiedTime());
+    return flow;
+  }
+
+  private void mapTo(Flow flow, CheckOrder order) throws JsonProcessingException {
+    order.setName(flow.getName());
+    order.setDescription(flow.getDescription());
+    order.setNodes(Lists.mutable.ofAll(flow.getNodes()).collect(this::mapTo));
+    order.setCurrentNode(mapTo(flow.getCurrentNodeObject()));
+    switch (flow.getStatus()) {
+      case APPROVED:
+        order.setState(CheckOrder.State.OVER);
+        break;
+      case PENDING:
+        order.setState(CheckOrder.State.CHECKING);
+        break;
+      case REJECTED:
+        order.setState(CheckOrder.State.RETRACT);
+        break;
+    }
+    order.setContext(mapper.writeValueAsString(flow.getContextVariables()));
+  }
+
+  @SneakyThrows
+  @Override
+  public Flow save(Flow flow) {
+    CheckOrder order = new CheckOrder();
+    mapTo(flow, order);
+    Long id = checkOrderService.save(order);
+    flow.setId(id.toString());
+    return flow;
+  }
+
+  @SneakyThrows
+  @Override
+  public Flow update(Flow flow) {
+    CheckOrder order = checkOrderService.detailOrThrow(Long.parseLong(flow.getId()));
+    mapTo(flow, order);
+    checkOrderService.save(order);
+    return flow;
+  }
+
+  @SneakyThrows
+  @Override
+  public Flow findById(String id) {
+    CheckOrder order = checkOrderService.detailOrThrow(Long.parseLong(id));
+    return mapTo(order);
+  }
+}

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/flowable/node/RoleCheckFlowNode.java

@@ -0,0 +1,19 @@
+package com.eshore.gringotts.web.domain.flowable.node;
+
+import com.eshore.gringotts.web.domain.entity.User;
+import com.lanyuanxiaoyao.flowable.node.AbstractFlowNode;
+import lombok.Getter;
+
+/**
+ * @author lanyuanxiaoyao
+ * @version 20241225
+ */
+@Getter
+public class RoleCheckFlowNode extends AbstractFlowNode {
+  private final User.Role role;
+
+  public RoleCheckFlowNode(String nodeId, User.Role role) {
+    super(nodeId);
+    this.role = role;
+  }
+}

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/flowable/node/UserCheckFlowNode.java

@@ -0,0 +1,34 @@
+package com.eshore.gringotts.web.domain.flowable.node;
+
+import com.eshore.gringotts.web.domain.entity.User;
+import com.eshore.gringotts.web.domain.service.ConfirmationService;
+import com.lanyuanxiaoyao.flowable.model.FlowContext;
+import com.lanyuanxiaoyao.flowable.node.AbstractFlowNode;
+import lombok.Getter;
+
+/**
+ * @author lanyuanxiaoyao
+ * @version 20241225
+ */
+@Getter
+public class UserCheckFlowNode extends AbstractFlowNode {
+  private final User user;
+  private final ConfirmationService confirmationService;
+
+  public UserCheckFlowNode(String nodeId, User user, ConfirmationService confirmationService) {
+    super(nodeId);
+    this.user = user;
+    this.confirmationService = confirmationService;
+  }
+
+  @Override
+  public void onApprove(FlowContext context) {
+    super.onApprove(context);
+    Long confirmationId = context.getVariable("confirmationId", Long.class);
+  }
+
+  @Override
+  public void onReject(FlowContext context) {
+    super.onReject(context);
+  }
+}

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/repository/CheckOrderNodeRepository.java

@@ -0,0 +1,13 @@
+package com.eshore.gringotts.web.domain.repository;
+
+import com.eshore.gringotts.web.domain.base.repository.SimpleRepository;
+import com.eshore.gringotts.web.domain.entity.order.node.CheckOrderNode;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @author lanyuanxiaoyao
+ * @version 20241225
+ */
+@Repository
+public interface CheckOrderNodeRepository extends SimpleRepository<CheckOrderNode, Long> {
+}

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/repository/CheckOrderRepository.java

@@ -1,8 +1,8 @@
 package com.eshore.gringotts.web.domain.repository;
 
 import com.eshore.gringotts.web.domain.base.repository.SimpleRepository;
-import com.eshore.gringotts.web.domain.entity.CheckOrder;
 import com.eshore.gringotts.web.domain.entity.User;
+import com.eshore.gringotts.web.domain.entity.order.CheckOrder;
 import java.util.List;
 import java.util.Optional;
 import javax.transaction.Transactional;

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/service/AuthenticationService.java

@@ -1,29 +1,11 @@
 package com.eshore.gringotts.web.domain.service;
 
 import cn.hutool.core.util.ObjectUtil;
-import cn.hutool.core.util.StrUtil;
-import com.eshore.gringotts.web.domain.base.entity.CheckingNeededEntity;
-import com.eshore.gringotts.web.domain.base.service.CheckingService;
+import com.eshore.gringotts.web.domain.base.service.LogicDeleteService;
 import com.eshore.gringotts.web.domain.entity.Authentication;
-import com.eshore.gringotts.web.domain.entity.Authentication_;
-import com.eshore.gringotts.web.domain.entity.CheckOrder;
-import com.eshore.gringotts.web.domain.entity.CheckOrder_;
-import com.eshore.gringotts.web.domain.entity.User;
 import com.eshore.gringotts.web.domain.repository.AuthenticationRepository;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
 import javax.persistence.EntityManager;
-import javax.persistence.criteria.CriteriaBuilder;
-import javax.persistence.criteria.CriteriaQuery;
-import javax.persistence.criteria.Predicate;
-import javax.persistence.criteria.Root;
-import javax.transaction.Transactional;
 import lombok.extern.slf4j.Slf4j;
-import org.eclipse.collections.api.factory.Lists;
-import org.eclipse.collections.api.factory.Maps;
-import org.eclipse.collections.api.list.ImmutableList;
-import org.eclipse.collections.api.map.ImmutableMap;
-import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 import org.springframework.stereotype.Service;
 
 /**
@@ -31,38 +13,15 @@ import org.springframework.stereotype.Service;
  * @date 2024-12-02
  */
 @Slf4j
-@Service("com.eshore.gringotts.web.domain.service.AuthenticationService")
-public class AuthenticationService extends CheckingService<Authentication> {
+@Service
+public class AuthenticationService extends LogicDeleteService<Authentication> {
   private final AuthenticationRepository authenticationRepository;
   private final UserService userService;
-  private final CheckOrderService checkOrderService;
-  private final ObjectMapper mapper;
 
-  public AuthenticationService(AuthenticationRepository repository, UserService userService, EntityManager manager, CheckOrderService checkOrderService, Jackson2ObjectMapperBuilder builder) {
+  public AuthenticationService(AuthenticationRepository repository, UserService userService, EntityManager manager) {
     super(repository, userService, manager);
     this.authenticationRepository = repository;
     this.userService = userService;
-    this.checkOrderService = checkOrderService;
-    this.mapper = builder.build();
-  }
-
-  @Override
-  protected ImmutableList<Predicate> listPredicate(Root<Authentication> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
-    User loginUser = userService.currentLoginUser();
-    if (User.isAdministrator(loginUser)) {
-      return Lists.immutable.empty();
-    }
-    return Lists.immutable.of(builder.or(
-        builder.equal(root.get(Authentication_.createdUser), loginUser),
-        builder.and(
-            builder.equal(root.get(Authentication_.order).get(CheckOrder_.target), CheckOrder.Target.ROLE),
-            builder.equal(root.get(Authentication_.order).get(CheckOrder_.targetRole), loginUser.getRole())
-        ),
-        builder.and(
-            builder.equal(root.get(Authentication_.order).get(CheckOrder_.target), CheckOrder.Target.USER),
-            builder.equal(root.get(Authentication_.order).get(CheckOrder_.targetUser), loginUser)
-        )
-    ));
   }
 
   @Override
@@ -82,75 +41,6 @@ public class AuthenticationService extends CheckingService<Authentication> {
     return super.save(entity);
   }
 
-  @Transactional(rollbackOn = Throwable.class)
-  @Override
-  public void submit(Long id) throws JsonProcessingException {
-    Authentication authentication = detailOrThrow(id);
-    authentication.setState(CheckingNeededEntity.State.OWNER_CHECKING);
-    Long orderId = checkOrderService.save(new CheckOrder(
-        "authentication_owner_check",
-        StrUtil.format("数据资源「{}」的授权申请", authentication.getTarget().getName()),
-        CheckOrder.Type.AUTHENTICATION,
-        mapper.writeValueAsString(Maps.immutable.of("authenticationId", authentication.getId())),
-        "com.eshore.gringotts.web.domain.service.AuthenticationService",
-        authentication.getCreatedUser()
-    ));
-    CheckOrder order = checkOrderService.detailOrThrow(orderId);
-    authentication.setOrder(order);
-    save(authentication);
-  }
-
-  @Transactional(rollbackOn = Throwable.class)
-  @Override
-  public void retract(Long id) {
-    Authentication authentication = detailOrThrow(id);
-    authentication.setState(Authentication.State.DRAFT);
-    save(authentication);
-
-    CheckOrder order = authentication.getOrder();
-    order.setState(CheckOrder.State.RETRACT);
-    checkOrderService.save(order);
-  }
-
-  @Override
-  @Transactional(rollbackOn = Throwable.class)
-  public void onChecked(CheckOrder order, CheckOrder.Operation operation, ImmutableMap<String, Object> parameters) {
-    Long id = (Long) parameters.get("authenticationId");
-    Authentication authentication = detailOrThrow(id);
-    if (StrUtil.equals(order.getKeyword(), "authentication_owner_check")) {
-      switch (operation) {
-        case APPLY:
-          authentication.setState(Authentication.State.CHECKING);
-          order.setKeyword("authentication_checker_check");
-          order.setTarget(CheckOrder.Target.ROLE);
-          order.setTargetRole(User.Role.CHECKER);
-          break;
-        case REJECT:
-          authentication.setState(Authentication.State.DRAFT);
-          order.setState(CheckOrder.State.OVER);
-          break;
-      }
-    } else if (StrUtil.equals(order.getKeyword(), "authentication_checker_check")) {
-      switch (operation) {
-        case APPLY:
-          authentication.setState(Authentication.State.NORMAL);
-          order.setState(CheckOrder.State.OVER);
-          break;
-        case REJECT:
-          authentication.setState(Authentication.State.DRAFT);
-          order.setState(CheckOrder.State.OVER);
-          break;
-      }
-    }
-    save(authentication);
-    checkOrderService.save(order);
-  }
-
-  @Override
-  public ImmutableMap<String, Object> archive(Authentication authentication) {
-    return null;
-  }
-
   public static final class AuthenticationDuplicatedException extends RuntimeException {
     public AuthenticationDuplicatedException() {
       super("数据资源已绑定该账号的授权申请，无法再次申请");

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/service/CheckOrderService.java

@@ -1,26 +1,12 @@
 package com.eshore.gringotts.web.domain.service;
 
-import cn.hutool.core.util.ObjectUtil;
-import cn.hutool.core.util.StrUtil;
-import com.eshore.gringotts.web.domain.base.service.CheckingService;
 import com.eshore.gringotts.web.domain.base.service.SimpleServiceSupport;
-import com.eshore.gringotts.web.domain.entity.CheckOrder;
-import com.eshore.gringotts.web.domain.entity.CheckOrder_;
-import com.eshore.gringotts.web.domain.entity.User;
+import com.eshore.gringotts.web.domain.entity.order.CheckOrder;
+import com.eshore.gringotts.web.domain.flowable.FlowDatabaseRepository;
 import com.eshore.gringotts.web.domain.repository.CheckOrderRepository;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import javax.persistence.criteria.CriteriaBuilder;
-import javax.persistence.criteria.CriteriaQuery;
-import javax.persistence.criteria.Predicate;
-import javax.persistence.criteria.Root;
+import com.lanyuanxiaoyao.flowable.service.FlowService;
+import javax.transaction.Transactional;
 import lombok.extern.slf4j.Slf4j;
-import org.eclipse.collections.api.factory.Lists;
-import org.eclipse.collections.api.list.ImmutableList;
-import org.eclipse.collections.api.map.ImmutableMap;
-import org.springframework.context.ApplicationContext;
-import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 import org.springframework.stereotype.Service;
 
 /**
@@ -30,53 +16,30 @@ import org.springframework.stereotype.Service;
 @Slf4j
 @Service
 public class CheckOrderService extends SimpleServiceSupport<CheckOrder> {
-  private final ApplicationContext applicationContext;
-  private final ObjectMapper mapper;
-  private final CheckOrderRepository checkOrderRepository;
-  private final UserService userService;
+  private final FlowService flowService;
 
-  public CheckOrderService(CheckOrderRepository repository, UserService userService, ApplicationContext applicationContext, Jackson2ObjectMapperBuilder builder) {
+  public CheckOrderService(CheckOrderRepository repository, UserService userService, FlowDatabaseRepository flowDatabaseRepository) {
     super(repository, userService);
-    this.applicationContext = applicationContext;
-    this.mapper = builder.build();
-    this.checkOrderRepository = repository;
-    this.userService = userService;
+    this.flowService = new FlowService(flowDatabaseRepository);
   }
 
-  @Override
-  protected ImmutableList<Predicate> listPredicate(Root<CheckOrder> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
-    User user = userService.currentLoginUser();
-    if (User.isAdministrator(user)) {
-      return Lists.immutable.empty();
-    }
-    return Lists.immutable.of(builder.or(
-        builder.equal(root.get(CheckOrder_.createdUser), user),
-        builder.and(
-            builder.equal(root.get(CheckOrder_.target), CheckOrder.Target.USER),
-            builder.equal(root.get(CheckOrder_.targetUser), user)
-        ),
-        builder.and(
-            builder.equal(root.get(CheckOrder_.target), CheckOrder.Target.ROLE),
-            builder.equal(root.get(CheckOrder_.targetRole), user.getRole())
-        )
-    ));
+  @Transactional(rollbackOn = Throwable.class)
+  public void startFlow(CheckOrder order) {
+    startFlow(order.getId());
   }
 
-  public void operation(Long id, CheckOrder.Operation operation) throws JsonProcessingException {
-    CheckOrder order = detailOrThrow(id);
-    CheckingService service = applicationContext.getBean(order.getTargetClass(), CheckingService.class);
-    if (ObjectUtil.isNull(service)) {
-      throw new RuntimeException(StrUtil.format("名为「{}」的服务未找到", order.getTargetClass()));
-    }
-    ImmutableMap<String, Object> parameters = mapper.readValue(order.getParameters(), new TypeReference<>() {});
-    service.onChecked(order, operation, parameters);
+  @Transactional(rollbackOn = Throwable.class)
+  public void startFlow(Long id) {
+    flowService.startFlow(id.toString());
   }
 
-  public void retract(Long id) {
-    checkOrderRepository.overById(id, CheckOrder.State.RETRACT, userService.currentLoginUser());
+  @Transactional(rollbackOn = Throwable.class)
+  public void approve(Long id) {
+    flowService.approve(id.toString());
   }
 
-  public void over(Long id) {
-    checkOrderRepository.overById(id, CheckOrder.State.OVER, userService.currentLoginUser());
+  @Transactional(rollbackOn = Throwable.class)
+  public void reject(Long id) {
+    flowService.reject(id.toString());
   }
 }

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/service/ConfirmationService.java

@@ -1,30 +1,19 @@
 package com.eshore.gringotts.web.domain.service;
 
 import cn.hutool.core.util.ObjectUtil;
-import cn.hutool.core.util.StrUtil;
-import com.eshore.gringotts.web.domain.base.entity.CheckingNeededEntity;
-import com.eshore.gringotts.web.domain.base.service.CheckingService;
-import com.eshore.gringotts.web.domain.entity.CheckOrder;
-import com.eshore.gringotts.web.domain.entity.CheckOrder_;
+import com.eshore.gringotts.web.domain.base.service.LogicDeleteService;
 import com.eshore.gringotts.web.domain.entity.Confirmation;
-import com.eshore.gringotts.web.domain.entity.Confirmation_;
 import com.eshore.gringotts.web.domain.entity.User;
+import com.eshore.gringotts.web.domain.entity.order.CheckOrder;
+import com.eshore.gringotts.web.domain.entity.order.node.RoleCheckOrderNode;
 import com.eshore.gringotts.web.domain.repository.ConfirmationRepository;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import javax.persistence.EntityManager;
-import javax.persistence.criteria.CriteriaBuilder;
-import javax.persistence.criteria.CriteriaQuery;
-import javax.persistence.criteria.Join;
-import javax.persistence.criteria.JoinType;
-import javax.persistence.criteria.Predicate;
-import javax.persistence.criteria.Root;
 import javax.transaction.Transactional;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.collections.api.factory.Lists;
 import org.eclipse.collections.api.factory.Maps;
-import org.eclipse.collections.api.list.ImmutableList;
-import org.eclipse.collections.api.map.ImmutableMap;
 import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 import org.springframework.stereotype.Service;
 
@@ -33,8 +22,8 @@ import org.springframework.stereotype.Service;
  * @date 2024-11-26
  */
 @Slf4j
-@Service("com.eshore.gringotts.web.domain.service.ConfirmationService")
-public class ConfirmationService extends CheckingService<Confirmation> {
+@Service
+public class ConfirmationService extends LogicDeleteService<Confirmation> {
   private final ConfirmationRepository confirmationRepository;
   private final CheckOrderService checkOrderService;
   private final ObjectMapper mapper;
@@ -46,31 +35,6 @@ public class ConfirmationService extends CheckingService<Confirmation> {
     this.mapper = builder.build();
   }
 
-  @Override
-  protected ImmutableList<Predicate> listPredicate(Root<Confirmation> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
-    User loginUser = userService.currentLoginUser();
-    if (User.isAdministrator(loginUser)) {
-      return Lists.immutable.empty();
-    }
-    Join<Confirmation, CheckOrder> orderJoin = root.join(Confirmation_.order, JoinType.LEFT);
-    return Lists.immutable.of(builder.or(
-        builder.equal(root.get(Confirmation_.createdUser), loginUser),
-        builder.and(
-            builder.isNotNull(orderJoin),
-            builder.or(
-                builder.and(
-                    builder.equal(orderJoin.get(CheckOrder_.target), CheckOrder.Target.ROLE),
-                    builder.equal(orderJoin.get(CheckOrder_.targetRole), loginUser.getRole())
-                ),
-                builder.and(
-                    builder.equal(orderJoin.get(CheckOrder_.target), CheckOrder.Target.USER),
-                    builder.equal(orderJoin.get(CheckOrder_.targetUser), loginUser)
-                )
-            )
-        )
-    ));
-  }
-
   @Override
   public Long save(Confirmation entity) {
     if (ObjectUtil.isNull(entity.getId()) && confirmationRepository.existsByTarget_Id(entity.getTarget().getId())) {
@@ -80,59 +44,16 @@ public class ConfirmationService extends CheckingService<Confirmation> {
   }
 
   @Transactional(rollbackOn = Throwable.class)
-  @Override
   public void submit(Long id) throws JsonProcessingException {
-    Confirmation confirmation = detailOrThrow(id);
-    confirmation.setState(Confirmation.State.CHECKING);
-    Long orderId = checkOrderService.save(new CheckOrder(
-        "confirmation_check",
-        StrUtil.format("数据资源「{}」的确权申请", confirmation.getTarget().getName()),
-        CheckOrder.Type.CONFIRMATION,
-        mapper.writeValueAsString(Maps.immutable.of("confirmationId", confirmation.getId())),
-        "com.eshore.gringotts.web.domain.service.ConfirmationService",
-        User.Role.CHECKER
+    CheckOrder order = new CheckOrder();
+    order.setName("确权申请");
+    order.setDescription("确权申请");
+    order.setNodes(Lists.mutable.of(
+        new RoleCheckOrderNode(User.Role.CHECKER)
     ));
-    CheckOrder order = checkOrderService.detailOrThrow(orderId);
-    confirmation.setOrder(order);
-    save(confirmation);
-  }
-
-  @Transactional(rollbackOn = Throwable.class)
-  @Override
-  public void retract(Long id) {
-    Confirmation confirmation = detailOrThrow(id);
-    confirmation.setState(CheckingNeededEntity.State.DRAFT);
-    save(confirmation);
-
-    CheckOrder order = confirmation.getOrder();
-    order.setState(CheckOrder.State.RETRACT);
+    order.setContext(mapper.writeValueAsString(Maps.immutable.of("confirmationId", id)));
     checkOrderService.save(order);
-  }
-
-  @Override
-  @Transactional(rollbackOn = Throwable.class)
-  public void onChecked(CheckOrder order, CheckOrder.Operation operation, ImmutableMap<String, Object> parameters) {
-    if (StrUtil.equals(order.getKeyword(), "confirmation_check")) {
-      Long id = (Long) parameters.get("confirmationId");
-      Confirmation confirmation = detailOrThrow(id);
-      switch (operation) {
-        case APPLY:
-          confirmation.setState(Confirmation.State.NORMAL);
-          order.setState(CheckOrder.State.OVER);
-          break;
-        case REJECT:
-          confirmation.setState(Confirmation.State.DRAFT);
-          order.setState(CheckOrder.State.OVER);
-          break;
-      }
-      save(confirmation);
-      checkOrderService.save(order);
-    }
-  }
-
-  @Override
-  public ImmutableMap<String, Object> archive(Confirmation confirmation) {
-    return null;
+    checkOrderService.startFlow(order);
   }
 
   public static final class ConfirmationDuplicatedException extends RuntimeException {

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/service/WareService.java

@@ -1,21 +1,12 @@
 package com.eshore.gringotts.web.domain.service;
 
-import cn.hutool.core.util.StrUtil;
-import com.eshore.gringotts.web.domain.base.service.CheckingService;
-import com.eshore.gringotts.web.domain.entity.CheckOrder;
-import com.eshore.gringotts.web.domain.entity.User;
+import com.eshore.gringotts.web.domain.base.service.LogicDeleteService;
 import com.eshore.gringotts.web.domain.entity.Ware;
 import com.eshore.gringotts.web.domain.repository.WareRepository;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
 import javax.persistence.EntityManager;
-import javax.transaction.Transactional;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.collections.api.factory.Lists;
-import org.eclipse.collections.api.factory.Maps;
 import org.eclipse.collections.api.list.ImmutableList;
-import org.eclipse.collections.api.map.ImmutableMap;
-import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 import org.springframework.stereotype.Service;
 
 /**
@@ -23,17 +14,13 @@ import org.springframework.stereotype.Service;
  * @date 2024-12-13
  */
 @Slf4j
-@Service("com.eshore.gringotts.web.domain.service.WareService")
-public class WareService extends CheckingService<Ware> {
+@Service
+public class WareService extends LogicDeleteService<Ware> {
   private final WareRepository wareRepository;
-  private final CheckOrderService checkOrderService;
-  private final ObjectMapper mapper;
 
-  public WareService(WareRepository repository, UserService userService, EntityManager entityManager, CheckOrderService checkOrderService, Jackson2ObjectMapperBuilder builder) {
+  public WareService(WareRepository repository, UserService userService, EntityManager entityManager) {
     super(repository, userService, entityManager);
     this.wareRepository = repository;
-    this.checkOrderService = checkOrderService;
-    this.mapper = builder.build();
   }
 
   public ImmutableList<Ware> listPublic() {
@@ -41,60 +28,4 @@ public class WareService extends CheckingService<Ware> {
         wareRepository.findAll((root, query, builder) -> builder.equal(root.get("state"), Ware.State.NORMAL))
     );
   }
-
-  @Transactional(rollbackOn = Throwable.class)
-  @Override
-  public void onChecked(CheckOrder order, CheckOrder.Operation operation, ImmutableMap<String, Object> parameters) {
-    if (StrUtil.equals(order.getKeyword(), "ware_check")) {
-      Long wareId = (Long) parameters.get("wareId");
-      Ware ware = detailOrThrow(wareId);
-      switch (operation) {
-        case APPLY:
-          ware.setState(Ware.State.NORMAL);
-          order.setState(CheckOrder.State.OVER);
-          break;
-        case REJECT:
-          ware.setState(Ware.State.DRAFT);
-          order.setState(CheckOrder.State.OVER);
-          break;
-      }
-      save(ware);
-      checkOrderService.save(order);
-    }
-  }
-
-  @Override
-  public ImmutableMap<String, Object> archive(Ware ware) {
-    return null;
-  }
-
-  @Transactional(rollbackOn = Throwable.class)
-  @Override
-  public void submit(Long id) throws JsonProcessingException {
-    Ware ware = detailOrThrow(id);
-    ware.setState(Ware.State.CHECKING);
-    Long orderId = checkOrderService.save(new CheckOrder(
-        "ware_check",
-        StrUtil.format("数据资源「{}」的上架申请", ware.getName()),
-        CheckOrder.Type.MARKET,
-        mapper.writeValueAsString(Maps.immutable.of("wareId", ware.getId())),
-        "com.eshore.gringotts.web.domain.service.WareService",
-        User.Role.CHECKER
-    ));
-    CheckOrder order = checkOrderService.detailOrThrow(orderId);
-    ware.setOrder(order);
-    save(ware);
-  }
-
-  @Transactional(rollbackOn = Throwable.class)
-  @Override
-  public void retract(Long id) {
-    Ware ware = detailOrThrow(id);
-    ware.setState(Ware.State.DRAFT);
-    save(ware);
-
-    CheckOrder order = ware.getOrder();
-    order.setState(CheckOrder.State.RETRACT);
-    checkOrderService.save(order);
-  }
 }

gringotts-web/src/main/java/com/eshore/gringotts/web/helper/EntityHelper.java

@@ -3,9 +3,9 @@ package com.eshore.gringotts.web.helper;
 import cn.hutool.core.util.ObjectUtil;
 import com.eshore.gringotts.web.domain.base.entity.CheckingNeededEntity;
 import com.eshore.gringotts.web.domain.base.entity.CheckingNeededEntity_;
-import com.eshore.gringotts.web.domain.entity.CheckOrder;
 import com.eshore.gringotts.web.domain.entity.CheckOrder_;
 import com.eshore.gringotts.web.domain.entity.User;
+import com.eshore.gringotts.web.domain.entity.order.CheckOrder;
 import java.util.function.Supplier;
 import javax.persistence.criteria.CriteriaBuilder;
 import javax.persistence.criteria.Predicate;

gringotts-web/src/main/resources/application.yml

@@ -34,8 +34,6 @@ logging:
           sdk:
             eventsub:
               EventSubscribeImp: error
-warm-flow:
-  jpa_persistence_provider: org.springframework.orm.jpa.vendor.SpringHibernateJpaPersistenceProvider
 
 ---
 spring: