update

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/common/enums/SubTaskStatusEnum.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/common/enums/ExecutionTaskStatusEnum.java

@@ -8,7 +8,7 @@ import lombok.Getter;
  * @author supeng
  */
 @Getter
-public enum SubTaskStatusEnum {
+public enum ExecutionTaskStatusEnum {
     INIT(0, "初始化"),
     SUBMITTED(1, "已提交"),
     RUNNING(2, "运行中"),
@@ -19,7 +19,7 @@ public enum SubTaskStatusEnum {
     private final Integer value;
     private final String desc;
 
-    SubTaskStatusEnum(Integer value, String desc) {
+    ExecutionTaskStatusEnum(Integer value, String desc) {
         this.value = value;
         this.desc = desc;
     }

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/common/enums/SubTaskTypeEnum.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/common/enums/ExecutionTaskTypeEnum.java

@@ -8,19 +8,19 @@ import lombok.Getter;
  * @author supeng
  */
 @Getter
-public enum SubTaskTypeEnum {
+public enum ExecutionTaskTypeEnum {
     DECONSTRUCT(1, "解构"),
     CLUSTER(2, "聚类");
 
     private final Integer value;
     private final String desc;
 
-    SubTaskTypeEnum(Integer value, String desc) {
+    ExecutionTaskTypeEnum(Integer value, String desc) {
         this.value = value;
         this.desc = desc;
     }
-    public static SubTaskTypeEnum getInstance(Integer value) {
-        for (SubTaskTypeEnum subTaskTypeEnum : SubTaskTypeEnum.values()) {
+    public static ExecutionTaskTypeEnum getInstance(Integer value) {
+        for (ExecutionTaskTypeEnum subTaskTypeEnum : ExecutionTaskTypeEnum.values()) {
             if (subTaskTypeEnum.getValue().equals(value)) {
                 return subTaskTypeEnum;
             }

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/integration/ContentDeconstructionClient.java

@@ -1,6 +1,6 @@
 package com.tzld.piaoquan.sde.integration;
 
-import com.tzld.piaoquan.sde.model.entity.SdSubTask;
+import com.tzld.piaoquan.sde.model.entity.SdExecutionTask;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
@@ -15,11 +15,11 @@ public class ContentDeconstructionClient {
     /**
      * 提交解构任务
      *
-     * @param sdSubTask 子任务
+     * @param sdExecutionTask 执行任务
      * @return 解构任务ID
      */
-    public String submitDeconstructionTask(SdSubTask sdSubTask) {
-        if (sdSubTask == null) {
+    public String submitDeconstructionTask(SdExecutionTask sdExecutionTask) {
+        if (sdExecutionTask == null) {
 
         }
         return "";

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdTaskResultMapper.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdExecutionTaskMapper.java

@@ -1,10 +1,10 @@
 package com.tzld.piaoquan.sde.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.tzld.piaoquan.sde.model.entity.SdTaskResult;
+import com.tzld.piaoquan.sde.model.entity.SdExecutionTask;
 import org.apache.ibatis.annotations.Mapper;
 
 @Mapper
-public interface SdTaskResultMapper extends BaseMapper<SdTaskResult> {
+public interface SdExecutionTaskMapper extends BaseMapper<SdExecutionTask> {
 
 }

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdExecutionTaskRawResultMapper.java

@@ -0,0 +1,10 @@
+package com.tzld.piaoquan.sde.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.tzld.piaoquan.sde.model.entity.SdExecutionTaskRawResult;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface SdExecutionTaskRawResultMapper extends BaseMapper<SdExecutionTaskRawResult> {
+
+}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdExecutionTaskResultItemMapper.java

@@ -0,0 +1,10 @@
+package com.tzld.piaoquan.sde.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.tzld.piaoquan.sde.model.entity.SdExecutionTaskResultItem;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface SdExecutionTaskResultItemMapper extends BaseMapper<SdExecutionTaskResultItem> {
+
+}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdSubTaskMapper.java

@@ -1,10 +0,0 @@
-package com.tzld.piaoquan.sde.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.tzld.piaoquan.sde.model.entity.SdSubTask;
-import org.apache.ibatis.annotations.Mapper;
-
-@Mapper
-public interface SdSubTaskMapper extends BaseMapper<SdSubTask> {
-
-}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdSubTaskRawResultMapper.java

@@ -1,10 +0,0 @@
-package com.tzld.piaoquan.sde.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.tzld.piaoquan.sde.model.entity.SdSubTaskRawResult;
-import org.apache.ibatis.annotations.Mapper;
-
-@Mapper
-public interface SdSubTaskRawResultMapper extends BaseMapper<SdSubTaskRawResult> {
-
-}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdTaskMapper.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdWorkflowTaskMapper.java

@@ -1,10 +1,10 @@
 package com.tzld.piaoquan.sde.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.tzld.piaoquan.sde.model.entity.SdTask;
+import com.tzld.piaoquan.sde.model.entity.SdWorkflowTask;
 import org.apache.ibatis.annotations.Mapper;
 
 @Mapper
-public interface SdTaskMapper extends BaseMapper<SdTask> {
+public interface SdWorkflowTaskMapper extends BaseMapper<SdWorkflowTask> {
 
 }

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdSubTaskResultItemMapper.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/mapper/SdWorkflowTaskResultMapper.java

@@ -1,10 +1,10 @@
 package com.tzld.piaoquan.sde.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.tzld.piaoquan.sde.model.entity.SdSubTaskResultItem;
+import com.tzld.piaoquan.sde.model.entity.SdWorkflowTaskResult;
 import org.apache.ibatis.annotations.Mapper;
 
 @Mapper
-public interface SdSubTaskResultItemMapper extends BaseMapper<SdSubTaskResultItem> {
+public interface SdWorkflowTaskResultMapper extends BaseMapper<SdWorkflowTaskResult> {
 
 }

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdSubTask.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdExecutionTask.java

@@ -3,47 +3,41 @@ package com.tzld.piaoquan.sde.model.entity;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
-import com.tzld.piaoquan.sde.common.enums.SubTaskStatusEnum;
-import com.tzld.piaoquan.sde.common.enums.SubTaskTypeEnum;
 import lombok.Data;
 
 import java.util.Date;
 
 /**
- * 供需子任务表
+ * 执行任务表
  *
  * @author supeng
  */
 @Data
-@TableName("sd_sub_task")
-public class SdSubTask {
+@TableName("sd_execution_task")
+public class SdExecutionTask {
     /**
      * 主键ID
      */
     @TableId(type = IdType.AUTO)
     private Long id;
     /**
-     * 父任务ID，关联 sd_task.id
+     * 执行任务编号，用于异步回调时的精确匹配 & 对外暴露
      */
-    private Long taskId;
-    /**
-     * 子任务业务编号，用于异步回调时的精确匹配 & 对外暴露
-     */
-    private String subTaskNo;
+    private String taskNo;
     /**
      * 内容ID，videoId等
      */
     private String contentId;
     /**
-     * 子任务类型：1 DECONSTRUCT(解构), 2 CLUSTER(聚类)
+     * 执行任务编号：1 DECONSTRUCT(解构), 2 CLUSTER(聚类)
      *
-     * @see SubTaskTypeEnum
+     * @see com.tzld.piaoquan.sde.common.enums.ExecutionTaskTypeEnum
      */
-    private Integer subTaskType;
+    private Integer taskType;
     /**
      * 执行状态：0 INIT, 1 SUBMITTED(已提交), 2 RUNNING(运行中), 3 SUCCESS, 4 FAILED 5 TIMEOUT
      *
-     * @see SubTaskStatusEnum
+     * @see com.tzld.piaoquan.sde.common.enums.ExecutionTaskStatusEnum
      */
     private Integer taskStatus;
     /**

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdSubTaskRawResult.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdExecutionTaskRawResult.java

@@ -8,22 +8,22 @@ import lombok.Data;
 import java.util.Date;
 
 /**
- * 子任务原始结果表
+ * 执行任务原始结果表
  *
  * @author supeng
  */
 @Data
-@TableName("sd_sub_task_raw_result")
-public class SdSubTaskRawResult {
+@TableName("sd_execution_task_raw_result")
+public class SdExecutionTaskRawResult {
     /**
      * 主键ID
      */
     @TableId(type = IdType.AUTO)
     private Long id;
     /**
-     * 关联子任务ID，关联 sd_sub_task.id
+     * 关联子任务ID，关联 sd_execution_task.id
      */
-    private Long subTaskId;
+    private Long executionTaskId;
     /**
      * 原始结果数据
      */

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdSubTaskResultItem.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdExecutionTaskResultItem.java

@@ -8,24 +8,24 @@ import lombok.Data;
 import java.util.Date;
 
 /**
- * 子任务结果明细项表
+ * 执行任务结果明细项表
  *
  * @author supeng
  */
 @Data
-@TableName("sd_sub_task_result_item")
-public class SdSubTaskResultItem {
+@TableName("sd_execution_task_result_item")
+public class SdExecutionTaskResultItem {
     /**
      * 主键ID
      */
     @TableId(type = IdType.AUTO)
     private Long id;
     /**
-     * 来源子任务ID，关联 sd_sub_task.id
+     * 来源子任务ID，关联 sd_execution_task.id
      */
-    private Long subTaskId;
+    private Long executionTaskId;
     /**
-     * 明细类型：1 灵感点, 2 目的点-意图, 3 关键点
+     * 明细类型：1 灵感点, 2 目的点-意图, 3 关键点等；会随业务变化
      */
     private Integer itemType;
     /**

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdPromptTemplate.java

@@ -24,6 +24,10 @@ public class SdPromptTemplate {
      * 模板名称
      */
     private String templateName;
+    /**
+     * Prompt模版内容
+     */
+    private String promptContent;
     /**
      * 版本号(如:v1.0.0)
      */
@@ -40,8 +44,4 @@ public class SdPromptTemplate {
      * 逻辑删除标记：0-正常状态，1-已删除
      */
     private Integer isDeleted;
-    /**
-     * Prompt模版内容
-     */
-    private String promptContent;
 }

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdWorkflowExecutionRel.java

@@ -0,0 +1,42 @@
+package com.tzld.piaoquan.sde.model.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 流程任务与执行任务关联表
+ * @author supeng
+ */
+@Data
+@TableName("sd_workflow_execution_rel")
+public class SdWorkflowExecutionRel {
+    /**
+     * 主键ID
+     */
+    @TableId(type = IdType.AUTO)
+    private Long id;
+    /**
+     * 流程任务ID
+     */
+    private Long workflowTaskId;
+    /**
+     * 执行任务ID
+     */
+    private Long executionTaskId;
+    /**
+     * 记录创建时间，由数据库自动生成
+     */
+    private Date createTime;
+    /**
+     * 记录最后更新时间，由数据库自动维护
+     */
+    private Date updateTime;
+    /**
+     * 逻辑删除标记：0-正常状态，1-已删除
+     */
+    private Integer isDeleted;
+}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdTask.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdWorkflowTask.java

@@ -10,13 +10,13 @@ import lombok.Data;
 import java.util.Date;
 
 /**
- * 供需任务表
+ * 流程任务表
  *
  * @author supeng
  */
 @Data
-@TableName("sd_task")
-public class SdTask {
+@TableName("sd_workflow_task")
+public class SdWorkflowTask {
     /**
      * 主键ID
      */
@@ -33,12 +33,12 @@ public class SdTask {
      */
     private String taskName;
 
-    /**
-     * 任务类型：1 DECONSTRUCT(解构), 2 CLUSTER(聚类)
-     *
-     * @see TaskTypeEnum
-     */
-    private Integer taskType;
+//    /**
+//     * 任务类型：1 DECONSTRUCT(解构), 2 CLUSTER(聚类)
+//     *
+//     * @see TaskTypeEnum
+//     */
+//    private Integer taskType;
     /**
      * 任务状态：0 INIT(初始化), 1 PRE_PROCESSING(前置处理/子任务处理中),
      * 2 READY(就绪), 3 PROCESSING(处理中), 4 SUCCESS(成功) 5 FAILED(失败) 6 TIMEOUT(超时)
@@ -59,13 +59,13 @@ public class SdTask {
      */
     private String inputPayload;
     /**
-     * 子任务总数
+     * 执行任务总数
      */
-    private Integer subTaskCount;
+    private Integer executionTaskCount;
     /**
-     * 已结束的子任务数
+     * 已结束的执行任务数
      */
-    private Integer finishedSubTaskCount;
+    private Integer finishedExecutionTaskCount;
     /**
      * 任务实际结束时间，仅在状态转为SUCCESS/FAILED/TIMEOUT时填入
      */

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdTaskResult.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/entity/SdWorkflowTaskResult.java

@@ -8,21 +8,25 @@ import lombok.Data;
 import java.util.Date;
 
 /**
- * 供需任务提取需求结果表
+ * 流程任务表执行结果表
  * @author supeng
  */
 @Data
-@TableName("sd_task_result")
-public class SdTaskResult {
+@TableName("sd_workflow_task_result")
+public class SdWorkflowTaskResult {
     /**
      * 主键ID
      */
     @TableId(type = IdType.AUTO)
     private Long id;
     /**
-     * 关联 sd_task.id
+     * 关联 sd_workflow_task.id
      */
-    private Long taskId;
+    private Long workflowTaskId;
+    /**
+     * 流程执行结果
+     */
+    private String result;
     /**
      * 记录创建时间，由数据库自动生成
      */
@@ -35,8 +39,4 @@ public class SdTaskResult {
      * 逻辑删除标记：0-正常状态，1-已删除
      */
     private Integer isDeleted;
-    /**
-     * 引擎最终提取出的需求结果
-     */
-    private String result;
 }

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/SubTaskGetParam.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/ExecutionTaskGetParam.java

@@ -10,7 +10,7 @@ import javax.validation.constraints.NotNull;
  * @author supeng
  */
 @Data
-public class SubTaskGetParam {
+public class ExecutionTaskGetParam {
     /**
      * 子任务ID
      */

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/SubTaskListParam.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/ExecutionTaskListParam.java

@@ -1,7 +1,5 @@
 package com.tzld.piaoquan.sde.model.request;
 
-import com.tzld.piaoquan.sde.common.enums.SubTaskStatusEnum;
-import com.tzld.piaoquan.sde.common.enums.SubTaskTypeEnum;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
@@ -12,7 +10,7 @@ import lombok.EqualsAndHashCode;
  */
 @EqualsAndHashCode(callSuper = true)
 @Data
-public class SubTaskListParam extends PageParam {
+public class ExecutionTaskListParam extends PageParam {
     /**
      * 父任务ID，关联 sd_task.id
      */
@@ -20,17 +18,17 @@ public class SubTaskListParam extends PageParam {
     /**
      * 子任务业务编号，用于异步回调时的精确匹配 & 对外暴露
      */
-    private String subTaskNo;
+    private String taskNo;
     /**
      * 子任务类型：1 DECONSTRUCT(解构), 2 CLUSTER(聚类)
      *
-     * @see SubTaskTypeEnum
+     * @see com.tzld.piaoquan.sde.common.enums.ExecutionTaskTypeEnum
      */
-    private Integer subTaskType;
+    private Integer taskType;
     /**
      * 执行状态：0 INIT, 1 SUBMITTED(已提交), 2 RUNNING(运行中), 3 SUCCESS, 4 FAILED 5 TIMEOUT
      *
-     * @see SubTaskStatusEnum
+     * @see com.tzld.piaoquan.sde.common.enums.ExecutionTaskStatusEnum
      */
     private Integer taskStatus;
     /**

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/TaskCreateParam.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/WorkflowTaskCreateParam.java

@@ -13,7 +13,7 @@ import java.util.List;
  * @author supeng
  */
 @Data
-public class TaskCreateParam {
+public class WorkflowTaskCreateParam {
     /**
      * 任务类型
      *

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/TaskGetParam.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/WorkflowTaskGetParam.java

@@ -10,7 +10,7 @@ import javax.validation.constraints.NotNull;
  * @author supeng
  */
 @Data
-public class TaskGetParam {
+public class WorkflowTaskGetParam {
     /**
      * 任务ID
      */

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/TaskListParam.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/request/WorkflowTaskListParam.java

@@ -13,7 +13,7 @@ import javax.validation.constraints.NotNull;
  */
 @EqualsAndHashCode(callSuper = true)
 @Data
-public class TaskListParam extends PageParam {
+public class WorkflowTaskListParam extends PageParam {
     /**
      * 任务名称
      */

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/vo/SdSubTaskVO.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/vo/SdExecutionTaskVO.java

@@ -1,7 +1,5 @@
 package com.tzld.piaoquan.sde.model.vo;
 
-import com.tzld.piaoquan.sde.common.enums.SubTaskStatusEnum;
-import com.tzld.piaoquan.sde.common.enums.SubTaskTypeEnum;
 import lombok.Data;
 
 import java.util.Date;
@@ -12,7 +10,7 @@ import java.util.Date;
  * @author supeng
  */
 @Data
-public class SdSubTaskVO {
+public class SdExecutionTaskVO {
     /**
      * 主键ID
      */
@@ -24,18 +22,18 @@ public class SdSubTaskVO {
     /**
      * 子任务业务编号，用于异步回调时的精确匹配 & 对外暴露
      */
-    private String subTaskNo;
+    private String taskNo;
     /**
      * 子任务类型：1 DECONSTRUCT(解构), 2 CLUSTER(聚类)
      *
-     * @see SubTaskTypeEnum
+     * @see com.tzld.piaoquan.sde.common.enums.ExecutionTaskTypeEnum
      */
-    private Integer subTaskType;
-    private String subTaskTypeLabel;
+    private Integer taskType;
+    private String taskTypeLabel;
     /**
      * 执行状态：0 INIT, 1 SUBMITTED(已提交), 2 RUNNING(运行中), 3 SUCCESS, 4 FAILED 5 TIMEOUT
      *
-     * @see SubTaskStatusEnum
+     * @see com.tzld.piaoquan.sde.common.enums.ExecutionTaskStatusEnum
      */
     private Integer taskStatus;
     private String taskStatusLabel;

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/vo/SdTaskVO.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/model/vo/SdWorkflowTaskVO.java

@@ -7,7 +7,7 @@ import lombok.Data;
 import java.util.Date;
 
 @Data
-public class SdTaskVO {
+public class SdWorkflowTaskVO {
 
     /**
      * 主键ID

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/ExecutionTaskService.java

@@ -0,0 +1,44 @@
+package com.tzld.piaoquan.sde.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.tzld.piaoquan.sde.common.api.CommonRequest;
+import com.tzld.piaoquan.sde.model.entity.SdExecutionTask;
+import com.tzld.piaoquan.sde.model.request.ExecutionTaskGetParam;
+import com.tzld.piaoquan.sde.model.request.ExecutionTaskListParam;
+import com.tzld.piaoquan.sde.model.vo.SdExecutionTaskVO;
+
+import java.util.List;
+
+/**
+ * @author supeng
+ */
+public interface ExecutionTaskService {
+
+    void create(SdExecutionTask sdSubTask);
+
+    void create(List<SdExecutionTask> sdSubTasks);
+
+    /**
+     * 任务列表
+     *
+     * @param request
+     */
+    Page<SdExecutionTaskVO> list(CommonRequest<ExecutionTaskListParam> request);
+
+    /**
+     * 获取任务信息
+     *
+     * @param request
+     */
+    SdExecutionTask get(CommonRequest<ExecutionTaskGetParam> request);
+
+    /**
+     * 子任务提交
+     */
+    void executionTaskSubmitHandler();
+
+    /**
+     * 更新子任务状态/结果同步
+     */
+    void executionTaskSyncHandler();
+}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/SubTaskService.java

@@ -1,44 +0,0 @@
-package com.tzld.piaoquan.sde.service;
-
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.tzld.piaoquan.sde.common.api.CommonRequest;
-import com.tzld.piaoquan.sde.model.request.SubTaskGetParam;
-import com.tzld.piaoquan.sde.model.request.SubTaskListParam;
-import com.tzld.piaoquan.sde.model.entity.SdSubTask;
-import com.tzld.piaoquan.sde.model.vo.SdSubTaskVO;
-
-import java.util.List;
-
-/**
- * @author supeng
- */
-public interface SubTaskService {
-
-    void create(SdSubTask sdSubTask);
-
-    void create(List<SdSubTask> sdSubTasks);
-
-    /**
-     * 任务列表
-     *
-     * @param request
-     */
-    Page<SdSubTaskVO> list(CommonRequest<SubTaskListParam> request);
-
-    /**
-     * 获取任务信息
-     *
-     * @param request
-     */
-    SdSubTask get(CommonRequest<SubTaskGetParam> request);
-
-    /**
-     * 子任务提交
-     */
-    void subTaskSubmitHandler();
-
-    /**
-     * 更新子任务状态/结果同步
-     */
-    void subTaskSyncHandler();
-}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/TaskService.java

@@ -1,45 +0,0 @@
-package com.tzld.piaoquan.sde.service;
-
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.tzld.piaoquan.sde.common.api.CommonRequest;
-import com.tzld.piaoquan.sde.model.request.TaskCreateParam;
-import com.tzld.piaoquan.sde.model.request.TaskGetParam;
-import com.tzld.piaoquan.sde.model.request.TaskListParam;
-import com.tzld.piaoquan.sde.model.entity.SdTask;
-import com.tzld.piaoquan.sde.model.vo.SdTaskVO;
-
-/**
- * @author supeng
- */
-public interface TaskService {
-    /**
-     * 创建任务
-     *
-     * @param request
-     */
-    void create(CommonRequest<TaskCreateParam> request);
-
-    /**
-     * 任务列表
-     *
-     * @param request
-     */
-    Page<SdTaskVO> list(CommonRequest<TaskListParam> request);
-
-    /**
-     * 获取任务信息
-     *
-     * @param request
-     */
-    SdTask get(CommonRequest<TaskGetParam> request);
-
-    /**
-     * 任务状态检查更新
-     */
-    void taskStatusCheckHandler();
-
-    /**
-     * 任务执行
-     */
-    void taskExecuteHandler();
-}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/WorkflowTaskService.java

@@ -0,0 +1,45 @@
+package com.tzld.piaoquan.sde.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.tzld.piaoquan.sde.common.api.CommonRequest;
+import com.tzld.piaoquan.sde.model.entity.SdWorkflowTask;
+import com.tzld.piaoquan.sde.model.request.WorkflowTaskCreateParam;
+import com.tzld.piaoquan.sde.model.request.WorkflowTaskGetParam;
+import com.tzld.piaoquan.sde.model.request.WorkflowTaskListParam;
+import com.tzld.piaoquan.sde.model.vo.SdWorkflowTaskVO;
+
+/**
+ * @author supeng
+ */
+public interface WorkflowTaskService {
+    /**
+     * 创建任务
+     *
+     * @param request
+     */
+    void create(CommonRequest<WorkflowTaskCreateParam> request);
+
+    /**
+     * 任务列表
+     *
+     * @param request
+     */
+    Page<SdWorkflowTaskVO> list(CommonRequest<WorkflowTaskListParam> request);
+
+    /**
+     * 获取任务信息
+     *
+     * @param request
+     */
+    SdWorkflowTask get(CommonRequest<WorkflowTaskGetParam> request);
+
+    /**
+     * 任务状态检查更新
+     */
+    void workflowTaskStatusCheckHandler();
+
+    /**
+     * 任务执行
+     */
+    void workflowTaskExecuteHandler();
+}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/impl/ExecutionTaskServiceImpl.java

@@ -0,0 +1,198 @@
+package com.tzld.piaoquan.sde.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.tzld.piaoquan.sde.common.api.CommonRequest;
+import com.tzld.piaoquan.sde.common.enums.ExecutionTaskStatusEnum;
+import com.tzld.piaoquan.sde.common.enums.ExecutionTaskTypeEnum;
+import com.tzld.piaoquan.sde.common.enums.IsDeleteEnum;
+import com.tzld.piaoquan.sde.common.enums.TaskStatusEnum;
+import com.tzld.piaoquan.sde.integration.ContentDeconstructionClient;
+import com.tzld.piaoquan.sde.mapper.SdExecutionTaskMapper;
+import com.tzld.piaoquan.sde.mapper.SdExecutionTaskRawResultMapper;
+import com.tzld.piaoquan.sde.mapper.SdExecutionTaskResultItemMapper;
+import com.tzld.piaoquan.sde.mapper.SdWorkflowTaskMapper;
+import com.tzld.piaoquan.sde.model.entity.SdExecutionTask;
+import com.tzld.piaoquan.sde.model.entity.SdExecutionTaskRawResult;
+import com.tzld.piaoquan.sde.model.entity.SdWorkflowTask;
+import com.tzld.piaoquan.sde.model.request.ExecutionTaskGetParam;
+import com.tzld.piaoquan.sde.model.request.ExecutionTaskListParam;
+import com.tzld.piaoquan.sde.model.vo.SdExecutionTaskVO;
+import com.tzld.piaoquan.sde.service.ExecutionTaskService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author supeng
+ */
+@Slf4j
+@Service
+public class ExecutionTaskServiceImpl implements ExecutionTaskService {
+
+    @Autowired
+    private ContentDeconstructionClient contentDeconstructionClient;
+
+    @Autowired
+    private SdExecutionTaskMapper sdExecutionTaskMapper;
+    @Autowired
+    private SdExecutionTaskRawResultMapper sdExecutionTaskRawResultMapper;
+    @Autowired
+    private SdExecutionTaskResultItemMapper sdExecutionTaskResultItemMapper;
+    @Autowired
+    private SdWorkflowTaskMapper sdWorkflowTaskMapper;
+
+    @Override
+    public void create(SdExecutionTask sdExecutionTask) {
+        int rows = sdExecutionTaskMapper.insert(sdExecutionTask);
+        log.info("create Execution task rows = {}", rows);
+    }
+
+    @Override
+    public void create(List<SdExecutionTask> sdExecutionTasks) {
+        for (SdExecutionTask sdExecutionTask : sdExecutionTasks) {
+            create(sdExecutionTask);
+        }
+    }
+
+    @Override
+    public Page<SdExecutionTaskVO> list(CommonRequest<ExecutionTaskListParam> request) {
+        ExecutionTaskListParam params = request.getParams();
+        int pageNo = params.getPageNo();
+        int pageSize = params.getPageSize();
+        Long taskId = params.getTaskId();
+        String executionTaskNo = params.getTaskNo();
+        Integer taskStatus = params.getTaskStatus();
+        Integer executionTaskType = params.getTaskType();
+        String externalJobId = params.getExternalJobId();
+
+        LambdaQueryWrapper<SdExecutionTask> wrapper = Wrappers.lambdaQuery(SdExecutionTask.class)
+//                .eq(Objects.nonNull(taskId), SdExecutionTask::getTaskId, taskId)
+                .eq(Objects.nonNull(executionTaskNo), SdExecutionTask::getTaskNo, executionTaskNo)
+                .eq(Objects.nonNull(taskStatus), SdExecutionTask::getTaskStatus, taskStatus)
+                .eq(Objects.nonNull(executionTaskType), SdExecutionTask::getTaskType, executionTaskType)
+                .eq(Objects.nonNull(externalJobId), SdExecutionTask::getExternalJobId, externalJobId)
+                .eq(SdExecutionTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+                .orderByDesc(SdExecutionTask::getId);
+
+        Page<SdExecutionTask> page = new Page<>(pageNo, pageSize);
+        Page<SdExecutionTask> pageList = sdExecutionTaskMapper.selectPage(page, wrapper);
+        Page<SdExecutionTaskVO> pageVO = new Page<>();
+        if (Objects.isNull(pageList) || pageList.getTotal() == 0) {
+            return pageVO;
+        }
+        for (SdExecutionTask sdExecutionTask : pageList.getRecords()) {
+            SdExecutionTaskVO sdExecutionTaskVO = new SdExecutionTaskVO();
+            BeanUtils.copyProperties(sdExecutionTask, sdExecutionTaskVO);
+            ExecutionTaskTypeEnum executionTaskTypeEnum = ExecutionTaskTypeEnum.getInstance(sdExecutionTask.getTaskType());
+            if (Objects.nonNull(executionTaskTypeEnum)) {
+                sdExecutionTaskVO.setTaskTypeLabel(executionTaskTypeEnum.getDesc());
+            }
+            TaskStatusEnum taskStatusEnum = TaskStatusEnum.getInstance(sdExecutionTask.getTaskStatus());
+            if (Objects.nonNull(taskStatusEnum)) {
+                sdExecutionTaskVO.setTaskStatusLabel(taskStatusEnum.getDesc());
+            }
+            pageVO.getRecords().add(sdExecutionTaskVO);
+        }
+        return pageVO;
+    }
+
+    @Override
+    public SdExecutionTask get(CommonRequest<ExecutionTaskGetParam> request) {
+        Long id = request.getParams().getId();
+        return sdExecutionTaskMapper.selectById(id);
+    }
+
+    @Override
+    public void executionTaskSubmitHandler() {
+        long start = System.nanoTime();
+        log.info("executionTaskSubmitHandler start");
+        // 6 小时前
+        Date hourAgo = Date.from(
+                LocalDateTime.now()
+                        .minusHours(6)
+                        .atZone(ZoneId.systemDefault())
+                        .toInstant());
+        LambdaQueryWrapper<SdExecutionTask> wrapper = Wrappers.lambdaQuery(SdExecutionTask.class)
+                .eq(SdExecutionTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+                .eq(SdExecutionTask::getTaskStatus, ExecutionTaskStatusEnum.INIT.getValue())
+                .ge(SdExecutionTask::getCreateTime, hourAgo);
+        List<SdExecutionTask> list = sdExecutionTaskMapper.selectList(wrapper);
+        if (Objects.isNull(list) || list.isEmpty()) {
+            log.info("there is no executionTask need submit.");
+            return;
+        }
+        //提交子任务
+        for (SdExecutionTask sdExecutionTask : list) {
+            try {
+                String jobId = contentDeconstructionClient.submitDeconstructionTask(sdExecutionTask);
+                if (Objects.isNull(jobId) || jobId.isEmpty()) {
+                    continue;
+                }
+                SdExecutionTask update = new SdExecutionTask();
+                update.setId(sdExecutionTask.getId());
+                update.setExternalJobId(jobId);
+                update.setTaskStatus(ExecutionTaskStatusEnum.SUBMITTED.getValue());
+                int rows = sdExecutionTaskMapper.updateById(update);
+                log.info("subTask submit success, id:{} rows = {}", sdExecutionTask.getId(), rows);
+            } catch (Exception e) {
+                log.error("subTask submit error {}", sdExecutionTask, e);
+            }
+        }
+        long costMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
+        log.info("subTaskExecutionmitHandler finish cost={}ms", costMs);
+    }
+
+    @Override
+    public void executionTaskSyncHandler() {
+        long start = System.nanoTime();
+        log.info("executionTaskSyncHandler start");
+        // 6 小时前
+        Date hourAgo = Date.from(
+                LocalDateTime.now()
+                        .minusHours(6)
+                        .atZone(ZoneId.systemDefault())
+                        .toInstant());
+        LambdaQueryWrapper<SdExecutionTask> wrapper = Wrappers.lambdaQuery(SdExecutionTask.class)
+                .eq(SdExecutionTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+                .eq(SdExecutionTask::getTaskStatus, ExecutionTaskStatusEnum.SUBMITTED.getValue())
+                .ge(SdExecutionTask::getCreateTime, hourAgo);
+        List<SdExecutionTask> list = sdExecutionTaskMapper.selectList(wrapper);
+        if (Objects.isNull(list) || list.isEmpty()) {
+            log.info("there is no executionTask need sync.");
+            return;
+        }
+        for (SdExecutionTask sdExecutionTask : list) {
+            try {
+                String rawResult = contentDeconstructionClient.getDeconstructionTaskResult(sdExecutionTask.getExternalJobId());
+                if (Objects.isNull(rawResult) || rawResult.isEmpty()) {
+                    continue;
+                }
+                SdExecutionTaskRawResult sdExecutionTaskRawResult = new SdExecutionTaskRawResult();
+                sdExecutionTaskRawResult.setExecutionTaskId(sdExecutionTask.getId());
+                sdExecutionTaskRawResult.setRawResult(rawResult);
+                int rows = sdExecutionTaskRawResultMapper.insert(sdExecutionTaskRawResult);
+                log.info("executionTask sync success, id:{} rows = {}", sdExecutionTask.getId(), rows);
+                //TODO解析结果
+//                if (rows > 0) {
+//                    SdExecutionTaskResultItem sdExecutionTaskResultItem = new SdExecutionTaskResultItem();
+//                    sdExecutionTaskResultItem.setExecutionTaskId(sdExecutionTask.getId());
+//                    sdExecutionTaskResultItemMapper.insert(sdExecutionTaskResultItem);
+//                }
+            } catch (Exception e) {
+                log.error("executionTask sync error {}", sdExecutionTask, e);
+            }
+        }
+        long costMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
+        log.info("executionTaskSyncHandler finish cost={}ms", costMs);
+    }
+}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/impl/SubTaskServiceImpl.java

@@ -1,197 +0,0 @@
-package com.tzld.piaoquan.sde.service.impl;
-
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.core.toolkit.Wrappers;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.tzld.piaoquan.sde.common.api.CommonRequest;
-import com.tzld.piaoquan.sde.common.enums.IsDeleteEnum;
-import com.tzld.piaoquan.sde.common.enums.SubTaskStatusEnum;
-import com.tzld.piaoquan.sde.common.enums.SubTaskTypeEnum;
-import com.tzld.piaoquan.sde.common.enums.TaskStatusEnum;
-import com.tzld.piaoquan.sde.integration.ContentDeconstructionClient;
-import com.tzld.piaoquan.sde.mapper.SdSubTaskMapper;
-import com.tzld.piaoquan.sde.mapper.SdSubTaskRawResultMapper;
-import com.tzld.piaoquan.sde.mapper.SdSubTaskResultItemMapper;
-import com.tzld.piaoquan.sde.mapper.SdTaskMapper;
-import com.tzld.piaoquan.sde.model.entity.SdSubTaskRawResult;
-import com.tzld.piaoquan.sde.model.request.SubTaskGetParam;
-import com.tzld.piaoquan.sde.model.request.SubTaskListParam;
-import com.tzld.piaoquan.sde.model.entity.SdSubTask;
-import com.tzld.piaoquan.sde.model.vo.SdSubTaskVO;
-import com.tzld.piaoquan.sde.service.SubTaskService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeanUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.time.LocalDateTime;
-import java.time.ZoneId;
-import java.util.Date;
-import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.TimeUnit;
-
-/**
- * @author supeng
- */
-@Slf4j
-@Service
-public class SubTaskServiceImpl implements SubTaskService {
-
-    @Autowired
-    private ContentDeconstructionClient contentDeconstructionClient;
-
-    @Autowired
-    private SdSubTaskMapper sdSubTaskMapper;
-    @Autowired
-    private SdSubTaskRawResultMapper sdSubTaskRawResultMapper;
-    @Autowired
-    private SdSubTaskResultItemMapper sdSubTaskResultItemMapper;
-    @Autowired
-    private SdTaskMapper sdTaskMapper;
-
-    @Override
-    public void create(SdSubTask sdSubTask) {
-        int rows = sdSubTaskMapper.insert(sdSubTask);
-        log.info("create sub task rows = {}", rows);
-    }
-
-    @Override
-    public void create(List<SdSubTask> sdSubTasks) {
-        for (SdSubTask sdSubTask : sdSubTasks) {
-            create(sdSubTask);
-        }
-    }
-
-    @Override
-    public Page<SdSubTaskVO> list(CommonRequest<SubTaskListParam> request) {
-        SubTaskListParam params = request.getParams();
-        int pageNo = params.getPageNo();
-        int pageSize = params.getPageSize();
-        Long taskId = params.getTaskId();
-        String subTaskNo = params.getSubTaskNo();
-        Integer taskStatus = params.getTaskStatus();
-        Integer subTaskType = params.getSubTaskType();
-        String externalJobId = params.getExternalJobId();
-
-        LambdaQueryWrapper<SdSubTask> wrapper = Wrappers.lambdaQuery(SdSubTask.class)
-                .eq(Objects.nonNull(taskId), SdSubTask::getTaskId, taskId)
-                .eq(Objects.nonNull(subTaskNo), SdSubTask::getSubTaskNo, subTaskNo)
-                .eq(Objects.nonNull(taskStatus), SdSubTask::getTaskStatus, taskStatus)
-                .eq(Objects.nonNull(subTaskType), SdSubTask::getSubTaskType, subTaskType)
-                .eq(Objects.nonNull(externalJobId), SdSubTask::getExternalJobId, externalJobId)
-                .eq(SdSubTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .orderByDesc(SdSubTask::getId);
-
-        Page<SdSubTask> page = new Page<>(pageNo, pageSize);
-        Page<SdSubTask> pageList = sdSubTaskMapper.selectPage(page, wrapper);
-        Page<SdSubTaskVO> pageVO = new Page<>();
-        if (Objects.isNull(pageList) || pageList.getTotal() == 0) {
-            return pageVO;
-        }
-        for (SdSubTask sdSubTask : pageList.getRecords()) {
-            SdSubTaskVO sdSubTaskVO = new SdSubTaskVO();
-            BeanUtils.copyProperties(sdSubTask, sdSubTaskVO);
-            SubTaskTypeEnum subTaskTypeEnum = SubTaskTypeEnum.getInstance(sdSubTask.getSubTaskType());
-            if (Objects.nonNull(subTaskTypeEnum)) {
-                sdSubTaskVO.setSubTaskTypeLabel(subTaskTypeEnum.getDesc());
-            }
-            TaskStatusEnum taskStatusEnum = TaskStatusEnum.getInstance(sdSubTask.getTaskStatus());
-            if (Objects.nonNull(taskStatusEnum)) {
-                sdSubTaskVO.setTaskStatusLabel(taskStatusEnum.getDesc());
-            }
-            pageVO.getRecords().add(sdSubTaskVO);
-        }
-        return pageVO;
-    }
-
-    @Override
-    public SdSubTask get(CommonRequest<SubTaskGetParam> request) {
-        Long id = request.getParams().getId();
-        return sdSubTaskMapper.selectById(id);
-    }
-
-    @Override
-    public void subTaskSubmitHandler() {
-        long start = System.nanoTime();
-        log.info("subTaskSubmitHandler start");
-        // 6 小时前
-        Date hourAgo = Date.from(
-                LocalDateTime.now()
-                        .minusHours(6)
-                        .atZone(ZoneId.systemDefault())
-                        .toInstant());
-        LambdaQueryWrapper<SdSubTask> wrapper = Wrappers.lambdaQuery(SdSubTask.class)
-                .eq(SdSubTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .eq(SdSubTask::getTaskStatus, SubTaskStatusEnum.INIT.getValue())
-                .ge(SdSubTask::getCreateTime, hourAgo);
-        List<SdSubTask> list = sdSubTaskMapper.selectList(wrapper);
-        if (Objects.isNull(list) || list.isEmpty()) {
-            log.info("there is no subTask need submit.");
-            return;
-        }
-        //提交子任务
-        for (SdSubTask sdSubTask : list) {
-            try {
-                String jobId = contentDeconstructionClient.submitDeconstructionTask(sdSubTask);
-                if (Objects.isNull(jobId) || jobId.isEmpty()) {
-                    continue;
-                }
-                SdSubTask update = new SdSubTask();
-                update.setId(sdSubTask.getId());
-                update.setExternalJobId(jobId);
-                update.setTaskStatus(SubTaskStatusEnum.SUBMITTED.getValue());
-                int rows = sdSubTaskMapper.updateById(update);
-                log.info("subTask submit success, id:{} rows = {}", sdSubTask.getId(), rows);
-            } catch (Exception e) {
-                log.error("subTask submit error {}", sdSubTask, e);
-            }
-        }
-        long costMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
-        log.info("subTaskSubmitHandler finish cost={}ms", costMs);
-    }
-
-    @Override
-    public void subTaskSyncHandler() {
-        long start = System.nanoTime();
-        log.info("subTaskSyncHandler start");
-        // 6 小时前
-        Date hourAgo = Date.from(
-                LocalDateTime.now()
-                        .minusHours(6)
-                        .atZone(ZoneId.systemDefault())
-                        .toInstant());
-        LambdaQueryWrapper<SdSubTask> wrapper = Wrappers.lambdaQuery(SdSubTask.class)
-                .eq(SdSubTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .eq(SdSubTask::getTaskStatus, SubTaskStatusEnum.SUBMITTED.getValue())
-                .ge(SdSubTask::getCreateTime, hourAgo);
-        List<SdSubTask> list = sdSubTaskMapper.selectList(wrapper);
-        if (Objects.isNull(list) || list.isEmpty()) {
-            log.info("there is no subTask need sync.");
-            return;
-        }
-        for (SdSubTask sdSubTask : list) {
-            try {
-                String rawResult = contentDeconstructionClient.getDeconstructionTaskResult(sdSubTask.getExternalJobId());
-                if (Objects.isNull(rawResult) || rawResult.isEmpty()) {
-                    continue;
-                }
-                SdSubTaskRawResult sdSubTaskRawResult = new SdSubTaskRawResult();
-                sdSubTaskRawResult.setSubTaskId(sdSubTask.getId());
-                sdSubTaskRawResult.setRawResult(rawResult);
-                int rows = sdSubTaskRawResultMapper.insert(sdSubTaskRawResult);
-                log.info("subTask sync success, id:{} rows = {}", sdSubTask.getId(), rows);
-                //TODO解析结果
-//                if (rows > 0) {
-//                    SdSubTaskResultItem sdSubTaskResultItem = new SdSubTaskResultItem();
-//                    sdSubTaskResultItem.setSubTaskId(sdSubTask.getId());
-//                    sdSubTaskResultItemMapper.insert(sdSubTaskResultItem);
-//                }
-            } catch (Exception e) {
-                log.error("subTask sync error {}", sdSubTask, e);
-            }
-        }
-        long costMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
-        log.info("subTaskSyncHandler finish cost={}ms", costMs);
-    }
-}

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/impl/TaskServiceImpl.java → supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/impl/WorkflowTaskServiceImpl.java

@@ -11,11 +11,11 @@ import com.tzld.piaoquan.sde.integration.OpenRouterClient;
 import com.tzld.piaoquan.sde.mapper.*;
 import com.tzld.piaoquan.sde.model.dto.StrategyResultDTO;
 import com.tzld.piaoquan.sde.model.entity.*;
-import com.tzld.piaoquan.sde.model.request.TaskCreateParam;
-import com.tzld.piaoquan.sde.model.request.TaskGetParam;
-import com.tzld.piaoquan.sde.model.request.TaskListParam;
-import com.tzld.piaoquan.sde.model.vo.SdTaskVO;
-import com.tzld.piaoquan.sde.service.TaskService;
+import com.tzld.piaoquan.sde.model.request.WorkflowTaskCreateParam;
+import com.tzld.piaoquan.sde.model.request.WorkflowTaskGetParam;
+import com.tzld.piaoquan.sde.model.request.WorkflowTaskListParam;
+import com.tzld.piaoquan.sde.model.vo.SdWorkflowTaskVO;
+import com.tzld.piaoquan.sde.service.WorkflowTaskService;
 import com.tzld.piaoquan.sde.service.strategy.DeconstructStrategy;
 import com.tzld.piaoquan.sde.service.strategy.DemandExtractionStrategy;
 import com.tzld.piaoquan.sde.util.DateUtil;
@@ -36,21 +36,21 @@ import java.util.stream.Collectors;
  */
 @Slf4j
 @Service
-public class TaskServiceImpl implements TaskService {
+public class WorkflowTaskServiceImpl implements WorkflowTaskService {
 
     private static final String PREFIX_TASK_NAME = "供给需求任务";
     private static final String TASK_NAME_DATETIME_PATTEN = "yyyyMMddHHmmss";
 
     @Autowired
-    private SdTaskMapper sdTaskMapper;
+    private SdWorkflowTaskMapper sdWorkflowTaskMapper;
     @Autowired
-    private SdSubTaskMapper sdSubTaskMapper;
+    private SdExecutionTaskMapper sdExecutionTaskMapper;
     @Autowired
     private SdStrategyMapper sdStrategyMapper;
     @Autowired
     private SdPromptTemplateMapper sdPromptTemplateMapper;
     @Autowired
-    private SdSubTaskResultItemMapper sdSubTaskResultItemMapper;
+    private SdExecutionTaskResultItemMapper sdExecutionTaskResultItemMapper;
     @Autowired
     private OpenRouterClient openRouterServiceClient;
     @Autowired
@@ -58,18 +58,18 @@ public class TaskServiceImpl implements TaskService {
     @Autowired
     private Map<Integer, DeconstructStrategy> strategyMap;
     @Autowired
-    private SdTaskResultMapper sdTaskResultMapper;
+    private SdWorkflowTaskResultMapper sdWorkflowTaskResultMapper;
 
     @Override
-    public void create(CommonRequest<TaskCreateParam> request) {
-        TaskCreateParam params = request.getParams();
-        SdTask sdTask = new SdTask();
-        sdTask.setTaskNo(IdGeneratorUtil.generateTaskNo());
+    public void create(CommonRequest<WorkflowTaskCreateParam> request) {
+        WorkflowTaskCreateParam params = request.getParams();
+        SdWorkflowTask sdWorkflowTask = new SdWorkflowTask();
+        sdWorkflowTask.setTaskNo(IdGeneratorUtil.generateTaskNo());
         String taskName = params.getTaskName();
         if (Objects.isNull(taskName) || taskName.trim().isEmpty()) {
             taskName = PREFIX_TASK_NAME + Constant.LINE + DateUtil.formatLocalDateTime(LocalDateTime.now(), TASK_NAME_DATETIME_PATTEN);
         }
-        sdTask.setTaskName(taskName);
+        sdWorkflowTask.setTaskName(taskName);
         //校验策略是否存在
         Long strategyId = params.getStrategyId();
         LambdaQueryWrapper<SdStrategy> wrapper = new LambdaQueryWrapper<>();
@@ -78,14 +78,14 @@ public class TaskServiceImpl implements TaskService {
         if (!strategyIdExists) {
             throw new BizException(ExceptionEnum.DATA_NOT_EXIST, "该策略不存在");
         }
-        sdTask.setStrategyId(params.getStrategyId());
+        sdWorkflowTask.setStrategyId(params.getStrategyId());
         TaskTypeEnum taskTypeEnum = TaskTypeEnum.getInstance(params.getTaskType());
         if (Objects.isNull(taskTypeEnum)) {
             throw new BizException(ExceptionEnum.NOT_SUPPORT_TASK_TYPE);
         }
-        sdTask.setTaskType(params.getTaskType());
-        sdTask.setTaskStatus(TaskStatusEnum.INIT.getValue());
-        int rows = sdTaskMapper.insert(sdTask);
+//        sdWorkflowTask.setTaskType(params.getTaskType());
+        sdWorkflowTask.setTaskStatus(TaskStatusEnum.INIT.getValue());
+        int rows = sdWorkflowTaskMapper.insert(sdWorkflowTask);
         log.info("create insert task rows = {}", rows);
         if (rows <= 0) {
             throw new BizException(ExceptionEnum.DATA_INSERT_ERROR);
@@ -93,27 +93,26 @@ public class TaskServiceImpl implements TaskService {
         //子任务创建
         int total = 0;
         for (Long videoId : params.getVideoIds()) {
-            SdSubTask sdSubTask = new SdSubTask();
-            sdSubTask.setTaskId(sdTask.getId());
-            String subTaskNo = IdGeneratorUtil.generateSubTaskNo(sdTask.getTaskNo());
-            sdSubTask.setSubTaskNo(subTaskNo);
-            sdSubTask.setContentId(String.valueOf(videoId));
-            sdSubTask.setTaskStatus(TaskStatusEnum.INIT.getValue());
-            int subRows = sdSubTaskMapper.insert(sdSubTask);
+            SdExecutionTask sdExecutionTask = new SdExecutionTask();
+            String executionTaskNo = IdGeneratorUtil.generateSubTaskNo(sdWorkflowTask.getTaskNo());
+            sdExecutionTask.setTaskNo(executionTaskNo);
+            sdExecutionTask.setContentId(String.valueOf(videoId));
+            sdExecutionTask.setTaskStatus(TaskStatusEnum.INIT.getValue());
+            int subRows = sdExecutionTaskMapper.insert(sdExecutionTask);
             total += subRows;
-            log.info("create subTask rows = {}", subRows);
+            log.info("create ExecutionTask rows = {}", subRows);
         }
         //更新子任务数
-        SdTask updateTask = new SdTask();
-        updateTask.setId(sdTask.getId());
-        updateTask.setSubTaskCount(total);
-        int updateRows = sdTaskMapper.updateById(updateTask);
-        log.info("create update task rows = {}, total = {}", updateRows, total);
+        SdWorkflowTask updateTask = new SdWorkflowTask();
+        updateTask.setId(sdWorkflowTask.getId());
+        updateTask.setExecutionTaskCount(total);
+        int updateRows = sdWorkflowTaskMapper.updateById(updateTask);
+        log.info("create update WorkflowTask rows = {}, total = {}", updateRows, total);
     }
 
     @Override
-    public Page<SdTaskVO> list(CommonRequest<TaskListParam> request) {
-        TaskListParam params = request.getParams();
+    public Page<SdWorkflowTaskVO> list(CommonRequest<WorkflowTaskListParam> request) {
+        WorkflowTaskListParam params = request.getParams();
         int pageNo = params.getPageNo();
         int pageSize = params.getPageSize();
         String taskNo = params.getTaskNo();
@@ -121,53 +120,48 @@ public class TaskServiceImpl implements TaskService {
         Integer taskType = params.getTaskType();
         Long strategyId = params.getStrategyId();
 
-        LambdaQueryWrapper<SdTask> wrapper = Wrappers.lambdaQuery(SdTask.class)
-                .eq(Objects.nonNull(taskNo), SdTask::getTaskNo, taskNo)
-                .eq(Objects.nonNull(taskType), SdTask::getTaskType, taskType)
-                .eq(Objects.nonNull(strategyId), SdTask::getStrategyId, strategyId)
-                .like(Objects.nonNull(taskName) && !taskName.isEmpty(), SdTask::getTaskName, taskName)
-                .eq(SdTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .orderByDesc(SdTask::getId);
+        LambdaQueryWrapper<SdWorkflowTask> wrapper = Wrappers.lambdaQuery(SdWorkflowTask.class)
+                .eq(Objects.nonNull(taskNo), SdWorkflowTask::getTaskNo, taskNo)
+                .eq(Objects.nonNull(strategyId), SdWorkflowTask::getStrategyId, strategyId)
+                .like(Objects.nonNull(taskName) && !taskName.isEmpty(), SdWorkflowTask::getTaskName, taskName)
+                .eq(SdWorkflowTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+                .orderByDesc(SdWorkflowTask::getId);
 
-        Page<SdTask> page = new Page<>(pageNo, pageSize);
-        Page<SdTask> pageList = sdTaskMapper.selectPage(page, wrapper);
-        Page<SdTaskVO> pageVO = new Page<>();
+        Page<SdWorkflowTask> page = new Page<>(pageNo, pageSize);
+        Page<SdWorkflowTask> pageList = sdWorkflowTaskMapper.selectPage(page, wrapper);
+        Page<SdWorkflowTaskVO> pageVO = new Page<>();
         if (Objects.isNull(pageList) || pageList.getTotal() == 0) {
             return pageVO;
         }
-        List<Long> strategyIds = pageList.getRecords().stream().map(SdTask::getStrategyId).collect(Collectors.toList());
+        List<Long> strategyIds = pageList.getRecords().stream().map(SdWorkflowTask::getStrategyId).collect(Collectors.toList());
         List<SdStrategy> strategyList = sdStrategyMapper.selectList(Wrappers.<SdStrategy>lambdaQuery().in(SdStrategy::getId, strategyIds));
         Map<Long, String> strategyMap = strategyList.stream().collect(Collectors.toMap(SdStrategy::getId, SdStrategy::getStrategyName));
-        for (SdTask sdTask : pageList.getRecords()) {
-            SdTaskVO sdTaskVO = new SdTaskVO();
-            BeanUtils.copyProperties(sdTask, sdTaskVO);
-            TaskTypeEnum taskTypeEnum = TaskTypeEnum.getInstance(sdTask.getTaskType());
-            if (Objects.nonNull(taskTypeEnum)) {
-                sdTaskVO.setTaskTypeLabel(taskTypeEnum.getDesc());
-            }
-            TaskStatusEnum taskStatusEnum = TaskStatusEnum.getInstance(sdTask.getTaskStatus());
+        for (SdWorkflowTask sdWorkflowTask : pageList.getRecords()) {
+            SdWorkflowTaskVO sdWorkflowTaskVO = new SdWorkflowTaskVO();
+            BeanUtils.copyProperties(sdWorkflowTask, sdWorkflowTaskVO);
+            TaskStatusEnum taskStatusEnum = TaskStatusEnum.getInstance(sdWorkflowTask.getTaskStatus());
             if (Objects.nonNull(taskStatusEnum)) {
-                sdTaskVO.setTaskStatusLabel(taskStatusEnum.getDesc());
+                sdWorkflowTaskVO.setTaskStatusLabel(taskStatusEnum.getDesc());
             }
-            String strategyName = strategyMap.get(sdTask.getStrategyId());
+            String strategyName = strategyMap.get(sdWorkflowTask.getStrategyId());
             if (Objects.nonNull(strategyName)) {
-                sdTaskVO.setStrategyName(strategyName);
+                sdWorkflowTaskVO.setStrategyName(strategyName);
             }
-            pageVO.getRecords().add(sdTaskVO);
+            pageVO.getRecords().add(sdWorkflowTaskVO);
         }
         return pageVO;
     }
 
     @Override
-    public SdTask get(CommonRequest<TaskGetParam> request) {
+    public SdWorkflowTask get(CommonRequest<WorkflowTaskGetParam> request) {
         Long id = request.getParams().getId();
-        return sdTaskMapper.selectById(id);
+        return sdWorkflowTaskMapper.selectById(id);
     }
 
     @Override
-    public void taskStatusCheckHandler() {
+    public void workflowTaskStatusCheckHandler() {
         long start = System.nanoTime();
-        log.info("taskStatusCheckHandler start");
+        log.info("workflowTaskStatusCheckHandler start");
         // 6 小时前
         Date hourAgo = Date.from(
                 LocalDateTime.now()
@@ -176,26 +170,26 @@ public class TaskServiceImpl implements TaskService {
                         .toInstant());
         List<Integer> taskStatusList = Arrays.asList(TaskStatusEnum.INIT.getValue(),
                 TaskStatusEnum.PRE_PROCESSING.getValue());
-        LambdaQueryWrapper<SdTask> wrapper = Wrappers.lambdaQuery(SdTask.class)
-                .eq(SdTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .in(SdTask::getTaskStatus, taskStatusList)
-                .ge(SdTask::getCreateTime, hourAgo);
-        List<SdTask> tasks = sdTaskMapper.selectList(wrapper);
+        LambdaQueryWrapper<SdWorkflowTask> wrapper = Wrappers.lambdaQuery(SdWorkflowTask.class)
+                .eq(SdWorkflowTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+                .in(SdWorkflowTask::getTaskStatus, taskStatusList)
+                .ge(SdWorkflowTask::getCreateTime, hourAgo);
+        List<SdWorkflowTask> tasks = sdWorkflowTaskMapper.selectList(wrapper);
         if (Objects.isNull(tasks) || tasks.isEmpty()) {
-            log.info("taskStatusCheckHandler tasks is empty");
+            log.info("workflowTaskStatusCheckHandler tasks is empty");
             return;
         }
-        for (SdTask sdTask : tasks) {
-            TaskStatusEnum taskStatusEnum = TaskStatusEnum.getInstance(sdTask.getTaskStatus());
+        for (SdWorkflowTask sdWorkflowTask : tasks) {
+            TaskStatusEnum taskStatusEnum = TaskStatusEnum.getInstance(sdWorkflowTask.getTaskStatus());
             if (Objects.isNull(taskStatusEnum)) {
                 continue;
             }
             switch (taskStatusEnum) {
                 case INIT:
-                    initTaskStatusCheck(sdTask);
+                    initTaskStatusCheck(sdWorkflowTask);
                     break;
                 case PRE_PROCESSING:
-                    preProcessingTaskStatsCheck(sdTask);
+                    preProcessingTaskStatsCheck(sdWorkflowTask);
                     break;
                 default:
                     //其他状态不在这里处理
@@ -203,35 +197,35 @@ public class TaskServiceImpl implements TaskService {
             }
         }
         long costMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
-        log.info("taskStatusCheckHandler finish cost={}ms", costMs);
+        log.info("workflowTaskStatusCheckHandler finish cost={}ms", costMs);
     }
 
-    private void preProcessingTaskStatsCheck(SdTask sdTask) {
+    private void preProcessingTaskStatsCheck(SdWorkflowTask sdWorkflowTask) {
         try {
             //获取完成任务数
             List<Integer> finishTaskStatusList = Arrays.asList(TaskStatusEnum.SUCCESS.getValue(),
                     TaskStatusEnum.FAILED.getValue(),
                     TaskStatusEnum.TIMEOUT.getValue());
-            LambdaQueryWrapper<SdSubTask> wrapper = Wrappers.lambdaQuery(SdSubTask.class)
-                    .eq(SdSubTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                    .eq(SdSubTask::getTaskId, sdTask.getId())
-                    .in(SdSubTask::getTaskStatus, finishTaskStatusList);
-            Long finishCount = sdSubTaskMapper.selectCount(wrapper);
+            LambdaQueryWrapper<SdExecutionTask> wrapper = Wrappers.lambdaQuery(SdExecutionTask.class)
+                    .eq(SdExecutionTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+//                    .eq(SdExecutionTask::getTaskId, sdworkflowTask.getId())
+                    .in(SdExecutionTask::getTaskStatus, finishTaskStatusList);
+            Long finishCount = sdExecutionTaskMapper.selectCount(wrapper);
             //更新主任务
             if (Objects.isNull(finishCount)) {
                 return;
             }
-            boolean needUpdateFinishedCount = finishCount.intValue() > sdTask.getFinishedSubTaskCount();
-            boolean allFinished = finishCount.intValue() == sdTask.getSubTaskCount();
+            boolean needUpdateFinishedCount = finishCount.intValue() > sdWorkflowTask.getFinishedExecutionTaskCount();
+            boolean allFinished = finishCount.intValue() == sdWorkflowTask.getExecutionTaskCount();
             if (needUpdateFinishedCount || allFinished) {
-                SdTask updateTask = new SdTask();
-                updateTask.setId(sdTask.getId());
-                updateTask.setFinishedSubTaskCount(finishCount.intValue());
+                SdWorkflowTask updateTask = new SdWorkflowTask();
+                updateTask.setId(sdWorkflowTask.getId());
+                updateTask.setFinishedExecutionTaskCount(finishCount.intValue());
                 //如果全部完成，更新状态
                 if (allFinished) {
                     updateTask.setTaskStatus(TaskStatusEnum.READY.getValue());
                 }
-                int updateRows = sdTaskMapper.updateById(updateTask);
+                int updateRows = sdWorkflowTaskMapper.updateById(updateTask);
                 log.info("preProcessingTaskStatsCheck status:{} task update rows:{}", TaskStatusEnum.PRE_PROCESSING.getDesc(), updateRows);
             }
         } catch (Exception e) {
@@ -242,20 +236,20 @@ public class TaskServiceImpl implements TaskService {
     /**
      * 初始任务状态更新
      */
-    private void initTaskStatusCheck(SdTask sdTask) {
+    private void initTaskStatusCheck(SdWorkflowTask sdTask) {
         try {
             //检查子任务状态
-            LambdaQueryWrapper<SdSubTask> wrapper = Wrappers.lambdaQuery(SdSubTask.class)
-                    .eq(SdSubTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                    .eq(SdSubTask::getTaskId, sdTask.getId())
-                    .ne(SdSubTask::getTaskStatus, SubTaskStatusEnum.INIT.getValue());
-            Long count = sdSubTaskMapper.selectCount(wrapper);
+            LambdaQueryWrapper<SdExecutionTask> wrapper = Wrappers.lambdaQuery(SdExecutionTask.class)
+                    .eq(SdExecutionTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+//                    .eq(SdExecutionTask::getTaskId, sdTask.getId())
+                    .ne(SdExecutionTask::getTaskStatus, ExecutionTaskStatusEnum.INIT.getValue());
+            Long count = sdExecutionTaskMapper.selectCount(wrapper);
             //更新主任务状态
             if (Objects.nonNull(count) && count > 0) {
-                SdTask updateTask = new SdTask();
+                SdWorkflowTask updateTask = new SdWorkflowTask();
                 updateTask.setId(sdTask.getId());
                 updateTask.setTaskStatus(TaskStatusEnum.PRE_PROCESSING.getValue());
-                int updateRows = sdTaskMapper.updateById(updateTask);
+                int updateRows = sdWorkflowTaskMapper.updateById(updateTask);
                 log.info("initTaskStatusCheck status:{} task update rows:{}", TaskStatusEnum.INIT.getDesc(), updateRows);
             }
         } catch (Exception e) {
@@ -264,55 +258,56 @@ public class TaskServiceImpl implements TaskService {
     }
 
     @Override
-    public void taskExecuteHandler() {
+    public void workflowTaskExecuteHandler() {
         long start = System.nanoTime();
-        log.info("taskExecuteHandler start");
+        log.info("workflowTaskExecuteHandler start");
         //查询可以执行的任务
-        LambdaQueryWrapper<SdTask> wrapper = Wrappers.lambdaQuery(SdTask.class)
-                .eq(SdTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .eq(SdTask::getTaskStatus, TaskStatusEnum.READY.getValue());
-        List<SdTask> tasks = sdTaskMapper.selectList(wrapper);
+        LambdaQueryWrapper<SdWorkflowTask> wrapper = Wrappers.lambdaQuery(SdWorkflowTask.class)
+                .eq(SdWorkflowTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+                .eq(SdWorkflowTask::getTaskStatus, TaskStatusEnum.READY.getValue());
+        List<SdWorkflowTask> tasks = sdWorkflowTaskMapper.selectList(wrapper);
         if (Objects.isNull(tasks) || tasks.isEmpty()) {
-            log.info("taskExecuteHandler tasks is empty");
+            log.info("workflowTaskExecuteHandler tasks is empty");
             return;
         }
-        for (SdTask sdTask : tasks) {
+        for (SdWorkflowTask sdWorkflowTask : tasks) {
             try {
                 //提取需求
-                SdStrategy strategy = sdStrategyMapper.selectById(sdTask.getStrategyId());
+                SdStrategy strategy = sdStrategyMapper.selectById(sdWorkflowTask.getStrategyId());
                 if (Objects.isNull(strategy)) {
-                    log.info("taskExecuteHandler strategy is null");
+                    log.info("workflowTaskExecuteHandler strategy is null");
                     return;
                 }
-                DemandExtractionStrategy demandExtractionStrategy = strategyMap.get(sdTask.getTaskType());
-                StrategyResultDTO strategyResultDTO = demandExtractionStrategy.execute(sdTask, strategy);
+                //TODO
+                DemandExtractionStrategy demandExtractionStrategy = strategyMap.get("");
+                StrategyResultDTO strategyResultDTO = demandExtractionStrategy.execute(sdWorkflowTask, strategy);
                 if (Objects.isNull(strategyResultDTO)) {
-                    SdTask updateTask = new SdTask();
-                    updateTask.setId(sdTask.getId());
+                    SdWorkflowTask updateTask = new SdWorkflowTask();
+                    updateTask.setId(sdWorkflowTask.getId());
                     updateTask.setTaskStatus(TaskStatusEnum.FAILED.getValue());
                     updateTask.setErrorMsg("");
-                    int updateRows = sdTaskMapper.updateById(updateTask);
+                    int updateRows = sdWorkflowTaskMapper.updateById(updateTask);
                     log.info("");
                     continue;
                 }
                 //成功
-                SdTaskResult sdTaskResult = new SdTaskResult();
-                sdTaskResult.setTaskId(sdTask.getId());
+                SdWorkflowTaskResult sdTaskResult = new SdWorkflowTaskResult();
+//                sdTaskResult.setTaskId(sdTask.getId());
                 sdTaskResult.setResult(strategyResultDTO.getResult());
-                int rows = sdTaskResultMapper.insert(sdTaskResult);
+                int rows = sdWorkflowTaskResultMapper.insert(sdTaskResult);
                 log.info("taskResult insert rows:{}", rows);
                 if (rows > 0) {
-                    SdTask updateTask = new SdTask();
-                    updateTask.setId(sdTask.getId());
+                    SdWorkflowTask updateTask = new SdWorkflowTask();
+                    updateTask.setId(sdWorkflowTask.getId());
                     updateTask.setTaskStatus(TaskStatusEnum.SUCCESS.getValue());
-                    int updateRows = sdTaskMapper.updateById(updateTask);
+                    int updateRows = sdWorkflowTaskMapper.updateById(updateTask);
                     log.info("task success update rows:{}", updateRows);
                 }
             } catch (Exception e) {
-                log.error("taskExecuteHandler error", e);
+                log.error("workflowTaskExecuteHandler error", e);
             }
         }
         long costMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
-        log.info("taskExecuteHandler finish cost={}ms", costMs);
+        log.info("workflowTaskExecuteHandler finish cost={}ms", costMs);
     }
 }

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/strategy/ClusterStrategy.java

@@ -3,13 +3,13 @@ package com.tzld.piaoquan.sde.service.strategy;
 import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.tzld.piaoquan.sde.common.enums.ExecutionTaskStatusEnum;
 import com.tzld.piaoquan.sde.common.enums.IsDeleteEnum;
-import com.tzld.piaoquan.sde.common.enums.SubTaskStatusEnum;
 import com.tzld.piaoquan.sde.common.enums.TaskTypeEnum;
 import com.tzld.piaoquan.sde.integration.OpenRouterClient;
+import com.tzld.piaoquan.sde.mapper.SdExecutionTaskMapper;
+import com.tzld.piaoquan.sde.mapper.SdExecutionTaskResultItemMapper;
 import com.tzld.piaoquan.sde.mapper.SdPromptTemplateMapper;
-import com.tzld.piaoquan.sde.mapper.SdSubTaskMapper;
-import com.tzld.piaoquan.sde.mapper.SdSubTaskResultItemMapper;
 import com.tzld.piaoquan.sde.model.dto.StrategyConfigDTO;
 import com.tzld.piaoquan.sde.model.dto.StrategyResultDTO;
 import com.tzld.piaoquan.sde.model.entity.*;
@@ -32,10 +32,10 @@ import java.util.stream.Collectors;
 public class ClusterStrategy implements DemandExtractionStrategy {
 
     @Autowired
-    private SdSubTaskMapper sdSubTaskMapper;
+    private SdExecutionTaskMapper sdExecutionTaskMapper;
 
     @Autowired
-    private SdSubTaskResultItemMapper sdSubTaskResultItemMapper;
+    private SdExecutionTaskResultItemMapper sdExecutionTaskResultItemMapper;
 
     @Autowired
     private SdPromptTemplateMapper sdPromptTemplateMapper;
@@ -49,7 +49,7 @@ public class ClusterStrategy implements DemandExtractionStrategy {
     }
 
     @Override
-    public StrategyResultDTO execute(SdTask task, SdStrategy strategy) {
+    public StrategyResultDTO execute(SdWorkflowTask task, SdStrategy strategy) {
         log.info("Executing cluster task: taskId={}, taskNo={}", task.getId(), task.getTaskNo());
 
         StrategyConfigDTO strategyConfigDTO = JSON.parseObject(strategy.getConfig(), StrategyConfigDTO.class);
@@ -64,42 +64,42 @@ public class ClusterStrategy implements DemandExtractionStrategy {
         }
 
         // 2. 查询成功的子任务
-        LambdaQueryWrapper<SdSubTask> subTaskWrapper = Wrappers.lambdaQuery(SdSubTask.class)
-                .eq(SdSubTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .eq(SdSubTask::getTaskId, task.getId())
-                .eq(SdSubTask::getTaskStatus, SubTaskStatusEnum.SUCCESS.getValue())
-                .eq(SdSubTask::getSubTaskType, task.getTaskType())
-                .select(SdSubTask::getId);
-        List<SdSubTask> subTasks = sdSubTaskMapper.selectList(subTaskWrapper);
-        if (Objects.isNull(subTasks) || subTasks.isEmpty()) {
-            log.warn("No successful subtasks found: taskId={}", task.getId());
+        LambdaQueryWrapper<SdExecutionTask> executionTaskWrapper = Wrappers.lambdaQuery(SdExecutionTask.class)
+                .eq(SdExecutionTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+//                .eq(SdExecutionTask::getTaskId, task.getId())
+                .eq(SdExecutionTask::getTaskStatus, ExecutionTaskStatusEnum.SUCCESS.getValue())
+                .eq(SdExecutionTask::getTaskType, "")
+                .select(SdExecutionTask::getId);
+        List<SdExecutionTask> executionTasks = sdExecutionTaskMapper.selectList(executionTaskWrapper);
+        if (Objects.isNull(executionTasks) || executionTasks.isEmpty()) {
+            log.warn("No successful executionTasks found: taskId={}", task.getId());
             return StrategyResultDTO.builder()
                     .success(false)
-                    .msg("No successful subtasks found")
+                    .msg("No successful executionTasks found")
                     .build();
         }
 
         // 3. 查询子任务结果项
-        List<Long> subTaskIds = subTasks.stream().map(SdSubTask::getId).collect(Collectors.toList());
+        List<Long> executionTaskIds = executionTasks.stream().map(SdExecutionTask::getId).collect(Collectors.toList());
         // TODO: 根据实际业务确定itemType
         String itemType = "";
-        LambdaQueryWrapper<SdSubTaskResultItem> resultItemWrapper = Wrappers.lambdaQuery(SdSubTaskResultItem.class)
-                .eq(SdSubTaskResultItem::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .in(SdSubTaskResultItem::getSubTaskId, subTaskIds)
-                .eq(SdSubTaskResultItem::getItemType, itemType)
-                .select(SdSubTaskResultItem::getItemContent);
-        List<SdSubTaskResultItem> resultItems = sdSubTaskResultItemMapper.selectList(resultItemWrapper);
+        LambdaQueryWrapper<SdExecutionTaskResultItem> resultItemWrapper = Wrappers.lambdaQuery(SdExecutionTaskResultItem.class)
+                .eq(SdExecutionTaskResultItem::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+                .in(SdExecutionTaskResultItem::getExecutionTaskId, executionTaskIds)
+                .eq(SdExecutionTaskResultItem::getItemType, itemType)
+                .select(SdExecutionTaskResultItem::getItemContent);
+        List<SdExecutionTaskResultItem> resultItems = sdExecutionTaskResultItemMapper.selectList(resultItemWrapper);
         if (Objects.isNull(resultItems) || resultItems.isEmpty()) {
-            log.warn("No subtask result items found: taskId={}", task.getId());
+            log.warn("No executionTask result items found: taskId={}", task.getId());
             return StrategyResultDTO.builder()
                     .success(false)
-                    .msg("No subtask result items found")
+                    .msg("No executionTask result items found")
                     .build();
         }
 
         // 4. 构建输入内容
         String input = resultItems.stream()
-                .map(SdSubTaskResultItem::getItemContent)
+                .map(SdExecutionTaskResultItem::getItemContent)
                 .filter(Objects::nonNull)
                 .collect(Collectors.joining("\n"));
 

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/strategy/DeconstructStrategy.java

@@ -3,13 +3,13 @@ package com.tzld.piaoquan.sde.service.strategy;
 import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.tzld.piaoquan.sde.common.enums.ExecutionTaskStatusEnum;
 import com.tzld.piaoquan.sde.common.enums.IsDeleteEnum;
-import com.tzld.piaoquan.sde.common.enums.SubTaskStatusEnum;
 import com.tzld.piaoquan.sde.common.enums.TaskTypeEnum;
 import com.tzld.piaoquan.sde.integration.OpenRouterClient;
+import com.tzld.piaoquan.sde.mapper.SdExecutionTaskMapper;
+import com.tzld.piaoquan.sde.mapper.SdExecutionTaskResultItemMapper;
 import com.tzld.piaoquan.sde.mapper.SdPromptTemplateMapper;
-import com.tzld.piaoquan.sde.mapper.SdSubTaskMapper;
-import com.tzld.piaoquan.sde.mapper.SdSubTaskResultItemMapper;
 import com.tzld.piaoquan.sde.model.dto.StrategyConfigDTO;
 import com.tzld.piaoquan.sde.model.dto.StrategyResultDTO;
 import com.tzld.piaoquan.sde.model.entity.*;
@@ -32,10 +32,10 @@ import java.util.stream.Collectors;
 public class DeconstructStrategy implements DemandExtractionStrategy {
 
     @Autowired
-    private SdSubTaskMapper sdSubTaskMapper;
+    private SdExecutionTaskMapper sdExecutionTaskMapper;
 
     @Autowired
-    private SdSubTaskResultItemMapper sdSubTaskResultItemMapper;
+    private SdExecutionTaskResultItemMapper sdExecutionTaskResultItemMapper;
 
     @Autowired
     private SdPromptTemplateMapper sdPromptTemplateMapper;
@@ -49,7 +49,7 @@ public class DeconstructStrategy implements DemandExtractionStrategy {
     }
 
     @Override
-    public StrategyResultDTO execute(SdTask task, SdStrategy strategy) {
+    public StrategyResultDTO execute(SdWorkflowTask task, SdStrategy strategy) {
         log.info("Executing deconstruct task: taskId={}, taskNo={}", task.getId(), task.getTaskNo());
         StrategyConfigDTO strategyConfigDTO = JSON.parseObject(strategy.getConfig(), StrategyConfigDTO.class);
         // 1. 获取Prompt模板
@@ -63,31 +63,31 @@ public class DeconstructStrategy implements DemandExtractionStrategy {
         }
 
         // 2. 查询成功的子任务
-        LambdaQueryWrapper<SdSubTask> subTaskWrapper = Wrappers.lambdaQuery(SdSubTask.class)
-                .eq(SdSubTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .eq(SdSubTask::getTaskId, task.getId())
-                .eq(SdSubTask::getTaskStatus, SubTaskStatusEnum.SUCCESS.getValue())
-                .eq(SdSubTask::getSubTaskType, task.getTaskType())
-                .select(SdSubTask::getId);
-        List<SdSubTask> subTasks = sdSubTaskMapper.selectList(subTaskWrapper);
-        if (Objects.isNull(subTasks) || subTasks.isEmpty()) {
-            log.warn("No successful subtasks found: taskId={}", task.getId());
+        LambdaQueryWrapper<SdExecutionTask> subTaskWrapper = Wrappers.lambdaQuery(SdExecutionTask.class)
+                .eq(SdExecutionTask::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+//                .eq(SdExecutionTask::getTaskId, task.getId())
+                .eq(SdExecutionTask::getTaskStatus, ExecutionTaskStatusEnum.SUCCESS.getValue())
+                .eq(SdExecutionTask::getTaskType, "")
+                .select(SdExecutionTask::getId);
+        List<SdExecutionTask> executionTasks = sdExecutionTaskMapper.selectList(subTaskWrapper);
+        if (Objects.isNull(executionTasks) || executionTasks.isEmpty()) {
+            log.warn("No successful executionTasks found: taskId={}", task.getId());
             return StrategyResultDTO.builder()
                     .success(false)
-                    .msg("No successful subtasks found")
+                    .msg("No successful executionTasks found")
                     .build();
         }
 
         // 3. 查询子任务结果项
-        List<Long> subTaskIds = subTasks.stream().map(SdSubTask::getId).collect(Collectors.toList());
+        List<Long> executionTaskIds = executionTasks.stream().map(SdExecutionTask::getId).collect(Collectors.toList());
         // TODO: 根据实际业务确定itemType
         String itemType = "";
-        LambdaQueryWrapper<SdSubTaskResultItem> resultItemWrapper = Wrappers.lambdaQuery(SdSubTaskResultItem.class)
-                .eq(SdSubTaskResultItem::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
-                .in(SdSubTaskResultItem::getSubTaskId, subTaskIds)
-                .eq(SdSubTaskResultItem::getItemType, itemType)
-                .select(SdSubTaskResultItem::getItemContent);
-        List<SdSubTaskResultItem> resultItems = sdSubTaskResultItemMapper.selectList(resultItemWrapper);
+        LambdaQueryWrapper<SdExecutionTaskResultItem> resultItemWrapper = Wrappers.lambdaQuery(SdExecutionTaskResultItem.class)
+                .eq(SdExecutionTaskResultItem::getIsDeleted, IsDeleteEnum.NORMAL.getValue())
+                .in(SdExecutionTaskResultItem::getExecutionTaskId, executionTaskIds)
+                .eq(SdExecutionTaskResultItem::getItemType, itemType)
+                .select(SdExecutionTaskResultItem::getItemContent);
+        List<SdExecutionTaskResultItem> resultItems = sdExecutionTaskResultItemMapper.selectList(resultItemWrapper);
         if (Objects.isNull(resultItems) || resultItems.isEmpty()) {
             log.warn("No subtask result items found: taskId={}", task.getId());
             return StrategyResultDTO.builder()
@@ -98,7 +98,7 @@ public class DeconstructStrategy implements DemandExtractionStrategy {
 
         // 4. 构建输入内容
         String input = resultItems.stream()
-                .map(SdSubTaskResultItem::getItemContent)
+                .map(SdExecutionTaskResultItem::getItemContent)
                 .filter(Objects::nonNull)
                 .collect(Collectors.joining("\n"));
 

supply-demand-engine-core/src/main/java/com/tzld/piaoquan/sde/service/strategy/DemandExtractionStrategy.java

@@ -2,7 +2,7 @@ package com.tzld.piaoquan.sde.service.strategy;
 
 import com.tzld.piaoquan.sde.model.dto.StrategyResultDTO;
 import com.tzld.piaoquan.sde.model.entity.SdStrategy;
-import com.tzld.piaoquan.sde.model.entity.SdTask;
+import com.tzld.piaoquan.sde.model.entity.SdWorkflowTask;
 
 /**
  * 需求提取策略接口
@@ -19,5 +19,5 @@ public interface DemandExtractionStrategy {
     /**
      * 执行需求提取
      */
-    StrategyResultDTO execute(SdTask task, SdStrategy strategy);
+    StrategyResultDTO execute(SdWorkflowTask task, SdStrategy strategy);
 }

supply-demand-engine-job/src/main/java/com/tzld/piaoquan/sde/job/SubTaskJob.java → supply-demand-engine-job/src/main/java/com/tzld/piaoquan/sde/job/ExecutionTaskJob.java

@@ -1,6 +1,6 @@
 package com.tzld.piaoquan.sde.job;
 
-import com.tzld.piaoquan.sde.service.SubTaskService;
+import com.tzld.piaoquan.sde.service.ExecutionTaskService;
 import com.xxl.job.core.biz.model.ReturnT;
 import com.xxl.job.core.handler.annotation.XxlJob;
 import com.xxl.job.core.log.XxlJobLogger;
@@ -13,10 +13,10 @@ import org.springframework.stereotype.Component;
  */
 @Slf4j
 @Component
-public class SubTaskJob {
+public class ExecutionTaskJob {
 
     @Autowired
-    private SubTaskService subTaskService;
+    private ExecutionTaskService executionTaskService;
 
     /**
      * 定时提交子任务
@@ -24,16 +24,16 @@ public class SubTaskJob {
      * @param params
      * @return
      */
-    @XxlJob("subTaskSubmitHandler")
-    public ReturnT<String> subTaskSubmitHandler(String params) {
-        XxlJobLogger.log("subTaskSubmitHandler start");
+    @XxlJob("executionTaskSubmitHandler")
+    public ReturnT<String> executionTaskSubmitHandler(String params) {
+        XxlJobLogger.log("executionTaskSubmitHandler start");
         try {
-            subTaskService.subTaskSubmitHandler();
+            executionTaskService.executionTaskSubmitHandler();
         } catch (Exception e) {
-            XxlJobLogger.log("subTaskSubmitHandler error", e);
+            XxlJobLogger.log("executionTaskSubmitHandler error", e);
             return ReturnT.FAIL;
         } finally {
-            XxlJobLogger.log("subTaskSubmitHandler end");
+            XxlJobLogger.log("executionTaskSubmitHandler end");
         }
         return ReturnT.SUCCESS;
     }
@@ -44,16 +44,16 @@ public class SubTaskJob {
      * @param params
      * @return
      */
-    @XxlJob("subTaskSyncHandler")
+    @XxlJob("executionTaskSyncHandler")
     public ReturnT<String> subTaskSyncHandler(String params) {
-        XxlJobLogger.log("subTaskSyncHandler start");
+        XxlJobLogger.log("executionTaskSyncHandler start");
         try {
-            subTaskService.subTaskSyncHandler();
+            executionTaskService.executionTaskSyncHandler();
         } catch (Exception e) {
-            XxlJobLogger.log("subTaskSyncHandler error", e);
+            XxlJobLogger.log("executionTaskSyncHandler error", e);
             return ReturnT.FAIL;
         } finally {
-            XxlJobLogger.log("subTaskSyncHandler end");
+            XxlJobLogger.log("executionTaskSyncHandler end");
         }
         return ReturnT.SUCCESS;
     }

supply-demand-engine-job/src/main/java/com/tzld/piaoquan/sde/job/TaskJob.java

@@ -1,54 +0,0 @@
-package com.tzld.piaoquan.sde.job;
-
-import com.tzld.piaoquan.sde.service.TaskService;
-import com.xxl.job.core.biz.model.ReturnT;
-import com.xxl.job.core.handler.annotation.XxlJob;
-import com.xxl.job.core.log.XxlJobLogger;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-/**
- * @author supeng
- */
-@Slf4j
-@Component
-public class TaskJob {
-
-    @Autowired
-    private TaskService taskService;
-
-    /**
-     * 任务状态检测更新
-     *
-     * @param params
-     * @return
-     */
-    @XxlJob("taskStatusCheckHandler")
-    public ReturnT<String> taskStatusCheckHandler(String params) {
-        XxlJobLogger.log("taskStatusCheckHandler start");
-        try {
-            taskService.taskStatusCheckHandler();
-        } catch (Exception e) {
-            XxlJobLogger.log("taskStatusCheckHandler error", e);
-            return ReturnT.FAIL;
-        } finally {
-            XxlJobLogger.log("taskStatusCheckHandler end");
-        }
-        return ReturnT.SUCCESS;
-    }
-
-    @XxlJob("taskExecuteHandler")
-    public ReturnT<String> taskExecuteHandler(String params) {
-        XxlJobLogger.log("taskExecuteHandler start");
-        try {
-            taskService.taskExecuteHandler();
-        } catch (Exception e) {
-            XxlJobLogger.log("taskExecuteHandler error", e);
-            return ReturnT.FAIL;
-        } finally {
-            XxlJobLogger.log("taskExecuteHandler end");
-        }
-        return ReturnT.SUCCESS;
-    }
-}

supply-demand-engine-job/src/main/java/com/tzld/piaoquan/sde/job/WorkflowTaskJob.java

@@ -0,0 +1,54 @@
+package com.tzld.piaoquan.sde.job;
+
+import com.tzld.piaoquan.sde.service.WorkflowTaskService;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.handler.annotation.XxlJob;
+import com.xxl.job.core.log.XxlJobLogger;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author supeng
+ */
+@Slf4j
+@Component
+public class WorkflowTaskJob {
+
+    @Autowired
+    private WorkflowTaskService workflowTaskService;
+
+    /**
+     * 任务状态检测更新
+     *
+     * @param params
+     * @return
+     */
+    @XxlJob("workflowTaskStatusCheckHandler")
+    public ReturnT<String> workflowTaskStatusCheckHandler(String params) {
+        XxlJobLogger.log("workflowTaskStatusCheckHandler start");
+        try {
+            workflowTaskService.workflowTaskStatusCheckHandler();
+        } catch (Exception e) {
+            XxlJobLogger.log("workflowTaskStatusCheckHandler error", e);
+            return ReturnT.FAIL;
+        } finally {
+            XxlJobLogger.log("workflowTaskStatusCheckHandler end");
+        }
+        return ReturnT.SUCCESS;
+    }
+
+    @XxlJob("workflowTaskExecuteHandler")
+    public ReturnT<String> workflowTaskExecuteHandler(String params) {
+        XxlJobLogger.log("workflowTaskExecuteHandler start");
+        try {
+            workflowTaskService.workflowTaskExecuteHandler();
+        } catch (Exception e) {
+            XxlJobLogger.log("workflowTaskExecuteHandler error", e);
+            return ReturnT.FAIL;
+        } finally {
+            XxlJobLogger.log("workflowTaskExecuteHandler end");
+        }
+        return ReturnT.SUCCESS;
+    }
+}

supply-demand-engine-service/src/main/java/com/tzld/piaoquan/sde/controller/SubTaskController.java → supply-demand-engine-service/src/main/java/com/tzld/piaoquan/sde/controller/ExecutionTaskController.java

@@ -3,12 +3,11 @@ package com.tzld.piaoquan.sde.controller;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.tzld.piaoquan.sde.common.api.CommonRequest;
 import com.tzld.piaoquan.sde.common.api.CommonResponse;
-import com.tzld.piaoquan.sde.model.request.SubTaskGetParam;
-import com.tzld.piaoquan.sde.model.request.SubTaskListParam;
-import com.tzld.piaoquan.sde.model.request.TaskCreateParam;
-import com.tzld.piaoquan.sde.model.entity.SdSubTask;
-import com.tzld.piaoquan.sde.model.vo.SdSubTaskVO;
-import com.tzld.piaoquan.sde.service.SubTaskService;
+import com.tzld.piaoquan.sde.model.entity.SdExecutionTask;
+import com.tzld.piaoquan.sde.model.request.ExecutionTaskGetParam;
+import com.tzld.piaoquan.sde.model.request.ExecutionTaskListParam;
+import com.tzld.piaoquan.sde.model.vo.SdExecutionTaskVO;
+import com.tzld.piaoquan.sde.service.ExecutionTaskService;
 import io.swagger.v3.oas.annotations.Operation;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -22,28 +21,28 @@ import org.springframework.web.bind.annotation.RestController;
  */
 @Slf4j
 @RestController
-@RequestMapping("/sub/task")
-public class SubTaskController {
+@RequestMapping("/task/execution")
+public class ExecutionTaskController {
 
     @Autowired
-    private SubTaskService subTaskService;
+    private ExecutionTaskService executionTaskService;
 
     @Operation(summary = "创建子任务")
     @PostMapping("/create")
-    public CommonResponse<Void> create(@RequestBody CommonRequest<TaskCreateParam> request) {
+    public CommonResponse<Void> create(@RequestBody CommonRequest<Void> request) {
 //        subTaskService.create(request);
         return CommonResponse.create();
     }
 
     @Operation(summary = "获取子任务列表")
     @PostMapping("/list")
-    public CommonResponse<Page<SdSubTaskVO>> list(@RequestBody CommonRequest<SubTaskListParam> request) {
-        return CommonResponse.create(subTaskService.list(request));
+    public CommonResponse<Page<SdExecutionTaskVO>> list(@RequestBody CommonRequest<ExecutionTaskListParam> request) {
+        return CommonResponse.create(executionTaskService.list(request));
     }
 
     @Operation(summary = "获取子任务信息")
     @PostMapping("/get")
-    public CommonResponse<SdSubTask> get(@RequestBody CommonRequest<SubTaskGetParam> request) {
-        return CommonResponse.create(subTaskService.get(request));
+    public CommonResponse<SdExecutionTask> get(@RequestBody CommonRequest<ExecutionTaskGetParam> request) {
+        return CommonResponse.create(executionTaskService.get(request));
     }
 }

supply-demand-engine-service/src/main/java/com/tzld/piaoquan/sde/controller/TaskController.java → supply-demand-engine-service/src/main/java/com/tzld/piaoquan/sde/controller/WorkflowTaskController.java

@@ -3,12 +3,12 @@ package com.tzld.piaoquan.sde.controller;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.tzld.piaoquan.sde.common.api.CommonRequest;
 import com.tzld.piaoquan.sde.common.api.CommonResponse;
-import com.tzld.piaoquan.sde.model.request.TaskCreateParam;
-import com.tzld.piaoquan.sde.model.request.TaskGetParam;
-import com.tzld.piaoquan.sde.model.request.TaskListParam;
-import com.tzld.piaoquan.sde.model.entity.SdTask;
-import com.tzld.piaoquan.sde.model.vo.SdTaskVO;
-import com.tzld.piaoquan.sde.service.TaskService;
+import com.tzld.piaoquan.sde.model.entity.SdWorkflowTask;
+import com.tzld.piaoquan.sde.model.request.WorkflowTaskCreateParam;
+import com.tzld.piaoquan.sde.model.request.WorkflowTaskGetParam;
+import com.tzld.piaoquan.sde.model.request.WorkflowTaskListParam;
+import com.tzld.piaoquan.sde.model.vo.SdWorkflowTaskVO;
+import com.tzld.piaoquan.sde.service.WorkflowTaskService;
 import io.swagger.v3.oas.annotations.Operation;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -23,28 +23,28 @@ import org.springframework.web.bind.annotation.RestController;
  */
 @Slf4j
 @RestController
-@RequestMapping("/task")
-public class TaskController {
+@RequestMapping("/task/workflow")
+public class WorkflowTaskController {
 
     @Autowired
-    private TaskService taskService;
+    private WorkflowTaskService workflowTaskService;
 
     @Operation(summary = "创建任务")
     @PostMapping("/create")
-    public CommonResponse<Void> create(@RequestBody CommonRequest<TaskCreateParam> request) {
-        taskService.create(request);
+    public CommonResponse<Void> create(@RequestBody CommonRequest<WorkflowTaskCreateParam> request) {
+        workflowTaskService.create(request);
         return CommonResponse.create();
     }
 
     @Operation(summary = "获取任务列表")
     @PostMapping("/list")
-    public CommonResponse<Page<SdTaskVO>> list(@RequestBody CommonRequest<TaskListParam> request) {
-        return CommonResponse.create(taskService.list(request));
+    public CommonResponse<Page<SdWorkflowTaskVO>> list(@RequestBody CommonRequest<WorkflowTaskListParam> request) {
+        return CommonResponse.create(workflowTaskService.list(request));
     }
 
     @Operation(summary = "获取任务信息")
     @PostMapping("/get")
-    public CommonResponse<SdTask> get(@RequestBody CommonRequest<TaskGetParam> request) {
-        return CommonResponse.create(taskService.get(request));
+    public CommonResponse<SdWorkflowTask> get(@RequestBody CommonRequest<WorkflowTaskGetParam> request) {
+        return CommonResponse.create(workflowTaskService.get(request));
     }
 }