feat(workflow): 补齐 workFlow 族 104 条端点并同步契约三处

- 影响:面 B 新增 104 条 `/api/workflow/**` 端点(契约端点 610 → 714),官方端点覆盖 596/602 → 700/706,`fe-gap` 的 `workFlow` 列 0/104 → 104/104。
- 改动:新增 `platform/compat/workflow.rs` —— 真实现 62 条(流程模板/版本/节点/任务/评论/委托/监控读),诚实失败 42 条(引擎动作 27 + 无文件服务 2 + 无在线表单设计器 13)。
- 改动:新增 24 张 `workflow_*` 表(官方 DDL 逐字导入),登记为 `WORKFLOW_TABLES` 固定装置,不导 Flowable 的 `act_*` 引擎表。
- 改动:契约生成器新增 workflow 族(控制器映射 / 官方前端独有路径 / 引擎·文件·表单三类 partial),`[ENDPOINT]` +104、`[OFFICIAL]` +104。
- 改动:修 pglite 参数类型推断坑(`$N::integer` → `$N::text::integer`),workflow 21 处、report 3 处潜伏 bug。
- 设计:官方流程引擎是独立 HTTP 服务(`FlowAbleUrl`)⇒ 动作类端点一律明确业务失败,不返假流程号、不返假 URL。

Co-Authored-By: Claude Code <[email protected]>
This commit is contained in:
adminandClaude Code committed 2026-11-02 19:42:12 +08:00
1 parent 1c224b7b79
commit 4ffd1e0ccb
12 files changed
+6561 -29

No files matched your search

+561
View File
@@ -3066,3 +3066,564 @@ CREATE TABLE report_version (
f_fence_list TEXT,
PRIMARY KEY (f_id, f_tenant_id)
);
-- ============================================================
-- 流程(workflow)元数据表 —— 官方 `jnpf-database` 的 `workflow_*` 24 张
-- 真源:`PostgreSQL/JNPF-PostgreSQL.sql` 的 workflow_* 段(逐字导入)。
-- 用途:官方 `/api/workflow/**` 契约面的**流程定义 / 任务 / 经办 / 委托 /
-- 评论 / 触发器** 元数据落库载体(与 `report_template` 同性质:
-- 契约面的固定装置,不是业务表)。
-- 🔴 Flowable 引擎表(`act_*`)**不导入** ⇒ 引擎相关动作一律「诚实失败」。
-- ============================================================
CREATE TABLE workflow_candidates (
f_id VARCHAR(50) NOT NULL,
f_node_code VARCHAR(50),
f_task_id VARCHAR(50),
f_handle_id VARCHAR(50),
f_account VARCHAR(50),
f_candidates TEXT,
f_operator_id VARCHAR(50),
f_type INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_circulate (
f_id VARCHAR(50) NOT NULL,
f_user_id VARCHAR(50),
f_task_id VARCHAR(50),
f_node_code VARCHAR(50),
f_node_name VARCHAR(50),
f_node_id VARCHAR(50),
f_operator_id VARCHAR(50),
f_read INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_comment (
f_id VARCHAR(50) NOT NULL,
f_task_id VARCHAR(50),
f_reply_id VARCHAR(50),
f_text TEXT,
f_image TEXT,
f_file TEXT,
f_delete_show INTEGER,
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_common (
f_id VARCHAR(50) NOT NULL,
f_type VARCHAR(50),
f_flow_id VARCHAR(50),
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_sort_code BIGINT,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_delegate (
f_id VARCHAR(50) NOT NULL,
f_flow_id VARCHAR(4000),
f_flow_name VARCHAR(4000),
f_start_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_end_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_user_id VARCHAR(50),
f_user_name VARCHAR(50),
f_type INTEGER,
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_delegate_info (
f_id VARCHAR(50) NOT NULL,
f_delegate_id VARCHAR(50) NOT NULL,
f_to_user_id VARCHAR(50),
f_to_user_name VARCHAR(50),
f_status INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_event_log (
f_id VARCHAR(50) NOT NULL,
f_task_id VARCHAR(50),
f_node_id VARCHAR(50),
f_node_name VARCHAR(50),
f_node_code VARCHAR(50),
f_type VARCHAR(50),
f_up_node VARCHAR(50),
f_interface_id VARCHAR(50),
f_data TEXT,
f_result TEXT,
f_status INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50),
PRIMARY KEY (f_id)
);
CREATE TABLE workflow_form_relation (
f_id VARCHAR(50) NOT NULL,
f_flow_id VARCHAR(50),
f_form_id VARCHAR(50),
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_launch_user (
f_id VARCHAR(50) NOT NULL,
f_organize_id TEXT,
f_position_id TEXT,
f_manager_id TEXT,
f_superior VARCHAR(50),
f_subordinate TEXT,
f_task_id VARCHAR(50),
f_department TEXT,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
f_node_code VARCHAR(50),
f_type INTEGER,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_node (
f_id VARCHAR(50) NOT NULL,
f_flow_id VARCHAR(50),
f_form_id VARCHAR(50),
f_node_type VARCHAR(50),
f_node_code VARCHAR(50),
f_node_json TEXT,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_node_record (
f_id VARCHAR(50) NOT NULL,
f_task_id VARCHAR(50),
f_node_id VARCHAR(50),
f_node_code VARCHAR(50),
f_node_name VARCHAR(50),
f_node_status INTEGER,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
f_sort_code BIGINT,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_operator (
f_id VARCHAR(50) NOT NULL,
f_node_name VARCHAR(50),
f_node_code VARCHAR(50),
f_task_id VARCHAR(50),
f_node_id VARCHAR(50),
f_parent_id VARCHAR(50),
f_handle_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_handle_id VARCHAR(50),
f_handle_all TEXT,
f_handle_status INTEGER,
f_handle_parameter TEXT,
f_start_handle_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_duedate TIMESTAMP(0) WITHOUT TIME ZONE,
f_sign_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_status INTEGER,
f_instance_id VARCHAR(50),
f_engine_type INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
f_draft_data TEXT,
f_completion INTEGER,
f_is_processing INTEGER,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_record (
f_id VARCHAR(50) NOT NULL,
f_task_id VARCHAR(50),
f_operator_id VARCHAR(50),
f_node_id VARCHAR(2000),
f_node_code VARCHAR(2000),
f_node_name VARCHAR(2000),
f_handle_type INTEGER,
f_handle_id VARCHAR(50),
f_handle_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_handle_opinion VARCHAR(500),
f_handle_user_id VARCHAR(4000),
f_sign_img TEXT,
f_file_list TEXT,
f_status INTEGER,
f_expand_field TEXT,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_reject_data (
f_id VARCHAR(50) NOT NULL,
f_task_json TEXT,
f_operator_json TEXT,
f_node_code VARCHAR(50),
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
f_event_log_json TEXT,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_revoke (
f_id VARCHAR(50) NOT NULL,
f_task_id VARCHAR(50),
f_revoke_task_id VARCHAR(50),
f_form_data TEXT,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_subtask_data (
f_id VARCHAR(50) NOT NULL,
f_subtask_json TEXT,
f_parent_id VARCHAR(50),
f_node_code VARCHAR(50),
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_task (
f_id VARCHAR(50) NOT NULL,
f_en_code VARCHAR(200),
f_full_name VARCHAR(200),
f_flow_name VARCHAR(200),
f_flow_code VARCHAR(200),
f_flow_category VARCHAR(50),
f_status INTEGER,
f_flow_type INTEGER,
f_flow_version VARCHAR(50),
f_is_async INTEGER,
f_sub_parameter VARCHAR(2000),
f_parent_id VARCHAR(50),
f_urgent INTEGER,
f_template_id VARCHAR(50),
f_flow_id VARCHAR(50),
f_instance_id VARCHAR(255),
f_engine_type INTEGER,
f_delegate_user_id VARCHAR(50),
f_start_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_end_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_current_node_name VARCHAR(2000),
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
f_engine_id VARCHAR(50),
f_current_node_code VARCHAR(2000),
f_reject_data_id VARCHAR(50),
f_sub_code VARCHAR(50),
f_global_parameter TEXT,
f_his_status INTEGER,
f_restore INTEGER,
f_is_file INTEGER,
f_type INTEGER,
f_free_code VARCHAR(255),
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_task_line (
f_id VARCHAR(50) NOT NULL,
f_task_id VARCHAR(50),
f_line_key VARCHAR(50),
f_line_value VARCHAR(50),
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_template (
f_id VARCHAR(50) NOT NULL,
f_flow_id VARCHAR(50),
f_version VARCHAR(50),
f_en_code VARCHAR(200),
f_full_name VARCHAR(200),
f_type INTEGER,
f_category VARCHAR(50),
f_icon VARCHAR(250),
f_icon_background VARCHAR(50),
f_configuration TEXT,
f_activiti_id VARCHAR(50),
f_flowable_id VARCHAR(50),
f_camunda_id VARCHAR(50),
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
f_visible_type INTEGER,
f_flow_config TEXT,
f_show_type INTEGER,
f_status INTEGER,
f_system_id VARCHAR(50),
f_decision_type INTEGER,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_template_use_num (
f_id VARCHAR(50) NOT NULL,
f_template_id VARCHAR(50) NOT NULL,
f_user_id VARCHAR(50) NOT NULL,
f_use_num INTEGER,
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_trigger_launchflow (
f_id VARCHAR(50) NOT NULL,
f_trigger_id VARCHAR(50),
f_task_id VARCHAR(50),
f_node_id VARCHAR(50),
f_record_id VARCHAR(50),
f_node_code VARCHAR(50),
f_node_name VARCHAR(50),
f_event_model TEXT,
f_extra_data TEXT,
f_task_ids TEXT,
f_group_id VARCHAR(500),
f_ratio INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_trigger_record (
f_id VARCHAR(50) NOT NULL,
f_trigger_id VARCHAR(50),
f_task_id VARCHAR(50),
f_node_id VARCHAR(50),
f_node_code VARCHAR(50),
f_node_name VARCHAR(50),
f_start_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_end_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_status INTEGER,
f_error_tip VARCHAR(500),
f_error_data TEXT,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
f_result_data TEXT,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_trigger_task (
f_id VARCHAR(50) NOT NULL,
f_full_name VARCHAR(50),
f_parent_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_parent_id VARCHAR(50),
f_task_id VARCHAR(50),
f_node_code VARCHAR(50),
f_node_id VARCHAR(50),
f_is_async INTEGER,
f_start_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_flow_id VARCHAR(50),
f_data TEXT,
f_data_id VARCHAR(50),
f_instance_id VARCHAR(50),
f_engine_type INTEGER,
f_status INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE workflow_version (
f_id VARCHAR(50) NOT NULL,
f_template_id VARCHAR(50),
f_flowable_id VARCHAR(50),
f_activiti_id VARCHAR(50),
f_camunda_id VARCHAR(50),
f_version VARCHAR(50),
f_xml TEXT,
f_status INTEGER,
f_sort_code BIGINT,
f_send_config_ids TEXT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE INDEX IF NOT EXISTS i_wlu_ftid ON workflow_launch_user(f_task_id);
CREATE INDEX IF NOT EXISTS i_wo_fni ON workflow_operator(f_node_id);
CREATE INDEX IF NOT EXISTS i_wr_fti ON workflow_record(f_task_id);
+17
View File
@@ -844,6 +844,17 @@ fn whitelist_self_check() -> Result<(), String> {
}
}
// 🔴 契约面的固定装置表(报表元数据 / 流程元数据)同样要过白名单 ——
// 它们的表名会被拼进 SQL 文本(`platform/compat/{report,workflow}.rs`)。
for table in ssw_platform::platform::db::REPORT_TABLES
.iter()
.chain(ssw_platform::platform::db::WORKFLOW_TABLES.iter())
{
if ssw_platform::platform::db::valid_table(table).is_none() {
return Err(format!("表名 {table} 未过标识符白名单"));
}
}
for spec in modules::all_specs() {
if ssw_platform::platform::db::valid_table(spec.table).is_none() {
return Err(format!("spec 表名 {} 未过标识符白名单", spec.table));
@@ -883,11 +894,17 @@ fn whitelist_self_check() -> Result<(), String> {
// 清单真源在 `sspf_store::db::REPORT_TABLES`(与存储层的表数断言同一处)。
let report_tables = ssw_platform::platform::db::REPORT_TABLES;
// 🔴 **流程元数据表**(`workflow_*` 24 张)同理:官方 `/api/workflow/**` 的
// 元数据载体(逐字照官方 DDL 导入),既不是 `base_*` 平台表也不是业务 spec 表。
// 清单真源在 `sspf_store::db::WORKFLOW_TABLES`。
let workflow_tables = ssw_platform::platform::db::WORKFLOW_TABLES;
for table in &ddl_tables {
if !BASE_TABLES.contains(&table.as_str())
&& !spec_tables.contains(&table.as_str())
&& !pack_tables.contains(&table.as_str())
&& !report_tables.contains(&table.as_str())
&& !workflow_tables.contains(&table.as_str())
{
return Err(format!(
"schema.sql 里的表 {table} 既不是 base_* 表、也没有对应的业务 spec(孤儿 DDL?)"
+1
View File
@@ -24,3 +24,4 @@ pub mod scheduletask;
pub mod core;
pub mod online_dev;
pub mod report;
pub mod workflow;
+2 -2
View File
@@ -614,7 +614,7 @@ pub async fn report_copy(
f_description, f_enabled_mark, f_sort_code, f_delete_mark, \
f_creator_user_id, f_creator_time) \
VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, \
$7::text, $8::integer, $9::bigint, 0, $10::text, now())";
$7::text, $8::text::integer, $9::text::bigint, 0, $10::text, now())";
let values = vec![
Some(new_id.clone()),
Some(tenant_id.to_string()),
@@ -928,7 +928,7 @@ pub async fn report_version_copy(
(f_id, f_tenant_id, f_template_id, f_state, f_version, f_cells, f_snapshot, \
f_query_list, f_sort_list, f_column_list, f_fence_list, f_convert_config, \
f_description, f_enabled_mark, f_delete_mark, f_creator_user_id, f_creator_time) \
VALUES ($1::text, $2::text, $3::text, 0, $4::integer, $5::text, $6::text, \
VALUES ($1::text, $2::text, $3::text, 0, $4::text::integer, $5::text, $6::text, \
$7::text, $8::text, $9::text, $10::text, $11::text, $12::text, 1, 0, \
$13::text, now())";
let values = vec![
File diff suppressed because it is too large. Load diff
+127 -1
View File
@@ -1571,7 +1571,133 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
.route("/api/Report/{id}/Actions/Export", get(compat::report::report_export_data))
.route("/api/Report/{id}/Actions/Module", post(compat::report::report_create_menu))
.route("/api/Report/{id}/getReleaseMenu", get(compat::report::report_release_menu))
.merge(crate::bootstrap::pack_router_or_empty());
// ---- 流程引擎(官方 `api/workFlow/**`,前缀 `/api/workflow/*` + `/api/flowForm/Form/*`)----
//
// 🔴 **官方流程模块是独立 Maven 模块 `jnpf-flowable`**,官方部署时**引擎本体是另一个
// HTTP 服务**(`FlowAbleUrl = <flowDomain>/api/Flow/*`)—— 本仓**没有**该服务。
// ⇒ 端点按三类分账(详见 `compat/workflow.rs` 文件头):
// ① **流程元数据**(模板 / 版本 / 节点 / 评论 / 委托 / 监控 / 触发记录)
// ⇒ **真落库**到官方 24 张 `workflow_*` 表(DDL 逐字照官方)。
// ② **引擎动作**(发起 / 审批 / 办理 / 转审 / 撤回 / 撤销 / 退回 / 加签 / 减签 /
// 协办 / 批量审批 / 暂停 / 终止 / 复活 / 重试 / 催办 / 签收)
// ⇒ **明确业务失败**(`code=FAIL` + 「本仓未接入流程引擎(Flowable)」),
// **绝不返假结果**。
// ③ **文件与在线表单设计器**(`Export` / `/api/flowForm/Form/**`)
// ⇒ **明确业务失败**(本仓无文件服务、无 `visualdev_*` 表)。
//
// 🔴 **权限守卫**(照官方 `@SaCheckPermission` 抄):
// - `onlineDev.flowEngine` ⇒ 模板写操作(新建 / 更新 / 删除 / 上下架 / 复制 …)
// - `workFlow.flowMonitor` ⇒ 监控与触发写操作(终止 / 指派 / 复活 / 重试 …)
// - 其余(Task / Operator / Comment / Delegate / Hooks)官方**没有**权限注解
// ⇒ 只要求登录。
//
// 🔴 **多应用隔离**:`workflow_*` 里只有 `workflow_template` 有 `f_system_id`
// (官方 DDL 如此)⇒ 任务 / 评论按「任务 → 模板」链路回溯系统归属。
.route("/api/workflow/template", get(compat::workflow::workflow_template_list))
.route("/api/workflow/template", post(compat::workflow::workflow_template_create))
.route("/api/workflow/template/{id}", put(compat::workflow::workflow_template_update))
.route("/api/workflow/template/{id}", get(compat::workflow::workflow_template_info))
.route("/api/workflow/template/{id}", delete(compat::workflow::workflow_template_delete))
.route("/api/workflow/template/{id}/Actions/Copy", post(compat::workflow::workflow_template_copy))
.route("/api/workflow/template/{id}/Actions/Export", get(compat::workflow::workflow_template_export))
.route("/api/workflow/template/{id}/UpdateType", put(compat::workflow::workflow_template_update_type))
.route("/api/workflow/template/Save", post(compat::workflow::workflow_template_save))
.route("/api/workflow/template/Info/{id}", get(compat::workflow::workflow_template_json_info))
.route("/api/workflow/template/Version/{id}", get(compat::workflow::workflow_template_version_list))
.route("/api/workflow/template/Info/{id}", delete(compat::workflow::workflow_template_version_delete))
.route("/api/workflow/template/Info/{id}", post(compat::workflow::workflow_template_version_copy))
.route("/api/workflow/template/Selector", get(compat::workflow::workflow_template_selector))
.route("/api/workflow/template/{id}/FormInfo", get(compat::workflow::workflow_template_form_info))
.route("/api/workflow/template/StartForm/{id}", get(compat::workflow::workflow_template_start_form))
.route("/api/workflow/template/StartFormId/{id}", get(compat::workflow::workflow_template_start_form_id))
.route("/api/workflow/template/TreeList", get(compat::workflow::workflow_template_tree_list))
.route("/api/workflow/template/GetFlowList", post(compat::workflow::workflow_template_get_flow_list))
.route("/api/workflow/template/getCommonFlowList", get(compat::workflow::workflow_template_common_flow_list))
.route("/api/workflow/template/SetCommonFlow/{id}", post(compat::workflow::workflow_template_set_common_flow))
.route("/api/workflow/template/{id}/SubFlowUserList", get(compat::workflow::workflow_template_sub_flow_user_list))
.route("/api/workflow/template/{id}/UpDownShelf", put(compat::workflow::workflow_template_up_down_shelf))
.route("/api/workflow/template/{id}/DecisionParameter", get(compat::workflow::workflow_template_decision_parameter))
.route("/api/workflow/template/{id}/FlowList", get(compat::workflow::workflow_template_flow_list))
.route("/api/workflow/comment", get(compat::workflow::workflow_comment_list))
.route("/api/workflow/comment", post(compat::workflow::workflow_comment_create))
.route("/api/workflow/comment/{id}", delete(compat::workflow::workflow_comment_delete))
.route("/api/workflow/Hooks/getUrl", get(compat::workflow::workflow_hook_url))
.route("/api/workflow/Hooks/getParams/{randomStr}", get(compat::workflow::workflow_hook_params))
.route("/api/workflow/Hooks/{id}/start/{randomStr}", get(compat::workflow::workflow_hook_start))
.route("/api/workflow/task", get(compat::workflow::workflow_task_list))
.route("/api/workflow/task/{id}", get(compat::workflow::workflow_task_info))
.route("/api/workflow/task", post(compat::workflow::workflow_task_create))
.route("/api/workflow/task/{id}", put(compat::workflow::workflow_task_update))
.route("/api/workflow/task/{id}", delete(compat::workflow::workflow_task_delete))
.route("/api/workflow/task/Recall/{id}", put(compat::workflow::workflow_task_recall))
.route("/api/workflow/task/Revoke/{id}", put(compat::workflow::workflow_task_revoke))
.route("/api/workflow/task/Press/{id}", post(compat::workflow::workflow_task_press))
.route("/api/workflow/task/{id}/EventLog", get(compat::workflow::workflow_task_event_log))
.route("/api/workflow/task/TaskUserList/{id}", get(compat::workflow::workflow_task_user_list))
.route("/api/workflow/task/SubFlowInfo", get(compat::workflow::workflow_task_sub_flow_info))
.route("/api/workflow/task/ViewStartForm/{id}", get(compat::workflow::workflow_task_view_start_form))
.route("/api/workflow/task/Hooks/Retry/{id}", get(compat::workflow::workflow_task_hooks_retry))
.route("/api/workflow/operator/CandidateUser/{id}", post(compat::workflow::workflow_operator_candidate_user))
.route("/api/workflow/operator/CandidateNode/{id}", post(compat::workflow::workflow_operator_candidate_node))
.route("/api/workflow/operator/List/{category}", get(compat::workflow::workflow_operator_list))
.route("/api/workflow/operator/Sign", post(compat::workflow::workflow_operator_sign))
.route("/api/workflow/operator/Transact", post(compat::workflow::workflow_operator_transact))
.route("/api/workflow/operator/Audit/{id}", post(compat::workflow::workflow_operator_audit))
.route("/api/workflow/operator/AddSignUserIdList/{id}", post(compat::workflow::workflow_operator_add_sign_user_list))
.route("/api/workflow/operator/ReduceApprover/{id}", post(compat::workflow::workflow_operator_reduce_approver))
.route("/api/workflow/operator/SaveAudit/{id}", post(compat::workflow::workflow_operator_save_audit))
.route("/api/workflow/operator/AssistSave/{id}", post(compat::workflow::workflow_operator_assist_save))
.route("/api/workflow/operator/Recall/{id}", post(compat::workflow::workflow_operator_recall))
.route("/api/workflow/operator/Transfer/{id}", post(compat::workflow::workflow_operator_transfer))
.route("/api/workflow/operator/Assist/{id}", post(compat::workflow::workflow_operator_assist))
.route("/api/workflow/operator/BatchOperation", post(compat::workflow::workflow_operator_batch_operation))
.route("/api/workflow/operator/BatchCandidate", get(compat::workflow::workflow_operator_batch_candidate))
.route("/api/workflow/operator/BatchFlowSelector", get(compat::workflow::workflow_operator_batch_flow_selector))
.route("/api/workflow/operator/BatchVersionSelector/{id}", get(compat::workflow::workflow_operator_batch_version_selector))
.route("/api/workflow/operator/BatchNodeSelector/{id}", get(compat::workflow::workflow_operator_batch_node_selector))
.route("/api/workflow/operator/BatchNode", get(compat::workflow::workflow_operator_batch_node))
.route("/api/workflow/operator/{id}/Info", get(compat::workflow::workflow_operator_info))
.route("/api/workflow/operator/SendBack/{id}", post(compat::workflow::workflow_operator_send_back))
.route("/api/workflow/operator/SendBackNodeList/{id}", get(compat::workflow::workflow_operator_send_back_node_list))
.route("/api/workflow/operator/AddSign/{id}", post(compat::workflow::workflow_operator_add_sign))
.route("/api/workflow/operator/RecordList", get(compat::workflow::workflow_operator_record_list))
.route("/api/workflow/operator/CirculateList", get(compat::workflow::workflow_operator_circulate_list))
.route("/api/workflow/delegate", get(compat::workflow::workflow_delegate_list))
.route("/api/workflow/delegate", post(compat::workflow::workflow_delegate_create))
.route("/api/workflow/delegate/{id}", put(compat::workflow::workflow_delegate_update))
.route("/api/workflow/delegate/{id}", get(compat::workflow::workflow_delegate_info))
.route("/api/workflow/delegate/{id}", delete(compat::workflow::workflow_delegate_delete))
.route("/api/workflow/delegate/UserList", get(compat::workflow::workflow_delegate_user_list))
.route("/api/workflow/delegate/Stop/{id}", put(compat::workflow::workflow_delegate_stop))
.route("/api/workflow/delegate/Info/{id}", get(compat::workflow::workflow_delegate_info_list))
.route("/api/workflow/delegate/Notarize/{id}", post(compat::workflow::workflow_delegate_notarize))
.route("/api/workflow/monitor", get(compat::workflow::workflow_monitor_list))
.route("/api/workflow/monitor", delete(compat::workflow::workflow_monitor_delete))
.route("/api/workflow/monitor/{id}/EventLog", get(compat::workflow::workflow_monitor_event_log))
.route("/api/workflow/monitor/Cancel/{id}", post(compat::workflow::workflow_monitor_cancel))
.route("/api/workflow/monitor/Assign/{id}", post(compat::workflow::workflow_monitor_assign))
.route("/api/workflow/monitor/Activate/{id}", post(compat::workflow::workflow_monitor_activate))
.route("/api/workflow/monitor/AnySubFlow/{id}", get(compat::workflow::workflow_monitor_any_sub_flow))
.route("/api/workflow/monitor/Pause/{id}", post(compat::workflow::workflow_monitor_pause))
.route("/api/workflow/monitor/Reboot/{id}", post(compat::workflow::workflow_monitor_reboot))
.route("/api/workflow/monitor/FlowTodoCount", post(compat::workflow::workflow_monitor_flow_todo_count))
.route("/api/workflow/monitor/FlowTodo", get(compat::workflow::workflow_monitor_flow_todo))
.route("/api/flowForm/Form", get(compat::workflow::workflow_form_list))
.route("/api/flowForm/Form", post(compat::workflow::workflow_form_create))
.route("/api/flowForm/Form", put(compat::workflow::workflow_form_update))
.route("/api/flowForm/Form/{id}", get(compat::workflow::workflow_form_info))
.route("/api/flowForm/Form/{id}", delete(compat::workflow::workflow_form_delete))
.route("/api/flowForm/Form/Release/{id}", post(compat::workflow::workflow_form_release))
.route("/api/flowForm/Form/{id}/Actions/Copy", get(compat::workflow::workflow_form_copy))
.route("/api/flowForm/Form/{id}/Actions/Export", get(compat::workflow::workflow_form_export))
.route("/api/flowForm/Form/{id}/getField", get(compat::workflow::workflow_form_field))
.route("/api/flowForm/Form/select", get(compat::workflow::workflow_form_select))
.route("/api/flowForm/Form/getFormById/{id}", get(compat::workflow::workflow_form_by_id))
.route("/api/workflow/trigger/task/List", get(compat::workflow::workflow_trigger_list))
.route("/api/workflow/trigger/task", get(compat::workflow::workflow_trigger_task_list))
.route("/api/workflow/trigger/task", delete(compat::workflow::workflow_trigger_delete))
.route("/api/workflow/trigger/task/Retry/{id}", post(compat::workflow::workflow_trigger_retry))
.merge(crate::bootstrap::pack_router_or_empty());
// 🔴 **仅测试构建**存在的「故意 panic」端点 —— 用来钉住 catch-all 中间件
// (契约 §6.5:panic ⇒ HTTP 200 + `code=400`)。
+804
View File
@@ -0,0 +1,804 @@
//! 批次 19 —— **workFlow 族 104 条**的集成测试。
//!
//! 🔴 **本批的形状分三类**(与 `platform/compat/workflow.rs` 的口径一致):
//! ① **流程元数据**(模板 / 版本 / 节点 / 评论 / 委托 / 监控 / 触发记录)
//! ⇒ **真落库**到官方 24 张 `workflow_*` 表(DDL 逐字照官方);
//! ② **引擎动作**(发起 / 审批 / 办理 / 转审 / 撤回 / 撤销 / 退回 / 加签 /
//! 减签 / 协办 / 批量审批 / 暂停 / 终止 / 复活 / 重试 / 催办 / 签收 / 触发器)
//! ⇒ **明确业务失败**(本仓未接入 Flowable,官方是独立 HTTP 服务
//! `FlowAbleUrl`)—— **绝不返假结果、假流程号**;
//! ③ **文件 / 在线表单设计器** ⇒ **明确业务失败**(本仓无文件服务、
//! 无 `visualdev_*` 表)。
//!
//! 🔴 **三类断言**:
//! ① **路由存在**(104 条逐条打一遍)—— 防 axum 的 `matchit` 参数名冲突
//! (同位置不能有两个参数名 ⇒ **启动即 panic**,静态闸门看不出来、编译也过);
//! ② **真实现**的**精确形状**(模板 CRUD 闭环、评论 / 委托落库、版本列表);
//! ③ **能力缺失**端点的**诚实失败**(`code=400` + `data:null` + 人话)。
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::{json, Value};
use ssw_platform::platform::db::Db;
use ssw_platform::platform::seed::first_seed;
use ssw_platform::platform::session::{SessionStore, TicketStore};
use ssw_platform::platform::state::AppState;
use ssw_platform::routes::build_app;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::sync::{Mutex, OnceCell};
static DB: OnceCell<Db> = OnceCell::const_new();
static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
ssw_platform::bootstrap::ensure_base(&db)
.await
.expect("ensure_base 失败");
first_seed(&db, "123456").await.expect("first_seed 失败");
db
})
.await
}
async fn serve(state: AppState) -> u16 {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("绑定失败");
let port = listener.local_addr().expect("取本地地址失败").port();
let server = tokio::spawn(async move {
let _ = axum::serve(listener, build_app(state)).await;
});
tokio::task::yield_now().await;
std::mem::forget(server);
port
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(ssw_platform::platform::config::Config::from_env(PathBuf::from(
"/tmp/ssw-platform-batch19-it",
))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
tickets: Arc::new(TicketStore::default()),
}
}
/// 🔴 `app_code` 可切 —— 多应用隔离测试要用(`app-b` 是官方的「故意无菜单」应用)。
async fn call_app(
port: u16,
method: &str,
path: &str,
token: &str,
body: Option<&str>,
app_code: &str,
) -> Value {
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let payload = body.unwrap_or("");
let req = format!(
"{method} {path} HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: {app_code}\r\n\
Authorization: {token}\r\n\
Content-Type: application/json\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream
.write_all(req.as_bytes())
.await
.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(15),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
serde_json::from_str(body.trim()).unwrap_or(Value::Null)
}
async fn call(port: u16, method: &str, path: &str, token: &str, body: Option<&str>) -> Value {
call_app(port, method, path, token, body, "mainSystem").await
}
async fn login(port: u16) -> String {
let enc = ssw_platform::platform::cipher::encrypt_password("123456");
let payload = format!("account=admin&password={enc}");
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let req = format!(
"POST /api/oauth/Login HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Content-Type: application/x-www-form-urlencoded\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream
.write_all(req.as_bytes())
.await
.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(15),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let v: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null);
v["data"]["token"]
.as_str()
.expect("登录必须返 token")
.to_string()
}
async fn boot() -> (u16, String) {
let state = new_state(db().await);
let port = serve(state).await;
let token = login(port).await;
(port, token)
}
/// 🔴 **104 条端点逐条打一遍** —— 判据「不是 404 / 405」。
///
/// 🔴 **为什么必须有这条测试**:axum 的 `matchit` 在**同一位置有两个参数名**
/// (如 `/api/workflow/task/{id}` 与 `/api/workflow/task/{taskId}`)时会
/// **启动即 panic** —— 静态闸门看不出来、编译也过,只有真把 router 建起来才炸。
#[tokio::test]
async fn workflow_all_104_endpoints_are_registered_without_matchit_conflict() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
// 🔴 建一条真流程(后面几条要用它的主键)。
let created = call(
port,
"POST",
"/api/workflow/template",
&token,
Some(&json!({"fullName":"路由探测流程","enCode":"probe"}).to_string()),
)
.await;
let tid = created["data"].as_str().unwrap_or("no-such-id").to_string();
let cases: Vec<(&str, &str)> = vec![
// ---- 模板(25 条)----
("GET", "/api/workflow/template"),
("POST", "/api/workflow/template"),
("PUT", "/api/workflow/template/{id}"),
("GET", "/api/workflow/template/{id}"),
("DELETE", "/api/workflow/template/{id}"),
("POST", "/api/workflow/template/{id}/Actions/Copy"),
("GET", "/api/workflow/template/{id}/Actions/Export"),
("PUT", "/api/workflow/template/{id}/UpdateType"),
("POST", "/api/workflow/template/Save"),
("GET", "/api/workflow/template/Info/{id}"),
("GET", "/api/workflow/template/Version/{id}"),
("DELETE", "/api/workflow/template/Info/{id}"),
("POST", "/api/workflow/template/Info/{id}"),
("GET", "/api/workflow/template/Selector"),
("GET", "/api/workflow/template/{id}/FormInfo"),
("GET", "/api/workflow/template/StartForm/{id}"),
("GET", "/api/workflow/template/StartFormId/{id}"),
("GET", "/api/workflow/template/TreeList"),
("POST", "/api/workflow/template/GetFlowList"),
("GET", "/api/workflow/template/getCommonFlowList"),
("POST", "/api/workflow/template/SetCommonFlow/{id}"),
("GET", "/api/workflow/template/{id}/SubFlowUserList"),
("PUT", "/api/workflow/template/{id}/UpDownShelf"),
("GET", "/api/workflow/template/{id}/DecisionParameter"),
("GET", "/api/workflow/template/{id}/FlowList"),
// ---- 评论(3 条)----
("GET", "/api/workflow/comment"),
("POST", "/api/workflow/comment"),
("DELETE", "/api/workflow/comment/{id}"),
// ---- 触发器 Hooks(3 条)----
("GET", "/api/workflow/Hooks/getUrl"),
("GET", "/api/workflow/Hooks/getParams/{randomStr}"),
("GET", "/api/workflow/Hooks/{id}/start/{randomStr}"),
// ---- 任务(13 条)----
("GET", "/api/workflow/task"),
("GET", "/api/workflow/task/{id}"),
("POST", "/api/workflow/task"),
("PUT", "/api/workflow/task/{id}"),
("DELETE", "/api/workflow/task/{id}"),
("PUT", "/api/workflow/task/Recall/{id}"),
("PUT", "/api/workflow/task/Revoke/{id}"),
("POST", "/api/workflow/task/Press/{id}"),
("GET", "/api/workflow/task/{id}/EventLog"),
("GET", "/api/workflow/task/TaskUserList/{id}"),
("GET", "/api/workflow/task/SubFlowInfo"),
("GET", "/api/workflow/task/ViewStartForm/{id}"),
("GET", "/api/workflow/task/Hooks/Retry/{id}"),
// ---- 办理(25 条)----
("POST", "/api/workflow/operator/CandidateUser/{id}"),
("POST", "/api/workflow/operator/CandidateNode/{id}"),
("GET", "/api/workflow/operator/List/{category}"),
("POST", "/api/workflow/operator/Sign"),
("POST", "/api/workflow/operator/Transact"),
("POST", "/api/workflow/operator/Audit/{id}"),
("POST", "/api/workflow/operator/AddSignUserIdList/{id}"),
("POST", "/api/workflow/operator/ReduceApprover/{id}"),
("POST", "/api/workflow/operator/SaveAudit/{id}"),
("POST", "/api/workflow/operator/AssistSave/{id}"),
("POST", "/api/workflow/operator/Recall/{id}"),
("POST", "/api/workflow/operator/Transfer/{id}"),
("POST", "/api/workflow/operator/Assist/{id}"),
("POST", "/api/workflow/operator/BatchOperation"),
("GET", "/api/workflow/operator/BatchCandidate"),
("GET", "/api/workflow/operator/BatchFlowSelector"),
("GET", "/api/workflow/operator/BatchVersionSelector/{id}"),
("GET", "/api/workflow/operator/BatchNodeSelector/{id}"),
("GET", "/api/workflow/operator/BatchNode"),
("GET", "/api/workflow/operator/{id}/Info"),
("POST", "/api/workflow/operator/SendBack/{id}"),
("GET", "/api/workflow/operator/SendBackNodeList/{id}"),
("POST", "/api/workflow/operator/AddSign/{id}"),
("GET", "/api/workflow/operator/RecordList"),
("GET", "/api/workflow/operator/CirculateList"),
// ---- 委托(9 条)----
("GET", "/api/workflow/delegate"),
("POST", "/api/workflow/delegate"),
("PUT", "/api/workflow/delegate/{id}"),
("GET", "/api/workflow/delegate/{id}"),
("DELETE", "/api/workflow/delegate/{id}"),
("GET", "/api/workflow/delegate/UserList"),
("PUT", "/api/workflow/delegate/Stop/{id}"),
("GET", "/api/workflow/delegate/Info/{id}"),
("POST", "/api/workflow/delegate/Notarize/{id}"),
// ---- 监控(10 条)----
("GET", "/api/workflow/monitor"),
("DELETE", "/api/workflow/monitor"),
("GET", "/api/workflow/monitor/{id}/EventLog"),
("POST", "/api/workflow/monitor/Cancel/{id}"),
("POST", "/api/workflow/monitor/Assign/{id}"),
("POST", "/api/workflow/monitor/Activate/{id}"),
("GET", "/api/workflow/monitor/AnySubFlow/{id}"),
("POST", "/api/workflow/monitor/Pause/{id}"),
("POST", "/api/workflow/monitor/Reboot/{id}"),
("POST", "/api/workflow/monitor/FlowTodoCount"),
("GET", "/api/workflow/monitor/FlowTodo"),
// ---- 在线表单设计器(11 条)----
("GET", "/api/flowForm/Form"),
("POST", "/api/flowForm/Form"),
("PUT", "/api/flowForm/Form"),
("GET", "/api/flowForm/Form/{id}"),
("DELETE", "/api/flowForm/Form/{id}"),
("POST", "/api/flowForm/Form/Release/{id}"),
("GET", "/api/flowForm/Form/{id}/Actions/Copy"),
("GET", "/api/flowForm/Form/{id}/Actions/Export"),
("GET", "/api/flowForm/Form/{id}/getField"),
("GET", "/api/flowForm/Form/select"),
("GET", "/api/flowForm/Form/getFormById/{id}"),
// ---- 触发任务(4 条)----
("GET", "/api/workflow/trigger/task/List"),
("GET", "/api/workflow/trigger/task"),
("DELETE", "/api/workflow/trigger/task"),
("POST", "/api/workflow/trigger/task/Retry/{id}"),
];
assert_eq!(cases.len(), 104, "本批就是 104 条");
for (method, raw_path) in cases {
let path = raw_path
.replace("{id}", &tid)
.replace("{randomStr}", "rs")
.replace("{category}", "1");
let res = call(port, method, &path, &token, Some("{}")).await;
let code = res["code"].as_i64().unwrap_or(-1);
assert!(
code != 404 && code != 405,
"`{method} {raw_path}` 必须已注册(404/405 说明路由没接上),实际 code={code}:{:?}",
res
);
}
}
/// 🔴 **模板 CRUD 闭环**(真落库)—— 官方 `TemplateController` 的元数据部分。
///
/// 断言形状:
/// - `POST /api/workflow/template` ⇒ `data` 是**裸 id 字符串**(官方
/// `ActionResult.success(msg, entity.getId())`);
/// - `GET /api/workflow/template` ⇒ `data` 是 `PageListVO`(`{pagination,list}`);
/// - `GET /api/workflow/template/{id}` ⇒ `data` 是**裸对象**(官方
/// `TemplateVO`),含 `id` / `fullName` / `enCode`。
#[tokio::test]
async fn template_crud_round_trip_lands_in_official_tables() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
// ---- 新建 ----
let created = call(
port,
"POST",
"/api/workflow/template",
&token,
Some(
&json!({
"fullName": "报销流程",
"enCode": "expense-flow",
"category": "OA",
"type": 0,
"flowXml": "<flow/>",
"flowNodes": [{"nodeCode":"node-1","nodeName":"发起","type":"start","formId":"form-1"}]
})
.to_string(),
),
)
.await;
assert_eq!(created["code"], 200, "新建流程应成功:{:?}", created);
let tid = created["data"]
.as_str()
.expect("data 必须是裸 id 字符串(官方口径)")
.to_string();
assert_eq!(tid.len(), 36, "主键必须是 36 位 UUID");
// ---- 列表(PageListVO)----
let list = call(port, "GET", "/api/workflow/template", &token, None).await;
assert_eq!(list["code"], 200, "流程列表应成功:{:?}", list);
assert!(
list["data"]["pagination"].is_object(),
"列表 data 必须是 PageListVO(带 pagination),实际:{:?}",
list["data"]
);
let rows = list["data"]["list"].as_array().expect("list 必须是数组");
assert!(
rows.iter().any(|r| r["id"] == tid.as_str()),
"新建的流程必须出现在列表里:{:?}",
rows
);
let row = rows
.iter()
.find(|r| r["id"] == tid.as_str())
.expect("必须找到刚建的流程");
assert_eq!(row["fullName"], "报销流程");
assert_eq!(row["enCode"], "expense-flow");
// ---- 详情(裸对象)----
let info = call(port, "GET", &format!("/api/workflow/template/{tid}"), &token, None).await;
assert_eq!(info["code"], 200, "流程详情应成功:{:?}", info);
assert_eq!(info["data"]["id"], tid.as_str(), "详情 data 必须是裸对象");
assert_eq!(info["data"]["fullName"], "报销流程");
// ---- 改(PUT 合并语义)----
let updated = call(
port,
"PUT",
&format!("/api/workflow/template/{tid}"),
&token,
Some(&json!({"fullName":"报销流程(改)"}).to_string()),
)
.await;
assert_eq!(updated["code"], 200, "改流程应成功:{:?}", updated);
let info2 = call(port, "GET", &format!("/api/workflow/template/{tid}"), &token, None).await;
assert_eq!(info2["data"]["fullName"], "报销流程(改)");
assert_eq!(
info2["data"]["enCode"], "expense-flow",
"PUT 是**合并**语义 ⇒ 未传的字段必须保留"
);
// ---- 版本列表(新建流程时自动落了一条版本)----
// 🔴 官方 `TemplateController.java:230` 返的是 `ActionResult.success(listVO)`
// ⇒ `data` 是**裸数组**(不是 PageListVO)。
let versions = call(
port,
"GET",
&format!("/api/workflow/template/Version/{tid}"),
&token,
None,
)
.await;
assert_eq!(versions["code"], 200, "版本列表应成功:{:?}", versions);
let vlist = versions["data"].as_array().expect("版本列表 data 必须是裸数组");
assert!(!vlist.is_empty(), "新建流程必须自动落一条版本:{:?}", versions);
assert!(
vlist[0]["fullName"]
.as_str()
.unwrap_or_default()
.starts_with("流程版本V"),
"版本 fullName 必须是官方口径「流程版本V<版本号>」,实际:{:?}",
vlist[0]
);
// ---- 流程引擎信息(`Info/{versionId}` —— 官方传的是**版本主键**)----
let version_id = vlist[0]["id"].as_str().expect("版本必须有 id").to_string();
let json_info = call(
port,
"GET",
&format!("/api/workflow/template/Info/{version_id}"),
&token,
None,
)
.await;
assert_eq!(json_info["code"], 200, "流程 JSON 应成功:{:?}", json_info);
assert!(
json_info["data"].is_object() || json_info["data"].is_string(),
"流程 JSON 的 data 必须是裸对象 / 串,实际:{:?}",
json_info["data"]
);
// ---- 上下架 ----
let shelf = call(
port,
"PUT",
&format!("/api/workflow/template/{tid}/UpDownShelf"),
&token,
Some(&json!({"status":1}).to_string()),
)
.await;
assert_eq!(shelf["code"], 200, "上下架应成功:{:?}", shelf);
// ---- 复制 ----
let copied = call(
port,
"POST",
&format!("/api/workflow/template/{tid}/Actions/Copy"),
&token,
Some("{}"),
)
.await;
assert_eq!(copied["code"], 200, "复制流程应成功:{:?}", copied);
// ---- 删(软删)⇒ 列表里不再出现,详情报「流程不存在」----
let deleted = call(
port,
"DELETE",
&format!("/api/workflow/template/{tid}"),
&token,
Some("{}"),
)
.await;
assert_eq!(deleted["code"], 200, "删流程应成功:{:?}", deleted);
let after = call(port, "GET", &format!("/api/workflow/template/{tid}"), &token, None).await;
assert_eq!(
after["code"], 400,
"删掉后详情必须业务失败(软删),实际:{:?}",
after
);
assert!(after["data"].is_null(), "失败信封的 data 必须是 null");
}
/// 🔴 **评论 / 委托**:真落库 + 必填校验。
///
/// 🔴 **评论的可见范围**:官方 `CommentController.list` 是**按任务**列的
/// (`taskService.getTaskUserList(taskId)` ⇒ 不在任务参与人里就返空)。
/// 本仓对应口径 = 「任务 → 模板 → 系统」链路(`workflow_comment` / `workflow_task`
/// **都没有** `f_system_id`)⇒ 评论**挂在一个真实存在的任务上**才可见。
/// ⇒ 本测试**先直接种一条任务行**(引擎在官方才会造,本仓无引擎)。
#[tokio::test]
async fn comment_and_delegate_land_in_official_tables() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
// ---- 先建模板 + 直接种一条任务行(相当于引擎造的数据)----
let tpl = call(
port,
"POST",
"/api/workflow/template",
&token,
Some(&json!({"fullName":"评论宿主流程","enCode":"comment-host"}).to_string()),
)
.await;
assert_eq!(tpl["code"], 200, "新建宿主流程应成功:{:?}", tpl);
let tid = tpl["data"].as_str().expect("data 是裸 id 串").to_string();
let task_id = "task-seeded-batch19";
db()
.await
.exec_params(
"INSERT INTO workflow_task \
(f_id, f_tenant_id, f_template_id, f_full_name, f_creator_user_id, f_delete_mark) \
VALUES ($1::text, '0', $2::text, '种子任务', 'admin', 0)",
&[&task_id, &tid.as_str()],
)
.await
.expect("种任务行失败");
// ---- 评论:缺 `taskId` 必须业务失败(不 500)----
let bad = call(
port,
"POST",
"/api/workflow/comment",
&token,
Some(&json!({"text":"少了 taskId"}).to_string()),
)
.await;
assert_eq!(bad["code"], 400, "缺 taskId 必须业务失败:{:?}", bad);
assert!(bad["data"].is_null(), "失败信封 data 必须 null");
// ---- 评论:正常写入 ----
let okc = call(
port,
"POST",
"/api/workflow/comment",
&token,
Some(&json!({"taskId":task_id,"text":"同意"}).to_string()),
)
.await;
assert_eq!(okc["code"], 200, "新增评论应成功:{:?}", okc);
let cid = okc["data"].as_str().expect("data 是裸 id 串").to_string();
let clist = call(port, "GET", "/api/workflow/comment", &token, None).await;
assert_eq!(clist["code"], 200, "评论列表应成功:{:?}", clist);
let crows = clist["data"]["list"].as_array().expect("评论列表是 PageListVO");
assert!(
crows.iter().any(|r| r["id"] == cid.as_str()),
"刚建的评论必须出现在列表里:{:?}",
crows
);
// 🔴 **多应用隔离**:评论没有 `f_system_id` ⇒ 靠「任务 → 模板」回溯系统。
let b_list = call_app(
port,
"GET",
"/api/workflow/comment",
&token,
None,
"app-b",
)
.await;
let b_rows = b_list["data"]["list"].as_array().expect("评论列表是 PageListVO");
assert!(
!b_rows.iter().any(|r| r["id"] == cid.as_str()),
"app-b **不许**看到主系统的评论(任务 → 模板 → 系统链路),实际:{:?}",
b_rows
);
let cdel = call(
port,
"DELETE",
&format!("/api/workflow/comment/{cid}"),
&token,
Some("{}"),
)
.await;
assert_eq!(cdel["code"], 200, "删评论应成功:{:?}", cdel);
// ---- 委托:缺必填 ⇒ 业务失败;齐了 ⇒ 落库 ----
let dbad = call(
port,
"POST",
"/api/workflow/delegate",
&token,
Some(&json!({"flowName":"委托"}).to_string()),
)
.await;
assert_eq!(dbad["code"], 400, "缺被委托人必须业务失败:{:?}", dbad);
let dok = call(
port,
"POST",
"/api/workflow/delegate",
&token,
Some(
&json!({
"flowName":"出差委托",
"userId":"admin",
"toUserId":["admin"],
"type":0,
"startTime": 1767225600000i64,
"endTime": 1767312000000i64
})
.to_string(),
),
)
.await;
assert_eq!(dok["code"], 200, "新建委托应成功:{:?}", dok);
let did = dok["data"].as_str().expect("data 是裸 id 串").to_string();
let dlist = call(port, "GET", "/api/workflow/delegate", &token, None).await;
assert_eq!(dlist["code"], 200, "委托列表应成功:{:?}", dlist);
let drows = dlist["data"]["list"].as_array().expect("委托列表是 PageListVO");
assert!(
drows.iter().any(|r| r["id"] == did.as_str()),
"刚建的委托必须出现在列表里:{:?}",
drows
);
// 🔴 **epoch 毫秒不能原样进 `::timestamp` 列** —— 落库成功即证明转换过,
// 且回读仍按官方口径返 **epoch 毫秒数字**。
let ddetail = call(
port,
"GET",
&format!("/api/workflow/delegate/{did}"),
&token,
None,
)
.await;
assert_eq!(ddetail["code"], 200, "委托详情应成功:{:?}", ddetail);
assert_eq!(
ddetail["data"]["startTime"].as_i64(),
Some(1767225600000),
"委托起止时间必须按官方口径返 epoch 毫秒,实际:{:?}",
ddetail["data"]
);
assert_eq!(
ddetail["data"]["endTime"].as_i64(),
Some(1767312000000),
"委托结束时间必须按官方口径返 epoch 毫秒,实际:{:?}",
ddetail["data"]
);
}
/// 🔴 **引擎动作必须诚实失败** —— 本仓未接入 Flowable。
///
/// 🔴 判据:`code=400` + `data:null` + `msg` 里点明「流程引擎」。
/// **绝不**返 `code=200` + 假状态、假流程号。
#[tokio::test]
async fn engine_actions_fail_honestly_instead_of_faking_results() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let cases: Vec<(&str, &str)> = vec![
("POST", "/api/workflow/task"),
("PUT", "/api/workflow/task/task-1"),
("PUT", "/api/workflow/task/Recall/task-1"),
("PUT", "/api/workflow/task/Revoke/task-1"),
("POST", "/api/workflow/task/Press/task-1"),
("GET", "/api/workflow/task/Hooks/Retry/task-1"),
("GET", "/api/workflow/Hooks/getUrl"),
("GET", "/api/workflow/Hooks/getParams/rs"),
("GET", "/api/workflow/Hooks/hook-1/start/rs"),
("POST", "/api/workflow/operator/Sign"),
("POST", "/api/workflow/operator/Transact"),
("POST", "/api/workflow/operator/Audit/op-1"),
("POST", "/api/workflow/operator/ReduceApprover/op-1"),
("POST", "/api/workflow/operator/SaveAudit/op-1"),
("POST", "/api/workflow/operator/AssistSave/op-1"),
("POST", "/api/workflow/operator/Recall/op-1"),
("POST", "/api/workflow/operator/Transfer/op-1"),
("POST", "/api/workflow/operator/Assist/op-1"),
("POST", "/api/workflow/operator/BatchOperation"),
("POST", "/api/workflow/operator/SendBack/op-1"),
("POST", "/api/workflow/operator/AddSign/op-1"),
("POST", "/api/workflow/monitor/Cancel/m-1"),
("POST", "/api/workflow/monitor/Assign/m-1"),
("POST", "/api/workflow/monitor/Activate/m-1"),
("POST", "/api/workflow/monitor/Pause/m-1"),
("POST", "/api/workflow/monitor/Reboot/m-1"),
("POST", "/api/workflow/trigger/task/Retry/tr-1"),
];
for (method, path) in cases {
let res = call(port, method, path, &token, Some("{}")).await;
assert_eq!(
res["code"], 400,
"`{method} {path}` 必须**明确业务失败**(本仓无流程引擎),实际:{:?}",
res
);
assert!(
res["data"].is_null(),
"`{method} {path}` 失败信封的 data 必须是 null(不能返假结果),实际:{:?}",
res
);
let msg = res["msg"].as_str().unwrap_or_default();
assert!(
msg.contains("流程引擎"),
"`{method} {path}` 的 msg 必须点明「流程引擎」,实际:{msg:?}"
);
}
}
/// 🔴 **文件类 / 在线表单设计器类必须诚实失败**。
#[tokio::test]
async fn file_and_form_actions_fail_honestly() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
// ---- 文件类 ----
for path in [
"/api/workflow/template/t-1/Actions/Export",
"/api/flowForm/Form/f-1/Actions/Export",
] {
let res = call(port, "GET", path, &token, None).await;
assert_eq!(res["code"], 400, "`{path}` 必须业务失败:{:?}", res);
assert!(res["data"].is_null(), "`{path}` 的 data 必须是 null");
let msg = res["msg"].as_str().unwrap_or_default();
assert!(
msg.contains("文件服务"),
"`{path}` 的 msg 必须点明「文件服务」,实际:{msg:?}"
);
}
// ---- 在线表单设计器类 ----
for (method, path) in [
("GET", "/api/flowForm/Form"),
("POST", "/api/flowForm/Form"),
("PUT", "/api/flowForm/Form"),
("GET", "/api/flowForm/Form/f-1"),
("DELETE", "/api/flowForm/Form/f-1"),
("POST", "/api/flowForm/Form/Release/f-1"),
("GET", "/api/flowForm/Form/f-1/Actions/Copy"),
("GET", "/api/flowForm/Form/f-1/getField"),
("GET", "/api/flowForm/Form/select"),
] {
let res = call(port, method, path, &token, Some("{}")).await;
assert_eq!(
res["code"], 400,
"`{method} {path}` 必须业务失败(本仓无在线表单设计器),实际:{:?}",
res
);
assert!(
res["data"].is_null(),
"`{method} {path}` 的 data 必须是 null,实际:{:?}",
res
);
}
}
/// 🔴 **多应用隔离**:`workflow_template.f_system_id` 是官方 DDL 里流程表
/// **唯一**的系统列 ⇒ `App-Code: app-b` 看到的必须是**另一个系统**的流程。
#[tokio::test]
async fn workflow_metadata_is_isolated_by_app_code() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let created = call(
port,
"POST",
"/api/workflow/template",
&token,
Some(&json!({"fullName":"主系统专属流程","enCode":"main-only"}).to_string()),
)
.await;
assert_eq!(created["code"], 200, "新建流程应成功:{:?}", created);
let tid = created["data"].as_str().expect("data 是裸 id 串").to_string();
// 主系统能看到
let main_list = call(port, "GET", "/api/workflow/template", &token, None).await;
let main_rows = main_list["data"]["list"].as_array().expect("list 是数组");
assert!(
main_rows.iter().any(|r| r["id"] == tid.as_str()),
"主系统必须看得到自己建的流程"
);
// app-b 看不到
let b_list = call_app(
port,
"GET",
"/api/workflow/template",
&token,
None,
"app-b",
)
.await;
assert_eq!(b_list["code"], 200, "app-b 看列表应成功:{:?}", b_list);
let b_rows = b_list["data"]["list"].as_array().expect("list 是数组");
assert!(
!b_rows.iter().any(|r| r["id"] == tid.as_str()),
"app-b **不许**看到主系统的流程(`f_system_id` 隔离),实际:{:?}",
b_rows
);
}
/// 🔴 **未登录返 602**(面 B 未登录是 `602`,不是面 A 的 `600`)。
#[tokio::test]
async fn workflow_unauthenticated_returns_602() {
let _g = LOCK.lock().await;
let (port, _token) = boot().await;
let res = call(port, "GET", "/api/workflow/template", "", None).await;
assert_eq!(
res["code"], 602,
"面 B 未登录必须是 602(官方前端只对 601/602 清 token),实际:{:?}",
res
);
}