diff --git a/docs/工作流模块说明.md b/docs/工作流模块说明.md new file mode 100644 index 00000000..8d2f4396 --- /dev/null +++ b/docs/工作流模块说明.md @@ -0,0 +1,432 @@ +# Ruoyi-AI 工作流模块详细说明文档 + +## 概述 + +Ruoyi-AI 工作流模块是一个基于 LangGraph4j 的智能工作流引擎，支持可视化工作流设计、AI 模型集成、条件分支、人机交互等高级功能。该模块采用微服务架构，提供完整的 RESTful API 和流式响应支持。 + +## 模块架构 + +### 1. 模块结构 + +``` +ruoyi-ai/ +├── ruoyi-modules/ +│ └── ruoyi-workflow/ # 工作流核心模块 +│ ├── pom.xml +│ └── src/main/java/org/ruoyi/workflow/ +│ └── controller/ # 控制器层 +│ ├── WorkflowController.java +│ ├── WorkflowRuntimeController.java +│ └── admin/ # 管理端控制器 +│ ├── AdminWorkflowController.java +│ └── AdminWorkflowComponentController.java +└── ruoyi-modules-api/ + └── ruoyi-workflow-api/ # 工作流API模块 + ├── pom.xml + └── src/main/java/org/ruoyi/workflow/ + ├── entity/ # 实体类 + ├── dto/ # 数据传输对象 + ├── service/ # 服务接口 + ├── mapper/ # 数据访问层 + ├── workflow/ # 工作流核心逻辑 + ├── enums/ # 枚举类 + ├── util/ # 工具类 + └── exception/ # 异常处理 +``` + +### 2. 核心依赖 + +- **LangGraph4j**: 1.5.3 - 工作流图执行引擎 +- **LangChain4j**: 1.2.0 - AI 模型集成框架 +- **Spring Boot**: 3.x - 应用框架 +- **MyBatis Plus**: 数据访问层 +- **Redis**: 缓存和状态管理 +- **Swagger/OpenAPI**: API 文档 + +## 核心功能 + +### 1. 工作流管理 + +#### 1.1 工作流定义 +- **创建工作流**: 支持自定义标题、描述、公开性设置 +- **编辑工作流**: 可视化节点编辑、连接线配置 +- **版本控制**: 支持工作流的版本管理和回滚 +- **权限管理**: 支持公开/私有工作流设置 + +#### 1.2 工作流执行 +- **流式执行**: 基于 SSE 的实时流式响应 +- **状态管理**: 完整的执行状态跟踪 +- **错误处理**: 详细的错误信息和异常处理 +- **中断恢复**: 支持工作流中断和恢复执行 + +### 2. 节点类型 + +#### 2.1 基础节点 +- **Start**: 开始节点，定义工作流入口 +- **End**: 结束节点，定义工作流出口 + +#### 2.2 AI 模型节点 +- **Answer**: 大语言模型问答节点 +- **Dalle3**: DALL-E 3 图像生成 +- **Tongyiwanx**: 通义万相图像生成 +- **Classifier**: 内容分类节点 + +#### 2.3 数据处理节点 +- **DocumentExtractor**: 文档信息提取 +- **KeywordExtractor**: 关键词提取 +- **FaqExtractor**: 常见问题提取 +- **KnowledgeRetrieval**: 知识库检索 + +#### 2.4 控制流节点 +- **Switcher**: 条件分支节点 +- **HumanFeedback**: 人机交互节点 + +#### 2.5 外部集成节点 +- **Google**: Google 搜索集成 +- **MailSend**: 邮件发送 +- **HttpRequest**: HTTP 请求 +- **Template**: 模板转换 + +### 3. 数据流管理 + +#### 3.1 输入输出定义 +```java +// 节点输入输出数据结构 +public class NodeIOData { + private String name; // 参数名称 + private NodeIODataContent content; // 参数内容 +} + +// 支持的数据类型 +public enum WfIODataTypeEnum { + TEXT, // 文本 + NUMBER, // 数字 + BOOLEAN, // 布尔值 + FILES, // 文件 + OPTIONS // 选项 +} +``` + +#### 3.2 参数引用 +- **节点间引用**: 支持上游节点输出作为下游节点输入 +- **参数映射**: 自动处理参数名称映射 +- **类型转换**: 自动进行数据类型转换 + +## 数据库设计 + +### 1. 核心表结构 + +#### 1.1 工作流定义表 (t_workflow) +```sql +CREATE TABLE t_workflow ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) NOT NULL DEFAULT '', + title VARCHAR(100) NOT NULL DEFAULT '', + remark TEXT NOT NULL DEFAULT '', + user_id BIGINT NOT NULL DEFAULT 0, + is_public TINYINT(1) NOT NULL DEFAULT 0, + is_enable TINYINT(1) NOT NULL DEFAULT 1, + create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, + update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + is_deleted TINYINT(1) NOT NULL DEFAULT 0 +); +``` + +#### 1.2 工作流节点表 (t_workflow_node) +```sql +CREATE TABLE t_workflow_node ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) NOT NULL DEFAULT '', + workflow_id BIGINT NOT NULL DEFAULT 0, + workflow_component_id BIGINT NOT NULL DEFAULT 0, + user_id BIGINT NOT NULL DEFAULT 0, + title VARCHAR(100) NOT NULL DEFAULT '', + remark VARCHAR(500) NOT NULL DEFAULT '', + input_config JSON NOT NULL DEFAULT ('{}'), + node_config JSON NOT NULL DEFAULT ('{}'), + position_x DOUBLE NOT NULL DEFAULT 0, + position_y DOUBLE NOT NULL DEFAULT 0, + create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, + update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + is_deleted TINYINT(1) NOT NULL DEFAULT 0 +); +``` + +#### 1.3 工作流边表 (t_workflow_edge) +```sql +CREATE TABLE t_workflow_edge ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) NOT NULL DEFAULT '', + workflow_id BIGINT NOT NULL DEFAULT 0, + source_node_uuid VARCHAR(32) NOT NULL DEFAULT '', + source_handle VARCHAR(32) NOT NULL DEFAULT '', + target_node_uuid VARCHAR(32) NOT NULL DEFAULT '', + create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, + update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + is_deleted TINYINT(1) NOT NULL DEFAULT 0 +); +``` + +#### 1.4 工作流运行时表 (t_workflow_runtime) +```sql +CREATE TABLE t_workflow_runtime ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) NOT NULL DEFAULT '', + user_id BIGINT NOT NULL DEFAULT 0, + workflow_id BIGINT NOT NULL DEFAULT 0, + input JSON NOT NULL DEFAULT ('{}'), + output JSON NOT NULL DEFAULT ('{}'), + status SMALLINT NOT NULL DEFAULT 1, + status_remark VARCHAR(250) NOT NULL DEFAULT '', + create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, + update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + is_deleted TINYINT(1) NOT NULL DEFAULT 0 +); +``` + +#### 1.5 工作流组件表 (t_workflow_component) +```sql +CREATE TABLE t_workflow_component ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) DEFAULT '' NOT NULL, + name VARCHAR(32) DEFAULT '' NOT NULL, + title VARCHAR(100) DEFAULT '' NOT NULL, + remark TEXT NOT NULL, + display_order INT DEFAULT 0 NOT NULL, + is_enable TINYINT(1) DEFAULT 0 NOT NULL, + create_time DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL, + update_time DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL, + is_deleted TINYINT(1) DEFAULT 0 NOT NULL +); +``` + +## API 接口 + +### 1. 工作流管理接口 + +#### 1.1 基础操作 +```http +# 创建工作流 +POST /workflow/add +Content-Type: application/json +{ + "title": "工作流标题", + "remark": "工作流描述", + "isPublic": false +} + +# 更新工作流 +POST /workflow/update +Content-Type: application/json +{ + "uuid": "工作流UUID", + "title": "新标题", + "remark": "新描述" +} + +# 删除工作流 +POST /workflow/del/{uuid} + +# 启用/禁用工作流 +POST /workflow/enable/{uuid}?enable=true +``` + +#### 1.2 搜索和查询 +```http +# 搜索我的工作流 +GET /workflow/mine/search?keyword=关键词&isPublic=true¤tPage=1&pageSize=10 + +# 搜索公开工作流 +GET /workflow/public/search?keyword=关键词¤tPage=1&pageSize=10 + +# 获取工作流组件列表 +GET /workflow/public/component/list +``` + +### 2. 工作流执行接口 + +#### 2.1 流式执行 +```http +# 流式执行工作流 +POST /workflow/run +Content-Type: application/json +Accept: text/event-stream +{ + "uuid": "工作流UUID", + "inputs": [ + { + "name": "input", + "content": { + "type": 1, + "textContent": "用户输入内容" + } + } + ] +} +``` + +#### 2.2 运行时管理 +```http +# 恢复中断的工作流 +POST /workflow/runtime/resume/{runtimeUuid} +Content-Type: application/json +{ + "feedbackContent": "用户反馈内容" +} + +# 查询工作流执行历史 +GET /workflow/runtime/page?wfUuid=工作流UUID¤tPage=1&pageSize=10 + +# 查询运行时节点详情 +GET /workflow/runtime/nodes/{runtimeUuid} + +# 清理运行时数据 +POST /workflow/runtime/clear?wfUuid=工作流UUID +``` + +### 3. 管理端接口 + +#### 3.1 工作流管理 +```http +# 搜索所有工作流 +POST /admin/workflow/search +Content-Type: application/json +{ + "title": "搜索关键词", + "isPublic": true, + "isEnable": true +} + +# 启用/禁用工作流 +POST /admin/workflow/enable?uuid=工作流UUID&isEnable=true +``` + +## 核心实现 + +### 1. 工作流引擎 (WorkflowEngine) + +工作流引擎是整个模块的核心，负责： +- 工作流图的构建和编译 +- 节点执行调度 +- 状态管理和持久化 +- 流式输出处理 + +```java +public class WorkflowEngine { + // 核心执行方法 + public void run(User user, List userInputs, SseEmitter sseEmitter) { + // 1. 验证工作流状态 + // 2. 创建运行时实例 + // 3. 构建状态图 + // 4. 执行工作流 + // 5. 处理流式输出 + } + + // 恢复执行方法 + public void resume(String userInput) { + // 1. 更新状态 + // 2. 继续执行 + } +} +``` + +### 2. 节点工厂 (WfNodeFactory) + +节点工厂负责根据组件类型创建对应的节点实例： + +```java +public class WfNodeFactory { + public static AbstractWfNode create(WorkflowComponent component, + WorkflowNode node, + WfState wfState, + WfNodeState nodeState) { + // 根据组件类型创建对应的节点实例 + switch (component.getName()) { + case "Answer": + return new LLMAnswerNode(component, node, wfState, nodeState); + case "Switcher": + return new SwitcherNode(component, node, wfState, nodeState); + // ... 其他节点类型 + } + } +} +``` + +### 3. 图构建器 (WorkflowGraphBuilder) + +图构建器负责将工作流定义转换为可执行的状态图： + +```java +public class WorkflowGraphBuilder { + public StateGraph build(WorkflowNode startNode) { + // 1. 构建编译节点树 + // 2. 转换为状态图 + // 3. 添加节点和边 + // 4. 处理条件分支 + // 5. 处理并行执行 + } +} +``` + +## 流式响应机制 + +### 1. SSE 事件类型 + +工作流执行过程中会发送多种类型的 SSE 事件： + +```javascript +// 节点开始执行 +[NODE_RUN_节点UUID] - 节点执行开始事件 + +// 节点输入数据 +[NODE_INPUT_节点UUID] - 节点输入数据事件 + +// 节点输出数据 +[NODE_OUTPUT_节点UUID] - 节点输出数据事件 + +// 流式内容块 +[NODE_CHUNK_节点UUID] - 流式内容块事件 + +// 等待用户输入 +[NODE_WAIT_FEEDBACK_BY_节点UUID] - 等待用户输入事件 +``` + +### 2. 流式处理流程 + +1. **初始化**: 创建工作流运行时实例 +2. **节点执行**: 逐个执行工作流节点 +3. **实时输出**: 通过 SSE 实时推送执行结果 +4. **状态更新**: 实时更新节点和工作流状态 +5. **错误处理**: 捕获并处理执行过程中的错误 + + +## 扩展开发 + +### 1. 自定义节点开发 + +要开发自定义工作流节点，需要： + +1. **创建节点类**：继承 `AbstractWfNode` +2. **实现处理逻辑**：重写 `onProcess()` 方法 +3. **定义配置类**：创建节点配置类 +4. **注册组件**：在组件表中注册新组件 + +```java +public class CustomNode extends AbstractWfNode { + @Override + protected NodeProcessResult onProcess() { + // 实现自定义处理逻辑 + List outputs = new ArrayList<>(); + // ... 处理逻辑 + return NodeProcessResult.success(outputs); + } +} +``` + +### 2. 自定义组件注册 + +```sql +-- 在 t_workflow_component 表中添加新组件 +INSERT INTO t_workflow_component (uuid, name, title, remark, is_enable) +VALUES (REPLACE(UUID(), '-', ''), 'CustomNode', '自定义节点', '自定义节点描述', true); +``` diff --git a/pom.xml b/pom.xml index 87a48987..00a58a09 100644 --- a/pom.xml +++ b/pom.xml @@ -20,7 +20,7 @@ 17 8.0.33 3.5.16 - 2.8.5 + 2.8.13 0.15.0 5.2.3 3.2.1 @@ -265,13 +265,6 @@ ${lock4j.version} - - - com.xuxueli - xxl-job-core - ${xxl-job.version} - - com.alibaba transmittable-thread-local @@ -348,6 +341,19 @@ ${revision} + + + org.ruoyi + ruoyi-workflow + ${revision} + + + + org.ruoyi + ruoyi-workflow-api + ${revision} + + diff --git a/ruoyi-admin/pom.xml b/ruoyi-admin/pom.xml index c930d256..a5d639e6 100644 --- a/ruoyi-admin/pom.xml +++ b/ruoyi-admin/pom.xml @@ -57,6 +57,11 @@ ruoyi-generator + + org.ruoyi + ruoyi-workflow + + org.ruoyi ruoyi-aihuman diff --git a/ruoyi-admin/src/main/resources/application-dev.yml b/ruoyi-admin/src/main/resources/application-dev.yml index 1fd51a25..b45a7257 100644 --- a/ruoyi-admin/src/main/resources/application-dev.yml +++ b/ruoyi-admin/src/main/resources/application-dev.yml @@ -16,9 +16,9 @@ spring: master: type: ${spring.datasource.type} driverClassName: com.mysql.cj.jdbc.Driver - url: jdbc:mysql://127.0.0.1:3306/ruoyi-ai?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true&rewriteBatchedStatements=true - username: root - password: root + url: jdbc:mysql://47.112.190.27:3306/ruoyi-ai?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true&rewriteBatchedStatements=true + username: ruoyi-ai + password: 5YEAWhSFZXKaMGxi hikari: # 最大连接池数量 @@ -37,6 +37,8 @@ spring: connectionTestQuery: SELECT 1 # 多久检查一次连接的活性 keepaliveTime: 30000 + mail: + username: xx --- # redis 单机配置(单机与集群只能开启一个另一个需要注释掉) spring.data: @@ -102,5 +104,13 @@ pdf: #百炼模型配置 dashscope: key: sk-xxxx - model: qvq-max + +local: + images: xx + + + + files: xx + + diff --git a/ruoyi-admin/src/main/resources/application.yml b/ruoyi-admin/src/main/resources/application.yml index 2bb9f120..a60b4d36 100644 --- a/ruoyi-admin/src/main/resources/application.yml +++ b/ruoyi-admin/src/main/resources/application.yml @@ -156,6 +156,8 @@ security: # actuator 监控配置 - /actuator - /actuator/** + - /workflow/** + - /admin/workflow/** # 多租户配置 tenant: # 是否开启 diff --git a/ruoyi-modules-api/pom.xml b/ruoyi-modules-api/pom.xml index a3f0ef00..2cf63600 100644 --- a/ruoyi-modules-api/pom.xml +++ b/ruoyi-modules-api/pom.xml @@ -17,6 +17,7 @@ ruoyi-chat-api ruoyi-knowledge-api ruoyi-system-api + ruoyi-workflow-api diff --git a/ruoyi-modules-api/ruoyi-system-api/src/main/java/org/ruoyi/system/domain/vo/ChatConfigVo.java b/ruoyi-modules-api/ruoyi-system-api/src/main/java/org/ruoyi/system/domain/vo/ChatConfigVo.java index 148d2dc8..410e4a2d 100644 --- a/ruoyi-modules-api/ruoyi-system-api/src/main/java/org/ruoyi/system/domain/vo/ChatConfigVo.java +++ b/ruoyi-modules-api/ruoyi-system-api/src/main/java/org/ruoyi/system/domain/vo/ChatConfigVo.java @@ -18,7 +18,7 @@ import java.io.Serializable; */ @Data @ExcelIgnoreUnannotated -@AutoMapper(target = ChatConfig.class) + @AutoMapper(target = ChatConfig.class) public class ChatConfigVo implements Serializable { @Serial diff --git a/ruoyi-modules-api/ruoyi-workflow-api/pom.xml b/ruoyi-modules-api/ruoyi-workflow-api/pom.xml new file mode 100644 index 00000000..9049508f --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/pom.xml @@ -0,0 +1,133 @@ + + + 4.0.0 + + org.ruoyi + ruoyi-modules-api + ${revision} + ../pom.xml + + + ruoyi-workflow-api + + + 工作流API模块 + + + + 17 + 17 + UTF-8 + + + + + org.springframework.boot + spring-boot-starter + + + + com.fasterxml.jackson.core + jackson-databind + + + + org.springframework + spring-web + + + + org.ruoyi + ruoyi-system-api + + + + org.ruoyi + ruoyi-common-satoken + + + + org.ruoyi + ruoyi-common-mail + + + + org.ruoyi + ruoyi-chat + + + + dev.langchain4j + langchain4j-core + 1.2.0 + + + + cn.hutool + hutool-all + 5.8.12 + compile + + + + org.bsc.langgraph4j + langgraph4j-core + 1.5.3 + + + + org.bsc.langgraph4j + langgraph4j-langchain4j + 1.5.3 + + + + io.swagger.core.v3 + swagger-annotations + 2.2.8 + + + + dev.langchain4j + langchain4j-open-ai + 1.2.0 + compile + + + + dev.langchain4j + langchain4j-community-dashscope + 1.2.0-beta8 + + + + com.baomidou + mybatis-plus-generator + 3.5.3.1 + + + + dev.langchain4j + langchain4j-http-client-jdk + 1.2.0 + + + + dev.langchain4j + langchain4j-document-parser-apache-poi + 1.2.0-beta8 + + + + + com.google.api-client + google-api-client + 2.6.0 + + + + + + diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/CodeGenerator.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/CodeGenerator.java new file mode 100644 index 00000000..6b77b030 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/CodeGenerator.java @@ -0,0 +1,43 @@ +package org.ruoyi.workflow; + +import com.baomidou.mybatisplus.generator.FastAutoGenerator; +import com.baomidou.mybatisplus.generator.config.OutputFile; +import com.baomidou.mybatisplus.generator.config.rules.DbColumnType; + +import java.sql.Types; +import java.util.Collections; + +public class CodeGenerator { + public static void main(String[] args) { + FastAutoGenerator.create("jdbc:postgres://172.17.30.40:5432/aideepin?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&tinyInt1isBit=false&allowMultiQueries=true", "postgres", "postgres") + .globalConfig(builder -> { + builder.author("moyz") // 设置作者 + .enableSwagger() // 开启 swagger 模式 + .fileOverride() // 覆盖已生成文件 + .outputDir("D://"); // 指定输出目录 + }) + .dataSourceConfig(builder -> builder.typeConvertHandler((globalConfig, typeRegistry, metaInfo) -> { + int typeCode = metaInfo.getJdbcType().TYPE_CODE; + if (typeCode == Types.SMALLINT) { + // 自定义类型转换 + return DbColumnType.INTEGER; + } + return typeRegistry.getColumnType(metaInfo); + + })) + .packageConfig(builder -> { + builder.mapper("com.adi.common.mapper") + .parent("") + .moduleName("") + .entity("po") + .serviceImpl("service.impl") + .pathInfo(Collections.singletonMap(OutputFile.xml, "D://mybatisplus-generatorcode")); // 设置mapperXml生成路径 + }) + .strategyConfig(builder -> { + builder.addInclude("adi_knowledge_base_qa_record") // 设置需要生成的表名 + .addTablePrefix("adi_"); + builder.mapperBuilder().enableBaseResultMap().enableMapperAnnotation().build(); + }) + .execute(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/base/BaseResponse.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/base/BaseResponse.java new file mode 100644 index 00000000..d6220abd --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/base/BaseResponse.java @@ -0,0 +1,51 @@ +package org.ruoyi.workflow.base; + +import lombok.Data; +import org.ruoyi.workflow.enums.ErrorEnum; + +import java.io.Serializable; + +@Data +public class BaseResponse implements Serializable { + + private static final long serialVersionUID = 1L; + /** + * 是否成功 + */ + private boolean success; + /** + * 状态码 + */ + private String code; + /** + * 提示 + */ + private String message; + /** + * 数据 + */ + private T data; + + public BaseResponse() { + } + + public BaseResponse(boolean success) { + this.success = success; + } + + public BaseResponse(boolean success, T data) { + this.data = data; + this.success = success; + } + + public BaseResponse(String code, String message, T data) { + this.code = code; + this.success = false; + this.message = message; + this.data = data; + } + + public static BaseResponse success(String message) { + return new BaseResponse(ErrorEnum.SUCCESS.getCode(), message, ""); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/base/NodeInputConfigTypeHandler.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/base/NodeInputConfigTypeHandler.java new file mode 100644 index 00000000..4bd44fbb --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/base/NodeInputConfigTypeHandler.java @@ -0,0 +1,118 @@ +package org.ruoyi.workflow.base; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.ibatis.type.BaseTypeHandler; +import org.apache.ibatis.type.JdbcType; +import org.apache.ibatis.type.MappedJdbcTypes; +import org.apache.ibatis.type.MappedTypes; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.workflow.WfNodeInputConfig; +import org.ruoyi.workflow.workflow.def.WfNodeIO; +import org.ruoyi.workflow.workflow.def.WfNodeParamRef; + +import java.sql.CallableStatement; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import static org.ruoyi.workflow.workflow.WfNodeIODataUtil.INPUT_TYPE_TO_NODE_IO_DEF; + +@Slf4j +@MappedJdbcTypes({JdbcType.JAVA_OBJECT}) +@MappedTypes({WfNodeInputConfig.class}) +public class NodeInputConfigTypeHandler extends BaseTypeHandler { + + public static WfNodeInputConfig fillNodeInputConfig(String jsonSource) { + ObjectNode jsonNode = (ObjectNode) JsonUtil.toJsonNode(jsonSource); + return createNodeInputConfig(jsonNode); + } + + public static WfNodeInputConfig createNodeInputConfig(ObjectNode jsonNode) { + List userInputs = new ArrayList<>(); + WfNodeInputConfig result = new WfNodeInputConfig(); + result.setUserInputs(userInputs); + result.setRefInputs(new ArrayList<>()); + if (null == jsonNode) { + return result; + } + ArrayNode userInputsJson = jsonNode.withArray("user_inputs"); + ArrayNode refInputs = jsonNode.withArray("ref_inputs"); + if (!userInputsJson.isEmpty()) { + for (JsonNode userInput : userInputsJson) { + if (userInput instanceof ObjectNode objectNode) { + int type = objectNode.get("type").asInt(); + Class nodeIOClass = INPUT_TYPE_TO_NODE_IO_DEF.get(WfIODataTypeEnum.getByValue(type)); + WfNodeIO wfNodeIO = JsonUtil.fromJson(objectNode, nodeIOClass); + if (null != wfNodeIO) { + userInputs.add(wfNodeIO); + } else { + log.warn("用户输入格式不正确:{}", userInput); + } + } + } + } + if (!refInputs.isEmpty()) { + List list = JsonUtil.fromArrayNode(refInputs, WfNodeParamRef.class); + if (CollectionUtils.isNotEmpty(list)) { + result.setRefInputs(list); + } else { + log.warn("引用输入格式不正确:{}", refInputs); + } + } + return result; + } + + @Override + public void setNonNullParameter(PreparedStatement ps, int i, WfNodeInputConfig parameter, JdbcType jdbcType) { +// PGobject jsonObject = new PGobject(); +// jsonObject.setType("jsonb"); +// try { +// jsonObject.setValue(JsonUtil.toJson(parameter)); +// ps.setObject(i, jsonObject); +// } catch (Exception e) { +// throw new RuntimeException(e); +// } + } + + @Override + public WfNodeInputConfig getNullableResult(ResultSet rs, String columnName) throws SQLException { + String jsonSource = rs.getString(columnName); + if (jsonSource != null) { + try { + return fillNodeInputConfig(jsonSource); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + return null; + } + + @Override + public WfNodeInputConfig getNullableResult(ResultSet rs, int columnIndex) throws SQLException { + String jsonSource = rs.getString(columnIndex); + if (jsonSource != null) { + return fillNodeInputConfig(jsonSource); + } + return null; + } + + @Override + public WfNodeInputConfig getNullableResult(CallableStatement cs, int columnIndex) throws SQLException { + String jsonSource = cs.getString(columnIndex); + if (jsonSource != null) { + try { + return fillNodeInputConfig(jsonSource); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + return null; + } +} \ No newline at end of file diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/base/ThreadContext.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/base/ThreadContext.java new file mode 100644 index 00000000..cb7e992a --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/base/ThreadContext.java @@ -0,0 +1,122 @@ +package org.ruoyi.workflow.base; + +import cn.dev33.satoken.stp.StpUtil; +import org.apache.commons.lang3.StringUtils; +import org.ruoyi.common.core.domain.model.LoginUser; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.common.satoken.utils.LoginHelper; +import org.ruoyi.workflow.entity.User; +import org.ruoyi.workflow.enums.UserStatusEnum; + +import static org.ruoyi.workflow.enums.ErrorEnum.A_USER_NOT_FOUND; + +/** + * 线程上下文适配器，统一接入 Sa-Token 登录态。 + */ +public class ThreadContext { + + private static final ThreadLocal CURRENT_USER = new ThreadLocal<>(); + private static final ThreadLocal CURRENT_TOKEN = new ThreadLocal<>(); + + private ThreadContext() { + } + + /** + * 获取当前登录的工作流用户。 + */ + public static User getCurrentUser() { + User cached = CURRENT_USER.get(); + if (cached != null) { + return cached; + } + LoginUser loginUser = LoginHelper.getLoginUser(); + if (loginUser == null) { + throw new BaseException(A_USER_NOT_FOUND.getInfo()); + } + User mapped = mapToWorkflowUser(loginUser); + CURRENT_USER.set(mapped); + return mapped; + } + + /** + * 允许在测试或特殊场景下显式设置当前用户。 + */ + public static void setCurrentUser(User user) { + if (user == null) { + CURRENT_USER.remove(); + } else { + CURRENT_USER.set(user); + } + } + + /** + * 获取当前登录用户 ID。 + */ + public static Long getCurrentUserId() { + Long userId = LoginHelper.getUserId(); + if (userId != null) { + return userId; + } + return getCurrentUser().getId(); + } + + /** + * 获取当前访问 token。 + */ + public static String getToken() { + String token = CURRENT_TOKEN.get(); + if (StringUtils.isNotBlank(token)) { + return token; + } + try { + token = StpUtil.getTokenValue(); + } catch (Exception ignore) { + token = null; + } + if (StringUtils.isNotBlank(token)) { + CURRENT_TOKEN.set(token); + } + return token; + } + + public static void setToken(String token) { + if (StringUtils.isBlank(token)) { + CURRENT_TOKEN.remove(); + } else { + CURRENT_TOKEN.set(token); + } + } + + public static boolean isLogin() { + return LoginHelper.isLogin(); + } + + public static User getExistCurrentUser() { + return getCurrentUser(); + } + + public static void unload() { + CURRENT_USER.remove(); + CURRENT_TOKEN.remove(); + } + + private static User mapToWorkflowUser(LoginUser loginUser) { + User user = new User(); + user.setId(loginUser.getUserId()); + String nickname = loginUser.getNickName(); + user.setName(StringUtils.defaultIfBlank(nickname, loginUser.getUsername())); + user.setEmail(loginUser.getUsername()); + user.setUuid(String.valueOf(loginUser.getUserId())); + user.setUserStatus(UserStatusEnum.NORMAL); + user.setIsAdmin(LoginHelper.isSuperAdmin(loginUser.getUserId())); + user.setUnderstandContextMsgPairNum(0); + user.setQuotaByTokenDaily(0); + user.setQuotaByTokenMonthly(0); + user.setQuotaByRequestDaily(0); + user.setQuotaByRequestMonthly(0); + user.setQuotaByImageDaily(0); + user.setQuotaByImageMonthly(0); + user.setIsDeleted(false); + return user; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/config/BeanConfig.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/config/BeanConfig.java new file mode 100644 index 00000000..5623208b --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/config/BeanConfig.java @@ -0,0 +1,76 @@ +package org.ruoyi.workflow.config; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.datatype.jdk8.Jdk8Module; +import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; +import lombok.extern.slf4j.Slf4j; +import org.ruoyi.workflow.util.LocalDateTimeUtil; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Primary; +import org.springframework.core.task.AsyncTaskExecutor; +import org.springframework.http.client.BufferingClientHttpRequestFactory; +import org.springframework.http.client.SimpleClientHttpRequestFactory; +import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder; +import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; +import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean; +import org.springframework.web.client.RestTemplate; + +@Slf4j +@Configuration +public class BeanConfig { + + @Bean + public RestTemplate restTemplate() { + log.info("Configuration:create restTemplate"); + SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory(); + // 设置建立连接超时时间 毫秒 + requestFactory.setConnectTimeout(60000); + // 设置读取数据超时时间 毫秒 + requestFactory.setReadTimeout(60000); + RestTemplate restTemplate = new RestTemplate(); + // 注册LOG拦截器 +// restTemplate.setInterceptors(Lists.newArrayList(new LogClientHttpRequestInterceptor())); + restTemplate.setRequestFactory(new BufferingClientHttpRequestFactory(requestFactory)); + + return restTemplate; + } + + @Bean + @Primary + public ObjectMapper objectMapper() { + log.info("Configuration:create objectMapper"); + ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder().createXmlMapper(false).build(); + objectMapper.registerModules(LocalDateTimeUtil.getSimpleModule(), new JavaTimeModule(), new Jdk8Module()); + //设置null值不参与序列化(字段不被显示) + objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); + return objectMapper; + } + + @Bean(name = "mainExecutor") + @Primary + public AsyncTaskExecutor mainExecutor() { + int processorsNum = Runtime.getRuntime().availableProcessors(); + log.info("mainExecutor,processorsNum:{}", processorsNum); + ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); + executor.setCorePoolSize(processorsNum * 2); + executor.setMaxPoolSize(100); + return executor; + } + + @Bean(name = "imagesExecutor") + public AsyncTaskExecutor imagesExecutor() { + int processorsNum = Runtime.getRuntime().availableProcessors(); + ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); + log.info("imagesExecutor corePoolSize:{},maxPoolSize:{}", processorsNum, processorsNum * 2); + executor.setCorePoolSize(processorsNum); + executor.setMaxPoolSize(processorsNum * 2); + return executor; + } + + @Bean(name = "beanValidator") + public LocalValidatorFactoryBean validator() { + return new LocalValidatorFactoryBean(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/cosntant/AdiConstant.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/cosntant/AdiConstant.java new file mode 100644 index 00000000..d9b4bac7 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/cosntant/AdiConstant.java @@ -0,0 +1,407 @@ +package org.ruoyi.workflow.cosntant; + +import dev.langchain4j.model.input.PromptTemplate; +import lombok.extern.slf4j.Slf4j; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; + +@Slf4j +public class AdiConstant { + public static final int DEFAULT_PAGE_SIZE = 10; + /** + * 验证码id过期时间：1小时 + */ + public static final int AUTH_CAPTCHA_ID_EXPIRE = 1; + /** + * 验证码过期时间，5分钟 + */ + public static final int AUTH_CAPTCHA_EXPIRE = 5; + /** + * 注册激活码有效时长，8小时 + */ + public static final int AUTH_ACTIVE_CODE_EXPIRE = 8; + /** + * token存活时间（8小时） + */ + public static final int USER_TOKEN_EXPIRE = 8; + public static final String DEFAULT_PASSWORD = "123456"; + public static final int LOGIN_MAX_FAIL_TIMES = 3; + public static final String[] WEB_RESOURCES = { + "/swagger-ui/index.html", + "/swagger-ui", + "/swagger-resources", + "/v3/api-docs", + "/favicon.ico", + ".css", + ".js", + "/doc.html" + }; + public static final int SECRET_KEY_TYPE_SYSTEM = 1; + public static final int SECRET_KEY_TYPE_CUSTOM = 2; + public static final String OPENAI_MESSAGE_DONE_FLAG = "[DONE]"; + public static final String DEFAULT_MODEL = "gpt-3.5-turbo"; + public static final String CREATE_IMAGE_RESP_FORMATS_B64JSON = "b64_json"; + public static final String OPENAI_CREATE_IMAGE_RESP_FORMATS_URL = "url"; + public static final List DALLE2_CREATE_IMAGE_SIZES = List.of("256x256", "512x512", "1024x1024"); + public static final List DALLE3_CREATE_IMAGE_SIZES = List.of("1024x1024", "1024x1792", "1792x1024"); + public static final PromptTemplate PROMPT_EXTRA_TEMPLATE = PromptTemplate.from(""" + ## 要求 + 尽可能准确地回答用户的问题 + + ## 用户的问题 + {{question}} + + ## 注意 + {{extraInfo}} + """); + public static final PromptTemplate PROMPT_INFO_TEMPLATE = PromptTemplate.from(""" + ## 要求 + 根据已知信息，尽可能准确地回答用户的问题 + + ## 用户的问题 + {{question}} + + ## 已知信息 + {{information}} + + ## 注意 + 回答的内容不能让用户感知到已知信息的存在 + """); + /** + * 可能的 extraInfo 如适用转音频的要求： 2. 回答的内容要尽量口语化，以方便将内容转成语音 + */ + public static final PromptTemplate PROMPT_INFO_EXTRA_TEMPLATE = PromptTemplate.from(""" + ## 要求 + 根据已知信息，尽可能准确地回答用户的问题 + + ## 用户的问题 + {{question}} + + ## 已知信息 + {{information}} + + ## 注意 + 1. 回答的内容不能让用户感知到已知信息的存在 + {{extraInfo}} + """); + public static final String PROMPT_EXTRA_AUDIO = "2. 回答的内容要尽量口语化，以方便将内容转成语音"; + public static final Double LLM_TEMPERATURE_DEFAULT = 0.7D; + public static final Double RAG_RETRIEVE_MIN_SCORE_DEFAULT = 0.6D; + public static final int tts_ = 1; + public static final String[] POI_DOC_TYPES = {"doc", "docx", "ppt", "pptx", "xls", "xlsx"}; + public static final long SSE_TIMEOUT = (2 * 60 + 30) * 1000L; // 2.5分钟 + public static final int RAG_TYPE_KB = 1; + public static final int RAG_TYPE_SEARCH = 2; + /** + * 每块文档长度（按token算） + */ + public static final int RAG_MAX_SEGMENT_SIZE_IN_TOKENS = 1000; + /** + * 文档召回默认数量 + */ + public static final int RAG_RETRIEVE_NUMBER_DEFAULT = 3; + /** + * 文档召回最大数量 + */ + public static final int RAG_RETRIEVE_NUMBER_MAX = 5; + /** + * 向量搜索时命中所需的最低分数 + */ + public static final double RAG_MIN_SCORE = 0.6; + /** + * 默认的最大输入token数 + */ + public static final int LLM_MAX_INPUT_TOKENS_DEFAULT = 4096; + public static final String LLM_INPUT_TYPE_TEXT = "text"; + public static final String LLM_INPUT_TYPE_IMAGE = "image"; + public static final String LLM_INPUT_TYPE_AUDIO = "audio"; + public static final String LLM_INPUT_TYPE_VIDEO = "video"; + public static final String[] GRAPH_ENTITY_EXTRACTION_ENTITY_TYPES = {"organization", "person", "geo", "event"}; + public static final String GRAPH_TUPLE_DELIMITER = "<|>"; + public static final String GRAPH_RECORD_DELIMITER = "##"; + public static final String GRAPH_COMPLETION_DELIMITER = "<|COMPLETE|>"; + public static final List GRAPH_STORE_MAIN_FIELDS = List.of("name", "label", "text_segment_id", "description"); + /** + * 唯一标识字段，如果该字段有指定，则根据该配置判断Vertex或Edge是否唯一，如知识库中根据 name、metadata->>kb_uuid 来做判断 + */ + public static final String GRAPH_METADATA_IDENTIFY_COLUMNS = "graph_metadata_identify_columns"; + /** + * 内容追加字段 + * 更新数据时，如遇到该标识中的字段，追加内容而不是替换 + */ + public static final String GRAPH_METADATA_APPEND_COLUMNS = "graph_metadata_append_columns_if_exist"; + public static final int AI_IMAGE_TYPE_REGULAR = 1; + public static final int AI_IMAGE_TYPE_THUMBNAIL = 2; + public static final int AI_IMAGE_TYPE_REGULAR_MARK = 3; + public static final int AI_IMAGE_TYPE_THUMBNAIL_MARK = 4; + public static final String DOC_INDEX_TYPE_EMBEDDING = "embedding"; + public static final String DOC_INDEX_TYPE_GRAPHICAL = "graphical"; + public static final String DRAW_TYPE_PUBLIC = "public"; + public static final String DRAW_TYPE_STARRED = "starred"; + public static final String DRAW_TYPE_MINE = "mine"; + public static final String MP_LIMIT_1 = "limit 1"; + /** + * 文件存储在本地 + */ + public static final int STORAGE_LOCATION_LOCAL = 1; + /** + * 文件存储到阿里云OSS + */ + public static final int STORAGE_LOCATION_ALI_OSS = 2; + public static final String URL_PREFIX_FILE = "/file/"; + public static final String URL_PREFIX_IMAGE = "/image/"; + public static final String URL_PREFIX_MY_IMAGE = "/my-image/"; + public static final String URL_PREFIX_MY_THUMBNAIL = "/my-thumbnail/"; + public static final List IMAGE_EXTENSIONS = List.of("jpg", "jpeg", "png", "gif", "bmp", "webp"); + public static final String W_FAILED = "FAILED"; + public static final String COLUMN_NAME_IS_DELETE = "is_deleted"; + public static final String COLUMN_NAME_USER_ID = "user_id"; + public static final String COLUMN_NAME_ID = "id"; + public static final String COLUMN_NAME_UUID = "uuid"; + public static final String FORM_DATA_BOUNDARY_PRE = "----WebKitFormBoundary"; + + private AdiConstant() { + } + + public static class ConversationConstant { + public static final String DEFAULT_NAME = "通用智能助手"; + public static final int ANSWER_CONTENT_TYPE_AUTO = 1; + public static final int ANSWER_CONTENT_TYPE_TEXT = 2; + public static final int ANSWER_CONTENT_TYPE_AUDIO = 3; + public static final String AUDIO_CONFIG_FIELD_ANSWER_VOICE = "answer_voice"; + public static final String AUDIO_CONFIG_FIELD_VOICE_PLATFORM = "platform"; + + private ConversationConstant() { + } + } + + public static class GenerateImage { + public static final int INTERACTING_METHOD_GENERATE_IMAGE = 1; + public static final int INTERACTING_METHOD_EDIT_IMAGE = 2; + public static final int INTERACTING_METHOD_VARIATION = 3; + public static final int INTERACTING_METHOD_BACKGROUND_GENERATION = 4; + public static final int STATUS_DOING = 1; + public static final int STATUS_FAIL = 2; + public static final int STATUS_SUCCESS = 3; + + private GenerateImage() { + } + } + + public static class MetadataKey { + public static final String KB_UUID = "kb_uuid"; + public static final String KB_ITEM_UUID = "kb_item_uuid"; + public static final String ENGINE_NAME = "engine_name"; + public static final String SEARCH_UUID = "search_uuid"; + + private MetadataKey() { + } + } + + public static class SysConfigKey { + public static final String DEEPSEEK_SETTING = "deepseek_setting"; + public static final String OPENAI_SETTING = "openai_setting"; + public static final String DASHSCOPE_SETTING = "dashscope_setting"; + public static final String QIANFAN_SETTING = "qianfan_setting"; + public static final String OLLAMA_SETTING = "ollama_setting"; + public static final String SILICONFLOW_SETTING = "siliconflow_setting"; + public static final String GOOGLE_SETTING = "google_setting"; + public static final String BING_SETTING = "bing_setting"; + public static final String BAIDU_SETTING = "baidu_setting"; + public static final String REQUEST_TEXT_RATE_LIMIT = "request_text_rate_limit"; + public static final String REQUEST_IMAGE_RATE_LIMIT = "request_image_rate_limit"; + public static final String CONVERSATION_MAX_NUM = "conversation_max_num"; + public static final String QUOTA_BY_TOKEN_DAILY = "quota_by_token_daily"; + public static final String QUOTA_BY_TOKEN_MONTHLY = "quota_by_token_monthly"; + public static final String QUOTA_BY_REQUEST_DAILY = "quota_by_request_daily"; + public static final String QUOTA_BY_REQUEST_MONTHLY = "quota_by_request_monthly"; + public static final String QUOTA_BY_IMAGE_DAILY = "quota_by_image_daily"; + public static final String QUOTA_BY_IMAGE_MONTHLY = "quota_by_image_monthly"; + public static final String QUOTA_BY_QA_ASK_DAILY = "quota_by_qa_ask_daily"; + public static final String STORAGE_LOCATION = "storage_location"; + public static final String STORAGE_LOCATION_ALI_OSS = "storage_location_ali_oss"; + public static final String ASR_SETTING = "asr_setting"; + public static final String TTS_SETTING = "tts_setting"; + + private SysConfigKey() { + } + } + + public static class ModelPlatform { + public static final String DEEPSEEK = "deepseek"; + public static final String OPENAI = "openai"; + public static final String DASHSCOPE = "dashscope"; + public static final String QIANFAN = "qianfan"; + public static final String OLLAMA = "ollama"; + public static final String SILICONFLOW = "siliconflow"; + + private ModelPlatform() { + } + + // 获取所有公共静态常量（String类型的值）的列表 + public static List getModelConstants() { + List list = new ArrayList<>(); + Class clazz = ModelPlatform.class; + for (Field field : clazz.getDeclaredFields()) { + try { + String value = (String) field.get(null); + list.add(value); + } catch (ReflectiveOperationException e) { + log.error("error", e); + } + + } + return list; + } + } + + public static class ModelType { + public static final String TEXT = "text"; + public static final String IMAGE = "image"; + public static final String EMBEDDING = "embedding"; + public static final String RERANK = "rerank"; + public static final String ASR = "asr"; + public static final String TTS = "tts"; + + private ModelType() { + } + + public static List getModelType() { + List list = new ArrayList<>(); + Class clazz = ModelType.class; + for (Field field : clazz.getDeclaredFields()) { + try { + String value = (String) field.get(null); + list.add(value); + } catch (ReflectiveOperationException e) { + log.error("error", e); + } + + } + return list; + } + } + + public static class SearchEngineName { + public static final String GOOGLE = "google"; + public static final String BING = "bing"; + public static final String BAIDU = "baidu"; + public static final String[] GOOGLE_COUNTRIES = {"cn", "af", "al", "dz", "as", "ad", "ao", "ai", "aq", "ag", "ar", "am", "aw", "au", "at", "az", "bs", "bh", "bd", "bb", "by", "be", "bz", "bj", "bm", "bt", "bo", "ba", "bw", "bv", "br", "io", "bn", "bg", "bf", "bi", "kh", "cm", "ca", "cv", "ky", "cf", "td", "cl", "cx", "cc", "co", "km", "cg", "cd", "ck", "cr", "ci", "hr", "cu", "cy", "cz", "dk", "dj", "dm", "do", "ec", "eg", "sv", "gq", "er", "ee", "et", "fk", "fo", "fj", "fi", "fr", "gf", "pf", "tf", "ga", "gm", "ge", "de", "gh", "gi", "gr", "gl", "gd", "gp", "gu", "gt", "gn", "gw", "gy", "ht", "hm", "va", "hn", "hk", "hu", "is", "in", "id", "ir", "iq", "ie", "il", "it", "jm", "jp", "jo", "kz", "ke", "ki", "kp", "kr", "kw", "kg", "la", "lv", "lb", "ls", "lr", "ly", "li", "lt", "lu", "mo", "mk", "mg", "mw", "my", "mv", "ml", "mt", "mh", "mq", "mr", "mu", "yt", "mx", "fm", "md", "mc", "mn", "ms", "ma", "mz", "mm", "na", "nr", "np", "nl", "an", "nc", "nz", "ni", "ne", "ng", "nu", "nf", "mp", "no", "om", "pk", "pw", "ps", "pa", "pg", "py", "pe", "ph", "pn", "pl", "pt", "pr", "qa", "re", "ro", "ru", "rw", "sh", "kn", "lc", "pm", "vc", "ws", "sm", "st", "sa", "sn", "rs", "sc", "sl", "sg", "sk", "si", "sb", "so", "za", "gs", "es", "lk", "sd", "sr", "sj", "sz", "se", "ch", "sy", "tw", "tj", "tz", "th", "tl", "tg", "tk", "to", "tt", "tn", "tr", "tm", "tc", "tv", "ug", "ua", "ae", "uk", "gb", "us", "um", "uy", "uz", "vu", "ve", "vn", "vg", "vi", "wf", "eh", "ye", "zm", "zw"}; + public static final String[] GOOGLE_LANGUAGES = {"zh-cn", "zh-tw", "af", "ak", "sq", "ws", "am", "ar", "hy", "az", "eu", "be", "bem", "bn", "bh", "xx-bork", "bs", "br", "bg", "bt", "km", "ca", "chr", "ny", "co", "hr", "cs", "da", "nl", "xx-elmer", "en", "eo", "et", "ee", "fo", "tl", "fi", "fr", "fy", "gaa", "gl", "ka", "de", "el", "kl", "gn", "gu", "xx-hacker", "ht", "ha", "haw", "iw", "hi", "hu", "is", "ig", "id", "ia", "ga", "it", "ja", "jw", "kn", "kk", "rw", "rn", "xx-klingon", "kg", "ko", "kri", "ku", "ckb", "ky", "lo", "la", "lv", "ln", "lt", "loz", "lg", "ach", "mk", "mg", "ms", "ml", "mt", "mv", "mi", "mr", "mfe", "mo", "mn", "sr-me", "my", "ne", "pcm", "nso", "no", "nn", "oc", "or", "om", "ps", "fa", "xx-pirate", "pl", "pt", "pt-br", "pt-pt", "pa", "qu", "ro", "rm", "nyn", "ru", "gd", "sr", "sh", "st", "tn", "crs", "sn", "sd", "si", "sk", "sl", "so", "es", "es-419", "su", "sw", "sv", "tg", "ta", "tt", "te", "th", "ti", "to", "lua", "tum", "tr", "tk", "tw", "ug", "uk", "ur", "uz", "vu", "vi", "cy", "wo", "xh", "yi", "yo", "zu"}; + + private SearchEngineName() { + } + } + + public static class SSEEventName { + public static final String START = "[START]"; + public static final String DONE = "[DONE]"; + public static final String ERROR = "[ERROR]"; + public static final String META = "[META]"; + public static final String AUDIO = "[AUDIO]"; + public static final String THINKING = "[THINKING]"; + public static final String AI_SEARCH_SOURCE_LINKS = "[SOURCE_LINKS]"; + public static final String WF_NODE_CHUNK = "[WF_NODE_CHUNK]"; + public static final String WF_NODE_OUTPUT = "[WF_NODE_OUTPUT]"; + public static final String STATE_CHANGED = "[STATE_CHANGED]"; + + private SSEEventName() { + } + } + + public static class SSEEventData { + + /** + * 状态：问题分析中 + * 如敏感词校验等 + */ + public static final String STATE_QUESTION_ANALYSING = """ + {"state":"question_analysing","remark":"问题分析中"} + """; + + public static final String STATE_KNOWLEDGE_SEARCHING = """ + {"state":"knowledge_searching","remark":"知识库搜索中"} + """; + //使用 THINKING 事件代替 + public static final String STATE_THINKING = """ + {"state":"thinking","remark":"推理中"} + """; + public static final String STATE_RESPONDING = """ + {"state":"responding","remark":"回答中"} + """; + } + + public static class WorkflowConstant { + public static final String DEFAULT_INPUT_PARAM_NAME = "input"; + public static final String DEFAULT_OUTPUT_PARAM_NAME = "output"; + public static final String DEFAULT_ERROR_OUTPUT_PARAM_NAME = "error_msg"; + public static final String HUMAN_FEEDBACK_KEY = "human_feedback"; + public static final int NODE_PROCESS_STATUS_READY = 1; + public static final int NODE_PROCESS_STATUS_DOING = 2; + public static final int NODE_PROCESS_STATUS_SUCCESS = 3; + public static final int NODE_PROCESS_STATUS_FAIL = 4; + + public static final int WORKFLOW_PROCESS_STATUS_READY = 1; + public static final int WORKFLOW_PROCESS_STATUS_DOING = 2; + public static final int WORKFLOW_PROCESS_STATUS_SUCCESS = 3; + public static final int WORKFLOW_PROCESS_STATUS_FAIL = 4; + public static final int WORKFLOW_PROCESS_STATUS_WAITING_INPUT = 5; + + public static final int WORKFLOW_NODE_PROCESS_TYPE_NORMAL = 1; + public static final int WORKFLOW_NODE_PROCESS_TYPE_CONDITIONAL = 2; + public static final int WORKFLOW_NODE_PROCESS_TYPE_PARALLEL = 3; + + public static final int MAIL_SENDER_TYPE_SYS = 1; + public static final int MAIL_SENDER_TYPE_CUSTOM = 2; + } + + public static class TokenEstimator { + public static String OPENAI = "openai"; + public static String HUGGING_FACE = "huggingface"; + public static String QWEN = "qwen"; + + public static List ALL = List.of(OPENAI, HUGGING_FACE, QWEN); + } + + public static class EmbeddingModel { + public static String ALL_MINILM_L6 = "local:all-minilm-l6-v2"; + } + + public static class McpConstant { + public static final String TRANSPORT_TYPE_SSE = "sse"; + public static final String TRANSPORT_TYPE_STDIO = "stdio"; + public static final String INSTALL_TYPE_REMOTE = "remote"; + public static final String INSTALL_TYPE_WASM = "wasm"; + public static final String INSTALL_TYPE_LOCAL = "local"; + public static final String INSTALL_TYPE_DOCKER = "docker"; + } + + public static class TtsConstant { + + /** + * 语音合成器位置-客户端 + */ + public static final String SYNTHESIZER_CLIENT = "client"; + /** + * 语音合成器位置-服务端 + */ + public static final String SYNTHESIZER_SERVER = "server"; + + /** + * 通义默认语音音色-龙应严(义正严辞女声) + */ + public static final String DASHSCOPE_DEFAULT_VOICE = "longyingyan"; + } + + public static class CustomChatRequestParameterKeys { + /** + * 是否开启思考模式，默认不开启 + */ + public static final String ENABLE_THINKING = "enable_thinking"; + + private CustomChatRequestParameterKeys() { + } + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/cosntant/RedisKeyConstant.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/cosntant/RedisKeyConstant.java new file mode 100644 index 00000000..77e86997 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/cosntant/RedisKeyConstant.java @@ -0,0 +1,116 @@ +package org.ruoyi.workflow.cosntant; + +public class RedisKeyConstant { + + /** + * 账号激活码的key + */ + public static final String AUTH_ACTIVE_CODE = "auth:activeCode:{0}"; + /** + * 注册时使用的验证码 + * 参数：验证码id + * 值：验证码 + */ + public static final String AUTH_REGISTER_CAPTCHA_ID = "auth:register:captcha:{0}"; + /** + * 登录时使用的验证码id缓存 + * 参数：验证码id + * 值：验证码 + */ + public static final String AUTH_LOGIN_CAPTCHA_ID = "auth:login:captcha:{0}"; + /** + * 注册验证码缓存 + * 参数：验证码 + * 值：1 + */ + public static final String AUTH_CAPTCHA = "auth:register:captcha:{0}"; + /** + * 登录token + * {0}:用户token + * 值：json.format(user) + */ + public static final String USER_TOKEN = "user:token:{0}"; + /** + * 参数：游客的uuid + * 值：json.format(guest) + */ + public static final String GUEST_UUID = "guest:uuid:{0}"; + /** + * 登录失败次数 + * 参数：用户邮箱 + * 值: 失效次数 + */ + public static final String LOGIN_FAIL_COUNT = "user:login:fail:{0}"; + /** + * 用户是否请求ai中 + * 参数：用户id + * 值: 1或者0 + */ + public static final String USER_ASKING = "user:asking:{0}"; + /** + * 用户是否画画中 + * 参数：用户id + * 值: 1或者0 + */ + public static final String USER_DRAWING = "user:drawing:{0}"; + /** + * 用户提问限流计数 + * 参数：用户id + * 值: 当前时间窗口访问量 + */ + public static final String USER_REQUEST_TEXT_TIMES = "user:request-text:times:{0}"; + public static final String USER_REQUEST_IMAGE_TIMES = "user:request-image:times:{0}"; + /** + * 用户信息缓存 + * 参数：用户id + * 值: user object + */ + public static final String USER_INFO = "user:info:"; + /** + * 找回密码的请求绑在 + * 参数：随机数 + * 值: 用户id，用于校验后续流程中的重置密码使用 + */ + public static final String FIND_MY_PASSWORD = "user:find:password:{0}"; + /** + * qa提问次数（每天） + * 参数：用户id:日期yyyyMMdd + * 值：提问数量 + */ + public static final String AQ_ASK_TIMES = "qa:ask:limit:{0}:{1}"; + /** + * 知识库知识点生成数量 + * 值: 用户id + */ + public static final String QA_ITEM_CREATE_LIMIT = "aq:item:create:{0}"; + /** + * 信号(重新生成知识库统计数据) + * 值:知识库uuid + */ + public static final String KB_STATISTIC_RECALCULATE_SIGNAL = "kb:statistic:recalculate:signal"; + public static final String STATISTIC = "statistic"; + public static final String STATISTIC_USER = "user"; + public static final String STATISTIC_KNOWLEDGE_BASE = "kb"; + public static final String STATISTIC_TOKEN_COST = "token-cost"; + public static final String STATISTIC_CONVERSATION = "conversation"; + public static final String STATISTIC_IMAGE_COST = "image-cost"; + public static final String TOKEN_USAGE_KEY = "token:usage:{0}"; + /** + * 用户正在对文档进行索引 + * 值：用户id + */ + public static final String USER_INDEXING = "user:indexing:{0}"; + /** + * 用户评论并发限制 + * 值：用户id + */ + public static final String DRAW_COMMENT_LIMIT_KEY = "user:draw:comment-submitting:{0}"; + public static final String WORKFLOW_KEY = "workflow"; + public static final String WORKFLOW_COMPONENTS = "workflow:components"; + public static final String WORKFLOW_COMPONENT_START_KEY = "workflow:component:start"; + public static final String WORKFLOW_COMPONENT_KEY = "workflow:component"; + public static final String WORKFLOW_COPY_DOING = "workflow:copy:doing:{0}"; + + private RedisKeyConstant() { + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfAddReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfAddReq.java new file mode 100644 index 00000000..f201919d --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfAddReq.java @@ -0,0 +1,17 @@ +package org.ruoyi.workflow.dto.workflow; + +import jakarta.validation.constraints.NotBlank; +import lombok.Data; +import org.springframework.validation.annotation.Validated; + +@Data +@Validated +public class WfAddReq { + + @NotBlank + private String title; + + private String remark; + + private Boolean isPublic; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfBaseInfoUpdateReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfBaseInfoUpdateReq.java new file mode 100644 index 00000000..7b12335b --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfBaseInfoUpdateReq.java @@ -0,0 +1,15 @@ +package org.ruoyi.workflow.dto.workflow; + +import jakarta.validation.constraints.NotBlank; +import lombok.Data; +import org.springframework.validation.annotation.Validated; + +@Validated +@Data +public class WfBaseInfoUpdateReq { + @NotBlank + private String uuid; + private String title; + private String remark; + private Boolean isPublic; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfComponentReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfComponentReq.java new file mode 100644 index 00000000..84da556f --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfComponentReq.java @@ -0,0 +1,18 @@ +package org.ruoyi.workflow.dto.workflow; + +import jakarta.validation.constraints.NotBlank; +import lombok.Data; +import org.springframework.validation.annotation.Validated; + +@Data +@Validated +public class WfComponentReq { + private String uuid; + @NotBlank(message = "标题不能为空") + private String name; + @NotBlank(message = "标题不能为空") + private String title; + private String remark; + private Boolean isEnable; + private Integer displayOrder; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfComponentSearchReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfComponentSearchReq.java new file mode 100644 index 00000000..5ebc9dff --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfComponentSearchReq.java @@ -0,0 +1,9 @@ +package org.ruoyi.workflow.dto.workflow; + +import lombok.Data; + +@Data +public class WfComponentSearchReq { + private String title; + private Boolean isEnable; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfEdgeReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfEdgeReq.java new file mode 100644 index 00000000..40eb9a19 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfEdgeReq.java @@ -0,0 +1,25 @@ +package org.ruoyi.workflow.dto.workflow; + +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotBlank; +import lombok.Data; +import org.springframework.validation.annotation.Validated; + +@Validated +@Data +public class WfEdgeReq { + private Long id; + @NotBlank + private String uuid; + @Min(1) + private Long workflowId; + @NotBlank + private String sourceNodeUuid; + private String sourceHandle; + @NotBlank + private String targetNodeUuid; + /** + * 是否新增 + */ + private Boolean isNew; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfNodeDto.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfNodeDto.java new file mode 100644 index 00000000..b5c5baa5 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfNodeDto.java @@ -0,0 +1,32 @@ +package org.ruoyi.workflow.dto.workflow; + +import com.fasterxml.jackson.databind.node.ObjectNode; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; +import jakarta.validation.constraints.Size; +import lombok.Data; +import org.springframework.validation.annotation.Validated; + +@Validated +@Data +public class WfNodeDto { + private Long id; + @NotBlank + @Size(min = 32, max = 32) + private String uuid; + private Long workflowId; + @Min(1) + private Long workflowComponentId; + @NotBlank + private String title; + private String remark; + @NotNull + private ObjectNode inputConfig; + @NotNull + private ObjectNode nodeConfig; + @NotNull + private Double positionX; + @NotNull + private Double positionY; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfRuntimeNodeDto.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfRuntimeNodeDto.java new file mode 100644 index 00000000..4ca93525 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfRuntimeNodeDto.java @@ -0,0 +1,17 @@ +package org.ruoyi.workflow.dto.workflow; + +import com.fasterxml.jackson.databind.node.ObjectNode; +import lombok.Data; +import org.springframework.validation.annotation.Validated; + +@Validated +@Data +public class WfRuntimeNodeDto { + private Long id; + private String uuid; + private Long workflowRuntimeId; + private Long nodeId; + private ObjectNode input; + private ObjectNode output; + private Integer status; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfRuntimeResp.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfRuntimeResp.java new file mode 100644 index 00000000..b5f5fd8a --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfRuntimeResp.java @@ -0,0 +1,22 @@ +package org.ruoyi.workflow.dto.workflow; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.databind.node.ObjectNode; +import lombok.Data; + +import java.time.LocalDateTime; + +@Data +public class WfRuntimeResp { + private Long id; + private String uuid; + private Long workflowId; + private ObjectNode input; + private ObjectNode output; + private Integer status; + private String statusRemark; + + private String workflowUuid; + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private LocalDateTime createTime; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfSearchReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfSearchReq.java new file mode 100644 index 00000000..939c3970 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WfSearchReq.java @@ -0,0 +1,10 @@ +package org.ruoyi.workflow.dto.workflow; + +import lombok.Data; + +@Data +public class WfSearchReq { + private String title; + private Boolean isEnable; + private Boolean isPublic; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowResp.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowResp.java new file mode 100644 index 00000000..1e14b116 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowResp.java @@ -0,0 +1,22 @@ +package org.ruoyi.workflow.dto.workflow; + +import lombok.Data; + +import java.time.LocalDateTime; +import java.util.List; + +@Data +public class WorkflowResp { + private Long id; + private String uuid; + private String title; + private String remark; + private Boolean isPublic; + private Long userId; + private String userUuid; + private String userName; + private List nodes; + private List edges; + private LocalDateTime createTime; + private LocalDateTime updateTime; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowResumeReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowResumeReq.java new file mode 100644 index 00000000..27680932 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowResumeReq.java @@ -0,0 +1,8 @@ +package org.ruoyi.workflow.dto.workflow; + +import lombok.Data; + +@Data +public class WorkflowResumeReq { + private String feedbackContent; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowRunReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowRunReq.java new file mode 100644 index 00000000..54a32a03 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowRunReq.java @@ -0,0 +1,14 @@ +package org.ruoyi.workflow.dto.workflow; + +import com.fasterxml.jackson.databind.node.ObjectNode; +import lombok.Data; + +import java.util.List; + +@Data +public class WorkflowRunReq { + private List inputs; + private String uuid; + + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowUpdateReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowUpdateReq.java new file mode 100644 index 00000000..3e26c490 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/dto/workflow/WorkflowUpdateReq.java @@ -0,0 +1,24 @@ +package org.ruoyi.workflow.dto.workflow; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; +import jakarta.validation.constraints.Size; +import lombok.Data; +import org.springframework.validation.annotation.Validated; + +import java.util.List; + +@Validated +@Data +public class WorkflowUpdateReq { + @NotBlank + private String uuid; + @Size(min = 1) + private List nodes; + @NotNull + private List edges; + + private List deleteNodes; + + private List deleteEdges; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/BaseEntity.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/BaseEntity.java new file mode 100644 index 00000000..b657eb16 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/BaseEntity.java @@ -0,0 +1,29 @@ +package org.ruoyi.workflow.entity; + +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableId; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; + +import java.io.Serializable; +import java.time.LocalDateTime; + +@Data +public class BaseEntity implements Serializable { + + private static final long serialVersionUID = 1L; + + @TableId(type = IdType.AUTO) + private Long id; + + @TableField(value = "create_time") + private LocalDateTime createTime; + + @TableField(value = "update_time") + private LocalDateTime updateTime; + + @Schema(title = "是否删除（0：未删除，1：已删除）") + @TableField(value = "is_deleted") + private Boolean isDeleted; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/User.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/User.java new file mode 100644 index 00000000..20ac4dc0 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/User.java @@ -0,0 +1,66 @@ +package org.ruoyi.workflow.entity; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.ruoyi.workflow.enums.UserStatusEnum; + +import java.time.LocalDateTime; + +@EqualsAndHashCode(callSuper = true) +@Data +@TableName("adi_user") +@Schema(title = "User对象") +public class User extends BaseEntity { + + @Schema(name = "用户名称") + @TableField("name") + private String name; + + @TableField("email") + private String email; + + @TableField("password") + private String password; + + @TableField("uuid") + private String uuid; + + @Schema(name = "上下文理解中需要携带的消息对数量（提示词及回复）") + @TableField("understand_context_msg_pair_num") + private Integer understandContextMsgPairNum; + + @Schema(name = "token quota in one day") + @TableField("quota_by_token_daily") + private Integer quotaByTokenDaily; + + @Schema(name = "token quota in one month") + @TableField("quota_by_token_monthly") + private Integer quotaByTokenMonthly; + + @Schema(name = "request quota in one day") + @TableField("quota_by_request_daily") + private Integer quotaByRequestDaily; + + @Schema(name = "request quota in one month") + @TableField("quota_by_request_monthly") + private Integer quotaByRequestMonthly; + + @TableField("quota_by_image_daily") + private Integer quotaByImageDaily; + + @TableField("quota_by_image_monthly") + private Integer quotaByImageMonthly; + + @TableField("user_status") + private UserStatusEnum userStatus; + + @TableField("active_time") + private LocalDateTime activeTime; + + @Schema(title = "是否管理员（0：否，1：是）") + @TableField(value = "is_admin") + private Boolean isAdmin; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/Workflow.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/Workflow.java new file mode 100644 index 00000000..4334b069 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/Workflow.java @@ -0,0 +1,37 @@ +package org.ruoyi.workflow.entity; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.io.Serial; + +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("t_workflow") +@Schema(title = "工作流定义 | workflow definition") +public class Workflow extends BaseEntity { + + @Serial + private static final long serialVersionUID = 1L; + + @TableField("uuid") + private String uuid; + + @TableField("title") + private String title; + + @TableField("remark") + private String remark; + + @TableField("user_id") + private Long userId; + + @TableField("is_public") + private Boolean isPublic; + + @TableField("is_enable") + private Boolean isEnable; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowComponent.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowComponent.java new file mode 100644 index 00000000..d75e92c8 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowComponent.java @@ -0,0 +1,37 @@ +package org.ruoyi.workflow.entity; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.io.Serial; + +@Data +@EqualsAndHashCode(callSuper = true) +@TableName(value = "t_workflow_component", autoResultMap = true) +@Schema(title = "工作流组件") +public class WorkflowComponent extends BaseEntity { + + @Serial + private static final long serialVersionUID = 1L; + + @TableField("uuid") + private String uuid; + + @TableField("name") + private String name; + + @TableField("title") + private String title; + + @TableField("remark") + private String remark; + + @TableField("display_order") + private Integer displayOrder; + + @TableField("is_enable") + private Boolean isEnable; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowEdge.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowEdge.java new file mode 100644 index 00000000..0a9bffda --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowEdge.java @@ -0,0 +1,34 @@ +package org.ruoyi.workflow.entity; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.io.Serial; + +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("t_workflow_edge") +@Schema(title = "工作流定义-边 | workflow definition edge") +public class WorkflowEdge extends BaseEntity { + + @Serial + private static final long serialVersionUID = 1L; + + @TableField("uuid") + private String uuid; + + @TableField("workflow_id") + private Long workflowId; + + @TableField("source_node_uuid") + private String sourceNodeUuid; + + @TableField("source_handle") + private String sourceHandle; + + @TableField("target_node_uuid") + private String targetNodeUuid; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowNode.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowNode.java new file mode 100644 index 00000000..cc15504a --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowNode.java @@ -0,0 +1,46 @@ +package org.ruoyi.workflow.entity; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.io.Serial; + +@Data +@EqualsAndHashCode(callSuper = true) +@TableName(value = "t_workflow_node", autoResultMap = true) +@Schema(title = "工作流定义-节点 | workflow definition node") +public class WorkflowNode extends BaseEntity { + + @Serial + private static final long serialVersionUID = 1L; + + @TableField("uuid") + private String uuid; + + @TableField("workflow_id") + private Long workflowId; + + @TableField("workflow_component_id") + private Long workflowComponentId; + + @TableField("title") + private String title; + + @TableField("remark") + private String remark; + + @TableField(value = "input_config") + private String inputConfig; + + @TableField(value = "node_config") + private String nodeConfig; + + @TableField("position_x") + private Double positionX; + + @TableField("position_y") + private Double positionY; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowRuntime.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowRuntime.java new file mode 100644 index 00000000..557de3f4 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowRuntime.java @@ -0,0 +1,40 @@ +package org.ruoyi.workflow.entity; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.io.Serial; + +@Data +@EqualsAndHashCode(callSuper = true) +@TableName(value = "t_workflow_runtime", autoResultMap = true) +@Schema(title = "工作流运行时 | Workflow runtime") +public class WorkflowRuntime extends BaseEntity { + + @Serial + private static final long serialVersionUID = 1L; + + @TableField("uuid") + private String uuid; + + @TableField("user_id") + private Long userId; + + @TableField("workflow_id") + private Long workflowId; + + @TableField(value = "input") + private String input; + + @TableField(value = "output") + private String output; + + @TableField("status") + private Integer status; + + @TableField("status_remark") + private String statusRemark; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowRuntimeNode.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowRuntimeNode.java new file mode 100644 index 00000000..271d9eb7 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/entity/WorkflowRuntimeNode.java @@ -0,0 +1,42 @@ +package org.ruoyi.workflow.entity; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.io.Serial; + +@Data +@EqualsAndHashCode(callSuper = true) +@TableName(value = "t_workflow_runtime_node", autoResultMap = true) +@Schema(title = "工作流实例-节点 | Workflow runtime - node") +public class WorkflowRuntimeNode extends BaseEntity { + @Serial + private static final long serialVersionUID = 1L; + + @TableField("uuid") + private String uuid; + + @TableField("user_id") + private Long userId; + + @TableField("workflow_runtime_id") + private Long workflowRuntimeId; + + @TableField("node_id") + private Long nodeId; + + @TableField(value = "input") + private String input; + + @TableField(value = "output") + private String output; + + @TableField("status") + private Integer status; + + @TableField("status_remark") + private String statusRemark; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/AiModelStatus.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/AiModelStatus.java new file mode 100644 index 00000000..0dec4a94 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/AiModelStatus.java @@ -0,0 +1,14 @@ +package org.ruoyi.workflow.enums; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +@Getter +@AllArgsConstructor +public enum AiModelStatus implements BaseEnum { + ACTIVE(1, "启用"), + INACTIVE(2, "停用"); + + private final Integer value; + private final String desc; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/BaseEnum.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/BaseEnum.java new file mode 100644 index 00000000..66a2fb63 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/BaseEnum.java @@ -0,0 +1,12 @@ +package org.ruoyi.workflow.enums; + +import com.baomidou.mybatisplus.annotation.IEnum; + +public interface BaseEnum extends IEnum { + /** + * 获取对应名称 + * + * @return String + */ + String getDesc(); +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/ErrorEnum.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/ErrorEnum.java new file mode 100644 index 00000000..f9de801e --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/ErrorEnum.java @@ -0,0 +1,127 @@ +package org.ruoyi.workflow.enums; + +import lombok.Getter; + +@Getter +public enum ErrorEnum { + SUCCESS("00000", "成功"), + A_URL_NOT_FOUND("A0001", "地址不存在"), + A_PARAMS_ERROR("A0002", "参数校验不通过"), + A_REQUEST_TOO_MUCH("A0003", "访问次数太多"), + A_LOGIN_ERROR("A0004", "登陆失败，账号或密码错误"), + A_LOGIN_ERROR_MAX("A0005", "失败次数太多，请输入验证码重试"), + A_LOGIN_CAPTCHA_ERROR("A0006", "验证码不正确"), + A_USER_NOT_EXIST("A0007", "用户不存在"), + A_CONVERSATION_NOT_EXIST("A0008", "对话不存在"), + A_IMAGE_NUMBER_ERROR("A0009", "图片数量不对"), + A_IMAGE_SIZE_ERROR("A0010", "图片尺寸不对"), + A_FILE_NOT_EXIST("A0011", "文件不存在"), + A_DRAWING("A0012", "作图还未完成"), + A_USER_EXIST("A0013", "账号已经存在，请使用账号密码登录"), + A_FIND_PASSWORD_CODE_ERROR("A0014", "重置码已过期或不存在"), + A_USER_WAIT_CONFIRM("A0015", "用户未激活"), + A_USER_NOT_AUTH("A0016", "用户无权限"), + A_DATA_NOT_FOUND("A0017", "数据不存在"), + A_UPLOAD_FAIL("A0018", "上传失败"), + A_QA_ASK_LIMIT("A0019", "请求次数太多"), + A_QA_ITEM_LIMIT("A0020", "知识点生成已超额度"), + A_CONVERSATION_EXIST("A0021", "会话(角色)已存在"), + A_MODEL_NOT_FOUND("A0022", "模型不存在"), + A_MODEL_ALREADY_EXIST("A0023", "模型已存在"), + A_CONVERSATION_NOT_FOUND("A0024", "会话(角色)找不到"), + A_AI_IMAGE_NOT_FOUND("A0024", "图片找不到"), + A_ENABLE_MODEL_NOT_FOUND("A0025", "没有可用的模型"), + A_DOC_INDEX_DOING("A0026", "文档索引正在进行中，请稍后重试"), + A_PRESET_CONVERSATION_NOT_EXIST("A0027", "预设会话或角色不存在"), + A_CONVERSATION_TITLE_EXIST("A0028", "会话(角色)标题已存在"), + A_AI_IMAGE_NO_AUTH("A0029", "无权限查看该图片"), + A_USER_NOT_FOUND("A0030", "用户不存在"), + A_ACTIVE_CODE_INVALID("A0031", "激活码已失效"), + A_OLD_PASSWORD_INVALID("A0032", "原密码不正确"), + A_OPT_TOO_FREQUENTLY("A0032", "操作太频繁"), + A_DRAW_NOT_FOUND("A00033", "绘图记录找不到"), + A_WF_NOT_FOUND("A00034", "工作流找不到"), + A_WF_DISABLED("A0035", "工作流已停用"), + A_WF_NODE_NOT_FOUND("A0036", "工作流节点找不到"), + A_WF_NODE_CONFIG_NOT_FOUND("A0037", "工作流节点配置找不到"), + A_WF_NODE_CONFIG_ERROR("A0038", "工作流节点配置异常"), + A_WF_INPUT_INVALID("A0039", "工作流输入参数错误"), + A_WF_INPUT_MISSING("A0040", "工作流输入缺少参数"), + A_WF_MULTIPLE_START_NODE("A0041", "多个开始节点"), + A_WF_START_NODE_NOT_FOUND("A0042", "没有开始节点"), + A_WF_END_NODE_NOT_FOUND("A0043", "没有结束节点"), + A_WF_EDGE_NOT_FOUND("A0044", "工作流的边找不到"), + A_WF_RUNTIME_NOT_FOUND("A00045", "工作流运行时数据找不到"), + A_SEARCH_QUERY_IS_EMPTY("A00046", "搜索内容不能为空"), + A_WF_COMPONENT_NOT_FOUND("A00047", "工作流基础组件找不到"), + A_WF_RESUME_FAIL("A00048", "工作流恢复执行时失败"), + A_MAIL_SENDER_EMPTY("A00049", "邮件发送人不能为空"), + A_MAIL_SENDER_CONFIG_ERROR("A00050", "邮件发送人配置错误"), + A_MAIL_RECEIVER_EMPTY("A00051", "邮件接收人不能为空"), + A_MCP_SERVER_NOT_FOUND("A00052", "MCP服务找不到"), + A_USER_MCP_SERVER_NOT_FOUND("A00053", "用户的MCP服务找不到"), + A_PARAMS_INVALID_BY_("A00054", "参数校验异常:{0}"), + A_AI_MESSAGE_NOT_FOUND("A00055", "找不到AI的消息"), + A_USER_QUESTION_NOT_FOUND("A00056", "用户问题不存在"), + A_PLATFORM_NOT_MATCH("A0057", "平台不匹配"), + B_UNCAUGHT_ERROR("B0001", "未捕捉异常"), + B_COMMON_ERROR("B0002", "业务出错"), + B_GLOBAL_ERROR("B0003", "全局异常"), + B_SAVE_IMAGE_ERROR("B0004", "保存图片异常"), + B_FIND_IMAGE_404("B0005", "无法找到图片"), + B_DAILY_QUOTA_USED("B0006", "今天额度已经用完"), + B_MONTHLY_QUOTA_USED("B0007", "当月额度已经用完"), + B_LLM_NOT_SUPPORT("B0008", "LLM不支持该功能"), + B_LLM_SECRET_KEY_NOT_SET("B0009", "LLM的secret key没设置"), + B_MESSAGE_NOT_FOUND("B0008", "消息不存在"), + B_LLM_SERVICE_DISABLED("B0009", "LLM服务不可用"), + B_KNOWLEDGE_BASE_IS_EMPTY("B0010", "知识库内容为空"), + B_NO_ANSWER("B0011", "[无答案]"), + B_SAVE_FILE_ERROR("B0012", "保存文件异常"), + B_BREAK_SEARCH("B0013", "中断搜索"), + B_GRAPH_FILTER_NOT_FOUND("B0014", "图过滤器未定义"), + B_DB_ERROR("B0015", "数据库查询异常"), + B_ACTIVE_USER_ERROR("B0016", "激活用户失败"), + B_RESET_PASSWORD_ERROR("B0017", "重置密码失败"), + B_IMAGE_LOAD_ERROR("B0018", "加载图片失败"), + B_IO_EXCEPTION("B0019", "IO异常"), + B_SERVER_EXCEPTION("B0020", "服务端异常"), + B_DELETE_FILE_ERROR("B0021", "删除文件异常"), + B_WF_RUN_ERROR("B0022", "工作流运行异常"), + B_WF_NODE_DEFINITION_NOT_FOUND("B0023", "工作流节点定义找不到"), + B_DIR_CREATE_FAIL("B0024", "创建目录失败"), + B_LLM_TEMPERATURE_ERROR("B0025", "采样温度应该在 0.1-1之间"), + B_ASR_SETTING_NOT_FOUND("B0026", "语音识别设置未找到"), + B_URL_INVALID("B0027", "不是有效的网络地址"), + B_ASR_MODEL_NOT_FOUND("B0028", "语音识别模型未找到"), + B_TTS_SETTING_NOT_FOUND("B0029", "语音合成设置未找到"), + B_TTS_MODEL_NOT_FOUND("B0030", "语音合成模型未找到"), + B_VOICE_NOT_FOUND("B0031", "声音不存在"), + C_DRAW_FAIL("C0001", "大模型生成图片失败,原因:{0}"), + C_ALI_OSS_CONFIG_ERROR("C0002", "阿里云OSS初始化失败,原因:{0}"), + C_LLM_RESPONSE_INVALID("C0003", "大模型生成结果内容无效"), + C_WF_COMPONENT_DELETED_FAIL_BY_USED("C0004", "工作流组件已经被使用，无法被删除，可先停用"); + + private final String code; + private final String info; + + ErrorEnum(String code, String info) { + this.code = code; + this.info = info; + } + + public static ErrorEnum getErrorEnum(String code) { + ErrorEnum result = null; + for (ErrorEnum c : ErrorEnum.values()) { + if (c.getCode().equals(code)) { + result = c; + break; + } + } + if (null == result) { + result = B_COMMON_ERROR; + } + return result; + } + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/UserStatusEnum.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/UserStatusEnum.java new file mode 100644 index 00000000..2be9a950 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/UserStatusEnum.java @@ -0,0 +1,23 @@ +package org.ruoyi.workflow.enums; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +import java.util.Arrays; + +@Getter +@AllArgsConstructor +public enum UserStatusEnum implements BaseEnum { + + WAIT_CONFIRM(1, "待验证"), + NORMAL(2, "正常"), + FREEZE(3, "冻结"); + + private final Integer value; + private final String desc; + + public static UserStatusEnum getByValue(Integer val) { + return Arrays.stream(UserStatusEnum.values()).filter(item -> item.value.equals(val)).findFirst().orElse(null); + } + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/WfIODataTypeEnum.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/WfIODataTypeEnum.java new file mode 100644 index 00000000..8f8989c6 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/enums/WfIODataTypeEnum.java @@ -0,0 +1,25 @@ +package org.ruoyi.workflow.enums; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +import java.util.Arrays; + +@Getter +@AllArgsConstructor +public enum WfIODataTypeEnum implements BaseEnum { + TEXT(1, "文本"), + NUMBER(2, "数字"), + OPTIONS(3, "下拉选项"), + FILES(4, "文件列表"), + BOOL(5, "布尔值"), + REF_INPUT(6, "引用节点的输入参数"), + REF_OUTPUT(7, "引用节点的输出参数"); + + private final Integer value; + private final String desc; + + public static WfIODataTypeEnum getByValue(Integer val) { + return Arrays.stream(WfIODataTypeEnum.values()).filter(item -> item.value.equals(val)).findFirst().orElse(null); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/helper/SSEEmitterHelper.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/helper/SSEEmitterHelper.java new file mode 100644 index 00000000..4d432c07 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/helper/SSEEmitterHelper.java @@ -0,0 +1,138 @@ +package org.ruoyi.workflow.helper; + +import com.google.common.cache.Cache; +import com.google.common.cache.CacheBuilder; +import jakarta.annotation.Resource; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.ruoyi.workflow.cosntant.AdiConstant; +import org.ruoyi.workflow.cosntant.RedisKeyConstant; +import org.ruoyi.workflow.entity.User; +import org.springframework.data.redis.core.StringRedisTemplate; +import org.springframework.stereotype.Service; +import org.springframework.web.servlet.mvc.method.annotation.SseEmitter; + +import java.io.IOException; +import java.text.MessageFormat; +import java.util.Objects; +import java.util.concurrent.TimeUnit; + +@Slf4j +@Service +public class SSEEmitterHelper { + + private static final Cache COMPLETED_SSE = CacheBuilder.newBuilder() + .expireAfterWrite(10, TimeUnit.MINUTES).build(); + + @Resource + private StringRedisTemplate stringRedisTemplate; + + public static void parseAndSendPartialMsg(SseEmitter sseEmitter, String name, String content) { + if (Boolean.TRUE.equals(COMPLETED_SSE.getIfPresent(sseEmitter))) { + log.warn("sseEmitter already completed,name:{}", name); + return; + } + String[] lines = content.split("[\\r\\n]", -1); + if (lines.length > 1) { + sendPartial(sseEmitter, name, " " + lines[0]); + for (int i = 1; i < lines.length; i++) { + sendPartial(sseEmitter, name, "-_wrap_-"); + sendPartial(sseEmitter, name, " " + lines[i]); + } + } else { + sendPartial(sseEmitter, name, " " + content); + } + } + + public static void sendPartial(SseEmitter sseEmitter, String name, String msg) { + if (Boolean.TRUE.equals(COMPLETED_SSE.getIfPresent(sseEmitter))) { + log.warn("sseEmitter already completed,name:{}", name); + return; + } + try { + if (StringUtils.isNotBlank(name)) { + sseEmitter.send(SseEmitter.event().name(name).data(msg)); + } else { + sseEmitter.send(msg); + } + } catch (IOException ioException) { + log.error("stream onNext error", ioException); + } + } + + + public boolean checkOrComplete(User user, SseEmitter sseEmitter) { + //Check: If still waiting response + String askingKey = MessageFormat.format(RedisKeyConstant.USER_ASKING, user.getId()); + String askingVal = stringRedisTemplate.opsForValue().get(askingKey); + if (StringUtils.isNotBlank(askingVal)) { + sendErrorAndComplete(user.getId(), sseEmitter, "正在回复中..."); + return false; + } + return true; + } + + + public void startSse(User user, SseEmitter sseEmitter, String data) { + + String askingKey = MessageFormat.format(RedisKeyConstant.USER_ASKING, user.getId()); + stringRedisTemplate.opsForValue().set(askingKey, "1", 15, TimeUnit.SECONDS); + + try { + SseEmitter.SseEventBuilder builder = SseEmitter.event().name(AdiConstant.SSEEventName.START); + if (StringUtils.isNotBlank(data)) { + builder.data(data); + } + sseEmitter.send(builder); + } catch (IOException e) { + log.error("startSse error", e); + sseEmitter.completeWithError(e); + COMPLETED_SSE.put(sseEmitter, Boolean.TRUE); + stringRedisTemplate.delete(askingKey); + } + } + + public void sendComplete(long userId, SseEmitter sseEmitter, String msg) { + if (Boolean.TRUE.equals(COMPLETED_SSE.getIfPresent(sseEmitter))) { + log.warn("sseEmitter already completed,userId:{}", userId); + delSseRequesting(userId); + return; + } + try { + sseEmitter.send(SseEmitter.event().name(AdiConstant.SSEEventName.DONE).data(msg)); + } catch (IOException e) { + throw new RuntimeException(e); + } finally { + COMPLETED_SSE.put(sseEmitter, Boolean.TRUE); + delSseRequesting(userId); + sseEmitter.complete(); + } + } + + + public void sendErrorAndComplete(long userId, SseEmitter sseEmitter, String errorMsg) { + if (Boolean.TRUE.equals(COMPLETED_SSE.getIfPresent(sseEmitter))) { + log.warn("sseEmitter already completed,ignore error:{}", errorMsg); + delSseRequesting(userId); + return; + } + try { + SseEmitter.SseEventBuilder event = SseEmitter.event(); + event.name(AdiConstant.SSEEventName.ERROR); + event.data(Objects.toString(errorMsg, "")); + sseEmitter.send(event); + } catch (IOException e) { + log.warn("sendErrorAndComplete userId:{},errorMsg:{}", userId, errorMsg); + throw new RuntimeException(e); + } finally { + COMPLETED_SSE.put(sseEmitter, Boolean.TRUE); + delSseRequesting(userId); + sseEmitter.complete(); + } + } + + private void delSseRequesting(long userId) { + String askingKey = MessageFormat.format(RedisKeyConstant.USER_ASKING, userId); + stringRedisTemplate.delete(askingKey); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowComponentMapper.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowComponentMapper.java new file mode 100644 index 00000000..0935eb58 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowComponentMapper.java @@ -0,0 +1,11 @@ +package org.ruoyi.workflow.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.ruoyi.workflow.entity.WorkflowComponent; + +@Mapper +public interface WorkflowComponentMapper extends BaseMapper { + Integer countRefNodes(@Param("uuid") String uuid); +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowEdgeMapper.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowEdgeMapper.java new file mode 100644 index 00000000..28d21dec --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowEdgeMapper.java @@ -0,0 +1,9 @@ +package org.ruoyi.workflow.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import org.apache.ibatis.annotations.Mapper; +import org.ruoyi.workflow.entity.WorkflowEdge; + +@Mapper +public interface WorkflowEdgeMapper extends BaseMapper { +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowMapper.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowMapper.java new file mode 100644 index 00000000..b8bb1988 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowMapper.java @@ -0,0 +1,9 @@ +package org.ruoyi.workflow.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import org.apache.ibatis.annotations.Mapper; +import org.ruoyi.workflow.entity.Workflow; + +@Mapper +public interface WorkflowMapper extends BaseMapper { +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowNodeMapper.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowNodeMapper.java new file mode 100644 index 00000000..380eec9d --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowNodeMapper.java @@ -0,0 +1,10 @@ +package org.ruoyi.workflow.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import org.apache.ibatis.annotations.Mapper; +import org.ruoyi.workflow.entity.WorkflowNode; + +@Mapper +public interface WorkflowNodeMapper extends BaseMapper { + WorkflowNode getStartNode(long workflowId); +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowRunMapper.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowRunMapper.java new file mode 100644 index 00000000..3e73dd6a --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowRunMapper.java @@ -0,0 +1,13 @@ +package org.ruoyi.workflow.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.ruoyi.workflow.entity.WorkflowRuntime; + +@Mapper +public interface WorkflowRunMapper extends BaseMapper { + + Page pageByWfUuid(Page page, @Param("wfUuid") String wfUuid, @Param("userId") Long userId); +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowRuntimeNodeMapper.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowRuntimeNodeMapper.java new file mode 100644 index 00000000..91345f1c --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/mapper/WorkflowRuntimeNodeMapper.java @@ -0,0 +1,9 @@ +package org.ruoyi.workflow.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import org.apache.ibatis.annotations.Mapper; +import org.ruoyi.workflow.entity.WorkflowRuntimeNode; + +@Mapper +public interface WorkflowRuntimeNodeMapper extends BaseMapper { +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowComponentService.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowComponentService.java new file mode 100644 index 00000000..04e3b03c --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowComponentService.java @@ -0,0 +1,126 @@ +package org.ruoyi.workflow.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers; +import jakarta.annotation.Resource; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.dto.workflow.WfComponentReq; +import org.ruoyi.workflow.dto.workflow.WfComponentSearchReq; +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.enums.ErrorEnum; +import org.ruoyi.workflow.mapper.WorkflowComponentMapper; +import org.ruoyi.workflow.util.PrivilegeUtil; +import org.ruoyi.workflow.util.UuidUtil; +import org.ruoyi.workflow.workflow.WfComponentNameEnum; +import org.springframework.beans.BeanUtils; +import org.springframework.cache.annotation.CacheEvict; +import org.springframework.cache.annotation.Cacheable; +import org.springframework.context.annotation.Lazy; +import org.springframework.stereotype.Service; + +import java.util.List; + +import static org.ruoyi.workflow.cosntant.RedisKeyConstant.WORKFLOW_COMPONENTS; +import static org.ruoyi.workflow.cosntant.RedisKeyConstant.WORKFLOW_COMPONENT_START_KEY; +import static org.ruoyi.workflow.enums.ErrorEnum.C_WF_COMPONENT_DELETED_FAIL_BY_USED; + +@Slf4j +@Service +public class WorkflowComponentService extends ServiceImpl { + + @Lazy + @Resource + private WorkflowComponentService self; + + @CacheEvict(cacheNames = {WORKFLOW_COMPONENTS, WORKFLOW_COMPONENT_START_KEY}) + public WorkflowComponent addOrUpdate(WfComponentReq req) { + WorkflowComponent wfComponent; + if (StringUtils.isNotBlank(req.getUuid())) { + wfComponent = PrivilegeUtil.checkAndGetByUuid(req.getUuid(), this.query(), ErrorEnum.A_WF_COMPONENT_NOT_FOUND); + + WorkflowComponent update = new WorkflowComponent(); + BeanUtils.copyProperties(req, update, "id", "uuid"); + update.setId(wfComponent.getId()); + update.setName(req.getName()); + update.setTitle(req.getTitle()); + update.setRemark(req.getRemark()); + update.setIsEnable(req.getIsEnable()); + update.setDisplayOrder(req.getDisplayOrder()); + this.baseMapper.updateById(update); + + return update; + } else { + wfComponent = new WorkflowComponent(); + BeanUtils.copyProperties(req, wfComponent, "id", "uuid"); + wfComponent.setUuid(UuidUtil.createShort()); + this.baseMapper.insert(wfComponent); + + return wfComponent; + } + } + + @CacheEvict(cacheNames = {WORKFLOW_COMPONENTS, WORKFLOW_COMPONENT_START_KEY}) + public void enable(String uuid, Boolean isEnable) { + WorkflowComponent wfComponent = PrivilegeUtil.checkAndGetByUuid(uuid, this.query(), ErrorEnum.A_WF_COMPONENT_NOT_FOUND); + WorkflowComponent update = new WorkflowComponent(); + update.setIsEnable(isEnable); + update.setId(wfComponent.getId()); + this.baseMapper.updateById(update); + } + + @CacheEvict(cacheNames = {WORKFLOW_COMPONENTS, WORKFLOW_COMPONENT_START_KEY}) + public void deleteByUuid(String uuid) { + WorkflowComponent component = PrivilegeUtil.checkAndGetByUuid(uuid, this.query(), ErrorEnum.A_WF_COMPONENT_NOT_FOUND); + Integer refNodeCount = baseMapper.countRefNodes(uuid); + if (refNodeCount != null && refNodeCount > 0) { + throw new BaseException(C_WF_COMPONENT_DELETED_FAIL_BY_USED.getInfo()); + } + boolean updated = ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(WorkflowComponent::getId, component.getId()) + .set(WorkflowComponent::getIsDeleted, true) + .set(WorkflowComponent::getIsEnable, false) + .update(); + if (!updated) { + throw new BaseException(ErrorEnum.A_WF_COMPONENT_NOT_FOUND.getInfo()); + } + } + + public Page search(WfComponentSearchReq searchReq, Integer currentPage, Integer pageSize) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(WorkflowComponent::getIsDeleted, false); + wrapper.eq(null != searchReq.getIsEnable(), WorkflowComponent::getIsEnable, searchReq.getIsEnable()); + wrapper.like(StringUtils.isNotBlank(searchReq.getTitle()), WorkflowComponent::getTitle, searchReq.getTitle()); + wrapper.orderByAsc(List.of(WorkflowComponent::getDisplayOrder, WorkflowComponent::getId)); + return baseMapper.selectPage(new Page<>(currentPage, pageSize), wrapper); + } + + @Cacheable(cacheNames = WORKFLOW_COMPONENTS) + public List getAllEnable() { + return ChainWrappers.lambdaQueryChain(baseMapper) + .eq(WorkflowComponent::getIsEnable, true) + .eq(WorkflowComponent::getIsDeleted, false) + .orderByAsc(List.of(WorkflowComponent::getDisplayOrder, WorkflowComponent::getId)) + .list(); + } + + @Cacheable(cacheNames = WORKFLOW_COMPONENT_START_KEY) + public WorkflowComponent getStartComponent() { + List components = self.getAllEnable(); + return components.stream() + .filter(component -> WfComponentNameEnum.START.getName().equals(component.getName())) + .findFirst() + .orElseThrow(() -> new BaseException(ErrorEnum.B_WF_NODE_DEFINITION_NOT_FOUND.getInfo())); + } + + public WorkflowComponent getComponent(Long id) { + List components = self.getAllEnable(); + return components.stream() + .filter(component -> component.getId().equals(id)) + .findFirst() + .orElseThrow(() -> new BaseException(ErrorEnum.B_WF_NODE_DEFINITION_NOT_FOUND.getInfo())); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowEdgeService.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowEdgeService.java new file mode 100644 index 00000000..ba545e2d --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowEdgeService.java @@ -0,0 +1,118 @@ +package org.ruoyi.workflow.service; + +import cn.hutool.core.collection.CollUtil; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers; +import jakarta.annotation.Resource; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.collections4.CollectionUtils; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.dto.workflow.WfEdgeReq; +import org.ruoyi.workflow.entity.WorkflowEdge; +import org.ruoyi.workflow.enums.ErrorEnum; +import org.ruoyi.workflow.mapper.WorkflowEdgeMapper; +import org.ruoyi.workflow.util.MPPageUtil; +import org.ruoyi.workflow.util.UuidUtil; +import org.springframework.beans.BeanUtils; +import org.springframework.context.annotation.Lazy; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.ArrayList; +import java.util.List; + +@Slf4j +@Service +public class WorkflowEdgeService extends ServiceImpl { + + @Lazy + @Resource + private WorkflowEdgeService self; + + public List listDtoByWfId(long workflowId) { + List edges = ChainWrappers.lambdaQueryChain(baseMapper) + .eq(WorkflowEdge::getWorkflowId, workflowId) + .eq(WorkflowEdge::getIsDeleted, false) + .list(); + return MPPageUtil.convertToList(edges, WfEdgeReq.class); + } + + @Transactional + public void createOrUpdateEdges(Long workflowId, List edges) { + List uuidList = new ArrayList<>(); + for (WfEdgeReq edge : edges) { + WorkflowEdge newOne = new WorkflowEdge(); + BeanUtils.copyProperties(edge, newOne); + newOne.setWorkflowId(workflowId); + + WorkflowEdge old = self.getByUuid(edge.getUuid()); + if (null != old) { + log.info("更新边,id:{},uuid:{},source:{},sourceHandle:{},target:{}", + edge.getId(), edge.getUuid(), edge.getSourceNodeUuid(), edge.getSourceHandle(), edge.getTargetNodeUuid()); + newOne.setId(old.getId()); + } else { + newOne.setId(null); + log.info("新增边,uuid:{},source:{},sourceHandle:{},target:{}", + edge.getUuid(), edge.getSourceNodeUuid(), edge.getSourceHandle(), edge.getTargetNodeUuid()); + } + uuidList.add(edge.getUuid()); + self.saveOrUpdate(newOne); + } + ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(WorkflowEdge::getWorkflowId, workflowId) + .notIn(CollUtil.isNotEmpty(uuidList), WorkflowEdge::getUuid, uuidList) + .set(WorkflowEdge::getIsDeleted, true) + .update(); + } + + public List listByWorkflowId(Long workflowId) { + return ChainWrappers.lambdaQueryChain(baseMapper) + .eq(WorkflowEdge::getWorkflowId, workflowId) + .eq(WorkflowEdge::getIsDeleted, false) + .list(); + } + + public List copyByWorkflowId(long workflowId, long targetWorkflow) { + List result = new ArrayList<>(); + self.listByWorkflowId(workflowId).forEach(edge -> { + result.add(self.copyEdge(targetWorkflow, edge)); + }); + return result; + } + + public WorkflowEdge copyEdge(long targetWorkflow, WorkflowEdge sourceEdge) { + WorkflowEdge newEdge = new WorkflowEdge(); + BeanUtils.copyProperties(sourceEdge, newEdge, "id", "uuid", "createTime", "updateTime"); + newEdge.setUuid(UuidUtil.createShort()); + newEdge.setWorkflowId(targetWorkflow); + baseMapper.insert(newEdge); + return getById(newEdge.getId()); + } + + @Transactional + public void deleteEdges(Long workflowId, List uuids) { + if (CollectionUtils.isEmpty(uuids)) { + return; + } + for (String uuid : uuids) { + WorkflowEdge old = self.getByUuid(uuid); + if (null != old && !old.getWorkflowId().equals(workflowId)) { + log.error("该边不属于指定的工作流,删除失败,workflowId:{},node workflowId:{}", workflowId, workflowId); + throw new BaseException(ErrorEnum.A_PARAMS_ERROR.getInfo()); + } + ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(WorkflowEdge::getWorkflowId, workflowId) + .eq(WorkflowEdge::getUuid, uuid) + .set(WorkflowEdge::getIsDeleted, true) + .update(); + } + } + + public WorkflowEdge getByUuid(String uuid) { + return ChainWrappers.lambdaQueryChain(baseMapper) + .eq(WorkflowEdge::getUuid, uuid) + .eq(WorkflowEdge::getIsDeleted, false) + .last("limit 1") + .one(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowNodeService.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowNodeService.java new file mode 100644 index 00000000..cfd1d19a --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowNodeService.java @@ -0,0 +1,245 @@ +package org.ruoyi.workflow.service; + +import cn.hutool.core.collection.CollUtil; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers; +import com.fasterxml.jackson.databind.node.ObjectNode; +import jakarta.annotation.Resource; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.collections4.CollectionUtils; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.dto.workflow.WfNodeDto; +import org.ruoyi.workflow.entity.Workflow; +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.entity.WorkflowNode; +import org.ruoyi.workflow.enums.ErrorEnum; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.mapper.WorkflowNodeMapper; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.util.MPPageUtil; +import org.ruoyi.workflow.util.UuidUtil; +import org.ruoyi.workflow.workflow.WfComponentNameEnum; +import org.ruoyi.workflow.workflow.WfNodeInputConfig; +import org.ruoyi.workflow.workflow.def.WfNodeIOText; +import org.springframework.beans.BeanUtils; +import org.springframework.context.annotation.Lazy; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.ArrayList; +import java.util.List; + +@Slf4j +@Service +public class WorkflowNodeService extends ServiceImpl { + + @Lazy + @Resource + private WorkflowNodeService self; + + @Resource + private WorkflowComponentService workflowComponentService; + + public WorkflowNode getStartNode(long workflowId) { + return baseMapper.getStartNode(workflowId); + } + + public List listDtoByWfId(long workflowId) { + List workflowNodeList = ChainWrappers.lambdaQueryChain(baseMapper) + .eq(WorkflowNode::getWorkflowId, workflowId) + .eq(WorkflowNode::getIsDeleted, false) + .list(); + workflowNodeList.forEach(this::checkAndDecrypt); + return MPPageUtil.convertToList(workflowNodeList, WfNodeDto.class, (source, target) -> { + target.setInputConfig(JsonUtil.toBean(source.getInputConfig(), ObjectNode.class)); + target.setNodeConfig(JsonUtil.toBean(source.getNodeConfig(), ObjectNode.class)); + return target; + }); + } + + public WorkflowNode getByUuid(long workflowId, String uuid) { + WorkflowNode node = ChainWrappers.lambdaQueryChain(baseMapper) + .eq(WorkflowNode::getWorkflowId, workflowId) + .eq(WorkflowNode::getUuid, uuid) + .eq(WorkflowNode::getIsDeleted, false) + .last("limit 1") + .one(); + checkAndDecrypt(node); + return node; + } + + public List listByWorkflowId(Long workflowId) { + List list = ChainWrappers.lambdaQueryChain(baseMapper) + .eq(WorkflowNode::getWorkflowId, workflowId) + .eq(WorkflowNode::getIsDeleted, false) + .list(); + list.forEach(this::checkAndDecrypt); + return list; + } + + public List copyByWorkflowId(long workflowId, long targetWorkflowId) { + List result = new ArrayList<>(); + self.listByWorkflowId(workflowId).forEach(node -> { + result.add(self.copyNode(targetWorkflowId, node)); + }); + return result; + } + + public WorkflowNode copyNode(Long targetWorkflowId, WorkflowNode sourceNode) { + WorkflowNode newNode = new WorkflowNode(); + BeanUtils.copyProperties(sourceNode, newNode, "id", "createTime", "updateTime"); + newNode.setWorkflowId(targetWorkflowId); + baseMapper.insert(newNode); + + return ChainWrappers.lambdaQueryChain(baseMapper) + .eq(WorkflowNode::getWorkflowId, targetWorkflowId) + .eq(WorkflowNode::getUuid, newNode.getUuid()) + .eq(WorkflowNode::getIsDeleted, false) + .last("limit 1") + .one(); + } + + @Transactional + public void createOrUpdateNodes(Long workflowId, List nodes) { + List uuidList = new ArrayList<>(); + for (WfNodeDto node : nodes) { + WorkflowNode newOrUpdate = new WorkflowNode(); + BeanUtils.copyProperties(node, newOrUpdate); + newOrUpdate.setInputConfig(JsonUtil.toJson(node.getInputConfig())); + newOrUpdate.setNodeConfig(JsonUtil.toJson(node.getNodeConfig())); + newOrUpdate.setWorkflowId(workflowId); + checkAndEncrypt(newOrUpdate); + WorkflowNode old = self.getByUuid(workflowId, node.getUuid()); + if (null != old) { + log.info("更新节点,uuid:{},title:{}", node.getUuid(), node.getTitle()); + newOrUpdate.setId(old.getId()); + } else { + log.info("新增节点,uuid:{},title:{}", node.getUuid(), node.getTitle()); + newOrUpdate.setId(null); + } + uuidList.add(node.getUuid()); + self.saveOrUpdate(newOrUpdate); + } + ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(WorkflowNode::getWorkflowId, workflowId) + .notIn(CollUtil.isNotEmpty(uuidList), WorkflowNode::getUuid, uuidList) + .set(WorkflowNode::getIsDeleted, true) + .update(); + } + + private void checkAndEncrypt(WorkflowNode workflowNode) { + WorkflowComponent component = workflowComponentService.getAllEnable() + .stream() + .filter(item -> item.getId().equals(workflowNode.getWorkflowComponentId())) + .findFirst() + .orElse(null); + if (null == component) { + log.error("节点不存在,uuid:{},title:{}", workflowNode.getUuid(), workflowNode.getTitle()); + throw new BaseException(ErrorEnum.A_PARAMS_ERROR.getInfo()); + } + if (component.getName().equals(WfComponentNameEnum.MAIL_SEND.getName())) { + + //加密（目前暂时只在数据库层做加密，前后端交互时数据加解密待定） +// MailSendNodeConfig mailSendNodeConfig = JsonUtil.fromJson(workflowNode.getNodeConfig(), MailSendNodeConfig.class); +// if (null != mailSendNodeConfig && null != mailSendNodeConfig.getSender() && null != mailSendNodeConfig.getSender().getPassword()) { +// String password = mailSendNodeConfig.getSender().getPassword(); +// String encrypt = AesUtil.encrypt(password); +// mailSendNodeConfig.getSender().setPassword(encrypt); +// workflowNode.setNodeConfig(JsonUtil.toJson(mailSendNodeConfig)); +// } + } + } + + private void checkAndDecrypt(WorkflowNode workflowNode) { + if (null == workflowNode) { + log.warn("节点不存在"); + return; + } + WorkflowComponent component = workflowComponentService.getAllEnable() + .stream() + .filter(item -> item.getId().equals(workflowNode.getWorkflowComponentId())) + .findFirst() + .orElse(null); + if (null == component) { + log.error("节点不存在,uuid:{},title:{}", workflowNode.getUuid(), workflowNode.getTitle()); + throw new BaseException(ErrorEnum.A_PARAMS_ERROR.getInfo()); + } + if (component.getName().equals(WfComponentNameEnum.MAIL_SEND.getName())) { +// MailSendNodeConfig mailSendNodeConfig = JsonUtil.fromJson(workflowNode.getNodeConfig(), MailSendNodeConfig.class); +// if (null != mailSendNodeConfig && null != mailSendNodeConfig.getSender() && null != mailSendNodeConfig.getSender().getPassword()) { +// String password = mailSendNodeConfig.getSender().getPassword(); +// if (StringUtils.isNotBlank(password)) { +// String decrypt = AesUtil.decrypt(password); +// mailSendNodeConfig.getSender().setPassword(decrypt); +// } +// workflowNode.setNodeConfig(JsonUtil.toJson(mailSendNodeConfig)); +// } + } + } + + @Transactional + public void deleteNodes(Long workflowId, List uuids) { + if (CollectionUtils.isEmpty(uuids)) { + return; + } + for (String uuid : uuids) { + WorkflowNode old = self.getByUuid(workflowId, uuid); + if (null == old) { + continue; + } + if (!old.getWorkflowId().equals(workflowId)) { + log.error("节点不属于指定的工作流,删除失败,workflowId:{},node workflowId:{}", workflowId, workflowId); + throw new BaseException(ErrorEnum.A_PARAMS_ERROR.getInfo()); + } + if (workflowComponentService.getStartComponent().getId().equals(old.getWorkflowComponentId())) { + log.warn("开始节点不能删除,uuid:{}", old.getUuid()); + continue; + } + ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(WorkflowNode::getWorkflowId, workflowId) + .eq(WorkflowNode::getUuid, uuid) + .set(WorkflowNode::getIsDeleted, true) + .update(); + } + + } + + /** + * user_inputs: + * [ + * { + * "uuid": "12bc919774aa4e779d97e3dd9c836e11", + * "name": "var_user_input", + * "title": "用户输入", + * "type": 1, + * "required": true, + * "max_length": 1000 + * } + * ] + * + * @param workflow 工作流定义 + */ + public WorkflowNode createStartNode(Workflow workflow) { + WfNodeIOText wfNodeIOText = new WfNodeIOText(); + wfNodeIOText.setUuid(UuidUtil.createShort()); + wfNodeIOText.setType(WfIODataTypeEnum.TEXT.getValue()); + wfNodeIOText.setName("var_user_input"); + wfNodeIOText.setTitle("用户输入"); + wfNodeIOText.setRequired(false); + wfNodeIOText.setMaxLength(1000); + WfNodeInputConfig nodeInputConfig = new WfNodeInputConfig(); + nodeInputConfig.setUserInputs(List.of(wfNodeIOText)); + nodeInputConfig.setRefInputs(new ArrayList<>()); + WorkflowComponent startComponent = workflowComponentService.getStartComponent(); + WorkflowNode node = new WorkflowNode(); + node.setWorkflowComponentId(startComponent.getId()); + node.setWorkflowId(workflow.getId()); + node.setRemark("用户输入"); + node.setUuid(UuidUtil.createShort()); + node.setTitle("开始"); + node.setInputConfig(JsonUtil.toJson(nodeInputConfig)); + node.setNodeConfig("{}"); + baseMapper.insert(node); + return node; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowRuntimeNodeService.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowRuntimeNodeService.java new file mode 100644 index 00000000..43c73207 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowRuntimeNodeService.java @@ -0,0 +1,103 @@ +package org.ruoyi.workflow.service; + +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers; +import com.fasterxml.jackson.databind.node.ObjectNode; +import lombok.extern.slf4j.Slf4j; +import org.ruoyi.workflow.base.ThreadContext; +import org.ruoyi.workflow.dto.workflow.WfRuntimeNodeDto; +import org.ruoyi.workflow.entity.User; +import org.ruoyi.workflow.entity.WorkflowRuntimeNode; +import org.ruoyi.workflow.mapper.WorkflowRuntimeNodeMapper; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.util.MPPageUtil; +import org.ruoyi.workflow.workflow.WfNodeState; +import org.springframework.beans.BeanUtils; +import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; + +import java.util.List; + +@Slf4j +@Service +public class WorkflowRuntimeNodeService extends ServiceImpl { + + + public List listByWfRuntimeId(long runtimeId) { + List workflowNodeList = ChainWrappers.lambdaQueryChain(baseMapper) + .eq(!ThreadContext.getCurrentUser().getIsAdmin(), WorkflowRuntimeNode::getUserId, ThreadContext.getCurrentUser().getId()) + .eq(WorkflowRuntimeNode::getWorkflowRuntimeId, runtimeId) + .eq(WorkflowRuntimeNode::getIsDeleted, false) + .orderByAsc(WorkflowRuntimeNode::getId) + .list(); + List result = MPPageUtil.convertToList(workflowNodeList, WfRuntimeNodeDto.class); + for (WfRuntimeNodeDto dto : result) { + fillInputOutput(dto); + } + return result; + } + + public WfRuntimeNodeDto createByState(User user, long wfNodeId, long wfRuntimeId, WfNodeState state) { + WorkflowRuntimeNode runtimeNode = new WorkflowRuntimeNode(); + runtimeNode.setUuid(state.getUuid()); + runtimeNode.setWorkflowRuntimeId(wfRuntimeId); + runtimeNode.setStatus(state.getProcessStatus()); + runtimeNode.setUserId(user.getId()); + runtimeNode.setNodeId(wfNodeId); + baseMapper.insert(runtimeNode); + runtimeNode = baseMapper.selectById(runtimeNode.getId()); + + WfRuntimeNodeDto result = new WfRuntimeNodeDto(); + BeanUtils.copyProperties(runtimeNode, result); + fillInputOutput(result); + return result; + } + + public void updateInput(Long id, WfNodeState state) { + if (CollectionUtils.isEmpty(state.getInputs())) { + log.warn("没有输入数据,id:{}", id); + return; + } + WorkflowRuntimeNode node = baseMapper.selectById(id); + if (null == node) { + log.error("节点实例不存在,id:{}", id); + return; + } + WorkflowRuntimeNode updateOne = new WorkflowRuntimeNode(); + updateOne.setId(id); + ObjectNode ob = JsonUtil.createObjectNode(); + state.getInputs().forEach(data -> ob.set(data.getName(), JsonUtil.classToJsonNode(data.getContent()))); + updateOne.setInput(JsonUtil.toJson(ob)); + updateOne.setStatus(state.getProcessStatus()); + updateOne.setStatusRemark(state.getProcessStatusRemark()); + baseMapper.updateById(updateOne); + } + + public void updateOutput(Long id, WfNodeState state) { + WorkflowRuntimeNode node = baseMapper.selectById(id); + if (null == node) { + log.error("节点实例不存在,id:{}", id); + return; + } + WorkflowRuntimeNode updateOne = new WorkflowRuntimeNode(); + updateOne.setId(id); + if (!CollectionUtils.isEmpty(state.getOutputs())) { + ObjectNode ob = JsonUtil.createObjectNode(); + state.getOutputs().forEach(data -> ob.set(data.getName(), JsonUtil.classToJsonNode(data.getContent()))); + updateOne.setOutput(JsonUtil.toJson(ob)); + } + updateOne.setStatus(state.getProcessStatus()); + updateOne.setStatusRemark(state.getProcessStatusRemark()); + baseMapper.updateById(updateOne); + } + + private void fillInputOutput(WfRuntimeNodeDto dto) { + if (null == dto.getInput()) { + dto.setInput(JsonUtil.createObjectNode()); + } + if (null == dto.getOutput()) { + dto.setOutput(JsonUtil.createObjectNode()); + } + } + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowRuntimeService.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowRuntimeService.java new file mode 100644 index 00000000..330974a9 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowRuntimeService.java @@ -0,0 +1,174 @@ +package org.ruoyi.workflow.service; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers; +import com.fasterxml.jackson.databind.node.ObjectNode; +import jakarta.annotation.Resource; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.ruoyi.workflow.base.ThreadContext; +import org.ruoyi.workflow.dto.workflow.WfRuntimeNodeDto; +import org.ruoyi.workflow.dto.workflow.WfRuntimeResp; +import org.ruoyi.workflow.entity.User; +import org.ruoyi.workflow.entity.Workflow; +import org.ruoyi.workflow.entity.WorkflowRuntime; +import org.ruoyi.workflow.enums.ErrorEnum; +import org.ruoyi.workflow.mapper.WorkflowRunMapper; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.util.MPPageUtil; +import org.ruoyi.workflow.util.PrivilegeUtil; +import org.ruoyi.workflow.util.UuidUtil; +import org.ruoyi.workflow.workflow.WfState; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.springframework.beans.BeanUtils; +import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; + +import java.util.List; + +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.WORKFLOW_PROCESS_STATUS_DOING; + +@Slf4j +@Service +public class WorkflowRuntimeService extends ServiceImpl { + + @Resource + private WorkflowService workflowService; + + @Resource + private WorkflowRuntimeNodeService workflowRuntimeNodeService; + + public WfRuntimeResp create(User user, Long workflowId) { + WorkflowRuntime one = new WorkflowRuntime(); + one.setUuid(UuidUtil.createShort()); + one.setUserId(user.getId()); + one.setWorkflowId(workflowId); + baseMapper.insert(one); + + one = baseMapper.selectById(one.getId()); + return changeToDTO(one); + } + + public void updateInput(long id, WfState wfState) { + if (CollectionUtils.isEmpty(wfState.getInput())) { + log.warn("没有输入数据,id:{}", id); + return; + } + WorkflowRuntime node = baseMapper.selectById(id); + if (null == node) { + log.error("工作流实例不存在,id:{}", id); + return; + } + WorkflowRuntime updateOne = new WorkflowRuntime(); + updateOne.setId(id); + ObjectNode ob = JsonUtil.createObjectNode(); + for (NodeIOData data : wfState.getInput()) { + ob.set(data.getName(), JsonUtil.classToJsonNode(data.getContent())); + } + updateOne.setInput(JsonUtil.toJson(ob)); + updateOne.setStatus(WORKFLOW_PROCESS_STATUS_DOING); + baseMapper.updateById(updateOne); + } + + public WorkflowRuntime updateOutput(long id, WfState wfState) { + WorkflowRuntime node = baseMapper.selectById(id); + if (null == node) { + log.error("工作流实例不存在,id:{}", id); + return null; + } + WorkflowRuntime updateOne = new WorkflowRuntime(); + updateOne.setId(id); + ObjectNode ob = JsonUtil.createObjectNode(); + for (NodeIOData data : wfState.getOutput()) { + ob.set(data.getName(), JsonUtil.classToJsonNode(data.getContent())); + } + updateOne.setOutput(JsonUtil.toJson(ob)); + updateOne.setStatus(wfState.getProcessStatus()); + baseMapper.updateById(updateOne); + return updateOne; + } + + public void updateStatus(long id, int processStatus, String statusRemark) { + WorkflowRuntime node = baseMapper.selectById(id); + if (null == node) { + log.error("工作流实例不存在,id:{}", id); + return; + } + WorkflowRuntime updateOne = new WorkflowRuntime(); + updateOne.setId(id); + updateOne.setStatus(processStatus); + updateOne.setStatusRemark(StringUtils.substring(statusRemark, 0, 250)); + baseMapper.updateById(updateOne); + } + + public WorkflowRuntime getByUuid(String uuid) { + return ChainWrappers.lambdaQueryChain(baseMapper) + .eq(!ThreadContext.getCurrentUser().getIsAdmin(), WorkflowRuntime::getUserId, ThreadContext.getCurrentUserId()) + .eq(WorkflowRuntime::getUuid, uuid) + .eq(WorkflowRuntime::getIsDeleted, false) + .last("limit 1") + .one(); + } + + public Page page(String wfUuid, Integer currentPage, Integer pageSize) { + Workflow workflow = workflowService.getOrThrow(wfUuid); + User user = ThreadContext.getCurrentUser(); + Page page = ChainWrappers.lambdaQueryChain(baseMapper) + .eq(WorkflowRuntime::getWorkflowId, workflow.getId()) + .eq(WorkflowRuntime::getIsDeleted, false) + .eq(!user.getIsAdmin(), WorkflowRuntime::getUserId, user.getId()) + .orderByDesc(WorkflowRuntime::getUpdateTime) + .page(new Page<>(currentPage, pageSize)); + Page result = new Page<>(); + MPPageUtil.convertToPage(page, result, WfRuntimeResp.class, (source, target) -> { + fillInputOutput(target); + return target; + }); + return result; + } + + public List listByRuntimeUuid(String runtimeUuid) { + WorkflowRuntime runtime = PrivilegeUtil.checkAndGetByUuid(runtimeUuid, this.query(), ErrorEnum.A_WF_RUNTIME_NOT_FOUND); + return workflowRuntimeNodeService.listByWfRuntimeId(runtime.getId()); + } + + public boolean deleteAll(String wfUuid) { + Workflow workflow = workflowService.getOrThrow(wfUuid); + User user = ThreadContext.getCurrentUser(); + return ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(WorkflowRuntime::getWorkflowId, workflow.getId()) + .eq(!user.getIsAdmin(), WorkflowRuntime::getUserId, user.getId()) + .set(WorkflowRuntime::getIsDeleted, true) + .update(); + } + + private WfRuntimeResp changeToDTO(WorkflowRuntime runtime) { + WfRuntimeResp result = new WfRuntimeResp(); + BeanUtils.copyProperties(runtime, result); + fillInputOutput(result); + return result; + } + +// private void fillNodes(WfRuntimeResp runtimeResp) { +// List nodes = workflowRuntimeNodeService.listByWfRuntimeId(runtimeResp.getId()); +// runtimeResp.setNodes(nodes); +// } + + private void fillInputOutput(WfRuntimeResp target) { + if (null == target.getInput()) { + target.setInput(JsonUtil.createObjectNode()); + } + if (null == target.getOutput()) { + target.setOutput(JsonUtil.createObjectNode()); + } + } + + public boolean softDelete(String uuid) { + WorkflowRuntime workflowRuntime = PrivilegeUtil.checkAndGetByUuid(uuid, this.query(), ErrorEnum.A_WF_NOT_FOUND); + return ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(WorkflowRuntime::getId, workflowRuntime.getId()) + .set(WorkflowRuntime::getIsDeleted, true) + .update(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowService.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowService.java new file mode 100644 index 00000000..4d682d96 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/service/WorkflowService.java @@ -0,0 +1,193 @@ +package org.ruoyi.workflow.service; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers; +import jakarta.annotation.Resource; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.base.ThreadContext; +import org.ruoyi.workflow.dto.workflow.WfEdgeReq; +import org.ruoyi.workflow.dto.workflow.WfNodeDto; +import org.ruoyi.workflow.dto.workflow.WorkflowResp; +import org.ruoyi.workflow.dto.workflow.WorkflowUpdateReq; +import org.ruoyi.workflow.entity.User; +import org.ruoyi.workflow.entity.Workflow; +import org.ruoyi.workflow.enums.ErrorEnum; +import org.ruoyi.workflow.mapper.WorkflowMapper; +import org.ruoyi.workflow.util.MPPageUtil; +import org.ruoyi.workflow.util.PrivilegeUtil; +import org.ruoyi.workflow.util.UuidUtil; +import org.springframework.beans.BeanUtils; +import org.springframework.context.annotation.Lazy; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.ArrayList; +import java.util.List; + +@Slf4j +@Service +public class WorkflowService extends ServiceImpl { + + @Lazy + @Resource + private WorkflowService self; + + @Resource + private WorkflowNodeService workflowNodeService; + + @Resource + private WorkflowEdgeService workflowEdgeService; + + @Resource + private WorkflowComponentService workflowComponentService; + + @Transactional + public WorkflowResp add(String title, String remark, Boolean isPublic) { + String uuid = UuidUtil.createShort(); + Workflow one = new Workflow(); + one.setUuid(uuid); + one.setTitle(title); + one.setUserId(ThreadContext.getCurrentUserId()); + one.setRemark(remark); + one.setIsEnable(true); + one.setIsPublic(isPublic); + baseMapper.insert(one); + + workflowNodeService.createStartNode(one); + return changeWorkflowToDTO(one); + } + + public void setPublic(String wfUuid, Boolean isPublic) { + Workflow workflow = PrivilegeUtil.checkAndGetByUuid(wfUuid, this.query(), ErrorEnum.A_WF_NOT_FOUND); + ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(Workflow::getId, workflow.getId()) + .set(Workflow::getIsPublic, isPublic) + .update(); + } + + public WorkflowResp updateBaseInfo(String wfUuid, String title, String remark, Boolean isPublic) { + if (StringUtils.isAnyBlank(wfUuid, title)) { + throw new BaseException(ErrorEnum.A_PARAMS_ERROR.getInfo()); + } + ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(Workflow::getUuid, wfUuid) + .eq(!ThreadContext.getCurrentUser().getIsAdmin(), Workflow::getUserId, ThreadContext.getCurrentUserId()) + .set(Workflow::getTitle, title) + .set(Workflow::getRemark, remark) + .set(null != isPublic, Workflow::getIsPublic, isPublic) + .update(); + Workflow workflow = getOrThrow(wfUuid); + return changeWorkflowToDTO(workflow); + } + + @Transactional + public WorkflowResp update(WorkflowUpdateReq req) { + Workflow workflow = PrivilegeUtil.checkAndGetByUuid(req.getUuid(), this.query(), ErrorEnum.A_WF_NOT_FOUND); + long workflowId = workflow.getId(); + workflowNodeService.createOrUpdateNodes(workflowId, req.getNodes()); + workflowEdgeService.createOrUpdateEdges(workflowId, req.getEdges()); + Workflow workflow2 = getOrThrow(req.getUuid()); + return changeWorkflowToDTO(workflow2); + } + + public Workflow getByUuid(String uuid) { + return ChainWrappers.lambdaQueryChain(baseMapper) + .eq(Workflow::getUuid, uuid) + .eq(Workflow::getIsDeleted, false) + .last("limit 1") + .one(); + } + + public Workflow getOrThrow(String uuid) { + Workflow workflow = ChainWrappers.lambdaQueryChain(baseMapper) + .eq(Workflow::getUuid, uuid) + .eq(Workflow::getIsDeleted, false) + .last("limit 1") + .one(); + if (null == workflow) { + throw new BaseException(ErrorEnum.A_WF_NOT_FOUND.getInfo()); + } + return workflow; + } + + public Page search(String keyword, Boolean isPublic, Boolean isEnable, Integer currentPage, Integer pageSize) { + User user = ThreadContext.getCurrentUser(); + Page page = ChainWrappers.lambdaQueryChain(baseMapper) + .eq(Workflow::getIsDeleted, false) + .eq(null != isPublic, Workflow::getIsPublic, isPublic) + .eq(null != isEnable, Workflow::getIsEnable, isEnable) + .like(StringUtils.isNotBlank(keyword), Workflow::getTitle, keyword) + .eq(!user.getIsAdmin(), Workflow::getUserId, user.getId()) + .orderByDesc(Workflow::getUpdateTime) + .page(new Page<>(currentPage, pageSize)); + Page result = new Page<>(); + List userIds = new ArrayList<>(); + MPPageUtil.convertToPage(page, result, WorkflowResp.class, (source, target) -> { + fillNodesAndEdges(target); + userIds.add(source.getUserId()); + return target; + }); +// fillUserInfos(userIds, result.getRecords()); + return result; + } + + public Page searchPublic(String keyword, Integer currentPage, Integer pageSize) { + Page page = ChainWrappers.lambdaQueryChain(baseMapper) + .eq(Workflow::getIsDeleted, false) + .eq(Workflow::getIsPublic, true) + .eq(Workflow::getIsEnable, true) + .like(StringUtils.isNotBlank(keyword), Workflow::getTitle, keyword) + .orderByDesc(Workflow::getUpdateTime) + .page(new Page<>(currentPage, pageSize)); + Page result = new Page<>(); + List userIds = new ArrayList<>(); + MPPageUtil.convertToPage(page, result, WorkflowResp.class, (source, target) -> { + fillNodesAndEdges(target); + userIds.add(source.getUserId()); + return target; + }); + // fillUserInfos(userIds, result.getRecords()); + return result; + } + + public void softDelete(String uuid) { + ChainWrappers.lambdaUpdateChain(baseMapper).eq(Workflow::getUuid, uuid) + .set(Workflow::getIsDeleted, true).update(); + } + + public void enable(String uuid, Boolean enable) { + if (null == enable) { + throw new BaseException(ErrorEnum.A_PARAMS_ERROR.getInfo()); + } + Workflow workflow = PrivilegeUtil.checkAndGetByUuid(uuid, this.query(), ErrorEnum.A_WF_NOT_FOUND); + ChainWrappers.lambdaUpdateChain(baseMapper) + .eq(Workflow::getId, workflow.getId()) + .eq(!ThreadContext.getCurrentUser().getIsAdmin(), Workflow::getUserId, ThreadContext.getCurrentUserId()) + .set(Workflow::getIsEnable, enable) + .update(); + } + + private WorkflowResp changeWorkflowToDTO(Workflow workflow) { + WorkflowResp workflowResp = new WorkflowResp(); + BeanUtils.copyProperties(workflow, workflowResp); + + fillNodesAndEdges(workflowResp); +// User user = userService.getById(workflow.getUserId()); +// if (null != user) { +// workflowResp.setUserUuid(user.getUuid()); +// workflowResp.setUserName(user.getName()); +// } + return workflowResp; + } + + private void fillNodesAndEdges(WorkflowResp workflowResp) { + List nodes = workflowNodeService.listDtoByWfId(workflowResp.getId()); + workflowResp.setNodes(nodes); + List edges = workflowEdgeService.listDtoByWfId(workflowResp.getId()); + workflowResp.setEdges(edges); + } + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/JsonUtil.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/JsonUtil.java new file mode 100644 index 00000000..975d67bc --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/JsonUtil.java @@ -0,0 +1,152 @@ +package org.ruoyi.workflow.util; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.SerializationFeature; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.fasterxml.jackson.datatype.jdk8.Jdk8Module; +import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Slf4j +public class JsonUtil { + + private static final ObjectMapper objectMapper = new ObjectMapper(); + + static { + objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); + objectMapper.configure(SerializationFeature.INDENT_OUTPUT, Boolean.FALSE); + objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + objectMapper.registerModules(LocalDateTimeUtil.getSimpleModule(), new JavaTimeModule(), new Jdk8Module()); + } + + public static String toJson(Object obj) { + String resp = null; + try { + resp = objectMapper.writeValueAsString(obj); + } catch (IOException e) { + log.error("JsonUtil error", e); + } + return resp; + } + + + /** + * 创建JSON处理器的静态方法 + * + * @param content JSON字符串 + * @return + */ + private static JsonParser getParser(String content) { + if (StringUtils.isNotBlank(content)) { + try { + return objectMapper.getFactory().createParser(content); + } catch (IOException ioe) { + log.error("JsonUtil getParser error", ioe); + } + } + return null; + } + + /** + * JSON对象反序列化 + */ + public static T fromJson(String json, Class clazz) { + if (StringUtils.isBlank(json)) { + return null; + } + try { + JsonParser jp = getParser(json); + if (null == jp) { + log.error("json parser is null"); + return null; + } + return jp.readValueAs(clazz); + } catch (IOException ioe) { + log.error("反序列化失败", ioe); + } + return null; + } + + public static T fromJson(JsonNode jsonNode, Class clazz) { + try { + return objectMapper.treeToValue(jsonNode, clazz); + } catch (JsonProcessingException e) { + log.error("反序列化失败", e); + } + return null; + } + + + public static List fromArrayNode(ArrayNode arrayNode, Class clazz) { + List result = new ArrayList<>(); + try { + for (JsonNode jsonNode : arrayNode) { + result.add(objectMapper.treeToValue(jsonNode, clazz)); + } + } catch (JsonProcessingException e) { + log.error("反序列化失败", e); + } + return result; + } + + public static JsonNode toJsonNode(String json) { + try { + return objectMapper.readTree(json); + } catch (JsonProcessingException e) { + log.error("反序列化失败", e); + } + return null; + } + + public static Map toMap(String json) { + Map result; + try { + result = objectMapper.readValue(json, Map.class); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + return result; + } + + public static T toBean(String json, Class tClass) { + T result; + try { + result = objectMapper.readValue(json, tClass); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + return result; + } + + public static Map toMap(Object obj) { + try { + return objectMapper.convertValue(obj, new TypeReference>() { + }); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + public static JsonNode classToJsonNode(Object obj) { + return objectMapper.valueToTree(obj); + } + + public static ObjectNode createObjectNode() { + return objectMapper.createObjectNode(); + } + +} \ No newline at end of file diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/LocalDateTimeDeserializer.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/LocalDateTimeDeserializer.java new file mode 100644 index 00000000..b6845fb2 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/LocalDateTimeDeserializer.java @@ -0,0 +1,18 @@ +package org.ruoyi.workflow.util; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonDeserializer; + +import java.io.IOException; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; + +public class LocalDateTimeDeserializer extends JsonDeserializer { + + @Override + public LocalDateTime deserialize(JsonParser p, DeserializationContext deserializationContext) + throws IOException { + return LocalDateTime.parse(p.getValueAsString(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/LocalDateTimeSerializer.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/LocalDateTimeSerializer.java new file mode 100644 index 00000000..605e5ec5 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/LocalDateTimeSerializer.java @@ -0,0 +1,18 @@ +package org.ruoyi.workflow.util; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; + +public class LocalDateTimeSerializer extends JsonSerializer { + + @Override + public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers) + throws IOException { + gen.writeString(value.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); + } +} \ No newline at end of file diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/LocalDateTimeUtil.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/LocalDateTimeUtil.java new file mode 100644 index 00000000..ade5bddc --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/LocalDateTimeUtil.java @@ -0,0 +1,68 @@ +package org.ruoyi.workflow.util; + +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.databind.ser.std.ToStringSerializer; +import org.apache.commons.lang3.StringUtils; + +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; + +public class LocalDateTimeUtil { + + public static final DateTimeFormatter PATTERN_DEFAULT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + public static final DateTimeFormatter PATTERN_YYYYMMDDMMHHSS = DateTimeFormatter.ofPattern("yyyyMMddmmHHss"); + public static final DateTimeFormatter PATTERN_YYYY_MM_DD = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + + private LocalDateTimeUtil() { + } + + public static SimpleModule getSimpleModule() { + // jackson中自定义处理序列化和反序列化 + SimpleModule customModule = new SimpleModule(); + customModule.addSerializer(Long.class, ToStringSerializer.instance); + // 时间序列化 + customModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer()); + customModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer()); + return customModule; + } + + public static LocalDateTime parse(String localDateTime) { + return LocalDateTime.parse(localDateTime, PATTERN_DEFAULT); + } + + public static LocalDateTime parse(Long epochMilli) { + return LocalDateTime.ofInstant(Instant.ofEpochMilli(epochMilli), ZoneId.systemDefault()); + } + + public static String format(LocalDateTime localDateTime) { + if (null == localDateTime) { + return StringUtils.EMPTY; + } + return localDateTime.format(PATTERN_DEFAULT); + } + + public static String format(LocalDateTime localDateTime, String pattern) { + if (null == localDateTime) { + return StringUtils.EMPTY; + } + return localDateTime.format(DateTimeFormatter.ofPattern(pattern)); + } + + public static String format(LocalDateTime localDateTime, DateTimeFormatter pattern) { + if (null == localDateTime) { + return StringUtils.EMPTY; + } + return localDateTime.format(pattern); + } + + public static int getIntDay(LocalDateTime localDateTime) { + return localDateTime.getYear() * 10000 + localDateTime.getMonthValue() * 100 + localDateTime.getDayOfMonth(); + } + + public static int getToday() { + LocalDateTime now = LocalDateTime.now(); + return now.getYear() * 10000 + now.getMonthValue() * 100 + now.getDayOfMonth(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/MPPageUtil.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/MPPageUtil.java new file mode 100644 index 00000000..fde8b0d3 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/MPPageUtil.java @@ -0,0 +1,86 @@ +package org.ruoyi.workflow.util; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.collections4.CollectionUtils; +import org.springframework.beans.BeanUtils; + +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.function.BiFunction; + +@Slf4j +public class MPPageUtil { + + private MPPageUtil() { + } + + public static Page convertToPage(Page source, Class targetRecordClass) { + return MPPageUtil.convertToPage(source, new Page<>(), targetRecordClass, null); + } + + public static Page convertToPage(Page source, Page target, Class targetRecordClass) { + return MPPageUtil.convertToPage(source, target, targetRecordClass, null); + } + + public static Page convertToPage(Page source, Page target, Class targetRecordClass, BiFunction biFunction) { + BeanUtils.copyProperties(source, target); + List records = new ArrayList<>(); + target.setRecords(records); + try { + for (T t : source.getRecords()) { + U u = targetRecordClass.getDeclaredConstructor().newInstance(); + BeanUtils.copyProperties(t, u); + if (null != biFunction) { + biFunction.apply(t, u); + } + records.add(u); + } + } catch (NoSuchMethodException e1) { + log.error("convertTo error1", e1); + } catch (Exception e2) { + log.error("convertTo error2", e2); + } + + return target; + } + + public static List convertToList(List source, Class targetRecordClass) { + return convertToList(source, targetRecordClass, null); + } + + public static List convertToList(List source, Class targetRecordClass, BiFunction biFunction) { + if (CollectionUtils.isEmpty(source)) { + return Collections.emptyList(); + } + List result = new ArrayList<>(); + for (T t : source) { + try { + U u = targetRecordClass.getDeclaredConstructor().newInstance(); + BeanUtils.copyProperties(t, u); + if (null != biFunction) { + biFunction.apply(t, u); + } + result.add(u); + } catch (NoSuchMethodException e1) { + log.error("convertTo error1", e1); + } catch (Exception e2) { + log.error("convertTo error2", e2); + } + } + return result; + } + + public static U convertTo(T source, Class targetClass) { + try { + U target = targetClass.getDeclaredConstructor().newInstance(); + BeanUtils.copyProperties(source, target); + return target; + } catch (InstantiationException | IllegalAccessException | InvocationTargetException | + NoSuchMethodException e) { + throw new RuntimeException(e); + } + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/PrivilegeUtil.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/PrivilegeUtil.java new file mode 100644 index 00000000..7ad0dc7a --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/PrivilegeUtil.java @@ -0,0 +1,32 @@ +package org.ruoyi.workflow.util; + +import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.base.ThreadContext; +import org.ruoyi.workflow.enums.ErrorEnum; + +import static org.ruoyi.workflow.cosntant.AdiConstant.*; + +public class PrivilegeUtil { + + private PrivilegeUtil() { + } + + public static T checkAndGetByUuid(String uuid, QueryChainWrapper lambdaQueryChainWrapper, ErrorEnum exceptionMessage) { + return checkAndGet(null, uuid, lambdaQueryChainWrapper, exceptionMessage); + } + + public static T checkAndGet(Long id, String uuid, QueryChainWrapper lambdaQueryChainWrapper, ErrorEnum exceptionMessage) { + T target; + if (Boolean.TRUE.equals(ThreadContext.getCurrentUser().getIsAdmin())) { + target = lambdaQueryChainWrapper.eq(null != id, COLUMN_NAME_ID, id).eq(null != uuid, COLUMN_NAME_UUID, uuid).eq(COLUMN_NAME_IS_DELETE, false).oneOpt().orElse(null); + } else { + target = lambdaQueryChainWrapper.eq(null != id, COLUMN_NAME_ID, id).eq(null != uuid, COLUMN_NAME_UUID, uuid).eq(COLUMN_NAME_USER_ID, ThreadContext.getCurrentUserId()).eq(COLUMN_NAME_IS_DELETE, false).oneOpt().orElse(null); + } + if (null == target) { + throw new BaseException(exceptionMessage.getInfo()); + } + return target; + } + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/RedisTemplateUtil.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/RedisTemplateUtil.java new file mode 100644 index 00000000..87239a6a --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/RedisTemplateUtil.java @@ -0,0 +1,27 @@ +package org.ruoyi.workflow.util; + +import jakarta.annotation.Resource; +import org.springframework.data.redis.core.StringRedisTemplate; +import org.springframework.stereotype.Component; + +import java.util.concurrent.TimeUnit; + +@Component +public class RedisTemplateUtil { + + @Resource + private StringRedisTemplate stringRedisTemplate; + + public boolean lock(String key, String clientId, int lockExpireInSecond) { + return Boolean.TRUE.equals(stringRedisTemplate.opsForValue().setIfAbsent(key, clientId, lockExpireInSecond, TimeUnit.SECONDS)); + } + + public boolean unlock(String key, String clientId) { + boolean result = false; + if (clientId.equals(stringRedisTemplate.opsForValue().get(key))) { + result = Boolean.TRUE.equals(stringRedisTemplate.delete(key)); + } + return result; + } + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/SpringUtil.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/SpringUtil.java new file mode 100644 index 00000000..82b9dd6f --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/SpringUtil.java @@ -0,0 +1,30 @@ +package org.ruoyi.workflow.util; + +import org.jetbrains.annotations.NotNull; +import org.springframework.beans.BeansException; +import org.springframework.context.ApplicationContext; +import org.springframework.context.ApplicationContextAware; +import org.springframework.stereotype.Component; + +@Component +public class SpringUtil implements ApplicationContextAware { + + private static ApplicationContext applicationContext; + + public static T getBean(String name, Class clazz) { + return applicationContext.getBean(name, clazz); + } + + public static T getBean(Class clazz) { + return applicationContext.getBean(clazz); + } + + public static String getProperty(String key) { + return applicationContext.getEnvironment().getProperty(key); + } + + @Override + public void setApplicationContext(@NotNull ApplicationContext applicationContext) throws BeansException { + SpringUtil.applicationContext = applicationContext; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/UuidUtil.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/UuidUtil.java new file mode 100644 index 00000000..57952e68 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/util/UuidUtil.java @@ -0,0 +1,12 @@ +package org.ruoyi.workflow.util; + +import java.util.UUID; + +public class UuidUtil { + private UuidUtil() { + } + + public static String createShort() { + return UUID.randomUUID().toString().replace("-", ""); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/CompileNode.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/CompileNode.java new file mode 100644 index 00000000..20960113 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/CompileNode.java @@ -0,0 +1,28 @@ +package org.ruoyi.workflow.workflow; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; +import lombok.extern.slf4j.Slf4j; + +import java.util.ArrayList; +import java.util.List; + +@Slf4j +@Builder +@Data +@NoArgsConstructor +@AllArgsConstructor +public class CompileNode { + protected String id; + protected Boolean conditional = false; + + /** + * 以下两种情况会导致多个nextNode出现： + * 1. 下游节点为并行节点，所有的下游节点同时运行 + * 2. 当前节点为条件分支节点，下游节点为多个节点，实际执行时只会执行一条 + * 两种节点根据是否GraphCompileNode来区分 + */ + protected List nextNodes = new ArrayList<>(); +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/GraphCompileNode.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/GraphCompileNode.java new file mode 100644 index 00000000..19497b89 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/GraphCompileNode.java @@ -0,0 +1,38 @@ +package org.ruoyi.workflow.workflow; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.extern.slf4j.Slf4j; + +@Slf4j +@EqualsAndHashCode(callSuper = true) +@Data +public class GraphCompileNode extends CompileNode { + private CompileNode root; + + public void appendToLeaf(CompileNode node) { + boolean exists = false; + CompileNode tail = root; + while (!tail.getNextNodes().isEmpty()) { + tail = tail.getNextNodes().get(0); + if (tail.getId().equals(node.getId())) { + exists = true; + break; + } + } + if (!exists) { + tail.getNextNodes().add(node); + } + } + + public CompileNode getTail() { + if (root.nextNodes.isEmpty()) { + return root; + } + CompileNode tail = root.nextNodes.get(0); + while (!tail.getNextNodes().isEmpty()) { + tail = tail.getNextNodes().get(0); + } + return tail; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/InterruptedFlow.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/InterruptedFlow.java new file mode 100644 index 00000000..34b0018f --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/InterruptedFlow.java @@ -0,0 +1,17 @@ +package org.ruoyi.workflow.workflow; + +import org.apache.commons.collections4.map.PassiveExpiringMap; + +/** + * 已中断正在等待用户输入的流程
+ * TODO 需要考虑项目多节点部署的情况 + */ +public class InterruptedFlow { + + /** + * 10分钟超时 + */ + private static final PassiveExpiringMap.ExpirationPolicy ep = new PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy<>(60 * 1000 * 10); + public static PassiveExpiringMap RUNTIME_TO_GRAPH = new PassiveExpiringMap<>(ep); + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/NodeProcessResult.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/NodeProcessResult.java new file mode 100644 index 00000000..d78e1c4b --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/NodeProcessResult.java @@ -0,0 +1,24 @@ +package org.ruoyi.workflow.workflow; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.ruoyi.workflow.workflow.data.NodeIOData; + +import java.util.ArrayList; +import java.util.List; + +@Builder +@Data +@AllArgsConstructor +@NoArgsConstructor +public class NodeProcessResult { + + private List content = new ArrayList<>(); + + /** + * 条件执行时使用 + */ + private String nextNodeUuid; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfComponentNameEnum.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfComponentNameEnum.java new file mode 100644 index 00000000..5e40a6d4 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfComponentNameEnum.java @@ -0,0 +1,50 @@ +package org.ruoyi.workflow.workflow; + +import lombok.Getter; + +import java.util.Arrays; + +@Getter +public enum WfComponentNameEnum { + START("Start"), + + END("End"), + + LLM_ANSWER("Answer"), + + DALLE3("Dalle3"), + + TONGYI_WANX("Tongyiwanx"), + + DOCUMENT_EXTRACTOR("DocumentExtractor"), + + KEYWORD_EXTRACTOR("KeywordExtractor"), + + FAQ_EXTRACTOR("FaqExtractor"), + + KNOWLEDGE_RETRIEVER("KnowledgeRetrieval"), + + SWITCHER("Switcher"), + + CLASSIFIER("Classifier"), + + TEMPLATE("Template"), + + GOOGLE_SEARCH("Google"), + + HUMAN_FEEDBACK("HumanFeedback"), + + MAIL_SEND("MailSend"), + + HTTP_REQUEST("HttpRequest"); + + private final String name; + + WfComponentNameEnum(String name) { + this.name = name; + } + + public static WfComponentNameEnum getByName(String name) { + return Arrays.stream(WfComponentNameEnum.values()).filter(item -> item.name.equals(name)).findFirst().orElse(null); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeFactory.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeFactory.java new file mode 100644 index 00000000..92095f0e --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeFactory.java @@ -0,0 +1,23 @@ +package org.ruoyi.workflow.workflow; + +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.entity.WorkflowNode; +import org.ruoyi.workflow.workflow.node.AbstractWfNode; +import org.ruoyi.workflow.workflow.node.EndNode; +import org.ruoyi.workflow.workflow.node.answer.LLMAnswerNode; +import org.ruoyi.workflow.workflow.node.start.StartNode; + +public class WfNodeFactory { + public static AbstractWfNode create(WorkflowComponent wfComponent, WorkflowNode nodeDefinition, + WfState wfState, WfNodeState nodeState) { + AbstractWfNode wfNode = null; + switch (WfComponentNameEnum.getByName(wfComponent.getName())) { + case START -> wfNode = new StartNode(wfComponent, nodeDefinition, wfState, nodeState); + case LLM_ANSWER -> wfNode = new LLMAnswerNode(wfComponent, nodeDefinition, wfState, nodeState); + case END -> wfNode = new EndNode(wfComponent, nodeDefinition, wfState, nodeState); + default -> { + } + } + return wfNode; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeIODataUtil.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeIODataUtil.java new file mode 100644 index 00000000..61828568 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeIODataUtil.java @@ -0,0 +1,132 @@ +package org.ruoyi.workflow.workflow; + +import cn.hutool.core.collection.CollUtil; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import org.apache.commons.collections4.CollectionUtils; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.enums.ErrorEnum; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.data.NodeIODataFilesContent; +import org.ruoyi.workflow.workflow.def.*; + +import java.util.*; + +import static org.ruoyi.workflow.cosntant.AdiConstant.IMAGE_EXTENSIONS; +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.DEFAULT_INPUT_PARAM_NAME; +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.DEFAULT_OUTPUT_PARAM_NAME; + +public class WfNodeIODataUtil { + + public static final Map> INPUT_TYPE_TO_NODE_IO_DEF = new HashMap<>(); + + static { + INPUT_TYPE_TO_NODE_IO_DEF.put(WfIODataTypeEnum.TEXT, WfNodeIOText.class); + INPUT_TYPE_TO_NODE_IO_DEF.put(WfIODataTypeEnum.BOOL, WfNodeIOBool.class); + INPUT_TYPE_TO_NODE_IO_DEF.put(WfIODataTypeEnum.NUMBER, WfNodeIONumber.class); + INPUT_TYPE_TO_NODE_IO_DEF.put(WfIODataTypeEnum.OPTIONS, WfNodeIOOptions.class); + INPUT_TYPE_TO_NODE_IO_DEF.put(WfIODataTypeEnum.FILES, WfNodeIOFiles.class); + + } + + public static NodeIOData createNodeIOData(ObjectNode data) { + JsonNode nameObj = data.get("name"); + JsonNode content = data.get("content"); + if (null == nameObj || null == content) { + throw new BaseException(ErrorEnum.A_PARAMS_ERROR.getInfo()); + } + String name = nameObj.asText(); + Integer type = content.get("type").asInt(); + String title = content.get("title").asText(); + JsonNode value = content.get("value"); + NodeIOData result = null; + if (WfIODataTypeEnum.TEXT.getValue().equals(type)) { + result = NodeIOData.createByText(name, title, value.asText()); + } else if (WfIODataTypeEnum.NUMBER.getValue().equals(type)) { + result = NodeIOData.createByNumber(name, title, value.asDouble()); + } else if (WfIODataTypeEnum.BOOL.getValue().equals(type)) { + result = NodeIOData.createByBool(name, title, value.asBoolean()); + } else if (WfIODataTypeEnum.FILES.getValue().equals(type)) { + if (value.isArray()) { + List fileUrls = new ArrayList<>(); + Iterator iterator = value.elements(); + while (iterator.hasNext()) { + fileUrls.add(iterator.next().asText()); + } + result = NodeIOData.createByFiles(name, title, fileUrls); + } + } else if (WfIODataTypeEnum.OPTIONS.getValue().equals(type)) { + if (value instanceof ObjectNode) { + result = NodeIOData.createByOptions(name, title, JsonUtil.toMap(value)); + } + } + return result; + } + + /** + * 1.如果没有名称为 output 的输出参数，则需要新增
+ * 2.判断是否已经有文本类型的输出参数，如果有，则复制该参数并将参数名改为 output
+ * 3.如果没有文本类型的参数，则复制第一个参数，并将参数名改为 output + * + * @param inputs 输入参数列表 + * @return 输出参数列表 + */ + public static List changeInputsToOutputs(List inputs) { + if (CollectionUtils.isEmpty(inputs)) { + return new ArrayList<>(); + } + List result = CollUtil.newCopyOnWriteArrayList(inputs); + + boolean outputExist = false; + NodeIOData defaultInputName = null, txtExist = null, first = null; + for (NodeIOData nodeIOData : result) { + if (null == first) { + first = nodeIOData; + } + if (DEFAULT_OUTPUT_PARAM_NAME.equals(nodeIOData.getName())) { + outputExist = true; + } else if (DEFAULT_INPUT_PARAM_NAME.equals(nodeIOData.getName())) { + defaultInputName = nodeIOData; + } else if (null == txtExist && WfIODataTypeEnum.TEXT.getValue().equals(nodeIOData.getContent().getType())) { + txtExist = nodeIOData; + } + } + + if (outputExist) { + return result; + } + if (null != defaultInputName) { + defaultInputName.setName(DEFAULT_OUTPUT_PARAM_NAME); + } else if (null != txtExist) { + txtExist.setName(DEFAULT_OUTPUT_PARAM_NAME); + } else if (null != first) { + first.setName(DEFAULT_OUTPUT_PARAM_NAME); + } + result.add(inputs.get(0)); + return result; + } + + /** + * 将输入输出中的文件url转成markdown格式的文件地址
+ * 将变量渲染到模板时使用该方法，其他情况交由前端处理 + * + * @param ioDataList 输入输出列表 + */ + public static void changeFilesContentToMarkdown(List ioDataList) { + ioDataList.forEach(input -> { + if (input.getContent() instanceof NodeIODataFilesContent filesContent) { + List newValues = new ArrayList<>(); + for (String s : filesContent.getValue()) { + if (IMAGE_EXTENSIONS.contains(s.substring(s.lastIndexOf(".") + 1))) { + newValues.add("![" + filesContent.getTitle() + "](" + s + ")"); + } else { + newValues.add("[" + filesContent.getTitle() + "](" + s + ")"); + } + } + filesContent.setValue(newValues); + } + }); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeInputConfig.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeInputConfig.java new file mode 100644 index 00000000..8e66a507 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeInputConfig.java @@ -0,0 +1,26 @@ +package org.ruoyi.workflow.workflow; + +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.validation.constraints.NotNull; +import lombok.Data; +import org.ruoyi.workflow.workflow.def.WfNodeIO; +import org.ruoyi.workflow.workflow.def.WfNodeParamRef; +import org.springframework.validation.annotation.Validated; + +import java.util.List; + +/** + * 节点的输入参数配置 + */ +@Validated +@Data +public class WfNodeInputConfig { + + @NotNull + @JsonProperty("user_inputs") + private List userInputs; + + @NotNull + @JsonProperty("ref_inputs") + private List refInputs; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeState.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeState.java new file mode 100644 index 00000000..650a087c --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfNodeState.java @@ -0,0 +1,53 @@ +package org.ruoyi.workflow.workflow; + +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; +import org.bsc.langgraph4j.state.AgentState; +import org.ruoyi.workflow.util.UuidUtil; +import org.ruoyi.workflow.workflow.data.NodeIOData; + +import java.io.Serial; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.DEFAULT_INPUT_PARAM_NAME; +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.NODE_PROCESS_STATUS_READY; + +/** + * 工作流节点实例状态 | workflow node instance state + */ +@Setter +@Getter +@ToString(callSuper = true) +public class WfNodeState extends AgentState implements Serializable { + + @Serial + private static final long serialVersionUID = 1L; + + private String uuid = UuidUtil.createShort(); + private int processStatus = NODE_PROCESS_STATUS_READY; + private String processStatusRemark = ""; + private List inputs = new ArrayList<>(); + private List outputs = new ArrayList<>(); + + /** + * Constructs an AgentState with the given initial data. + * + * @param initData the initial data for the agent state + */ + public WfNodeState(Map initData) { + super(initData); + } + + public WfNodeState() { + super(Map.of()); + } + + public Optional getDefaultInput() { + return inputs.stream().filter(item -> DEFAULT_INPUT_PARAM_NAME.equals(item.getName())).findFirst(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfState.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfState.java new file mode 100644 index 00000000..0988d36c --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WfState.java @@ -0,0 +1,131 @@ +package org.ruoyi.workflow.workflow; + +import lombok.Getter; +import lombok.Setter; +import org.bsc.langgraph4j.langchain4j.generators.StreamingChatGenerator; +import org.bsc.langgraph4j.state.AgentState; +import org.ruoyi.workflow.dto.workflow.WfRuntimeNodeDto; +import org.ruoyi.workflow.entity.User; +import org.ruoyi.workflow.entity.WorkflowNode; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.node.AbstractWfNode; + +import java.util.*; + +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.WORKFLOW_PROCESS_STATUS_READY; + +/** + * 工作流实例状态 | workflow instance state + */ +@Setter +@Getter +public class WfState { + + private String uuid; + private User user; + private String processingNodeUuid; + + //Source node uuid => target node uuid list + private Map> edges = new HashMap<>(); + private Map> conditionalEdges = new HashMap<>(); + + //Source node uuid => streaming chat generator + private Map> nodeToStreamingGenerator = new HashMap<>(); + + /** + * 已运行节点列表 + */ + private List completedNodes = new LinkedList<>(); + + private List runtimeNodes = new ArrayList<>(); + + /** + * 工作流接收到的输入（也是开始节点的输入参数） + */ + private List input; + + /** + * 工作流执行结束后的输出 + */ + private List output = new ArrayList<>(); + private Integer processStatus = WORKFLOW_PROCESS_STATUS_READY; + + /** + * 人机交互节点 + */ + private Set interruptNodes = new HashSet<>(); + + public WfState(User user, List input, String uuid) { + this.input = input; + this.user = user; + this.uuid = uuid; + } + + /** + * 获取最新的输出结果 + * + * @return 参数列表 + */ + public List getLatestOutputs() { + WfNodeState upstreamState = completedNodes.get(completedNodes.size() - 1).getState(); + return upstreamState.getOutputs(); + } + + public Optional getNodeStateByNodeUuid(String nodeUuid) { + return this.completedNodes.stream().filter(item -> item.getNode().getUuid().equals(nodeUuid)).map(AbstractWfNode::getState).findFirst(); + } + + /** + * 新增一条边 + * 并行执行分支的情况下会出现一个 source node 对应多个 target node + * + * @param sourceNodeUuid 开始节点 + * @param targetNodeUuid 目标节点 + */ + public void addEdge(String sourceNodeUuid, String targetNodeUuid) { + List targetNodeUuids = edges.computeIfAbsent(sourceNodeUuid, k -> new ArrayList<>()); + targetNodeUuids.add(targetNodeUuid); + } + + /** + * 新增一条边 + * 按条件执行的分支会出现一个 source node 对应多个 target node 的情况 + * + * @param sourceNodeUuid 开始节点 + * @param targetNodeUuid 目标节点 + */ + public void addConditionalEdge(String sourceNodeUuid, String targetNodeUuid) { + List targetNodeUuids = conditionalEdges.computeIfAbsent(sourceNodeUuid, k -> new ArrayList<>()); + targetNodeUuids.add(targetNodeUuid); + } + + public List getIOByNodeUuid(String nodeUuid) { + List result = new ArrayList<>(); + Optional optional = completedNodes.stream().filter(node -> nodeUuid.equals(node.getNode().getUuid())).findFirst(); + if (optional.isEmpty()) { + return result; + } + result.addAll(optional.get().getState().getInputs()); + result.addAll(optional.get().getState().getOutputs()); + return result; + } + + public WfRuntimeNodeDto getRuntimeNodeByNodeUuid(String wfNodeUuid) { + WorkflowNode wfNode = getCompletedNodes().stream() + .map(AbstractWfNode::getNode) + .filter(node -> node.getUuid().equals(wfNodeUuid)) + .findFirst() + .orElse(null); + if (null == wfNode) { + return null; + } + return getRuntimeNodes().stream() + .filter(item -> item.getNodeId().equals(wfNode.getId())) + .findFirst() + .orElse(null); + } + + public void addInterruptNode(String nodeUuid) { + this.interruptNodes.add(nodeUuid); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowEngine.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowEngine.java new file mode 100644 index 00000000..55d10a17 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowEngine.java @@ -0,0 +1,356 @@ +package org.ruoyi.workflow.workflow; + +import cn.hutool.core.collection.CollStreamUtil; +import cn.hutool.core.collection.CollUtil; +import com.fasterxml.jackson.databind.node.ObjectNode; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.tuple.Pair; +import org.bsc.async.AsyncGenerator; +import org.bsc.langgraph4j.*; +import org.bsc.langgraph4j.checkpoint.MemorySaver; +import org.bsc.langgraph4j.langchain4j.generators.StreamingChatGenerator; +import org.bsc.langgraph4j.state.AgentState; +import org.bsc.langgraph4j.state.StateSnapshot; +import org.bsc.langgraph4j.streaming.StreamingOutput; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.base.NodeInputConfigTypeHandler; +import org.ruoyi.workflow.dto.workflow.WfRuntimeNodeDto; +import org.ruoyi.workflow.dto.workflow.WfRuntimeResp; +import org.ruoyi.workflow.entity.*; +import org.ruoyi.workflow.enums.ErrorEnum; +import org.ruoyi.workflow.helper.SSEEmitterHelper; +import org.ruoyi.workflow.service.WorkflowRuntimeNodeService; +import org.ruoyi.workflow.service.WorkflowRuntimeService; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.def.WfNodeIO; +import org.ruoyi.workflow.workflow.def.WfNodeParamRef; +import org.ruoyi.workflow.workflow.node.AbstractWfNode; +import org.springframework.web.servlet.mvc.method.annotation.SseEmitter; + +import java.util.*; +import java.util.function.Function; + +import static org.bsc.langgraph4j.StateGraph.END; +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.*; +import static org.ruoyi.workflow.enums.ErrorEnum.*; + +@Slf4j +public class WorkflowEngine { + private final Workflow workflow; + private final List components; + private final List wfNodes; + private final List wfEdges; + private final SSEEmitterHelper sseEmitterHelper; + private final WorkflowRuntimeService workflowRuntimeService; + private final WorkflowRuntimeNodeService workflowRuntimeNodeService; + private CompiledGraph app; + private SseEmitter sseEmitter; + private User user; + private WfState wfState; + private WfRuntimeResp wfRuntimeResp; + + public WorkflowEngine( + Workflow workflow, + SSEEmitterHelper sseEmitterHelper, + List components, + List nodes, + List wfEdges, + WorkflowRuntimeService workflowRuntimeService, + WorkflowRuntimeNodeService workflowRuntimeNodeService) { + this.workflow = workflow; + this.sseEmitterHelper = sseEmitterHelper; + this.components = components; + this.wfNodes = nodes; + this.wfEdges = wfEdges; + this.workflowRuntimeService = workflowRuntimeService; + this.workflowRuntimeNodeService = workflowRuntimeNodeService; + } + + public void run(User user, List userInputs, SseEmitter sseEmitter) { + this.user = user; + this.sseEmitter = sseEmitter; + log.info("WorkflowEngine run,userId:{},workflowUuid:{},userInputs:{}", user.getId(), workflow.getUuid(), userInputs); + if (!this.workflow.getIsEnable()) { + sseEmitterHelper.sendErrorAndComplete(user.getId(), sseEmitter, ErrorEnum.A_WF_DISABLED.getInfo()); + throw new BaseException(ErrorEnum.A_WF_DISABLED.getInfo()); + } + + Long workflowId = this.workflow.getId(); + this.wfRuntimeResp = workflowRuntimeService.create(user, workflowId); + this.sseEmitterHelper.startSse(user, sseEmitter, JsonUtil.toJson(wfRuntimeResp)); + + String runtimeUuid = this.wfRuntimeResp.getUuid(); + try { + Pair> startAndEnds = findStartAndEndNode(); + WorkflowNode startNode = startAndEnds.getLeft(); + List wfInputs = getAndCheckUserInput(userInputs, startNode); + this.wfState = new WfState(user, wfInputs, runtimeUuid); + workflowRuntimeService.updateInput(this.wfRuntimeResp.getId(), wfState); + + + WorkflowGraphBuilder graphBuilder = new WorkflowGraphBuilder( + components, + wfNodes, + wfEdges, + this::runNode, + this.wfState); + StateGraph mainStateGraph = graphBuilder.build(startNode); + + MemorySaver saver = new MemorySaver(); + CompileConfig compileConfig = CompileConfig.builder().checkpointSaver(saver) + .interruptBefore(wfState.getInterruptNodes().toArray(String[]::new)) + .build(); + app = mainStateGraph.compile(compileConfig); + RunnableConfig invokeConfig = RunnableConfig.builder().build(); + exe(invokeConfig, false); + } catch (Exception e) { + errorWhenExe(e); + } + } + + private void exe(RunnableConfig invokeConfig, boolean resume) { + //不使用langgraph4j state的update相关方法，无需传入input + AsyncGenerator> outputs = app.stream(resume ? null : Map.of(), invokeConfig); + streamingResult(wfState, outputs, sseEmitter); + + StateSnapshot stateSnapshot = app.getState(invokeConfig); + String nextNode = stateSnapshot.config().nextNode().orElse(""); + //还有下个节点，表示进入中断状态，等待用户输入后继续执�? + if (StringUtils.isNotBlank(nextNode) && !nextNode.equalsIgnoreCase(END)) { + String intTip = WorkflowUtil.getHumanFeedbackTip(nextNode, wfNodes); + //将等待输入信息[事件与提示词]发送到到客户端 + SSEEmitterHelper.parseAndSendPartialMsg(sseEmitter, "[NODE_WAIT_FEEDBACK_BY_" + nextNode + "]", intTip); + InterruptedFlow.RUNTIME_TO_GRAPH.put(wfState.getUuid(), this); + //更新状�? + wfState.setProcessStatus(WORKFLOW_PROCESS_STATUS_WAITING_INPUT); + workflowRuntimeService.updateOutput(wfRuntimeResp.getId(), wfState); + } else { + WorkflowRuntime updatedRuntime = workflowRuntimeService.updateOutput(wfRuntimeResp.getId(), wfState); + sseEmitterHelper.sendComplete(user.getId(), sseEmitter, updatedRuntime.getOutput()); + InterruptedFlow.RUNTIME_TO_GRAPH.remove(wfState.getUuid()); + } + } + + /** + * 中断流程等待用户输入时，会进行暂停状态，用户输入后调用本方法执行流程剩余部分 + * + * @param userInput 用户输入 + */ + public void resume(String userInput) { + RunnableConfig invokeConfig = RunnableConfig.builder().build(); + try { + app.updateState(invokeConfig, Map.of(HUMAN_FEEDBACK_KEY, userInput), null); + exe(invokeConfig, true); + } catch (Exception e) { + errorWhenExe(e); + } finally { + //有可能多次接收人机交互，待整个流程完全执行后才能删除 + if (wfState.getProcessStatus() != WORKFLOW_PROCESS_STATUS_WAITING_INPUT) { + InterruptedFlow.RUNTIME_TO_GRAPH.remove(wfState.getUuid()); + } + } + } + + private void errorWhenExe(Exception e) { + log.error("error", e); + String errorMsg = e.getMessage(); + if (errorMsg.contains("parallel node doesn't support conditional branch")) { + errorMsg = "并行节点中不能包含条件分�?"; + } + sseEmitterHelper.sendErrorAndComplete(user.getId(), sseEmitter, errorMsg); + workflowRuntimeService.updateStatus(wfRuntimeResp.getId(), WORKFLOW_PROCESS_STATUS_FAIL, errorMsg); + } + + private Map runNode(WorkflowNode wfNode, WfNodeState nodeState) { + Map resultMap = new HashMap<>(); + try { + WorkflowComponent wfComponent = components.stream().filter(item -> item.getId().equals(wfNode.getWorkflowComponentId())).findFirst().orElseThrow(); + AbstractWfNode abstractWfNode = WfNodeFactory.create(wfComponent, wfNode, wfState, nodeState); + //节点实例 + WfRuntimeNodeDto runtimeNodeDto = workflowRuntimeNodeService.createByState(user, wfNode.getId(), wfRuntimeResp.getId(), nodeState); + wfState.getRuntimeNodes().add(runtimeNodeDto); + + SSEEmitterHelper.parseAndSendPartialMsg(sseEmitter, "[NODE_RUN_" + wfNode.getUuid() + "]", JsonUtil.toJson(runtimeNodeDto)); + + NodeProcessResult processResult = abstractWfNode.process((is) -> { + workflowRuntimeNodeService.updateInput(runtimeNodeDto.getId(), nodeState); + List nodeIODataList = nodeState.getInputs(); +// if (!wfNode.getWorkflowComponentId().equals(1L)) { +// String inputConfig = wfNode.getInputConfig(); +// WfNodeInputConfig nodeInputConfig = NodeInputConfigTypeHandler.fillNodeInputConfig(inputConfig); +// List refInputs = nodeInputConfig.getRefInputs(); +// Set nameSet = CollStreamUtil.toSet(refInputs, WfNodeParamRef::getNodeParamName); +// if (CollUtil.isNotEmpty(nameSet)) { +// nodeIODataList = nodeIODataList.stream().filter(item -> nameSet.contains(item.getName())) +// .collect(Collectors.toList()); +// } else { +// nodeIODataList = nodeIODataList.stream().filter(item -> item.getName().contains("input")) +// .collect(Collectors.toList()); +// } +// } + for (NodeIOData input : nodeIODataList) { + String inputConfig = wfNode.getInputConfig(); + WfNodeInputConfig nodeInputConfig = NodeInputConfigTypeHandler.fillNodeInputConfig(inputConfig); + List refInputs = nodeInputConfig.getRefInputs(); + if (CollUtil.isNotEmpty(refInputs) && "input".equals(input.getName())) { + continue; + } + SSEEmitterHelper.parseAndSendPartialMsg(sseEmitter, "[NODE_INPUT_" + wfNode.getUuid() + "]", JsonUtil.toJson(input)); + } + }, (is) -> { + workflowRuntimeNodeService.updateOutput(runtimeNodeDto.getId(), nodeState); + //并行节点内部的节点执行结束后，需要主动向客户端发送输出结�? + String nodeUuid = wfNode.getUuid(); + List nodeOutputs = nodeState.getOutputs(); + for (NodeIOData output : nodeOutputs) { + log.info("callback node:{},output:{}", nodeUuid, output.getContent()); + SSEEmitterHelper.parseAndSendPartialMsg(sseEmitter, "[NODE_OUTPUT_" + nodeUuid + "]", JsonUtil.toJson(output)); + } + }); + if (StringUtils.isNotBlank(processResult.getNextNodeUuid())) { + resultMap.put("next", processResult.getNextNodeUuid()); + } + } catch (Exception e) { + log.error("Node run error", e); + throw new BaseException(ErrorEnum.B_WF_RUN_ERROR.getInfo()); + } + resultMap.put("name", wfNode.getTitle()); + //langgraph4j state中的data不做数据存储，只存储元数�? + StreamingChatGenerator generator = wfState.getNodeToStreamingGenerator().get(wfNode.getUuid()); + if (null != generator) { + resultMap.put("_streaming_messages", generator); + return resultMap; + } + return resultMap; + } + + /** + * 流式输出结果 + * + * @param outputs 输出 + * @param sseEmitter sse emitter + */ + private void streamingResult(WfState wfState, AsyncGenerator> outputs, SseEmitter sseEmitter) { + for (NodeOutput out : outputs) { + if (out instanceof StreamingOutput streamingOutput) { + String node = streamingOutput.node(); + String chunk = streamingOutput.chunk(); + log.info("node:{},chunk:{}", node, chunk); + Map strMap = new HashMap<>(); + strMap.put("ck", chunk); +// SSEEmitterHelper.parseAndSendPartialMsg(sseEmitter, "[NODE_CHUNK_" + node + "]", strMap.toString()); + SSEEmitterHelper.parseAndSendPartialMsg(sseEmitter, "[NODE_CHUNK_" + node + "]", chunk); + } else { + AbstractWfNode abstractWfNode = wfState.getCompletedNodes().stream() + .filter(item -> item.getNode().getUuid().endsWith(out.node())).findFirst().orElse(null); + if (null != abstractWfNode) { + WfRuntimeNodeDto runtimeNodeDto = wfState.getRuntimeNodeByNodeUuid(out.node()); + if (null != runtimeNodeDto) { + workflowRuntimeNodeService.updateOutput(runtimeNodeDto.getId(), abstractWfNode.getState()); + wfState.setOutput(abstractWfNode.getState().getOutputs()); + } else { + log.warn("Can not find runtime node, node uuid:{}", out.node()); + } + } else { + log.warn("Can not find node state,node uuid:{}", out.node()); + } + } + } + } + + /** + * 校验用户输入并组装成工作流的输入 + * + * @param userInputs 用户输入 + * @param startNode 开始节点定�? + * @return 正确的用户输入列�? + */ + private List getAndCheckUserInput(List userInputs, WorkflowNode startNode) { + WfNodeInputConfig wfNodeInputConfig = NodeInputConfigTypeHandler.fillNodeInputConfig(startNode.getInputConfig()); + List defList = wfNodeInputConfig.getUserInputs(); + defList = CollStreamUtil.toList(defList, Function.identity()); + List wfInputs = new ArrayList<>(); + for (WfNodeIO paramDefinition : defList) { + String paramNameFromDef = paramDefinition.getName(); + boolean requiredParamMissing = paramDefinition.getRequired(); + for (ObjectNode userInput : userInputs) { + NodeIOData nodeIOData = WfNodeIODataUtil.createNodeIOData(userInput); + if (!paramNameFromDef.equalsIgnoreCase(nodeIOData.getName())) { + continue; + } + Integer dataType = nodeIOData.getContent().getType(); + if (null == dataType) { + throw new BaseException(A_WF_INPUT_INVALID.getInfo()); + } + requiredParamMissing = false; + boolean valid = paramDefinition.checkValue(nodeIOData); + if (!valid) { + log.error("用户输入无效,workflowId:{}", startNode.getWorkflowId()); + throw new BaseException(ErrorEnum.A_WF_INPUT_INVALID.getInfo()); + } + wfInputs.add(nodeIOData); + } + if (requiredParamMissing) { + log.error("在流程定义中必填的参数没有传进来,name:{}", paramNameFromDef); + throw new BaseException(A_WF_INPUT_MISSING.getInfo()); + } + } + return wfInputs; + } + + /** + * 查找开始及结束节点
+ * 开始节点只能有一个，结束节点可能多个 + * + * @return 开始节点及结束节点列表 + */ + public Pair> findStartAndEndNode() { + WorkflowNode startNode = null; + Set endNodes = new HashSet<>(); + for (WorkflowNode node : wfNodes) { + Optional wfComponent = components.stream().filter(item -> item.getId().equals(node.getWorkflowComponentId())).findFirst(); + if (wfComponent.isPresent() && WfComponentNameEnum.START.getName().equals(wfComponent.get().getName())) { + if (null != startNode) { + throw new BaseException(ErrorEnum.A_WF_MULTIPLE_START_NODE.getInfo()); + } + startNode = node; + } else if (wfComponent.isPresent() && WfComponentNameEnum.END.getName().equals(wfComponent.get().getName())) { + endNodes.add(node); + } + } + if (null == startNode) { + log.error("没有开始节点, workflowId:{}", wfNodes.get(0).getWorkflowId()); + throw new BaseException(ErrorEnum.A_WF_START_NODE_NOT_FOUND.getInfo()); + } + //Find all end nodes + wfNodes.forEach(item -> { + String nodeUuid = item.getUuid(); + boolean source = false; + boolean target = false; + for (WorkflowEdge edgeDef : wfEdges) { + if (edgeDef.getSourceNodeUuid().equals(nodeUuid)) { + source = true; + } else if (edgeDef.getTargetNodeUuid().equals(nodeUuid)) { + target = true; + } + } + if (!source && target) { + endNodes.add(item); + } + }); + log.info("start node:{}", startNode); + log.info("end nodes:{}", endNodes); + if (endNodes.isEmpty()) { + log.error("没有结束节点,workflowId:{}", startNode.getWorkflowId()); + throw new BaseException(A_WF_END_NODE_NOT_FOUND.getInfo()); + } + return Pair.of(startNode, endNodes); + } + + + public CompiledGraph getApp() { + return app; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowGraphBuilder.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowGraphBuilder.java new file mode 100644 index 00000000..aa11b4b5 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowGraphBuilder.java @@ -0,0 +1,257 @@ +package org.ruoyi.workflow.workflow; + +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.bsc.langgraph4j.GraphStateException; +import org.bsc.langgraph4j.StateGraph; +import org.bsc.langgraph4j.serializer.std.ObjectStreamStateSerializer; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.entity.WorkflowEdge; +import org.ruoyi.workflow.entity.WorkflowNode; +import org.ruoyi.workflow.enums.ErrorEnum; + +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; + +import static org.bsc.langgraph4j.StateGraph.END; +import static org.bsc.langgraph4j.StateGraph.START; +import static org.bsc.langgraph4j.action.AsyncEdgeAction.edge_async; +import static org.bsc.langgraph4j.action.AsyncNodeAction.node_async; +import static org.ruoyi.workflow.workflow.WfComponentNameEnum.HUMAN_FEEDBACK; + +/** + * 负责构建工作流运行所依赖的状态图�? + */ +@Slf4j +public class WorkflowGraphBuilder { + + private final Map componentIndex; + private final Map nodeIndex; + private final Map> edgesBySource; + private final Map> edgesByTarget; + private final WorkflowNodeRunner nodeRunner; + private final WfState wfState; + + private final ObjectStreamStateSerializer stateSerializer = new ObjectStreamStateSerializer<>(WfNodeState::new); + private final Map>> stateGraphNodes = new HashMap<>(); + private final Map>> stateGraphEdges = new HashMap<>(); + private final Map rootToSubGraph = new HashMap<>(); + private final Map nodeToParallelBranch = new HashMap<>(); + + public WorkflowGraphBuilder( + List components, + List nodes, + List edges, + WorkflowNodeRunner nodeRunner, + WfState wfState) { + this.componentIndex = components.stream() + .collect(Collectors.toMap(WorkflowComponent::getId, Function.identity(), (origin, ignore) -> origin)); + this.nodeIndex = nodes.stream() + .collect(Collectors.toMap(WorkflowNode::getUuid, Function.identity(), (origin, ignore) -> origin)); + this.edgesBySource = edges.stream().collect(Collectors.groupingBy(WorkflowEdge::getSourceNodeUuid)); + this.edgesByTarget = edges.stream().collect(Collectors.groupingBy(WorkflowEdge::getTargetNodeUuid)); + this.nodeRunner = nodeRunner; + this.wfState = wfState; + } + + public StateGraph build(WorkflowNode startNode) throws GraphStateException { + CompileNode rootCompileNode = new CompileNode(); + rootCompileNode.setId(startNode.getUuid()); + buildCompileNode(rootCompileNode, startNode); + + StateGraph mainStateGraph = new StateGraph<>(stateSerializer); + wfState.addEdge(START, startNode.getUuid()); + buildStateGraph(null, mainStateGraph, rootCompileNode); + return mainStateGraph; + } + + private void buildCompileNode(CompileNode parentNode, WorkflowNode node) { + log.info("buildCompileNode, parentNode:{}, node:{}, title:{}", parentNode.getId(), node.getUuid(), node.getTitle()); + CompileNode newNode; + List upstreamNodeUuids = getUpstreamNodeUuids(node.getUuid()); + if (upstreamNodeUuids.isEmpty()) { + log.error("节点{}没有上游节点", node.getUuid()); + newNode = parentNode; + } else if (upstreamNodeUuids.size() == 1) { + String upstreamUuid = upstreamNodeUuids.get(0); + boolean pointToParallel = pointToParallelBranch(upstreamUuid); + if (pointToParallel) { + String rootId = node.getUuid(); + GraphCompileNode graphCompileNode = getOrCreateGraphCompileNode(rootId); + appendToNextNodes(parentNode, graphCompileNode); + newNode = graphCompileNode; + } else if (parentNode instanceof GraphCompileNode graphCompileNode) { + newNode = CompileNode.builder().id(node.getUuid()).conditional(false).nextNodes(new ArrayList<>()).build(); + graphCompileNode.appendToLeaf(newNode); + } else { + newNode = CompileNode.builder().id(node.getUuid()).conditional(false).nextNodes(new ArrayList<>()).build(); + appendToNextNodes(parentNode, newNode); + } + } else { + newNode = CompileNode.builder().id(node.getUuid()).conditional(false).nextNodes(new ArrayList<>()).build(); + GraphCompileNode parallelBranch = nodeToParallelBranch.get(parentNode.getId()); + appendToNextNodes(Objects.requireNonNullElse(parallelBranch, parentNode), newNode); + } + + if (newNode == null) { + log.error("节点:{}不存�?", node.getUuid()); + return; + } + for (String downstream : getDownstreamNodeUuids(node.getUuid())) { + WorkflowNode downstreamNode = nodeIndex.get(downstream); + if (downstreamNode != null) { + buildCompileNode(newNode, downstreamNode); + } + } + } + + private void buildStateGraph(CompileNode upstreamCompileNode, + StateGraph stateGraph, + CompileNode compileNode) throws GraphStateException { + log.info("buildStateGraph, upstream:{}, node:{}", upstreamCompileNode, compileNode.getId()); + String stateGraphNodeUuid = compileNode.getId(); + if (upstreamCompileNode == null) { + addNodeToStateGraph(stateGraph, stateGraphNodeUuid); + addEdgeToStateGraph(stateGraph, START, compileNode.getId()); + } else { + if (compileNode instanceof GraphCompileNode graphCompileNode) { + String stateGraphId = graphCompileNode.getId(); + CompileNode root = graphCompileNode.getRoot(); + String rootId = root.getId(); + String existSubGraphId = rootToSubGraph.get(rootId); + + if (StringUtils.isBlank(existSubGraphId)) { + StateGraph subgraph = new StateGraph<>(stateSerializer); + addNodeToStateGraph(subgraph, rootId); + addEdgeToStateGraph(subgraph, START, rootId); + for (CompileNode child : root.getNextNodes()) { + buildStateGraph(root, subgraph, child); + } + addEdgeToStateGraph(subgraph, graphCompileNode.getTail().getId(), END); + stateGraph.addNode(stateGraphId, subgraph.compile()); + rootToSubGraph.put(rootId, stateGraphId); + stateGraphNodeUuid = stateGraphId; + } else { + stateGraphNodeUuid = existSubGraphId; + } + } else { + addNodeToStateGraph(stateGraph, stateGraphNodeUuid); + } + + if (Boolean.FALSE.equals(upstreamCompileNode.getConditional())) { + addEdgeToStateGraph(stateGraph, upstreamCompileNode.getId(), stateGraphNodeUuid); + } + } + + List nextNodes = compileNode.getNextNodes(); + if (nextNodes.size() > 1) { + boolean conditional = nextNodes.stream().noneMatch(item -> item instanceof GraphCompileNode); + compileNode.setConditional(conditional); + for (CompileNode nextNode : nextNodes) { + buildStateGraph(compileNode, stateGraph, nextNode); + } + if (conditional) { + List targets = nextNodes.stream().map(CompileNode::getId).toList(); + Map mappings = new HashMap<>(); + for (String target : targets) { + mappings.put(target, target); + } + stateGraph.addConditionalEdges( + stateGraphNodeUuid, + edge_async(state -> state.data().get("next").toString()), + mappings + ); + } + } else if (nextNodes.size() == 1) { + for (CompileNode nextNode : nextNodes) { + buildStateGraph(compileNode, stateGraph, nextNode); + } + } else { + addEdgeToStateGraph(stateGraph, stateGraphNodeUuid, END); + } + } + + private GraphCompileNode getOrCreateGraphCompileNode(String rootId) { + GraphCompileNode exist = nodeToParallelBranch.get(rootId); + if (exist == null) { + GraphCompileNode graphCompileNode = new GraphCompileNode(); + graphCompileNode.setId("parallel_" + rootId); + graphCompileNode.setRoot(CompileNode.builder().id(rootId).conditional(false).nextNodes(new ArrayList<>()).build()); + nodeToParallelBranch.put(rootId, graphCompileNode); + exist = graphCompileNode; + } + return exist; + } + + private List getUpstreamNodeUuids(String nodeUuid) { + return edgesByTarget.getOrDefault(nodeUuid, List.of()) + .stream() + .map(WorkflowEdge::getSourceNodeUuid) + .toList(); + } + + private List getDownstreamNodeUuids(String nodeUuid) { + return edgesBySource.getOrDefault(nodeUuid, List.of()) + .stream() + .map(WorkflowEdge::getTargetNodeUuid) + .toList(); + } + + private boolean pointToParallelBranch(String nodeUuid) { + return edgesBySource.getOrDefault(nodeUuid, List.of()) + .stream() + .filter(edge -> StringUtils.isBlank(edge.getSourceHandle())) + .count() > 1; + } + + private void addNodeToStateGraph(StateGraph stateGraph, String stateGraphNodeUuid) throws GraphStateException { + List> stateGraphList = stateGraphNodes.computeIfAbsent(stateGraphNodeUuid, k -> new ArrayList<>()); + boolean exist = stateGraphList.stream().anyMatch(item -> item == stateGraph); + if (exist) { + log.info("state graph node exist,stateGraphNodeUuid:{}", stateGraphNodeUuid); + return; + } + log.info("addNodeToStateGraph,node uuid:{}", stateGraphNodeUuid); + WorkflowNode wfNode = getNodeByUuid(stateGraphNodeUuid); + stateGraph.addNode(stateGraphNodeUuid, node_async(state -> nodeRunner.run(wfNode, state))); + stateGraphList.add(stateGraph); + + WorkflowComponent component = componentIndex.get(wfNode.getWorkflowComponentId()); + if (component == null) { + throw new BaseException(ErrorEnum.A_PARAMS_ERROR.getInfo()); + } + if (HUMAN_FEEDBACK.getName().equals(component.getName())) { + wfState.addInterruptNode(stateGraphNodeUuid); + } + } + + private void addEdgeToStateGraph(StateGraph stateGraph, String source, String target) throws GraphStateException { + String key = source + "_" + target; + List> stateGraphList = stateGraphEdges.computeIfAbsent(key, k -> new ArrayList<>()); + boolean exist = stateGraphList.stream().anyMatch(item -> item == stateGraph); + if (exist) { + log.info("state graph edge exist,source:{},target:{}", source, target); + return; + } + log.info("addEdgeToStateGraph,source:{},target:{}", source, target); + stateGraph.addEdge(source, target); + stateGraphList.add(stateGraph); + } + + private WorkflowNode getNodeByUuid(String nodeUuid) { + WorkflowNode workflowNode = nodeIndex.get(nodeUuid); + if (workflowNode == null) { + throw new BaseException(ErrorEnum.A_WF_NODE_NOT_FOUND.getInfo()); + } + return workflowNode; + } + + private void appendToNextNodes(CompileNode compileNode, CompileNode newNode) { + boolean exist = compileNode.getNextNodes().stream().anyMatch(item -> item.getId().equals(newNode.getId())); + if (!exist) { + compileNode.getNextNodes().add(newNode); + } + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowNodeRunner.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowNodeRunner.java new file mode 100644 index 00000000..324f344a --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowNodeRunner.java @@ -0,0 +1,14 @@ +package org.ruoyi.workflow.workflow; + +import org.ruoyi.workflow.entity.WorkflowNode; + +import java.util.Map; + +/** + * 回调接口，负责执行业务节点并返回下游编排所需的元数据。 + */ +@FunctionalInterface +public interface WorkflowNodeRunner { + + Map run(WorkflowNode node, WfNodeState nodeState); +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowStarter.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowStarter.java new file mode 100644 index 00000000..69e036fb --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowStarter.java @@ -0,0 +1,95 @@ +package org.ruoyi.workflow.workflow; + +import com.fasterxml.jackson.databind.node.ObjectNode; +import jakarta.annotation.Resource; +import lombok.extern.slf4j.Slf4j; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.entity.*; +import org.ruoyi.workflow.helper.SSEEmitterHelper; +import org.ruoyi.workflow.service.*; +import org.springframework.context.annotation.Lazy; +import org.springframework.scheduling.annotation.Async; +import org.springframework.stereotype.Component; +import org.springframework.web.servlet.mvc.method.annotation.SseEmitter; + +import java.util.List; + +import static org.ruoyi.workflow.cosntant.AdiConstant.SSE_TIMEOUT; +import static org.ruoyi.workflow.enums.ErrorEnum.*; + +@Slf4j +@Component +public class WorkflowStarter { + + @Lazy + @Resource + private WorkflowStarter self; + + @Resource + private WorkflowService workflowService; + + @Resource + private WorkflowNodeService workflowNodeService; + + @Resource + private WorkflowEdgeService workflowEdgeService; + + @Resource + private WorkflowComponentService workflowComponentService; + + @Resource + private WorkflowRuntimeService workflowRuntimeService; + + @Resource + private WorkflowRuntimeNodeService workflowRuntimeNodeService; + + @Resource + private SSEEmitterHelper sseEmitterHelper; + + + public SseEmitter streaming(User user, String workflowUuid, List userInputs) { + SseEmitter sseEmitter = new SseEmitter(SSE_TIMEOUT); + if (!sseEmitterHelper.checkOrComplete(user, sseEmitter)) { + return sseEmitter; + } + Workflow workflow = workflowService.getByUuid(workflowUuid); + if (null == workflow) { + sseEmitterHelper.sendErrorAndComplete(user.getId(), sseEmitter, A_WF_NOT_FOUND.getInfo()); + return sseEmitter; + } else if (Boolean.FALSE.equals(workflow.getIsEnable())) { + sseEmitterHelper.sendErrorAndComplete(user.getId(), sseEmitter, A_WF_DISABLED.getInfo()); + return sseEmitter; + } + self.asyncRun(user, workflow, userInputs, sseEmitter); + return sseEmitter; + } + + @Async + public void asyncRun(User user, Workflow workflow, List userInputs, SseEmitter sseEmitter) { + log.info("WorkflowEngine run,userId:{},workflowUuid:{},userInputs:{}", user.getId(), workflow.getUuid(), userInputs); + List components = workflowComponentService.getAllEnable(); + List nodes = workflowNodeService.lambdaQuery() + .eq(WorkflowNode::getWorkflowId, workflow.getId()) + .eq(WorkflowNode::getIsDeleted, false) + .list(); + List edges = workflowEdgeService.lambdaQuery() + .eq(WorkflowEdge::getWorkflowId, workflow.getId()) + .eq(WorkflowEdge::getIsDeleted, false) + .list(); + WorkflowEngine workflowEngine = new WorkflowEngine(workflow, + sseEmitterHelper, components, nodes, edges, + workflowRuntimeService, workflowRuntimeNodeService); + workflowEngine.run(user, userInputs, sseEmitter); + } + + @Async + public void resumeFlow(String runtimeUuid, String userInput) { + WorkflowEngine workflowEngine = InterruptedFlow.RUNTIME_TO_GRAPH.get(runtimeUuid); + if (null == workflowEngine) { + log.error("工作流恢复执行时失败,runtime:{}", runtimeUuid); + throw new BaseException(A_WF_RESUME_FAIL.getInfo()); + } + workflowEngine.resume(userInput); + } + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowUtil.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowUtil.java new file mode 100644 index 00000000..b4d96b57 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/WorkflowUtil.java @@ -0,0 +1,162 @@ +package org.ruoyi.workflow.workflow; + +import cn.hutool.core.collection.CollStreamUtil; +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.util.StrUtil; +import dev.langchain4j.data.message.UserMessage; +import jakarta.annotation.Resource; +import lombok.extern.slf4j.Slf4j; +import org.bsc.langgraph4j.langchain4j.generators.StreamingChatGenerator; +import org.bsc.langgraph4j.state.AgentState; +import org.ruoyi.chat.factory.ChatServiceFactory; +import org.ruoyi.chat.service.chat.IChatService; +import org.ruoyi.common.chat.entity.chat.Message; +import org.ruoyi.common.chat.request.ChatRequest; +import org.ruoyi.workflow.base.NodeInputConfigTypeHandler; +import org.ruoyi.workflow.entity.WorkflowNode; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.data.NodeIODataContent; +import org.ruoyi.workflow.workflow.def.WfNodeParamRef; +import org.springframework.stereotype.Component; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.DEFAULT_OUTPUT_PARAM_NAME; + +@Slf4j +@Component +public class WorkflowUtil { + + @Resource + private ChatServiceFactory chatServiceFactory; + + @SuppressWarnings("unchecked") + public static String renderTemplate(String template, List values) { + String result = template; + for (NodeIOData next : values) { + String name = next.getName(); + NodeIODataContent dataContent = next.getContent(); + if (dataContent.getType().equals(WfIODataTypeEnum.FILES.getValue())) { + List value = (List) dataContent.getValue(); + result = result.replace("{" + name + "}", String.join(",", value)); + } else if (dataContent.getType().equals(WfIODataTypeEnum.OPTIONS.getValue())) { + Map value = (Map) dataContent.getValue(); + result = result.replace("{" + name + "}", value.toString()); + } else { + result = result.replace("{" + name + "}", dataContent.getValue().toString()); + } + } + return result; + } + + public static String getHumanFeedbackTip(String nodeUuid, List wfNodes) { + WorkflowNode wfNode = wfNodes.stream() + .filter(item -> item.getUuid().equals(nodeUuid)) + .findFirst().orElse(null); + if (null == wfNode) { + return ""; + } + String wfNodeNodeConfig = wfNode.getNodeConfig(); + if (StrUtil.isBlank(wfNodeNodeConfig)) { + return ""; + } + Map map = JsonUtil.toMap(wfNodeNodeConfig); + Object tip = map.getOrDefault("tip", ""); + return String.valueOf(tip); + } + + public void streamingInvokeLLM(WfState wfState, WfNodeState state, WorkflowNode node, String category, + String modelName, List systemMessage) { + log.info("stream invoke, category: {}, modelName: {}", category, modelName); + + // 根据 category 获取对应的 ChatService（不使用计费代理，工作流场景单独计费） + IChatService chatService = chatServiceFactory.getOriginalService(category); + + StreamingChatGenerator streamingGenerator = StreamingChatGenerator.builder() + .mapResult(response -> { + String responseTxt = response.aiMessage().text(); + log.info("llm response:{}", responseTxt); + NodeIOData output = NodeIOData.createByText(DEFAULT_OUTPUT_PARAM_NAME, "", responseTxt); + wfState.getNodeStateByNodeUuid(node.getUuid()).ifPresent(item -> item.getOutputs().add(output)); + return Map.of("completeResult", response.aiMessage().text()); + }) + .startingNode(node.getUuid()) + .startingState(state) + .build(); + + // 构建 ruoyi-ai 的 ChatRequest + List messages = new ArrayList<>(); + + addUserMessage(node, state.getInputs(), messages); + + addSystemMessage(systemMessage, messages); + + ChatRequest chatRequest = new ChatRequest(); + chatRequest.setModel(modelName); + chatRequest.setMessages(messages); + + // 使用工作流专用方法 + chatService.chat(chatRequest, streamingGenerator.handler()); + wfState.getNodeToStreamingGenerator().put(node.getUuid(), streamingGenerator); + } + + /** + * 添加用户信息 + * + * @param node + * @param messages + */ + private void addUserMessage(WorkflowNode node, List userMessage, List messages) { + if (CollUtil.isEmpty(userMessage)) { + return; + } + + WfNodeInputConfig nodeInputConfig = NodeInputConfigTypeHandler.fillNodeInputConfig(node.getInputConfig()); + + List refInputs = nodeInputConfig.getRefInputs(); + + Set nameSet = CollStreamUtil.toSet(refInputs, WfNodeParamRef::getName); + + userMessage.stream().filter(item -> nameSet.contains(item.getName())) + .map(item -> getMessage("role", item.getContent().getValue())).forEach(messages::add); + + if (CollUtil.isNotEmpty(messages)) { + return; + } + + userMessage.stream().filter(item -> "input".equals(item.getName())) + .map(item -> getMessage("role", item.getContent().getValue())).forEach(messages::add); + } + + /** + * 组装message对象 + * + * @param role + * @param value + * @return + */ + private Message getMessage(String role, Object value) { + Message message = new Message(); + message.setContent(String.valueOf(value)); + message.setRole(role); + return message; + } + + /** + * 添加系统信息 + * + * @param systemMessage + * @param messages + */ + private void addSystemMessage(List systemMessage, List messages) { + if (CollUtil.isEmpty(systemMessage)) { + return; + } + systemMessage.stream().map(userMsg -> getMessage("system", userMsg.singleText())).forEach(messages::add); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIOData.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIOData.java new file mode 100644 index 00000000..3721ffb7 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIOData.java @@ -0,0 +1,63 @@ +package org.ruoyi.workflow.workflow.data; + +import lombok.Builder; +import lombok.Data; + +import java.io.Serial; +import java.io.Serializable; +import java.util.List; +import java.util.Map; + +/** + * 工作流节点输入输出数据 + */ +@Builder +@Data +public class NodeIOData implements Serializable { + + @Serial + private static final long serialVersionUID = 1L; + + protected String name; + + protected NodeIODataContent content; + + public static NodeIOData createByText(String name, String title, String value) { + NodeIODataTextContent datContent = new NodeIODataTextContent(); + datContent.setValue(value); + datContent.setTitle(title); + return NodeIOData.builder().name(name).content(datContent).build(); + } + + public static NodeIOData createByNumber(String name, String title, Double value) { + NodeIODataNumberContent datContent = new NodeIODataNumberContent(); + datContent.setValue(value); + datContent.setTitle(title); + return NodeIOData.builder().name(name).content(datContent).build(); + } + + public static NodeIOData createByBool(String name, String title, Boolean value) { + NodeIODataBoolContent datContent = new NodeIODataBoolContent(); + datContent.setValue(value); + datContent.setTitle(title); + return NodeIOData.builder().name(name).content(datContent).build(); + } + + public static NodeIOData createByFiles(String name, String title, List value) { + NodeIODataFilesContent datContent = new NodeIODataFilesContent(); + datContent.setValue(value); + datContent.setTitle(title); + return NodeIOData.builder().name(name).content(datContent).build(); + } + + public static NodeIOData createByOptions(String name, String title, Map value) { + NodeIODataOptionsContent datContent = new NodeIODataOptionsContent(); + datContent.setValue(value); + datContent.setTitle(title); + return NodeIOData.builder().name(name).content(datContent).build(); + } + + public String valueToString() { + return content.getValue().toString(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataBoolContent.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataBoolContent.java new file mode 100644 index 00000000..57730365 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataBoolContent.java @@ -0,0 +1,22 @@ +package org.ruoyi.workflow.workflow.data; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; + +import java.io.Serial; +import java.io.Serializable; + +@EqualsAndHashCode(callSuper = true) +@Data +public class NodeIODataBoolContent extends NodeIODataContent implements Serializable { + + @Serial + private static final long serialVersionUID = 1L; + + private String title; + + private Integer type = WfIODataTypeEnum.BOOL.getValue(); + + private Boolean value; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataContent.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataContent.java new file mode 100644 index 00000000..d99d9f67 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataContent.java @@ -0,0 +1,13 @@ +package org.ruoyi.workflow.workflow.data; + +import lombok.Data; + +@Data +public abstract class NodeIODataContent { + + private String title; + + private Integer type; + + private T value; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataFilesContent.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataFilesContent.java new file mode 100644 index 00000000..ff0ef6a8 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataFilesContent.java @@ -0,0 +1,23 @@ +package org.ruoyi.workflow.workflow.data; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; + +import java.io.Serial; +import java.io.Serializable; +import java.util.List; + +@EqualsAndHashCode(callSuper = true) +@Data +public class NodeIODataFilesContent extends NodeIODataContent> implements Serializable { + + @Serial + private static final long serialVersionUID = 1L; + + private String title; + + private Integer type = WfIODataTypeEnum.FILES.getValue(); + + private List value; +} \ No newline at end of file diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataNumberContent.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataNumberContent.java new file mode 100644 index 00000000..f9cc3f88 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataNumberContent.java @@ -0,0 +1,22 @@ +package org.ruoyi.workflow.workflow.data; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; + +import java.io.Serial; +import java.io.Serializable; + +@EqualsAndHashCode(callSuper = true) +@Data +public class NodeIODataNumberContent extends NodeIODataContent implements Serializable { + + @Serial + private static final long serialVersionUID = 1L; + + private String title; + + private Integer type = WfIODataTypeEnum.NUMBER.getValue(); + + private Double value; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataOptionsContent.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataOptionsContent.java new file mode 100644 index 00000000..7cc4ecc7 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataOptionsContent.java @@ -0,0 +1,23 @@ +package org.ruoyi.workflow.workflow.data; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; + +import java.io.Serial; +import java.io.Serializable; +import java.util.Map; + +@EqualsAndHashCode(callSuper = true) +@Data +public class NodeIODataOptionsContent extends NodeIODataContent> implements Serializable { + + @Serial + private static final long serialVersionUID = 1L; + + private String title; + + private Integer type = WfIODataTypeEnum.OPTIONS.getValue(); + + private Map value; +} \ No newline at end of file diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataTextContent.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataTextContent.java new file mode 100644 index 00000000..cb2cf920 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/NodeIODataTextContent.java @@ -0,0 +1,22 @@ +package org.ruoyi.workflow.workflow.data; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; + +import java.io.Serial; +import java.io.Serializable; + +@EqualsAndHashCode(callSuper = true) +@Data +public class NodeIODataTextContent extends NodeIODataContent implements Serializable { + + @Serial + private static final long serialVersionUID = 1L; + + private String title; + + private Integer type = WfIODataTypeEnum.TEXT.getValue(); + + private String value; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/WfUserReq.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/WfUserReq.java new file mode 100644 index 00000000..950a949c --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/data/WfUserReq.java @@ -0,0 +1,10 @@ +package org.ruoyi.workflow.workflow.data; + +import lombok.Data; + +import java.util.List; + +@Data +public class WfUserReq { + private List inputs; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIO.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIO.java new file mode 100644 index 00000000..50872cac --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIO.java @@ -0,0 +1,29 @@ +package org.ruoyi.workflow.workflow.def; + +import lombok.Data; +import lombok.NoArgsConstructor; +import org.ruoyi.workflow.workflow.data.NodeIOData; + +import java.io.Serializable; + +/** + * 工作流节点输入输出参数定义 + */ +@Data +@NoArgsConstructor +public abstract class WfNodeIO implements Serializable { + + protected String uuid; + protected Integer type; + protected String name; + protected String title; + protected Boolean required; + + /** + * 检查数据是否合规 + * + * @param data 节点输入输出数据 + * @return 是否正确 + */ + public abstract boolean checkValue(NodeIOData data); +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOBool.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOBool.java new file mode 100644 index 00000000..d884684b --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOBool.java @@ -0,0 +1,27 @@ +package org.ruoyi.workflow.workflow.def; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.data.NodeIODataBoolContent; + +/** + * 用户输入参数-布尔类型 参数定义 + */ +@EqualsAndHashCode(callSuper = true) +@Data +@NoArgsConstructor +public class WfNodeIOBool extends WfNodeIO { + + protected Integer type = WfIODataTypeEnum.BOOL.getValue(); + + @Override + public boolean checkValue(NodeIOData data) { + if (!(data.getContent() instanceof NodeIODataBoolContent)) { + return false; + } + return !required || null != data.getContent().getValue(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOFiles.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOFiles.java new file mode 100644 index 00000000..694e03df --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOFiles.java @@ -0,0 +1,28 @@ +package org.ruoyi.workflow.workflow.def; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import org.apache.commons.collections4.CollectionUtils; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.data.NodeIODataFilesContent; + +/** + * 用户输入参数-文件列表类型 参数定义 + */ +@EqualsAndHashCode(callSuper = true) +@Data +@NoArgsConstructor +public class WfNodeIOFiles extends WfNodeIO { + protected Integer type = WfIODataTypeEnum.FILES.getValue(); + private Integer limit; + + @Override + public boolean checkValue(NodeIOData data) { + if (!(data.getContent() instanceof NodeIODataFilesContent wfNodeIOFiles)) { + return false; + } + return !required || !CollectionUtils.isEmpty(wfNodeIOFiles.getValue()); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIONumber.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIONumber.java new file mode 100644 index 00000000..b7de4485 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIONumber.java @@ -0,0 +1,26 @@ +package org.ruoyi.workflow.workflow.def; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.data.NodeIODataNumberContent; + +/** + * 用户输入参数-数字类型 参数定义 + */ +@EqualsAndHashCode(callSuper = true) +@Data +@NoArgsConstructor +public class WfNodeIONumber extends WfNodeIO { + protected Integer type = WfIODataTypeEnum.NUMBER.getValue(); + + @Override + public boolean checkValue(NodeIOData data) { + if (!(data.getContent() instanceof NodeIODataNumberContent nodeIONumber)) { + return false; + } + return !required || null != nodeIONumber.getValue(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOOptions.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOOptions.java new file mode 100644 index 00000000..5e7aefe1 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOOptions.java @@ -0,0 +1,34 @@ +package org.ruoyi.workflow.workflow.def; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.data.NodeIODataOptionsContent; + +import java.util.Map; + +/** + * 用户输入参数-下拉选项类型 参数定义 + */ +@EqualsAndHashCode(callSuper = true) +@Data +@NoArgsConstructor +public class WfNodeIOOptions extends WfNodeIO { + protected Integer type = WfIODataTypeEnum.OPTIONS.getValue(); + private Boolean multiple; + + @Override + public boolean checkValue(NodeIOData data) { + if (!(data.getContent() instanceof NodeIODataOptionsContent optionsData)) { + return false; + } + Map value = optionsData.getValue(); + if (required && null == value) { + return false; + } + //如果设置了单选，传过来的值是多项，则检查不通过 + return multiple || null == value || value.size() <= 1; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOText.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOText.java new file mode 100644 index 00000000..83a0a15f --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeIOText.java @@ -0,0 +1,35 @@ +package org.ruoyi.workflow.workflow.def; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.data.NodeIODataTextContent; + +/** + * 用户输入参数-文本类型 参数定义 + */ +@EqualsAndHashCode(callSuper = true) +@Data +@NoArgsConstructor +public class WfNodeIOText extends WfNodeIO { + + protected Integer type = WfIODataTypeEnum.TEXT.getValue(); + + @JsonProperty("max_length") + private Integer maxLength; + + @Override + public boolean checkValue(NodeIOData data) { + if (!(data.getContent() instanceof NodeIODataTextContent optionsData)) { + return false; + } + String value = optionsData.getValue(); + if (required && null == value) { + return false; + } + return null == maxLength || value.length() <= maxLength; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeParamRef.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeParamRef.java new file mode 100644 index 00000000..82cf888e --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/def/WfNodeParamRef.java @@ -0,0 +1,23 @@ +package org.ruoyi.workflow.workflow.def; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Data; + +import java.io.Serializable; + +/** + * 输入参数-引用类型 参数定义
+ * 1.该参数的值是另一个节点的输出/或输入参数
+ * 2.该类型参数只在非开始节点中使用
+ * 3.通常做为输入参数使用 + */ +@Data +public class WfNodeParamRef implements Serializable { + + @JsonProperty("node_uuid") + private String nodeUuid; + @JsonProperty("node_param_name") + private String nodeParamName; + + private String name; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/edge/ConditionalEdge.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/edge/ConditionalEdge.java new file mode 100644 index 00000000..5be719cc --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/edge/ConditionalEdge.java @@ -0,0 +1,10 @@ +package org.ruoyi.workflow.workflow.edge; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode(callSuper = true) +@Data +public class ConditionalEdge extends Edge { + private String sourceHandle; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/edge/Edge.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/edge/Edge.java new file mode 100644 index 00000000..0d9a0dc2 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/edge/Edge.java @@ -0,0 +1,11 @@ +package org.ruoyi.workflow.workflow.edge; + +import lombok.Data; + +import java.util.List; + +@Data +public class Edge { + private String sourceNodeUuid; + private List targetNodeUuid; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/AbstractWfNode.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/AbstractWfNode.java new file mode 100644 index 00000000..d6119e5c --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/AbstractWfNode.java @@ -0,0 +1,213 @@ +package org.ruoyi.workflow.workflow.node; + +import com.fasterxml.jackson.databind.node.ObjectNode; +import jakarta.validation.ConstraintViolation; +import lombok.Data; +import lombok.Getter; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.SerializationUtils; +import org.apache.commons.lang3.StringUtils; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.base.NodeInputConfigTypeHandler; +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.entity.WorkflowNode; +import org.ruoyi.workflow.enums.WfIODataTypeEnum; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.util.SpringUtil; +import org.ruoyi.workflow.workflow.NodeProcessResult; +import org.ruoyi.workflow.workflow.WfNodeInputConfig; +import org.ruoyi.workflow.workflow.WfNodeState; +import org.ruoyi.workflow.workflow.WfState; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.def.WfNodeIO; +import org.ruoyi.workflow.workflow.def.WfNodeParamRef; +import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.Set; +import java.util.function.Consumer; +import java.util.stream.Collectors; + +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.*; +import static org.ruoyi.workflow.enums.ErrorEnum.A_WF_NODE_CONFIG_ERROR; +import static org.ruoyi.workflow.enums.ErrorEnum.A_WF_NODE_CONFIG_NOT_FOUND; + +/** + * 节点实例-运行时 + */ +@Data +@Slf4j +public abstract class AbstractWfNode { + + protected WorkflowComponent wfComponent; + protected WfState wfState; + @Getter + protected WfNodeState state; + protected WorkflowNode node; + + public AbstractWfNode(WorkflowComponent wfComponent, WorkflowNode node, WfState wfState, WfNodeState nodeState) { + this.wfState = wfState; + this.wfComponent = wfComponent; + this.state = nodeState; + this.node = node; + } + + public void initInput() { + WfNodeInputConfig nodeInputConfig = NodeInputConfigTypeHandler.fillNodeInputConfig(node.getInputConfig()); + if (wfState.getCompletedNodes().isEmpty()) { + log.info("没有上游节点，当前节点为开始节点"); + state.getInputs().addAll(wfState.getInput()); + return; + } + + List inputs = new ArrayList<>(); + + //将上游节点的输出转成当前节点的输入 + List upstreamOutputs = wfState.getLatestOutputs(); + if (!upstreamOutputs.isEmpty()) { + inputs.addAll(new ArrayList<>(upstreamOutputs)); + } else { + log.warn("upstream output params is empty"); + } + //处理引用类型的输入参数，非开始节点只有引用类型输入参数 + List refInputDefs = nodeInputConfig.getRefInputs(); + inputs.addAll(changeRefersToNodeIODatas(refInputDefs)); + + //根据节点的输入参数定义，刷选出符合要求的输入参数 + WfNodeInputConfig inputConfig = JsonUtil.toBean(node.getInputConfig(), WfNodeInputConfig.class); + List defInputNames = inputConfig.getRefInputs().stream().map(WfNodeParamRef::getName).collect(Collectors.toList()); + defInputNames.addAll(inputConfig.getUserInputs().stream().map(WfNodeIO::getName).toList()); + List needInputs = inputs.stream().filter(item -> { + String needInputName = item.getName(); + //上流节点的默认输出参数(output)，改成input即可 + if (DEFAULT_OUTPUT_PARAM_NAME.equals(needInputName)) { + item.setName(DEFAULT_INPUT_PARAM_NAME); + return true; + } + return defInputNames.contains(needInputName); + }).toList(); + state.getInputs().addAll(needInputs); + } + + /** + * 查找引用节点的参数并转成输入输出参数 + * + * @param referParams 引用类型的定义列表 + */ + private List changeRefersToNodeIODatas(List referParams) { + List result = new ArrayList<>(); + for (WfNodeParamRef referParam : referParams) { + String nodeUuid = referParam.getNodeUuid(); + String nodeParamName = referParam.getNodeParamName(); + NodeIOData newInput = createByReferParam(nodeUuid, nodeParamName); + if (null != newInput) { + newInput.setName(referParam.getName()); + result.add(newInput); + } else { + log.warn("Can not find reference node output param,refNodeId:{},refNodeOutputName:{}", nodeUuid, nodeParamName); + } + } + return result; + } + + public NodeIOData createByReferParam(String refNodeUuid, String refNodeParamName) { + Optional hitDataOpt = wfState.getIOByNodeUuid(refNodeUuid) + .stream() + .filter(wfNodeIOData -> wfNodeIOData.getName().equalsIgnoreCase(refNodeParamName)) + .findFirst(); + return hitDataOpt.map(SerializationUtils::clone).orElse(null); + } + + public NodeProcessResult process(Consumer inputConsumer, Consumer outputConsumer) { + log.info("↓↓↓↓↓ node process start,name:{},uuid:{}", node.getTitle(), node.getUuid()); + state.setProcessStatus(NODE_PROCESS_STATUS_DOING); + initInput(); + //HumanFeedback的情况 + Object humanFeedbackState = state.data().get(HUMAN_FEEDBACK_KEY); + if (null != humanFeedbackState) { + String userInput = humanFeedbackState.toString(); + if (StringUtils.isNotBlank(userInput)) { + state.getInputs().add(NodeIOData.createByText(HUMAN_FEEDBACK_KEY, "default", userInput)); + } + } + if (null != inputConsumer) { + inputConsumer.accept(state); + } + log.info("--node input:{}", JsonUtil.toJson(state.getInputs())); + NodeProcessResult processResult; + try { + processResult = onProcess(); + } catch (Exception e) { + state.setProcessStatus(NODE_PROCESS_STATUS_FAIL); + state.setProcessStatusRemark("process error:" + e.getMessage()); + wfState.setProcessStatus(WORKFLOW_PROCESS_STATUS_FAIL); + log.info("↑↑↑↑↑ node process error,name:{},uuid:{},error", node.getTitle(), node.getUuid(), e); + if (null != outputConsumer) { + outputConsumer.accept(state); + } + throw new RuntimeException(e); + } + + if (!processResult.getContent().isEmpty()) { + state.setOutputs(processResult.getContent()); + } + state.setProcessStatus(NODE_PROCESS_STATUS_SUCCESS); + wfState.getCompletedNodes().add(this); + log.info("↑↑↑↑↑ node process end,name:{},uuid:{},output:{}", + node.getTitle(), node.getUuid(), JsonUtil.toJson(state.getOutputs())); + if (null != outputConsumer) { + outputConsumer.accept(state); + } + return processResult; + } + + protected abstract NodeProcessResult onProcess(); + + protected String getFirstInputText() { + String firstInputText; + if (state.getInputs().size() > 1) { + firstInputText = state.getInputs() + .stream() + .filter(item -> WfIODataTypeEnum.TEXT.getValue().equals(item.getContent().getType()) && !DEFAULT_INPUT_PARAM_NAME.equals(item.getName())) + .map(NodeIOData::valueToString) + .findFirst() + .orElse(""); + } else { + firstInputText = state.getInputs().get(0).valueToString(); + } + return firstInputText; + } + + protected T checkAndGetConfig(Class clazz) { + ObjectNode configObj = JsonUtil.toBean(node.getNodeConfig(), ObjectNode.class); + if (configObj.isEmpty()) { + log.error("node config is empty,node uuid:{}", state.getUuid()); + throw new BaseException(A_WF_NODE_CONFIG_NOT_FOUND.getInfo()); + } + log.info("node config:{}", configObj); + T nodeConfig = JsonUtil.fromJson(configObj, clazz); + if (null == nodeConfig) { + log.warn("找不到节点的配置,node uuid:{}", state.getUuid()); + throw new BaseException(A_WF_NODE_CONFIG_ERROR.getInfo()); + } + boolean configValid = true; + try { + Set> violations = SpringUtil.getBean("beanValidator", LocalValidatorFactoryBean.class).validate(nodeConfig); + for (ConstraintViolation violation : violations) { + log.error(violation.getMessage()); + configValid = false; + } + } catch (Exception e) { + log.error("节点配置校验失败,node uuid:{},error:{}", state.getUuid(), e.getMessage()); + configValid = false; + } + if (!configValid) { + log.warn("节点配置错误,node uuid:{}", state.getUuid()); + throw new BaseException(A_WF_NODE_CONFIG_ERROR.getInfo()); + } + return nodeConfig; + } + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/EndNode.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/EndNode.java new file mode 100644 index 00000000..8b6c182f --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/EndNode.java @@ -0,0 +1,41 @@ +package org.ruoyi.workflow.workflow.node; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import lombok.extern.slf4j.Slf4j; +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.entity.WorkflowNode; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.workflow.*; +import org.ruoyi.workflow.workflow.data.NodeIOData; + +import java.util.ArrayList; +import java.util.List; + +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.DEFAULT_OUTPUT_PARAM_NAME; + + +@Slf4j +public class EndNode extends AbstractWfNode { + + public EndNode(WorkflowComponent wfComponent, WorkflowNode nodeDef, WfState wfState, WfNodeState nodeState) { + super(wfComponent, nodeDef, wfState, nodeState); + } + + @Override + protected NodeProcessResult onProcess() { + List result = new ArrayList<>(); + ObjectNode objectConfig = JsonUtil.toBean(node.getNodeConfig(), ObjectNode.class); + JsonNode resultNode = objectConfig.get("result"); + String output = ""; + if (null == resultNode) { + log.warn("EndNode result config is empty, nodeUuid: {}, title: {}", node.getUuid(), node.getTitle()); + } else { + String resultTemplate = resultNode.asText(); + WfNodeIODataUtil.changeFilesContentToMarkdown(state.getInputs()); + output = WorkflowUtil.renderTemplate(resultTemplate, state.getInputs()); + } + result.add(NodeIOData.createByText(DEFAULT_OUTPUT_PARAM_NAME, "", output)); + return NodeProcessResult.builder().content(result).build(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/answer/LLMAnswerNode.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/answer/LLMAnswerNode.java new file mode 100644 index 00000000..a9826112 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/answer/LLMAnswerNode.java @@ -0,0 +1,52 @@ +package org.ruoyi.workflow.workflow.node.answer; + +import dev.langchain4j.data.message.UserMessage; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.entity.WorkflowNode; +import org.ruoyi.workflow.util.SpringUtil; +import org.ruoyi.workflow.workflow.NodeProcessResult; +import org.ruoyi.workflow.workflow.WfNodeState; +import org.ruoyi.workflow.workflow.WfState; +import org.ruoyi.workflow.workflow.WorkflowUtil; +import org.ruoyi.workflow.workflow.node.AbstractWfNode; + +import java.util.List; + +/** + * 【节点】LLM生成回答
+ * 节点内容固定格式：LLMAnswerNodeConfig + */ +@Slf4j +public class LLMAnswerNode extends AbstractWfNode { + + public LLMAnswerNode(WorkflowComponent wfComponent, WorkflowNode nodeDef, WfState wfState, WfNodeState nodeState) { + super(wfComponent, nodeDef, wfState, nodeState); + } + + /** + * nodeConfig格式：
+ * {"prompt": "将以下内容翻译成英文：{input}","model_platform":"deepseek","model_name":"deepseek-chat"}
+ * + * @return LLM的返回内容 + */ + @Override + public NodeProcessResult onProcess() { + LLMAnswerNodeConfig nodeConfigObj = checkAndGetConfig(LLMAnswerNodeConfig.class); + String inputText = getFirstInputText(); + log.info("LLM answer node config:{}", nodeConfigObj); + String prompt = inputText; + if (StringUtils.isNotBlank(nodeConfigObj.getPrompt())) { + prompt = WorkflowUtil.renderTemplate(nodeConfigObj.getPrompt(), state.getInputs()); + } + log.info("LLM prompt:{}", prompt); + // 调用LLM + WorkflowUtil workflowUtil = SpringUtil.getBean(WorkflowUtil.class); + String modelName = nodeConfigObj.getModelName(); + String category = nodeConfigObj.getCategory(); + List systemMessage = List.of(UserMessage.from(prompt)); + workflowUtil.streamingInvokeLLM(wfState, state, node, category, modelName, systemMessage); + return new NodeProcessResult(); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/answer/LLMAnswerNodeConfig.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/answer/LLMAnswerNodeConfig.java new file mode 100644 index 00000000..fc90009f --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/answer/LLMAnswerNodeConfig.java @@ -0,0 +1,26 @@ +package org.ruoyi.workflow.workflow.node.answer; + +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode +@Data +public class LLMAnswerNodeConfig { + @NotBlank + private String prompt; + + /** + * TODO + */ + // @NotBlank + private String category; + + @NotNull + @JsonProperty("model_name") + private String modelName; + + private Boolean streaming; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/classifier/ClassifierNodeConfig.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/classifier/ClassifierNodeConfig.java new file mode 100644 index 00000000..a9432175 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/classifier/ClassifierNodeConfig.java @@ -0,0 +1,16 @@ +package org.ruoyi.workflow.workflow.node.classifier; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Data; + +import java.util.ArrayList; +import java.util.List; + +@Data +public class ClassifierNodeConfig { + private List categories = new ArrayList<>(); + @JsonProperty("model_platform") + private String modelPlatform; + @JsonProperty("model_name") + private String modelName; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/start/StartNode.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/start/StartNode.java new file mode 100644 index 00000000..6f5df29e --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/start/StartNode.java @@ -0,0 +1,49 @@ +package org.ruoyi.workflow.workflow.node.start; + +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.ruoyi.common.core.exception.base.BaseException; +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.entity.WorkflowNode; +import org.ruoyi.workflow.util.JsonUtil; +import org.ruoyi.workflow.workflow.NodeProcessResult; +import org.ruoyi.workflow.workflow.WfNodeIODataUtil; +import org.ruoyi.workflow.workflow.WfNodeState; +import org.ruoyi.workflow.workflow.WfState; +import org.ruoyi.workflow.workflow.data.NodeIOData; +import org.ruoyi.workflow.workflow.node.AbstractWfNode; + +import java.util.List; + +import static org.ruoyi.workflow.cosntant.AdiConstant.WorkflowConstant.DEFAULT_OUTPUT_PARAM_NAME; +import static org.ruoyi.workflow.enums.ErrorEnum.A_WF_NODE_CONFIG_ERROR; +import static org.ruoyi.workflow.enums.ErrorEnum.A_WF_NODE_CONFIG_NOT_FOUND; + +@Slf4j +public class StartNode extends AbstractWfNode { + + public StartNode(WorkflowComponent wfComponent, WorkflowNode nodeDef, WfState wfState, WfNodeState nodeState) { + super(wfComponent, nodeDef, wfState, nodeState); + } + + @Override + public NodeProcessResult onProcess() { + String objectConfig = node.getNodeConfig(); + if (null == objectConfig) { + throw new BaseException(A_WF_NODE_CONFIG_NOT_FOUND.getInfo()); + } + List result; + StartNodeConfig nodeConfigObj = JsonUtil.fromJson(objectConfig, StartNodeConfig.class); + if (null == nodeConfigObj) { + log.warn("找不到开始节点的配置"); + throw new BaseException(A_WF_NODE_CONFIG_ERROR.getInfo()); + } + if (StringUtils.isNotBlank(nodeConfigObj.getPrologue())) { + result = List.of(NodeIOData.createByText(DEFAULT_OUTPUT_PARAM_NAME, "default", nodeConfigObj.getPrologue())); + } else { + result = WfNodeIODataUtil.changeInputsToOutputs(state.getInputs()); + } + return NodeProcessResult.builder().content(result).build(); + } + +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/start/StartNodeConfig.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/start/StartNodeConfig.java new file mode 100644 index 00000000..86de0fb1 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/start/StartNodeConfig.java @@ -0,0 +1,10 @@ +package org.ruoyi.workflow.workflow.node.start; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode +@Data +public class StartNodeConfig { + private String prologue; +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/LogicOperatorEnum.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/LogicOperatorEnum.java new file mode 100644 index 00000000..079e9a20 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/LogicOperatorEnum.java @@ -0,0 +1,17 @@ +package org.ruoyi.workflow.workflow.node.switcher; + +public enum LogicOperatorEnum { + AND("and"), + + OR("or"); + + private final String name; + + LogicOperatorEnum(String name) { + this.name = name; + } + + public String getName() { + return name; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/OperatorEnum.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/OperatorEnum.java new file mode 100644 index 00000000..1e84e4c1 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/OperatorEnum.java @@ -0,0 +1,45 @@ +package org.ruoyi.workflow.workflow.node.switcher; + +import lombok.Getter; + +import java.util.Arrays; + +@Getter +public enum OperatorEnum { + CONTAINS("contains", "包含"), + + NOT_CONTAINS("not contains", "不包含"), + + START_WITH("start with", "开始内容是"), + + END_WITH("end with", "结束内容是"), + + EMPTY("empty", "为空"), + + NOT_EMPTY("not empty", "不为空"), + + EQUAL("=", "等于"), + + NOT_EQUAL("!=", "不等于"), + + GREATER(">", "大于"), + + GREATER_OR_EQUAL(">=", "大于或等于"), + + LESS("<", "小于"), + + LESS_OR_EQUAL("<=", "小于或等于"); + + private final String name; + + private final String desc; + + OperatorEnum(String name, String desc) { + this.name = name; + this.desc = desc; + } + + public static OperatorEnum getByName(String name) { + return Arrays.stream(OperatorEnum.values()).filter(item -> item.name.equals(name)).findFirst().orElse(null); + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/SwitcherCase.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/SwitcherCase.java new file mode 100644 index 00000000..fc35c377 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/SwitcherCase.java @@ -0,0 +1,27 @@ +package org.ruoyi.workflow.workflow.node.switcher; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Data; + +import java.util.List; + +@Data +public class SwitcherCase { + + private String uuid; + private String operator; + private List conditions; + @JsonProperty("target_node_uuid") + private String targetNodeUuid; + + @Data + public static class Condition { + private String uuid; + @JsonProperty("node_uuid") + private String nodeUuid; + @JsonProperty("node_param_name") + private String nodeParamName; + private String operator; + private String value; + } +} diff --git a/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/SwitcherNodeConfig.java b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/SwitcherNodeConfig.java new file mode 100644 index 00000000..40cf2f18 --- /dev/null +++ b/ruoyi-modules-api/ruoyi-workflow-api/src/main/java/org/ruoyi/workflow/workflow/node/switcher/SwitcherNodeConfig.java @@ -0,0 +1,14 @@ +package org.ruoyi.workflow.workflow.node.switcher; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Data; + +import java.util.List; + +@Data +public class SwitcherNodeConfig { + + private List cases; + @JsonProperty("default_target_node_uuid") + private String defaultTargetNodeUuid; +} diff --git a/ruoyi-modules/pom.xml b/ruoyi-modules/pom.xml index 50e9056b..a520b5bf 100644 --- a/ruoyi-modules/pom.xml +++ b/ruoyi-modules/pom.xml @@ -22,10 +22,9 @@ ruoyi-system ruoyi-generator ruoyi-wechat - ruoyi-aihuman - + ruoyi-workflow diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/IChatService.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/IChatService.java index 55ea2ac8..fe9861ab 100644 --- a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/IChatService.java +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/IChatService.java @@ -1,8 +1,16 @@ package org.ruoyi.chat.service.chat; +import dev.langchain4j.data.message.AiMessage; +import dev.langchain4j.data.message.ChatMessage; +import dev.langchain4j.data.message.SystemMessage; +import dev.langchain4j.data.message.UserMessage; +import dev.langchain4j.model.chat.response.StreamingChatResponseHandler; import org.ruoyi.common.chat.request.ChatRequest; import org.springframework.web.servlet.mvc.method.annotation.SseEmitter; +import java.util.ArrayList; +import java.util.List; + /** * 对话Service接口 * @@ -13,9 +21,36 @@ public interface IChatService { /** * 客户端发送消息到服务端 + * * @param chatRequest 请求对象 */ - SseEmitter chat(ChatRequest chatRequest,SseEmitter emitter); + SseEmitter chat(ChatRequest chatRequest, SseEmitter emitter); + + /** + * 工作流场景：支持 langchain4j 的 StreamingChatResponseHandler + * + * @param chatRequest ruoyi-ai 的请求对象 + * @param handler langchain4j 的流式响应处理器 + */ + default void chat(ChatRequest chatRequest, StreamingChatResponseHandler handler) { + throw new UnsupportedOperationException("此服务暂不支持工作流场景"); + } + + default dev.langchain4j.model.chat.request.ChatRequest convertToLangchainRequest(ChatRequest request) { + List messages = new ArrayList<>(); + for (org.ruoyi.common.chat.entity.chat.Message msg : request.getMessages()) { + // 简单转换，您可以根据实际需求调整 + if ("user".equals(msg.getRole())) { + messages.add(UserMessage.from(msg.getContent().toString())); + } else if ("system".equals(msg.getRole())) { + messages.add(SystemMessage.from(msg.getContent().toString())); + } else if ("assistant".equals(msg.getRole())) { + messages.add(AiMessage.from(msg.getContent().toString())); + } + } + return dev.langchain4j.model.chat.request.ChatRequest.builder().messages(messages).build(); + } + /** * 获取此服务支持的模型类别 */ diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/impl/DeepSeekChatImpl.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/impl/DeepSeekChatImpl.java index 703c17ff..003455ec 100644 --- a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/impl/DeepSeekChatImpl.java +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/impl/DeepSeekChatImpl.java @@ -1,6 +1,10 @@ package org.ruoyi.chat.service.chat.impl; +import dev.langchain4j.data.message.ChatMessage; +import dev.langchain4j.data.message.SystemMessage; +import dev.langchain4j.data.message.UserMessage; +import dev.langchain4j.data.message.AiMessage; import dev.langchain4j.data.message.ChatMessage; import dev.langchain4j.data.message.SystemMessage; import dev.langchain4j.data.message.UserMessage; @@ -34,6 +38,9 @@ import java.io.BufferedReader; import java.io.InputStreamReader; import com.fasterxml.jackson.databind.ObjectMapper; + +import java.util.ArrayList; +import java.util.List; /** * deepseek */ @@ -74,7 +81,7 @@ public class DeepSeekChatImpl implements IChatService { try { // 构建消息列表，包含历史对话消息和当前用户消息 List messages = new ArrayList<>(); - + // 添加历史对话消息 if (chatRequest.getMessages() != null) { for (Message message : chatRequest.getMessages()) { @@ -82,7 +89,7 @@ public class DeepSeekChatImpl implements IChatService { if (message.getContent() == null || String.valueOf(message.getContent()).trim().isEmpty()) { continue; // 跳过空消息 } - + if (Message.Role.SYSTEM.getName().equals(message.getRole())) { messages.add(new SystemMessage(String.valueOf(message.getContent()))); } else if (Message.Role.USER.getName().equals(message.getRole())) { @@ -92,7 +99,7 @@ public class DeepSeekChatImpl implements IChatService { } } } - + // 添加当前用户消息 messages.add(new UserMessage(chatRequest.getPrompt())); @@ -127,6 +134,34 @@ public class DeepSeekChatImpl implements IChatService { return emitter; } + /** + * 工作流场景：支持 langchain4j handler + */ + @Override + public void chat(ChatRequest request, StreamingChatResponseHandler handler) { + log.info("workflow chat, model: {}", request.getModel()); + + ChatModelVo chatModelVo = chatModelService.selectModelByName(request.getModel()); + + StreamingChatModel chatModel = OpenAiStreamingChatModel.builder() + .baseUrl(chatModelVo.getApiHost()) + .apiKey(chatModelVo.getApiKey()) + .modelName(chatModelVo.getModelName()) + .logRequests(true) + .logResponses(true) + .temperature(0.7) + .build(); + + try { + // 将 ruoyi-ai 的 ChatRequest 转换为 langchain4j 的格式 + dev.langchain4j.model.chat.request.ChatRequest chatRequest = convertToLangchainRequest(request); + chatModel.chat(chatRequest, handler); + } catch (Exception e) { + log.error("workflow deepseek请求失败：{}", e.getMessage(), e); + throw new RuntimeException("DeepSeek workflow chat failed: " + e.getMessage(), e); + } + } + /** * 处理启用深度思考的deepseek模型请求 */ @@ -157,13 +192,13 @@ public class DeepSeekChatImpl implements IChatService { if (message.getContent() == null || String.valueOf(message.getContent()).trim().isEmpty()) { continue; // 跳过空消息 } - + // DeepSeek模型在深度思考模式下只接受user和assistant角色的消息 if (Message.Role.SYSTEM.getName().equals(message.getRole())) { // 跳过系统消息 continue; } - + Map historyMessage = new HashMap<>(); historyMessage.put("role", message.getRole()); historyMessage.put("content", String.valueOf(message.getContent())); diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/impl/QianWenAiChatServiceImpl.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/impl/QianWenAiChatServiceImpl.java index 4128b84a..8175c47d 100644 --- a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/impl/QianWenAiChatServiceImpl.java +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/chat/service/chat/impl/QianWenAiChatServiceImpl.java @@ -8,13 +8,13 @@ import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import org.ruoyi.chat.enums.ChatModeType; import org.ruoyi.chat.service.chat.IChatService; +import org.ruoyi.chat.support.ChatServiceHelper; import org.ruoyi.common.chat.request.ChatRequest; import org.ruoyi.domain.vo.ChatModelVo; import org.ruoyi.service.IChatModelService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.web.servlet.mvc.method.annotation.SseEmitter; -import org.ruoyi.chat.support.ChatServiceHelper; /** @@ -22,7 +22,7 @@ import org.ruoyi.chat.support.ChatServiceHelper; */ @Service @Slf4j -public class QianWenAiChatServiceImpl implements IChatService { +public class QianWenAiChatServiceImpl implements IChatService { @Autowired private IChatModelService chatModelService; @@ -37,7 +37,6 @@ public class QianWenAiChatServiceImpl implements IChatService { .build(); - // 发送流式消息 try { model.chat(chatRequest.getPrompt(), new StreamingChatResponseHandler() { @@ -70,11 +69,34 @@ public class QianWenAiChatServiceImpl implements IChatService { } + /** + * 工作流场景：支持 langchain4j handler + */ + @Override + public void chat(ChatRequest request, StreamingChatResponseHandler handler) { + log.info("workflow chat, model: {}", request.getModel()); + + ChatModelVo chatModelVo = chatModelService.selectModelByName(request.getModel()); + + StreamingChatModel model = QwenStreamingChatModel.builder() + .apiKey(chatModelVo.getApiKey()) + .modelName(chatModelVo.getModelName()) + .build(); + + try { + // 将 ruoyi-ai 的 ChatRequest 转换为 langchain4j 的格式 + dev.langchain4j.model.chat.request.ChatRequest chatRequest = convertToLangchainRequest(request); + model.chat(chatRequest, handler); + } catch (Exception e) { + log.error("workflow 千问请求失败：{}", e.getMessage(), e); + throw new RuntimeException("QianWen workflow chat failed: " + e.getMessage(), e); + } + } + @Override public String getCategory() { return ChatModeType.QIANWEN.getCode(); } - } diff --git a/ruoyi-modules/ruoyi-workflow/pom.xml b/ruoyi-modules/ruoyi-workflow/pom.xml new file mode 100644 index 00000000..51c23ed1 --- /dev/null +++ b/ruoyi-modules/ruoyi-workflow/pom.xml @@ -0,0 +1,84 @@ + + + 4.0.0 + + org.ruoyi + ruoyi-modules + ${revision} + ../pom.xml + + + ruoyi-workflow + + + 工作流模块 + + + + 17 + 17 + UTF-8 + + + + + org.ruoyi + ruoyi-workflow-api + + + + org.ruoyi + ruoyi-system-api + + + + org.springframework.boot + spring-boot-starter-data-redis + + + + com.github.xiaoymin + knife4j-openapi3-jakarta-spring-boot-starter + 4.4.0 + + + + org.springdoc + springdoc-openapi-starter-webmvc-ui + ${springdoc.version} + + + + org.springframework.boot + spring-boot-configuration-processor + true + + + + org.projectlombok + lombok + true + + + + jakarta.servlet + jakarta.servlet-api + + + + com.talanlabs + avatar-generator + 1.1.0 + + + + com.talanlabs + avatar-generator-cat + 1.1.0 + + + + + \ No newline at end of file diff --git a/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/WorkflowController.java b/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/WorkflowController.java new file mode 100644 index 00000000..02fd3c96 --- /dev/null +++ b/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/WorkflowController.java @@ -0,0 +1,114 @@ +package org.ruoyi.workflow.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import io.swagger.v3.oas.annotations.Operation; +import jakarta.annotation.Resource; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import org.ruoyi.common.core.domain.R; +import org.ruoyi.workflow.base.ThreadContext; +import org.ruoyi.workflow.dto.workflow.*; +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.service.WorkflowComponentService; +import org.ruoyi.workflow.service.WorkflowService; +import org.ruoyi.workflow.workflow.WorkflowStarter; +import org.ruoyi.workflow.workflow.node.switcher.OperatorEnum; +import org.springframework.http.MediaType; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; +import org.springframework.web.servlet.mvc.method.annotation.SseEmitter; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +@RestController +@RequestMapping("/workflow") +@Validated +public class WorkflowController { + + @Resource + private WorkflowStarter workflowStarter; + + @Resource + private WorkflowService workflowService; + + @Resource + private WorkflowComponentService workflowComponentService; + + @PostMapping("/add") + public R add(@RequestBody @Validated WfAddReq addReq) { + return R.ok(workflowService.add(addReq.getTitle(), addReq.getRemark(), addReq.getIsPublic())); + } + + @PostMapping("/set-public/{wfUuid}") + public R setPublic(@PathVariable String wfUuid, @RequestParam(defaultValue = "true") Boolean isPublic) { + workflowService.setPublic(wfUuid, isPublic); + return R.ok(); + } + + @PostMapping("/update") + public R update(@RequestBody @Validated WorkflowUpdateReq req) { + return R.ok(workflowService.update(req)); + } + + @PostMapping("/del/{uuid}") + public R delete(@PathVariable String uuid) { + workflowService.softDelete(uuid); + return R.ok(); + } + + @PostMapping("/enable/{uuid}") + public R enable(@PathVariable String uuid, @RequestParam Boolean enable) { + workflowService.enable(uuid, enable); + return R.ok(); + } + + @PostMapping("/base-info/update") + public R updateBaseInfo(@RequestBody @Validated WfBaseInfoUpdateReq req) { + return R.ok(workflowService.updateBaseInfo(req.getUuid(), req.getTitle(), req.getRemark(), req.getIsPublic())); + } + + @Operation(summary = "流式响应") + @PostMapping(value = "/run", produces = MediaType.TEXT_EVENT_STREAM_VALUE) + public SseEmitter sseAsk(@RequestBody WorkflowRunReq runReq) { + return workflowStarter.streaming(ThreadContext.getCurrentUser(), runReq.getUuid(), runReq.getInputs()); + } + + @GetMapping("/mine/search") + public R> searchMine(@RequestParam(defaultValue = "") String keyword, + @RequestParam(required = false) Boolean isPublic, + @NotNull @Min(1) Integer currentPage, + @NotNull @Min(10) Integer pageSize) { + return R.ok(workflowService.search(keyword, isPublic, null, currentPage, pageSize)); + } + + /** + * 搜索公开工作流 + * + * @param keyword 搜索关键词 + * @param currentPage 当前页数 + * @param pageSize 每页数量 + * @return 工作流列表 + */ + @GetMapping("/public/search") + public R> searchPublic(@RequestParam(defaultValue = "") String keyword, + @NotNull @Min(1) Integer currentPage, + @NotNull @Min(10) Integer pageSize) { + return R.ok(workflowService.searchPublic(keyword, currentPage, pageSize)); + } + + @GetMapping("/public/operators") + public R>> searchPublic() { + List> result = new ArrayList<>(); + for (OperatorEnum operator : OperatorEnum.values()) { + result.add(Map.of("name", operator.getName(), "desc", operator.getDesc())); + } + return R.ok(result); + } + + @GetMapping("/public/component/list") + public R> component() { + return R.ok(workflowComponentService.getAllEnable()); + } +} diff --git a/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/WorkflowRuntimeController.java b/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/WorkflowRuntimeController.java new file mode 100644 index 00000000..34fc0065 --- /dev/null +++ b/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/WorkflowRuntimeController.java @@ -0,0 +1,58 @@ +package org.ruoyi.workflow.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import io.swagger.v3.oas.annotations.Operation; +import jakarta.annotation.Resource; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import org.ruoyi.common.core.domain.R; +import org.ruoyi.workflow.dto.workflow.WfRuntimeNodeDto; +import org.ruoyi.workflow.dto.workflow.WfRuntimeResp; +import org.ruoyi.workflow.dto.workflow.WorkflowResumeReq; +import org.ruoyi.workflow.service.WorkflowRuntimeService; +import org.ruoyi.workflow.workflow.WorkflowStarter; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@RestController +@RequestMapping("/workflow/runtime") +@Validated +public class WorkflowRuntimeController { + + @Resource + private WorkflowRuntimeService workflowRuntimeService; + + @Resource + private WorkflowStarter workflowStarter; + + @Operation(summary = "接收用户输入以继续执行剩余流程") + @PostMapping(value = "/resume/{runtimeUuid}") + public R resume(@PathVariable String runtimeUuid, @RequestBody WorkflowResumeReq resumeReq) { + workflowStarter.resumeFlow(runtimeUuid, resumeReq.getFeedbackContent()); + return R.ok(); + } + + @GetMapping("/page") + public R> search(@RequestParam String wfUuid, + @NotNull @Min(1) Integer currentPage, + @NotNull @Min(10) Integer pageSize) { + return R.ok(workflowRuntimeService.page(wfUuid, currentPage, pageSize)); + } + + @GetMapping("/nodes/{runtimeUuid}") + public R> listByRuntimeId(@PathVariable String runtimeUuid) { + return R.ok(workflowRuntimeService.listByRuntimeUuid(runtimeUuid)); + } + + @PostMapping("/clear") + public R clear(@RequestParam(defaultValue = "") String wfUuid) { + return R.ok(workflowRuntimeService.deleteAll(wfUuid)); + } + + @PostMapping("/del/{wfRuntimeUuid}") + public R delete(@PathVariable String wfRuntimeUuid) { + return R.ok(workflowRuntimeService.softDelete(wfRuntimeUuid)); + } +} diff --git a/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/admin/AdminWorkflowComponentController.java b/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/admin/AdminWorkflowComponentController.java new file mode 100644 index 00000000..7e1d8c71 --- /dev/null +++ b/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/admin/AdminWorkflowComponentController.java @@ -0,0 +1,45 @@ +package org.ruoyi.workflow.controller.admin; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import jakarta.annotation.Resource; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import org.ruoyi.common.core.domain.R; +import org.ruoyi.workflow.dto.workflow.WfComponentReq; +import org.ruoyi.workflow.dto.workflow.WfComponentSearchReq; +import org.ruoyi.workflow.entity.WorkflowComponent; +import org.ruoyi.workflow.service.WorkflowComponentService; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +@RestController +@RequestMapping("/admin/workflow/component") +@Validated +public class AdminWorkflowComponentController { + @Resource + private WorkflowComponentService workflowComponentService; + + @PostMapping("/search") + public R> search(@RequestBody WfComponentSearchReq searchReq, @NotNull @Min(1) Integer currentPage, @NotNull @Min(10) Integer pageSize) { + return R.ok(workflowComponentService.search(searchReq, currentPage, pageSize)); + } + + @PostMapping("/enable") + public R enable(@RequestParam String uuid, @RequestParam Boolean isEnable) { + workflowComponentService.enable(uuid, isEnable); + return R.ok(); + } + + @PostMapping("/del/{uuid}") + public R del(@PathVariable String uuid) { + workflowComponentService.deleteByUuid(uuid); + return R.ok(); + } + + + @PostMapping("/addOrUpdate") + public R addOrUpdate(@Validated @RequestBody WfComponentReq req) { + return R.ok(workflowComponentService.addOrUpdate(req)); + } + +} diff --git a/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/admin/AdminWorkflowController.java b/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/admin/AdminWorkflowController.java new file mode 100644 index 00000000..fe193d86 --- /dev/null +++ b/ruoyi-modules/ruoyi-workflow/src/main/java/org/ruoyi/workflow/controller/admin/AdminWorkflowController.java @@ -0,0 +1,35 @@ +package org.ruoyi.workflow.controller.admin; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import jakarta.annotation.Resource; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import org.ruoyi.common.core.domain.R; +import org.ruoyi.workflow.dto.workflow.WfSearchReq; +import org.ruoyi.workflow.dto.workflow.WorkflowResp; +import org.ruoyi.workflow.service.WorkflowService; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +@RestController +@RequestMapping("/admin/workflow") +@Validated +public class AdminWorkflowController { + + @Resource + private WorkflowService workflowService; + + @PostMapping("/search") + public R> search(@RequestBody WfSearchReq req, + @RequestParam @NotNull @Min(1) Integer currentPage, + @RequestParam @NotNull @Min(10) Integer pageSize) { + return R.ok(workflowService.search(req.getTitle(), req.getIsPublic(), + req.getIsEnable(), currentPage, pageSize)); + } + + @PostMapping("/enable") + public R enable(@RequestParam String uuid, @RequestParam Boolean isEnable) { + workflowService.enable(uuid, isEnable); + return R.ok(); + } +} diff --git a/script/sql/update/2025-09-30-work-flow.sql b/script/sql/update/2025-09-30-work-flow.sql new file mode 100644 index 00000000..59538259 --- /dev/null +++ b/script/sql/update/2025-09-30-work-flow.sql @@ -0,0 +1,162 @@ +CREATE TABLE t_workflow +( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) NOT NULL DEFAULT '', + title VARCHAR(100) NOT NULL DEFAULT '', + remark TEXT NOT NULL DEFAULT '', + user_id BIGINT NOT NULL DEFAULT 0, + is_public TINYINT(1) NOT NULL DEFAULT 0, + is_enable TINYINT(1) NOT NULL DEFAULT 1, + create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, + update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + is_deleted TINYINT(1) NOT NULL DEFAULT 0 +) ENGINE = InnoDB + DEFAULT CHARSET = utf8mb4 + COMMENT ='工作流定义（用户定义的工作流）| Workflow Definition'; + + +CREATE TABLE t_workflow_node +( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) NOT NULL DEFAULT '', + workflow_id BIGINT NOT NULL DEFAULT 0, + workflow_component_id BIGINT NOT NULL DEFAULT 0, + user_id BIGINT NOT NULL DEFAULT 0, + title VARCHAR(100) NOT NULL DEFAULT '', + remark VARCHAR(500) NOT NULL DEFAULT '', + input_config JSON NOT NULL DEFAULT ('{}'), + node_config JSON NOT NULL DEFAULT ('{}'), + position_x DOUBLE NOT NULL DEFAULT 0, + position_y DOUBLE NOT NULL DEFAULT 0, + create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, + update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + is_deleted TINYINT(1) NOT NULL DEFAULT 0, + INDEX idx_workflow_node_workflow_id (workflow_id) +) ENGINE = InnoDB + DEFAULT CHARSET = utf8mb4 + COMMENT ='工作流定义的节点 | Node of Workflow Definition'; + + +CREATE TABLE t_workflow_edge +( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) NOT NULL DEFAULT '', + workflow_id BIGINT NOT NULL DEFAULT 0, + source_node_uuid VARCHAR(32) NOT NULL DEFAULT '', + source_handle VARCHAR(32) NOT NULL DEFAULT '', + target_node_uuid VARCHAR(32) NOT NULL DEFAULT '', + create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, + update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + is_deleted TINYINT(1) NOT NULL DEFAULT 0, + INDEX idx_workflow_edge_workflow_id (workflow_id) +) ENGINE = InnoDB + DEFAULT CHARSET = utf8mb4; + + +CREATE TABLE t_workflow_runtime +( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) NOT NULL DEFAULT '', + user_id BIGINT NOT NULL DEFAULT 0, + workflow_id BIGINT NOT NULL DEFAULT 0, + input JSON NOT NULL DEFAULT ('{}'), + output JSON NOT NULL DEFAULT ('{}'), + status SMALLINT NOT NULL DEFAULT 1 COMMENT '执行状态，1：就绪，2：执行中，3：成功，4：失败', + status_remark VARCHAR(250) NOT NULL DEFAULT '' COMMENT '状态备注', + create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, + update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + is_deleted TINYINT(1) NOT NULL DEFAULT 0, + INDEX idx_workflow_runtime_workflow_id (workflow_id), + INDEX idx_workflow_runtime_user_id (user_id) +) ENGINE = InnoDB + DEFAULT CHARSET = utf8mb4 + COMMENT ='工作流实例（运行时）| Workflow Runtime'; + + +CREATE TABLE t_workflow_runtime_node +( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) NOT NULL DEFAULT '', + user_id BIGINT NOT NULL DEFAULT 0, + workflow_runtime_id BIGINT NOT NULL DEFAULT 0, + node_id BIGINT NOT NULL DEFAULT 0, + input JSON NOT NULL DEFAULT ('{}'), + output JSON NOT NULL DEFAULT ('{}'), + status SMALLINT NOT NULL DEFAULT 1 COMMENT '执行状态，1：进行中，2：失败，3：成功', + status_remark VARCHAR(250) NOT NULL DEFAULT '' COMMENT '状态备注', + create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, + update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + is_deleted TINYINT(1) NOT NULL DEFAULT 0, + INDEX idx_runtime_node_runtime_id (workflow_runtime_id), + INDEX idx_runtime_node_node_id (node_id) +) ENGINE = InnoDB + DEFAULT CHARSET = utf8mb4 + COMMENT ='工作流实例（运行时）- 节点 | Workflow Runtime Node'; + + +CREATE TABLE t_workflow_component +( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + uuid VARCHAR(32) DEFAULT '' NOT NULL, + name VARCHAR(32) DEFAULT '' NOT NULL, + title VARCHAR(100) DEFAULT '' NOT NULL, + remark TEXT NOT NULL, + display_order INT DEFAULT 0 NOT NULL, + is_enable TINYINT(1) DEFAULT 0 NOT NULL, + create_time DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL, + update_time DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL, + is_deleted TINYINT(1) DEFAULT 0 NOT NULL, + INDEX idx_display_order (display_order) +) ENGINE = InnoDB + DEFAULT CHARSET = utf8mb4 + COMMENT '工作流组件库 | Workflow Component'; + + +-- workflow +-- 如果不定义输入的变量名，则默认设置为input +-- 如果不定义输出的变量名，则默认设置为output +insert into t_workflow_component(uuid, name, title, remark, is_enable) +values (replace(uuid(), '-', ''), 'Start', '开始', '流程由此开始', true); +insert into t_workflow_component(uuid, name, title, remark, is_enable) +values (replace(uuid(), '-', ''), 'End', '结束', '流程由此结束', true); +insert into t_workflow_component(uuid, name, title, remark, is_enable) +values (replace(uuid(), '-', ''), 'Answer', '生成回答', '调用大语言模型回答问题', true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'Dalle3', 'DALL-E 3 画图', '调用Dall-e-3生成图片', 11, true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'DocumentExtractor', '文档提取', '从文档中提取信息', 4, true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'KeywordExtractor', '关键词提取', + '从内容中提取关键词，Top N指定需要提取的关键词数量', 5, true); +insert into t_workflow_component(uuid, name, title, remark, is_enable) +values (replace(uuid(), '-', ''), 'KnowledgeRetrieval', '知识检索', '从知识库中检索信息，需选中知识库', + true); +insert into t_workflow_component(uuid, name, title, remark, is_enable) +values (replace(uuid(), '-', ''), 'Switcher', '条件分支', '根据设置的条件引导执行不同的流程', true); +insert into t_workflow_component(uuid, name, title, remark, is_enable) +values (replace(uuid(), '-', ''), 'Classifier', '内容归类', + '使用大语言模型对输入信息进行分析并归类，根据类别调用对应的下游节点', true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'Template', '模板转换', + '将多个变量合并成一个输出内容', 10, true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'Google', 'Google搜索', '从Google中检索信息', 13, true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'FaqExtractor', '常见问题提取', + '从内容中提取出常见问题及对应的答案，Top N为提取的数量', + 6, true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'Tongyiwanx', '通义万相-画图', '调用文生图模型生成图片', 12, true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'HumanFeedback', '人机交互', + '中断执行中的流程并等待用户的输入，用户输入后继续执行后续流程', 10, true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'MailSend', '邮件发送', '发送邮件到指定邮箱', 10, true); +insert into t_workflow_component(uuid, name, title, remark, display_order, is_enable) +values (replace(uuid(), '-', ''), 'HttpRequest', 'Http请求', + '通过Http协议发送请求，可将其他组件的输出作为参数，也可设置常量作为参数。', 10, true); + + +INSERT INTO sys_menu (menu_id, menu_name, parent_id, order_num, path, component, query_param, is_frame, is_cache, menu_type, visible, status, perms, icon, create_dept, create_by, create_time, update_by, update_time, remark) VALUES (1976160997656043521, '流程管理', 0, 1, 'flow', '', null, 1, 0, 'M', '0', '0', null, 'ph:user-fill', null, null, '2025-10-09 13:41:12', 1, '2025-10-20 20:59:25', ''); +INSERT INTO sys_menu (menu_id, menu_name, parent_id, order_num, path, component, query_param, is_frame, is_cache, menu_type, visible, status, perms, icon, create_dept, create_by, create_time, update_by, update_time, remark) VALUES (1976161221409579010, '工作流编排', 1976160997656043521, 0, 'workflow', 'workflow/index', null, 1, 0, 'C', '0', '0', null, 'ph:user-fill', null, null, '2025-10-09 13:42:05', 1, '2025-10-20 20:59:16', ''); +