From 2f53f812b61a72cb1f04ce8e55f95534e6dc2ed5 Mon Sep 17 00:00:00 2001 From: admin Date: Sun, 1 Nov 2026 10:04:54 +0800 Subject: [PATCH] =?UTF-8?q?feat(face-b):=20=E6=95=B0=E6=8D=AE=E9=9B=86=20D?= =?UTF-8?q?ataset=20=E8=90=BD=E5=9C=B0=EF=BC=88=E9=9D=A2=20B=20=E6=89=B9?= =?UTF-8?q?=E6=AC=A1=208=EF=BC=8C+18=20=E7=AB=AF=E7=82=B9=EF=BC=8C?= =?UTF-8?q?=E7=9C=9F=E6=89=A7=E8=A1=8C=E7=94=A8=E6=88=B7=20SQL=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 影响:官方 jnpf-web-apps-main 的「数据中心 / 数据集」全部 18 个调用点可用; 后端首次具备执行用户手写 SQL 的能力,护栏与绑定引擎是本批核心。 - schema.sql 新增 base_data_set(26 列) / base_data_set_relation(13 列),表数 35→37 - Dataset 元数据 CRUD 9 条:列表/详情/新建/改/删 + 设计器 get/save + getList - 执行面 9 条:GetParam / fields / Preview / List / InfoByIds / getRes / previewSql / Copy / 导出导入 - SQL 护栏:只放行 select|with,禁分号,按词边界扫 12 个危险动词 + 7 个文件/延时函数 - 变量全走 $N 绑定(${}::text 打头),缺值 400 而非协议错;空集合给 NULL - 有意差异:系统变量只认 4 个;Export/Import 恒 400(本仓无对应基础设施) - 契约登记:routes +18、FACE_B_REGISTERED 181→196、[FACE] B 243→261、[OFFICIAL] +18(3 条 partial) 验证:cargo test --offline --workspace 527 passed / 0 failed;十二道闸门全绿, check-contract PASS=10 FAIL=0(官方覆盖 280/287,implemented 256 / partial 24)。 --- .workbuddy/memory/2026-11-01.md | 59 + CLAUDE.md | 4 +- HANDOFF.md | 82 +- PLAN.md | 2 +- crates/sspf-store/src/db.rs | 13 +- docs/contract.md | 39 +- src/backend/db/schema.sql | 62 + src/backend/src/main.rs | 8 +- src/backend/src/platform/face_b.rs | 1676 ++++++++++++++++++++++++++++ src/backend/src/routes.rs | 65 +- src/backend/tests/batch6_it.rs | 4 +- src/backend/tests/batch8_it.rs | 535 +++++++++ 12 files changed, 2519 insertions(+), 30 deletions(-) create mode 100644 src/backend/tests/batch8_it.rs diff --git a/.workbuddy/memory/2026-11-01.md b/.workbuddy/memory/2026-11-01.md index 974ae55..b09f5fc 100644 --- a/.workbuddy/memory/2026-11-01.md +++ b/.workbuddy/memory/2026-11-01.md @@ -129,3 +129,62 @@ `systemData` 的 `Dataset`(16) / `DataInterface`(10) / `InterfaceOauth`(9) / `PortalManage`(4) + `system/printDev`(15)。`printDev` 是本仓没有打印服务 ⇒ 多半只能恒空 stub(先看页面再定)。 + +--- + +## 批次 8 —— 数据集 Dataset(**真执行用户 SQL**),2026-11-01 + +**18 条面 B 端点**:CRUD 4 + `getList` / `previewSql` / `fields` / `GetParam` / `{id}/get` / +`{id}/save` + 六条取数(`Preview`/`List`/`InfoByIds`/`getRes`)+ `Export`/`Import`(恒失败)。 +新表 `base_data_set`(26 列) / `base_data_set_relation`(13 列),`tables` 35 → **37**。 + +### 🔴 全仓唯一执行用户手写 SQL 的地方,三道护栏 + +`dataset_sql_guard`: +1. 去尾分号后必须 `select` / `with` 开头; +2. 全文**不许再有 `;`**(pglite 的 `exec` 走 simple protocol,多语句会一起跑); +3. 按**词边界**扫危险动词 + 文件/延时函数。 + +**词边界是必须的**:子串匹配会把 `update_time` / `create_id` 这种别名一起拒掉, +一批正常业务 SQL 直接报废。测试里专门钉了「五拦一放」。 + +### 变量只走绑定,三处与官方**有意不同** + +- `${xxx}` / `@xxx` ⇒ `$N` + 参数数组,**绝不拼进 SQL 文本**。 +- 官方找不到值时**原样保留变量名**(结果是一条非法 SQL,用户看 PG 语法错) + ⇒ 本仓 `400 缺少参数 xxx`。 +- 官方空集合替换成**一个空格**(`in ( )` 语法错)⇒ 本仓 `NULL`(`in (NULL)` 合法且永不匹配)。 +- 系统变量官方十几个(靠 permission 的组织子树),本仓只认 4 个: + `@currentTime` / `@userId` / `@userAccount` / `@organizeId`(后者恒空串,没组织树), + 其余**明说不支持**。 + +### 踩到 / 想清楚的 5 个点 + +- 🔴 **`exec_params` 的每个 `$N` 必须 `::text` 打头**:`exec_params` 绑的永远是 + `Option`,SQL 里写 `${}::integer` 会让 PG 按列类型推断成 `int4` ⇒ + `protocol error: cannot convert between Option and Postgres type int4`。 + 正确写法 `${}::text::integer`。**create 第一版就是漏了 `::text`,报 500。** +- 🔴 **`getRes` 必须用 body 里的 `dataConfigJson`**:设计器边改边试跑,读库永远是 + 上一次保存的 SQL(官方 `getRes` 也是拿 `form.getDataConfigJson()`)。 +- ⚠️ **列名靠「执行 1 行」反推**:`row_to_json` 没行就没键 ⇒ **空结果集拿不到列名**, + `fields` 回空数组。官方走 JDBC 元数据,本仓做不到 —— 写进 `[OFFICIAL]` 备注,别装。 +- 🔴 **列表 VO 的 `type`/`returnType` 是中文名,详情里是数字**:同一份投影,两个整形函数 + (`DataSetListVO` vs `DataSetForm`)。搞混了前端下拉框全空。 +- 🔴 **`SELECT *` 被 `check-arch` MEM1 判红**(内存预算 120MB)。这里列名由用户 SQL 决定 + ⇒ 写 `jnpfs.*`(带表别名,语义等价,每句自带 `LIMIT`)。 + +### 顺手修的老 bug + +- `batch6_it.rs` 把表清单 total 写死 35 ⇒ 加表就红,改 37(与 DDL 计数测试同口径)。 +- `check-arch` MEM1 扫到 4 处 `SELECT *`,全改成 `别名.*`。 + +### 数字(批次 8 收尾) + +`cargo test --workspace` **527**(+6)| `fe-gap` **252/900 = 28.0%**(systemData **52/106 = 49.1%**) +| 契约端点 **291 条(面 B 261)** | 官方覆盖 **280/287(implemented 256 / partial 24 / absent 7)** +| 十二道闸门全绿 | 空载内存 7 MB + +### 下一个(批次 9) + +`DataInterface`(12) + `InterfaceOauth`(11) + `system/printDev`(17)。 +`printDev` 是本仓没有打印设计器 ⇒ 先看 `onlineDev/printDev/Form.vue` 再定是不是只做恒空 stub。 diff --git a/CLAUDE.md b/CLAUDE.md index 3c187fd..58f027a 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -222,7 +222,7 @@ ssw-platform/ 每把尺子结尾比对「实际断言数 vs 契约登记数」,对不上即失败 —— 尺子不会被悄悄改弱。 **加任何业务模块 / 改任何契约 / 加任何 crate 依赖 / 改任何内部标识 / 加任何表,十二道闸门必须全绿才算完成。** -🔴 **`cargo test --workspace` 当前 521 条**(内核 + contract 13 + store 17 + sdk 2 + pack-asset 5 + mcp 52 + adapter-baseline 19 + lowcode 112 + 集成测试)—— +🔴 **`cargo test --workspace` 当前 527 条**(内核 + contract 13 + store 17 + sdk 2 + pack-asset 5 + mcp 52 + adapter-baseline 19 + lowcode 112 + 集成测试)—— 拆 crate 后总数会变,**不许把断言数写死**,跑一遍看实际值。 cipher 自证(免 node):`./target/release/ssw-platform --enc 123456`。 @@ -276,7 +276,7 @@ cp .env.example .env && ./run.sh install && ./run.sh dev ```bash cargo build --release # 编译(workspace 根,含 crates/* 与 packs/*) -cargo test --workspace # 单测(当前 521 条) +cargo test --workspace # 单测(当前 527 条) bash run.sh dev # 起后端(30010) + 前端(5173) bash scripts/perm-smoke.sh # 面 A 43 条 bash scripts/perm-smoke-jnpf.sh # 面 B 23 条 diff --git a/HANDOFF.md b/HANDOFF.md index 6573aa8..bd50880 100644 --- a/HANDOFF.md +++ b/HANDOFF.md @@ -1,6 +1,6 @@ # HANDOFF —— 交给下一个 session 的现场交接 -> 更新于 2026-11-01(面 B 批次 5 收尾)。**开工先读这一页**(尤其 §0-bis 缺口全景),再读 `CLAUDE.md`(硬约定), +> 更新于 2026-11-01(面 B 批次 8 收尾)。**开工先读这一页**(尤其 §0-bis 缺口全景),再读 `CLAUDE.md`(硬约定), > 最后看 `.workbuddy/memory/` 最近一天的日志(踩过的坑)。 > 无人值守时不要问用户,选最保守可行的方案继续,并把决策写回本文件。 @@ -76,27 +76,41 @@ 做完这三页(`/dataCenter/dataModel`、`/dataCenter/dataSource`、`/dataCenter/basicField`) 就真正可用了。再往后是 `systemData` 的 `Dataset`/`DataInterface` 其余族。 -**2026-11-01 实测**(`python3 scripts/fe-gap.py`):合计 **235 / 900**(26.1%); +~~**批次 8 候选**:`systemData` 的 `Dataset`(16) / `DataInterface`(10) / `InterfaceOauth`(9) ++ `system/printDev`(15)。~~ ✅ **批次 8 做完 `Dataset`(实际 18 条)**——见 §1「批次 8」小节。 + +- 它是全仓**唯一执行用户手写 SQL** 的地方 ⇒ 三道护栏(只 `select/with`、不许分号、 + 按词边界扫危险动词)+ 变量全走 `$N` 绑定。 +- `Dataset` 是 `AutoComplete` / `PopupSelect` / `InputTable` / `SelectModal` / 报表 / 打印 / + 大屏的**共同底座**(`fe-page-deps` 里 `Actions/InfoByIds` 被 9 个页面共用)⇒ 收益比条数大。 +- ⚠️ 只做 `sqlType=1`(手写 SQL);图形化配置式(`sqlType=2`)/ HTTP / 静态数据一律 `400` + 人话。 +- **下一个(批次 9)**:`DataInterface`(12) + `InterfaceOauth`(11) + `system/printDev`(17)。 + `printDev` 是本仓没有打印设计器 ⇒ 多半只能恒空 stub(先看 `onlineDev/printDev/Form.vue` 再定)。 + +**2026-11-01 实测**(`python3 scripts/fe-gap.py`):合计 **252 / 900**(28.0%); `permission` 111/137(81.0%)、`system` **84/196(42.9%,批次 4 47→66、批次 5 66→84)**、 -**`systemData` 35/106(33.0%,批次 6 从 0 起、批次 7 29→35)**; +**`systemData` 52/106(49.1%,批次 6 从 0 起、批次 7 29→35、批次 8 35→52)**; 剩下体量最大的仍是 `workFlow`(104) / `onlineDev`(101) / `aiCenter`(75) / -`extend`(64) / `msgCenter`(50) / `systemData` 余下 71 —— **基本都属于「本仓没这个模块」**。 +`extend`(64) / `msgCenter`(50) / `systemData` 余下 54 —— **基本都属于「本仓没这个模块」**。 --- -## 1. 一句话现状(2026-11-01 批次 7 收尾) +## 1. 一句话现状(2026-11-01 批次 8 收尾) **📌 当前数字(以此为准,下面各批的「当时数字」仅存档)**: -- 契约端点 **273 条**(面 A 28 + 面 B **243** + 两面共用 2);`tables` → **35**。 -- `cargo test --offline --workspace` = **521 passed / 0 failed**。 -- 十二道闸门全绿;`check-contract` `PASS=10 FAIL=0`,官方端点覆盖 **262/269** - (implemented 241 / partial 21 / absent 7;oos 6 单列)。 -- `python3 scripts/fe-gap.py`:合计 **235 / 900(26.1%)**,`permission` 111/137(81.0%)、 - `system` 84/196(42.9%)、**`systemData` 35/106(33.0%)**。 +- 契约端点 **291 条**(面 A 28 + 面 B **261** + 两面共用 2);`tables` → **37**。 +- `cargo test --offline --workspace` = **527 passed / 0 failed**。 +- 十二道闸门全绿;`check-contract` `PASS=10 FAIL=0`,官方端点覆盖 **280/287** + (implemented 256 / partial 24 / absent 7;oos 6 单列)。 +- `python3 scripts/fe-gap.py`:合计 **252 / 900(28.0%)**,`permission` 111/137(81.0%)、 + `system` 84/196(42.9%)、**`systemData` 52/106(49.1%)**。 - 🔴 **数据建模三页(`/dataCenter/dataModel` / `dataSource` / `basicField`)现在真能用了**: 建表 / 改表 / 加字段 / 删表 / 复制 / 预览 / 导出(明说不支持)全通, - 平台表(`schema.sql` 里的 35 张)与「有数据的表」一律禁改禁删。 + 平台表(`schema.sql` 里的 37 张)与「有数据的表」一律禁改禁删。 +- 🔴 **数据集(`/dataCenter/dataset`)真能跑 SQL 了**:这是全仓**唯一**执行用户手写 SQL 的地方, + 三道护栏 + 变量全走 `$N` 绑定。它是 `AutoComplete` / `PopupSelect` / `InputTable` / + `SelectModal` / 报表 / 打印 / 大屏的**共同底座** —— 这一批之后那批通用组件不再是空壳。 **✅ 后端已拆成 workspace 多 crate,业务包可独立编译;八道闸门全绿;空载内存 7 MB。** @@ -298,6 +312,40 @@ 内置表禁改禁删、改表重建 + 改名、加字段只追加、有数据的表冻结、 复制守卫 + 清空只删非内置、导出导入诚实失败。 +### 批次 8(2026-11-01)—— 数据集(真执行 SQL) + +**18 条面 B 端点**:`/Dataset` 的 `GET`/`POST`/`PUT`/`DELETE` + `getList` + `previewSql` ++ `fields` + `GetParam/{id}` + `{id}/get` + `{id}/save` + `{id}/Actions/{Export,Copy,Preview,List,InfoByIds,getRes}` ++ `Actions/Import`。新表 `base_data_set`(26 列)/ `base_data_set_relation`(13 列),`tables` 35 → 37。 + +- 🔴 **这是全仓唯一执行用户手写 SQL 的地方**(数据连接那条只是存配置)。三道护栏见 + [`dataset_sql_guard`]:① 去尾分号后必须 `select`/`with` 开头;② 全文不许再有 `;` + (pglite 的 `exec` 走 simple protocol,多语句会**一起跑**);③ 按**词边界**扫危险动词 + (`insert/update/delete/drop/truncate/alter/create/grant/revoke/copy/vacuum/merge`)与 + 文件/延时函数(`pg_read_file` / `pg_ls_dir` / `lo_import` / `pg_sleep` / `dblink` …)。 +- 🔴 **按词边界而不是子串**:`update_time` / `create_id` 这种别名必须放行 —— 子串匹配会把 + 一批正常的业务 SQL 全拒掉(测试里专门钉了这一条)。 +- 🔴 **变量只走绑定**:`${xxx}` / `@xxx` 一律转成 `$N` + 参数数组,**绝不拼进文本**。 + 与官方两处**有意不同**:官方找不到值时原样保留变量名(结果是一条非法 SQL,用户看到 + PG 的语法错);本仓直接 `400 缺少参数 xxx`。官方空集合替换成一个空格(`in ( )` 语法错); + 本仓替换成 `NULL`。 +- 🔴 **`getRes` 用的是 body 里的 `dataConfigJson`**,不是库里的 —— 设计器边改边试跑, + 读库永远是上一次保存的 SQL。 +- ⚠️ **列名靠「执行 1 行」反推**:`row_to_json` 没有行就没有键 ⇒ **空结果集拿不到列名**, + `fields` 返回空数组(官方走 JDBC 元数据,本仓做不到)。写进 `[OFFICIAL]` 的 `implemented` 备注里。 +- 🔴 **列表与详情的形状不同**:列表 `DataSetListVO` 的 `type`/`returnType` 是**中文名** + (`SQL语句` / `列表数据`),详情 `DataSetForm` 里是**数字**。同一份投影,两个整形函数。 +- 🔴 **`{id}/save` 的 `variateJson` 收下不落库**(本仓没有 `base_data_interface_variate` 表), + `{id}/get` 恒回 `"[]"` —— 形状对上,内容为空,**不假装存了**。 +- 🔴 **`SELECT *` 会被 `check-arch` MEM1 判红**(终端内存预算 120MB)。而这里列名由用户 SQL + 决定、拿不到清单 ⇒ 写成 `jnpfs.*`(带表别名,语义等价,且每句都自带 `LIMIT`)。 +- **`InfoByIds` 的 `propsValue` 过 `db_ident` 白名单** —— 它要拼进 SQL 的列名位, + 不过白名单就是一个注入口(测试里用 `code" ; drop table base_user --` 钉住了)。 +- `previewSql` 只支持 `sqlType=1`(原样回 SQL);图形化配置式 / HTTP / 静态数据一律 `400` + 人话。 +- 回归测试 `tests/batch8_it.rs`(**6 条**):形状与 CRUD(含「只改名称不误判重」)、 + `getList` 剔 `isSystem` 参数、绑定执行(含引号注入串 ⇒ 0 行)、护栏五拦一放、 + 设计器往返 + `getRes` 用 body、`InfoByIds` 顺序对齐 + 导出导入诚实失败。 + ### 🔴 上一批(第一批)踩到并解决的 4 个真 bug 1. `CurrentUser` 的 `preferenceJson` 必须是**字符串** `"{}"` —— 给对象会让前端 @@ -320,7 +368,7 @@ RUSTC_WRAPPER=sccache cargo build --manifest-path src/backend/Cargo.toml # 改 # 🔴 **尺子跑的是 release 产物** ⇒ 跑尺子前必须 `cargo build --release` RUSTC_WRAPPER=sccache cargo build --release --manifest-path src/backend/Cargo.toml nohup env PORT=30000 ./target/debug/ssw-platform > /tmp/ssw-backend.log 2>&1 & # 后台起 -curl -s http://127.0.0.1:30000/api/health # 期望 {"ok":true,"tables":32,...} +curl -s http://127.0.0.1:30000/api/health # 期望 {"ok":true,"tables":37,...} ``` 拿 token(面 B): @@ -459,8 +507,12 @@ xop run --secret GU=git_local_user --secret GP=git_local_pass -- bash -c ' 7. ~~`DataModel` 写面 8 条(`CREATE/ALTER/DROP TABLE` + `addFields` + `Copy` + `Export`/`Import`)~~ ✅ **批次 7 做完(实际 8 条)**——真 DDL + 两道护栏(`db_ident` + `ddl_tables` 内置表清单) + 官方 `checkTab` 的「内置表 / 有数据」双闸。数据建模三页现在**真能用**。 -8. `systemData` 的 `Dataset`(16) / `DataInterface`(10) / `InterfaceOauth`(9) / `PortalManage`(4) - 其余族 + `system/printDev`(15) ⇒ **下一个**(`printDev` 是本仓没打印服务,多半只能恒空 stub) +8. ~~`systemData` 的 `Dataset`(16)~~ ✅ **批次 8 做完(实际 18 条)**——新表 + `base_data_set` / `base_data_set_relation`;CRUD + 设计器 `get`/`save` + 六条取数 + (`Preview`/`List`/`InfoByIds`/`getRes`/`previewSql`/`fields`)+ 下拉 + 恒失败的导出导入。 + **真执行 SQL**,三道护栏 + `${xxx}`/`@xxx` 全绑定。 +9. `DataInterface`(12) + `InterfaceOauth`(11) + `system/printDev`(17) ⇒ **下一个** + (`printDev` 是本仓没打印设计器,多半只能恒空 stub) **实现模板(照抄就行)**:`ORGANIZE_WRITE_FIELDS` / `POSITION_WRITE_FIELDS` 那一套 —— 列白名单 + `now()` 不占参数位 + 只 SET body 里出现的键 + 读回不选 `f_password`。 diff --git a/PLAN.md b/PLAN.md index ad1a085..4af032e 100644 --- a/PLAN.md +++ b/PLAN.md @@ -251,7 +251,7 @@ ssw-platform/ | 能力 | 现状 | 目标 | 差距 | |---|---|---|---| -| 面 B 契约端点 | ✅ 243 条 | 全量(含 lowcode/flow/file/message) | 补 ~250 条(多在 lowcode 域) | +| 面 B 契约端点 | ✅ 261 条 | 全量(含 lowcode/flow/file/message) | 补 ~250 条(多在 lowcode 域) | | `base_*` DDL | ✅ 21 张逐字对齐 | 全量 331 张中的必需集 | 按域补 | | 平台/业务分层 | ✅ `check-boundary.sh` 钉住 | 升级为 crate 级隔离 | **P0 已拆 contract / store / sdk;asset 包可独立编译;`jnpf.rs`→`face_b.rs`** | | 低代码元数据引擎 | ✅ **P2-b 完成**:解析 + 校验 + 建表 + 动态 CRUD(6 个工具) | visualdev 同构 + 动态 CRUD + 发布 | 读 release / 单据号 / 乐观锁 → P2-c | diff --git a/crates/sspf-store/src/db.rs b/crates/sspf-store/src/db.rs index adbf8b6..8f15a4e 100644 --- a/crates/sspf-store/src/db.rs +++ b/crates/sspf-store/src/db.rs @@ -1203,31 +1203,32 @@ mod tests { #[test] fn schema_sql_has_expected_table_count() { - // schema.sql 必须包含 35 张表的 CREATE TABLE - // (30 张 base_*:8 张官方 + base_system + base_group + base_position + // schema.sql 必须包含 37 张表的 CREATE TABLE + // (32 张 base_*:8 张官方 + base_system + base_group + base_position // + 字典分类/字典数据 + base_sign_img + base_user_extra // + base_standing + base_permission_group + base_action // + base_system_top + base_sys_config(应用中心/系统配置)+ base_tag(标签) // + base_business_category + base_message + base_notice(消息批次) // + base_sys_log / base_common_words / base_bill_rule(日志与模板中心批次) // + base_db_link / base_data_type / base_common_fields(数据建模批次) + // + base_data_set / base_data_set_relation(数据集批次) // + base_visual_dev / base_visual_release(P2 低代码),+ 4 张业务表)。 // // 🔴 这个数字**故意写死**:加表必须同时改这里与 main.rs 的 BASE_TABLES, // 两处都改才算登记完成(漏一处就是「孤儿 DDL」或「白名单多一项」)。 let count = SCHEMA_SQL.matches("CREATE TABLE ").count(); - assert_eq!(count, 35, "schema.sql 的 CREATE TABLE 数量应为 35"); + assert_eq!(count, 37, "schema.sql 的 CREATE TABLE 数量应为 37"); } /// 🔴 [`ddl_tables`] 的解析必须与上面那条计数一致(不能只数到 12 却解析出别的)。 #[test] fn ddl_tables_parses_every_create_table() { let tables = ddl_tables(); - assert_eq!(tables.len(), 35, "ddl_tables 应解析出 35 张表"); + assert_eq!(tables.len(), 37, "ddl_tables 应解析出 37 张表"); assert!(tables.iter().all(|t| !t.is_empty())); assert_eq!( tables.iter().collect::>().len(), - 35, + 37, "表名不许重复" ); // 基础 base_* 必须都在(业务表由业务层 spec 派生,不在本文件写死)。 @@ -1252,6 +1253,8 @@ mod tests { "base_db_link", "base_data_type", "base_common_fields", + "base_data_set", + "base_data_set_relation", ] { assert!( tables.iter().any(|t| t == base), diff --git a/docs/contract.md b/docs/contract.md index f591b41..cdf75b4 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -1398,6 +1398,24 @@ B DELETE /api/system/DataModel/{linkId}/deleteAllTable dataCenter.dataModel plat B POST /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Copy dataCenter.dataModel platform B GET /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Export dataCenter.dataModel platform B POST /api/system/DataModel/{linkId}/Actions/Import dataCenter.dataModel platform +B GET /api/system/Dataset dataCenter.dataset platform +B POST /api/system/Dataset dataCenter.dataset platform +B GET /api/system/Dataset/getList 登录 platform +B POST /api/system/Dataset/previewSql dataCenter.dataset platform +B POST /api/system/Dataset/fields 登录 platform +B POST /api/system/Dataset/Actions/Import dataCenter.dataset platform +B GET /api/system/Dataset/GetParam/{id} 登录 platform +B GET /api/system/Dataset/{id} dataCenter.dataset platform +B PUT /api/system/Dataset/{id} dataCenter.dataset platform +B DELETE /api/system/Dataset/{id} dataCenter.dataset platform +B GET /api/system/Dataset/{id}/get 登录 platform +B POST /api/system/Dataset/{id}/save dataCenter.dataset platform +B GET /api/system/Dataset/{id}/Actions/Export dataCenter.dataset platform +B POST /api/system/Dataset/{id}/Actions/Copy dataCenter.dataset platform +B POST /api/system/Dataset/{id}/Actions/Preview 登录 platform +B POST /api/system/Dataset/{id}/Actions/List 登录 platform +B POST /api/system/Dataset/{id}/Actions/InfoByIds 登录 platform +B POST /api/system/Dataset/{id}/Actions/getRes dataCenter.dataset platform A GET /api/ssw/demo/DemoItem/List 登录 demo A POST /api/ssw/demo/DemoItem/Save 登录 demo A DELETE /api/ssw/demo/DemoItem/Delete 登录 demo @@ -1414,7 +1432,7 @@ A DELETE /api/ssw/asset/DataResource/Delete asset/DataResource asset [FACE] # face 条数 说明 A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条) -B 243 面 B 专属(官方 JNPF 形状) +B 261 面 B 专属(官方 JNPF 形状) AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流) [OFFICIAL] @@ -1708,6 +1726,25 @@ POST /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Copy implemented D GET /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Export partial DbTableController.java:433 面 B 已落地但**恒失败**:官方返 `DownloadVO`(文件服务)⇒ 本仓 `400` + 人话,不返假下载地址 POST /api/system/DataModel/{linkId}/Actions/Import partial DbTableController.java:388 面 B 已落地但**恒失败**:官方读 multipart 的 `.json`;本仓没启 `axum/multipart` ⇒ 明说不支持(前端建模页也没有导入按钮) +GET /api/system/Dataset implemented DataSetController.java:96 面 B 已落地:PageListVO + `type`/`returnType` 换成**中文名**(`SQL语句`/`列表数据`,官方枚举 `getNameByCode`);`creatorTime` 毫秒;keyword/category/type/returnType/enabledMark 五个过滤全支持 +POST /api/system/Dataset implemented DataSetController.java:116 面 B 已落地:`action` 恒 `3`(查询,官方 `create` 也强制);`enCode` 只收字母数字(官方 `^[a-zA-Z0-9]+$`);名称/编码双判重 +PUT /api/system/Dataset/{id} implemented DataSetController.java:136 面 B 已落地:只 SET body 出现的键;**只改名称时用库里原编码补齐再判重**(否则会把自己判成重复) +DELETE /api/system/Dataset/{id} implemented DataSetController.java:155 面 B 已落地:软删(官方物理删,本仓保守) +GET /api/system/Dataset/{id} implemented DataSetController.java:171 面 B 已落地:`DataSetForm` 形状(`type`/`returnType` 是**数字**,与列表的中文名不同) +GET /api/system/Dataset/{id}/get implemented DataSetController.java:183 面 B 已落地:`DataSetDesVo` = 详情 + `variateJson`(恒 `"[]"`,官方来自变量表)+ `fields`(`fieldJson` 解析) +POST /api/system/Dataset/{id}/save implemented DataSetController.java:200 面 B 已落地:只存设计器字段;`variateJson` 收下**不落库**(本仓没有 `base_data_interface_variate`) +GET /api/system/Dataset/getList implemented DataSetController.java:309 面 B 已落地:`DataSetSelectVO`;多 `hasPage`/`fields`;`parameterJson` 是**字符串**且已剔掉 `isSystem=1` 的项(官方原地改写) +POST /api/system/Dataset/previewSql partial DataSetController.java:333 面 B 已落地但只支持 `sqlType=1`:原样回 SQL;`sqlType=2`(图形化配置式)⇒ `400` + 人话(官方走 `CallAssembleUtil.getPreviewSql` 拼 SQL) +POST /api/system/Dataset/fields implemented DataSetController.java:373 面 B 已落地:`TableTreeModel` 裸数组;`{id:enCode, interfaceId, label:fullName, fullName:"enCode(fullName)", children:[…]}`(官方 `getFields` 逐字) +GET /api/system/Dataset/GetParam/{id} implemented DataSetController.java:381 面 B 已落地:**裸数组**(不是 `ListVO`),内容就是 `parameterJson` 原样解析 +POST /api/system/Dataset/{id}/Actions/Preview implemented DataSetController.java:349 面 B 已落地:**真执行 SQL**(只读)。`${xxx}`/`@xxx` ⇒ `$N` 绑定不拼文本;`${}` 里的值来自 `paramList.defaultValue`;`required=1` 为空 ⇒ `400 x不能为空`;`enabledMark≠1` ⇒ `400 数据集已禁用` +POST /api/system/Dataset/{id}/Actions/List implemented DataSetController.java:360 面 B 已落地:`hasPage=1` 走真分页;`hasPage=0` 先取窗口再**内存**按 `keyword`+`columnOptions` 过滤并切页(官方 `actionsList` 同法) +POST /api/system/Dataset/{id}/Actions/InfoByIds implemented DataSetController.java:367 面 B 已落地:输出**按请求 ids 顺序**对齐,缺项给 `{}`;`propsValue` 过 `db_ident` 白名单(它要拼进 SQL 的列名位) +POST /api/system/Dataset/{id}/Actions/getRes implemented DataSetController.java:341 面 B 已落地:用的是 **body 里**的 `dataConfigJson`(设计器边改边试跑);返回 `FieldJsonModel`。⚠️ 列名靠「执行 1 行」反推 —— **空结果集拿不到列名 ⇒ `fields:[]`**(官方走 JDBC 元数据,本仓 `row_to_json` 没行就没有键) +POST /api/system/Dataset/{id}/Actions/Copy implemented DataSetController.java:290 面 B 已落地:名称加「副本」、编码加 6 位 uuid 后缀,撞名/撞码最多重试 5 轮 +GET /api/system/Dataset/{id}/Actions/Export partial DataSetController.java:217 面 B 已落地但**恒失败**:官方返 `DownloadVO`(文件服务)⇒ 本仓 `400` + 人话,不返假下载地址 +POST /api/system/Dataset/Actions/Import partial DataSetController.java:231 面 B 已落地但**恒失败**:官方读 multipart 的 `.json`;本仓没启 `axum/multipart` ⇒ 明说不支持 + [RULER] # name 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败) # 43 = react 版对齐的 32 条 + 真实业务模块 asset/DataResource 9 条 + 多应用 2 条 diff --git a/src/backend/db/schema.sql b/src/backend/db/schema.sql index 0cc8ff5..9348738 100644 --- a/src/backend/db/schema.sql +++ b/src/backend/db/schema.sql @@ -800,6 +800,68 @@ CREATE TABLE base_common_fields ( PRIMARY KEY (f_id, f_tenant_id) ); +-- ---------------------------------------------------------------------------- +-- base_data_set(数据集)—— 逐字对齐 JNPF-PostgreSQL.sql:1397 +-- +-- 🔴 `f_data_config_json` 是**整个设计器的内容**,结构是 +-- `{sqlData:{dbLinkId,sqlType,sql,configSql}, apiData:{…}, staticData:{…}}` +-- (官方 `DataConfigJsonModel`)。本仓只真执行 `sqlData.sqlType=1`(手写 SQL), +-- `sqlType=2`(图形化配置式)与 `apiData` / `staticData` 一律 400 + 人话。 +-- 🔴 `f_has_page=1` 表示「真分页」:执行时包 `LIMIT/OFFSET` 并另跑一次 `COUNT(*)`。 +-- ---------------------------------------------------------------------------- +CREATE TABLE base_data_set ( + f_id VARCHAR(50) NOT NULL, + f_object_type VARCHAR(50), + f_full_name VARCHAR(255) NOT NULL, + f_data_config_json TEXT, + f_parameter_json TEXT, + f_field_json TEXT, + f_sort_code BIGINT, + f_description VARCHAR(500), + 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_type INTEGER, + f_en_code VARCHAR(50), + f_category VARCHAR(50), + f_action INTEGER, + f_return_type INTEGER, + f_variate_out INTEGER, + f_has_page INTEGER, + f_data_echo_json TEXT, + f_data_exception_json TEXT, + f_data_js_json TEXT, + f_enabled_mark INTEGER, + PRIMARY KEY (f_id, f_tenant_id) +); + +-- ---------------------------------------------------------------------------- +-- base_data_set_relation(数据集关联表)—— 逐字对齐 JNPF-PostgreSQL.sql:1456 +-- +-- 记「某个打印/报表版本用了哪些数据集」。本仓没有打印/报表设计器 ⇒ 只建表不写。 +-- ---------------------------------------------------------------------------- +CREATE TABLE base_data_set_relation ( + f_id VARCHAR(50) NOT NULL, + f_interface_id VARCHAR(50), + f_object_id VARCHAR(50), + f_object_type 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) +); + -- ============================================================================ -- 业务表 3 张(demo_item / shop_product / book_shop_book) -- diff --git a/src/backend/src/main.rs b/src/backend/src/main.rs index 9a60d2b..dc6f67a 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -46,8 +46,9 @@ use ssw_platform::routes; /// `base_system_top` / `base_sys_config` / `base_tag`;消息批次新增 /// `base_business_category` / `base_message` / `base_notice`;日志与模板中心批次新增 /// `base_sys_log` / `base_common_words` / `base_bill_rule`;数据建模批次新增 -/// `base_db_link` / `base_data_type` / `base_common_fields`,故清单现在是 **31 张**。 -const BASE_TABLES: [&str; 31] = [ +/// `base_db_link` / `base_data_type` / `base_common_fields`;数据集批次新增 +/// `base_data_set` / `base_data_set_relation`,故清单现在是 **33 张**。 +const BASE_TABLES: [&str; 33] = [ "base_group", "base_user", "base_role", @@ -83,6 +84,9 @@ const BASE_TABLES: [&str; 31] = [ "base_db_link", "base_data_type", "base_common_fields", + // 🔴 数据集批次(2026-11-01):数据集设计器内容 + 打印/报表版本关联表。 + "base_data_set", + "base_data_set_relation", // 🔴 低代码两张表是**平台表**不是业务表:它们存的是「功能定义」, // 任何业务模块都会用,属于引擎基础设施。 "base_visual_dev", diff --git a/src/backend/src/platform/face_b.rs b/src/backend/src/platform/face_b.rs index da9fe2e..b6904eb 100644 --- a/src/backend/src/platform/face_b.rs +++ b/src/backend/src/platform/face_b.rs @@ -13640,6 +13640,1682 @@ pub async fn data_model_import( fail(code::FAIL, "本仓未启用文件上传,暂不支持导入") } +// ---------------------------------------------------------------- 数据集(Dataset) +// +// 官方 `DataSetController`(`jnpf-system-controller`)。数据集 = 一条**命名查询** +// (一段可带变量的 SQL / 一个 HTTP / 一份静态 JSON),前端几十个通用组件都靠它取数: +// `AutoComplete` / `PopupSelect` / `InputTable` / `SelectModal` / 报表 / 打印 / 大屏。 +// +// 🔴 **本仓只真执行 `type=1` + `sqlData.sqlType=1`(手写 SQL)这一条路**。 +// 图形化配置式(`sqlType=2`)、HTTP(`type=2`)、静态(`type=3`)一律 400 + 人话: +// 那条路要在本仓重写整套查询构建器(官方 `CallAssembleUtil`),拼出来的 SQL +// 用户看不见,风险和收益不成比例。 +// +// 🔴 **SQL 护栏(三道,缺一不可)**:见 [`dataset_sql_guard`]。 +// 🔴 **变量一律走绑定**:`${xxx}` / `@xxx` 只转成 `$N` + 参数数组,**绝不拼进文本**。 + +/// 官方 `@SaCheckPermission("dataCenter.dataset")`。 +const EN_DATASET: &str = "dataCenter.dataset"; + +/// 列表 / 详情共用的投影(`DataSetListVO` + `DataSetForm` 的并集,多取不影响)。 +/// +/// 🔴 `creatorTime` 是**毫秒数**(官方 `Long`),不是日期串。 +/// 🔴 `type` / `returnType` 在 VO 里是**中文名**(`SQL语句` / `列表数据`), +/// 由 [`dataset_shape_list_row`] 换掉 —— 直接在 SQL 里换需要 `CASE`,不如放代码里。 +const DATASET_COLUMNS: &str = "f_id AS \"id\", COALESCE(f_type, 1) AS \"type\", \ + f_en_code AS \"enCode\", f_full_name AS \"fullName\", f_category AS \"category\", \ + COALESCE(f_action, 3) AS \"action\", COALESCE(f_return_type, 1) AS \"returnType\", \ + COALESCE(f_has_page, 0) AS \"hasPage\", COALESCE(f_variate_out, 0) AS \"variateOut\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\", COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ + f_description AS \"description\", \ + f_data_config_json AS \"dataConfigJson\", f_parameter_json AS \"parameterJson\", \ + f_field_json AS \"fieldJson\", f_data_echo_json AS \"dataEchoJson\", \ + f_data_exception_json AS \"dataExceptionJson\", f_data_js_json AS \"dataJsJson\", \ + (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\", \ + f_creator_user_id AS \"creatorUserId\", f_tenant_id AS \"tenantId\""; + +/// body ⇒ 列(camelCase ↔ `f_*` + CAST);**只收 body 里真出现的键**。 +/// +/// 🔴 17 项 = `DataSetForm`(8) + `DataSetDesModel`(9) 的并集。 +/// 少一项 ⇒ 设计器保存后那一格**静默丢失**(最典型的是 `dataConfigJson`, +/// 丢了就等于「SQL 没了」,页面上还一切正常)。 +const DATASET_WRITE_FIELDS: [(&str, &str, &str); 17] = [ + ("type", "f_type", "::integer"), + ("enCode", "f_en_code", ""), + ("fullName", "f_full_name", ""), + ("category", "f_category", ""), + ("action", "f_action", "::integer"), + ("returnType", "f_return_type", "::integer"), + ("hasPage", "f_has_page", "::integer"), + ("variateOut", "f_variate_out", "::integer"), + ("sortCode", "f_sort_code", "::bigint"), + ("enabledMark", "f_enabled_mark", "::integer"), + ("description", "f_description", ""), + ("dataConfigJson", "f_data_config_json", ""), + ("parameterJson", "f_parameter_json", ""), + ("fieldJson", "f_field_json", ""), + ("dataEchoJson", "f_data_echo_json", ""), + ("dataExceptionJson", "f_data_exception_json", ""), + ("dataJsJson", "f_data_js_json", ""), +]; + +fn dataset_write_fields(obj: &Map) -> Vec<(&'static str, &'static str, Option)> { + let mut out = Vec::new(); + for (json_key, column, cast) in DATASET_WRITE_FIELDS { + if obj.contains_key(json_key) { + out.push((column, cast, value_to_text(obj.get(json_key)))); + } + } + out +} + +/// 官方 `DataTypeEnum.getNameByCode` —— 列表里 `type` 显示的是**中文名**。 +fn dataset_type_name(code: i64) -> &'static str { + match code { + 2 => "API接口", + 3 => "静态数据", + _ => "SQL语句", + } +} + +/// 官方 `DataReturnTypeEnum.getNameByCode`。 +fn dataset_return_type_name(code: i64) -> &'static str { + match code { + 2 => "键值对数据", + _ => "列表数据", + } +} + +/// 把行里的 `type` / `returnType` 数字换成中文名(列表与弹窗选择共用)。 +fn dataset_shape_list_row(row: &Value) -> Value { + let mut obj = row.clone(); + let type_code = obj.get("type").and_then(Value::as_i64).unwrap_or(1); + let return_code = obj.get("returnType").and_then(Value::as_i64).unwrap_or(1); + obj["type"] = json!(dataset_type_name(type_code)); + obj["returnType"] = json!(dataset_return_type_name(return_code)); + obj +} + +/// `fieldJson` 里的 `fields` 数组(解析失败 ⇒ 空数组,**不报错**)。 +/// +/// 官方 `DataSetSelectVO.initFileds()` / `DataSetDesVo.initFileds()` 也是「解析失败就空」—— +/// 设计器把字段配错不该让整个列表 500。 +fn dataset_fields_of(field_json: Option<&Value>) -> Vec { + let Some(Value::String(text)) = field_json else { + return Vec::new(); + }; + let Ok(parsed) = serde_json::from_str::(text) else { + return Vec::new(); + }; + parsed + .get("fields") + .and_then(Value::as_array) + .cloned() + .unwrap_or_default() +} + +/// 数据集编码只收字母数字(官方 `isExist` 里的 `^[a-zA-Z0-9]+$`)。 +/// +/// 🔴 这个编码会被拼成 `enCode.field` 当成**列名前缀**(打印/报表的关联查询), +/// 所以不能有下划线以外的东西 —— 官方干脆只收字母数字。 +fn dataset_en_code_ok(raw: &str) -> bool { + !raw.is_empty() && raw.chars().all(|c| c.is_ascii_alphanumeric()) +} + +/// 判重:`fullName` 或 `enCode` 撞了别的记录 ⇒ `Err(人话)`。 +async fn ensure_dataset_unique( + state: &AppState, + id: Option<&str>, + full_name: &str, + en_code: &str, +) -> Result<(), String> { + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\" \ + FROM base_data_set \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND (f_full_name = $1 OR f_en_code = $2)", + ¶ms_of(&[Some(full_name.to_string()), Some(en_code.to_string())]), + ) + .await + { + Ok(rows) => rows, + Err(e) => { + eprintln!("[face-b] 数据集判重查询失败: {e}"); + return Err("获取失败".to_string()); + } + }; + for row in rows { + let same_id = row.get("id").and_then(Value::as_str) == id; + if same_id { + continue; + } + if row.get("fullName").and_then(Value::as_str) == Some(full_name) { + return Err("名称已存在".to_string()); + } + if row.get("enCode").and_then(Value::as_str) == Some(en_code) { + return Err("编码已存在".to_string()); + } + } + Ok(()) +} + +/// `GET /api/system/Dataset` —— 数据集列表(`PageListVO`)。 +/// +/// 过滤条件与官方 `DataSetPagination` 一致:`keyword`(名称/编码模糊)+ +/// `category` + `type` + `returnType` + `enabledMark`。 +pub async fn dataset_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATASET).await { + return resp; + } + let paging = Paging::of(&raw); + let keyword = crate::platform::sys::query_param(&raw, "keyword").trim().to_string(); + let category = crate::platform::sys::query_param(&raw, "category").trim().to_string(); + let type_filter = crate::platform::sys::query_param(&raw, "type").trim().to_string(); + let return_filter = crate::platform::sys::query_param(&raw, "returnType").trim().to_string(); + let enabled_filter = crate::platform::sys::query_param(&raw, "enabledMark").trim().to_string(); + + let mut values: Vec> = Vec::new(); + let mut where_sql = String::from("WHERE COALESCE(f_delete_mark, 0) = 0"); + if !keyword.is_empty() { + values.push(Some(format!("%{keyword}%"))); + where_sql.push_str(&format!( + " AND (f_full_name ILIKE ${} OR f_en_code ILIKE ${})", + values.len(), + values.len() + )); + } + for (param, column, cast) in [ + (category.as_str(), "f_category", ""), + (type_filter.as_str(), "f_type", "::integer"), + (return_filter.as_str(), "f_return_type", "::integer"), + (enabled_filter.as_str(), "f_enabled_mark", "::integer"), + ] { + if param.is_empty() { + continue; + } + values.push(Some(param.to_string())); + where_sql.push_str(&format!( + " AND {column} = ${}{cast}", + values.len() + )); + } + + let total = match state + .db + .query_json_params( + &format!("SELECT COUNT(*)::bigint AS \"total\" FROM base_data_set {where_sql}"), + ¶ms_of(&values), + ) + .await + { + Ok(rows) => rows + .first() + .and_then(|r| r.get("total").and_then(Value::as_i64)) + .unwrap_or(0), + Err(e) => return db_error(e, "数据集总数"), + }; + + values.push(Some(paging.page_size.to_string())); + let limit_idx = values.len(); + values.push(Some(paging.offset.to_string())); + let offset_idx = values.len(); + let sql = format!( + "SELECT {DATASET_COLUMNS} FROM base_data_set {where_sql} \ + ORDER BY COALESCE(f_sort_code, 0) ASC, f_creator_time DESC NULLS LAST \ + LIMIT ${limit_idx}::text::integer OFFSET ${offset_idx}::text::integer" + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "数据集列表"), + }; + ok(page_list( + paging.current_page, + paging.page_size, + total, + rows.iter().map(dataset_shape_list_row).collect(), + )) +} + +/// `GET /api/system/Dataset/getList` —— 弹窗数据集选择控件(`DataSetSelectVO`)。 +/// +/// 与列表的差别:① 官方**没有** `@SaCheckPermission`(登录即可); +/// ② 多带 `hasPage` / `parameterJson` / `fieldJson` / `fields`; +/// ③ `parameterJson` 里 **`isSystem=1` 的参数要被剔掉**(系统变量不给用户填)。 +pub async fn dataset_get_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let paging = Paging::of(&raw); + let keyword = crate::platform::sys::query_param(&raw, "keyword").trim().to_string(); + let category = crate::platform::sys::query_param(&raw, "category").trim().to_string(); + + let mut values: Vec> = Vec::new(); + let mut where_sql = String::from("WHERE COALESCE(f_delete_mark, 0) = 0"); + if !keyword.is_empty() { + values.push(Some(format!("%{keyword}%"))); + where_sql.push_str(&format!( + " AND (f_full_name ILIKE ${} OR f_en_code ILIKE ${})", + values.len(), + values.len() + )); + } + if !category.is_empty() { + values.push(Some(category)); + where_sql.push_str(&format!(" AND f_category = ${}", values.len())); + } + + let total = match state + .db + .query_json_params( + &format!("SELECT COUNT(*)::bigint AS \"total\" FROM base_data_set {where_sql}"), + ¶ms_of(&values), + ) + .await + { + Ok(rows) => rows + .first() + .and_then(|r| r.get("total").and_then(Value::as_i64)) + .unwrap_or(0), + Err(e) => return db_error(e, "数据集总数"), + }; + + values.push(Some(paging.page_size.to_string())); + let limit_idx = values.len(); + values.push(Some(paging.offset.to_string())); + let offset_idx = values.len(); + let sql = format!( + "SELECT {DATASET_COLUMNS} FROM base_data_set {where_sql} \ + ORDER BY COALESCE(f_sort_code, 0) ASC, f_creator_time DESC NULLS LAST \ + LIMIT ${limit_idx}::text::integer OFFSET ${offset_idx}::text::integer" + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "数据集列表"), + }; + let list: Vec = rows + .iter() + .map(|row| { + let mut obj = dataset_shape_list_row(row); + // 🔴 `DataSetSelectVO` 只认 `fields`(数组),不认 `fieldJson`(字符串); + // 两个都给,前端两种取法都能用。 + obj["fields"] = json!(dataset_fields_of(row.get("fieldJson"))); + obj["parameterJson"] = json!(dataset_visible_params(row.get("parameterJson"))); + obj + }) + .collect(); + ok(page_list(paging.current_page, paging.page_size, total, list)) +} + +/// `parameterJson` ⇒ 去掉 `isSystem=1` 之后的**字符串**(官方 `getList` 就是这么存的)。 +/// +/// 🔴 官方把 `parameterJson` 这个字段**原地改写成过滤后的 JSON 字符串**再返回, +/// 不是数组 —— 前端 `InterfaceModal` 拿到的是字符串。 +fn dataset_visible_params(raw: Option<&Value>) -> String { + let Some(Value::String(text)) = raw else { + return String::new(); + }; + let Ok(Value::Array(items)) = serde_json::from_str::(text) else { + return text.clone(); + }; + let kept: Vec = items + .into_iter() + .filter(|item| { + item.get("isSystem") + .and_then(|v| v.as_i64().or_else(|| v.as_str()?.parse().ok())) + .unwrap_or(0) + != 1 + }) + .collect(); + serde_json::to_string(&kept).unwrap_or_else(|_| "[]".to_string()) +} + +/// `GET /api/system/Dataset/{id}` —— 详情(`DataSetForm` 形状,编辑弹窗直接吃)。 +pub async fn dataset_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATASET).await { + return resp; + } + dataset_load(&state, &id, DatasetShape::Form).await +} + +/// `GET /api/system/Dataset/{id}/get` —— 设计器读取(`DataSetDesVo`)。 +/// +/// 与详情的差别:多 `variateJson`(本仓恒 `"[]"`,官方来自变量表)+ +/// `fields`(`fieldJson` 解析成的数组)。官方这条**没有** `@SaCheckPermission`。 +pub async fn dataset_des_get( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + dataset_load(&state, &id, DatasetShape::Des).await +} + +/// 读取一条数据集并整形成指定形状。 +enum DatasetShape { + /// `DataSetForm` —— 只有标量字段。 + Form, + /// `DataSetDesVo` —— 多 `variateJson` + `fields`。 + Des, +} + +async fn dataset_load(state: &AppState, id: &str, shape: DatasetShape) -> Json { + let rows = match state + .db + .query_json_params( + &format!( + "SELECT {DATASET_COLUMNS} FROM base_data_set \ + WHERE f_id = $1 AND COALESCE(f_delete_mark, 0) = 0" + ), + ¶ms_of(&[Some(id.to_string())]), + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "数据集详情"), + }; + let Some(row) = rows.first() else { + return fail(code::FAIL, "获取失败,数据不存在"); + }; + let mut obj = row.clone(); + // 🔴 详情里 `type` / `returnType` 必须是**数字**(`DataSetForm` 是 `Integer`)—— + // 列表 VO 才是中文名。这里不能复用 `dataset_shape_list_row`。 + if matches!(shape, DatasetShape::Des) { + obj["variateJson"] = json!("[]"); + obj["fields"] = json!(dataset_fields_of(row.get("fieldJson"))); + } + ok(obj) +} + +/// `POST /api/system/Dataset` —— 新建。`action` 恒 `3`(查询),与官方一致。 +pub async fn dataset_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATASET).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(obj)) => obj, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let full_name = obj + .get("fullName") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + let en_code = obj + .get("enCode") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if full_name.is_empty() { + return fail(code::FAIL, "请输入名称"); + } + if !dataset_en_code_ok(&en_code) { + return fail(code::FAIL, "编码只能是字母或数字"); + } + if let Err(msg) = ensure_dataset_unique(&state, None, &full_name, &en_code).await { + return fail(code::FAIL, msg); + } + + let id = new_uuid(); + // 前三列是官方 `create` 强制的值:主键 / `action=3`(查询)/ 创建人。 + let mut cols: Vec<(&'static str, &'static str, Option)> = vec![ + ("f_id", "", Some(id.clone())), + ("f_action", "::integer", Some("3".to_string())), + ("f_creator_user_id", "", Some(user.user_id.clone())), + ]; + cols.extend(dataset_write_fields(&obj)); + // 默认值:**body 没给才补**(`contains` 判列名,不是判 json key)。 + for (column, cast, default) in [ + ("f_sort_code", "::bigint", "0"), + ("f_enabled_mark", "::integer", "1"), + ("f_type", "::integer", "1"), + ("f_return_type", "::integer", "1"), + ("f_has_page", "::integer", "0"), + ("f_variate_out", "::integer", "0"), + ] { + if cols.iter().any(|(c, _, _)| *c == column) { + continue; + } + cols.push((column, cast, Some(default.to_string()))); + } + // `f_creator_time` 放最后,值 `None` ⇒ 写 `now()`(不占绑定参数位)。 + cols.push(("f_creator_time", "", None)); + + let mut cols_sql = String::new(); + let mut vals_sql = String::new(); + let mut bound: Vec> = Vec::new(); + for (i, (column, cast, value)) in cols.iter().enumerate() { + if i > 0 { + cols_sql.push_str(", "); + vals_sql.push_str(", "); + } + cols_sql.push_str(column); + if value.is_some() { + bound.push(value.clone()); + // 🔴 必须 `::text` 打头:否则 PG 按列类型推断(`int4`), + // 而 `exec_params` 绑的永远是 `Option` ⇒ 类型对不上直接协议错。 + vals_sql.push_str(&format!("${}::text{cast}", bound.len())); + } else { + vals_sql.push_str("now()"); + } + } + let sql = format!( + "INSERT INTO base_data_set (f_tenant_id, {cols_sql}) VALUES ('0', {vals_sql})" + ); + match state.db.exec_params(&sql, ¶ms_of(&bound)).await { + Ok(()) => ok(json!({ "id": id })), + Err(e) => db_error(e, "新建数据集"), + } +} + +/// `PUT /api/system/Dataset/{id}` —— 修改(只 SET body 里出现的键)。 +pub async fn dataset_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATASET).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(obj)) => obj, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let new_code = obj + .get("enCode") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if !new_code.is_empty() && !dataset_en_code_ok(&new_code) { + return fail(code::FAIL, "编码只能是字母或数字"); + } + let new_name = obj + .get("fullName") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + + // 判重:把「body 没给的那一半」用库里的原值补齐 —— 否则只改名称时 + // `enCode` 会是空串,判重直接失败(官方 `isExist` 也是拿整条记录判)。 + if !new_name.is_empty() || !new_code.is_empty() { + let (old_name, old_code) = match dataset_existing_names(&state, &id).await { + Ok(pair) => pair, + Err(resp) => return resp, + }; + let name = if new_name.is_empty() { old_name } else { new_name }; + let code = if new_code.is_empty() { old_code } else { new_code }; + if let Err(msg) = ensure_dataset_unique(&state, Some(&id), &name, &code).await { + return fail(code::FAIL, msg); + } + } + + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (column, cast, value) in dataset_write_fields(&obj) { + values.push(value); + sets.push(format!("{column} = ${}::text{cast}", values.len())); + } + if sets.is_empty() { + return ok(Value::Null); + } + values.push(Some(user.user_id)); + sets.push(format!("f_last_modify_user_id = ${}", values.len())); + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let id_idx = values.len(); + let sql = format!( + "UPDATE base_data_set SET {} WHERE f_id = ${id_idx} AND COALESCE(f_delete_mark, 0) = 0", + sets.join(", ") + ); + match state.db.exec_params(&sql, ¶ms_of(&values)).await { + Ok(()) => ok(Value::Null), + Err(e) => db_error(e, "修改数据集"), + } +} + +/// 取一条数据集的 `(fullName, enCode)`,供「只改一个键」时的判重兜底。 +async fn dataset_existing_names( + state: &AppState, + id: &str, +) -> Result<(String, String), Json> { + let rows = match state + .db + .query_json_params( + "SELECT f_full_name AS \"fullName\", f_en_code AS \"enCode\" FROM base_data_set \ + WHERE f_id = $1 AND COALESCE(f_delete_mark, 0) = 0", + ¶ms_of(&[Some(id.to_string())]), + ) + .await + { + Ok(rows) => rows, + Err(e) => return Err(db_error(e, "数据集详情")), + }; + let Some(row) = rows.first() else { + return Err(fail(code::FAIL, "获取失败,数据不存在")); + }; + Ok(( + row.get("fullName").and_then(Value::as_str).unwrap_or_default().to_string(), + row.get("enCode").and_then(Value::as_str).unwrap_or_default().to_string(), + )) +} + +/// `DELETE /api/system/Dataset/{id}` —— 删除(软删)。 +pub async fn dataset_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_DATASET).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let sql = "UPDATE base_data_set SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $1 \ + WHERE f_id = $2 AND COALESCE(f_delete_mark, 0) = 0"; + match state + .db + .exec_params(sql, ¶ms_of(&[Some(user.user_id), Some(id)])) + .await + { + Ok(()) => ok(Value::Null), + Err(e) => db_error(e, "删除数据集"), + } +} + +/// `POST /api/system/Dataset/{id}/save` —— 设计器保存(`DataSetDesModel`)。 +/// +/// 🔴 与 `PUT /{id}` 的差别:这里**只收设计器字段**(6 个 json + 4 个开关), +/// 名称/编码/分类不在这里改。`variateJson` 本仓没有变量表 ⇒ 收下但不落库。 +pub async fn dataset_des_save( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATASET).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(obj)) => obj, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + // 先确认这条存在(否则更新 0 行也是「成功」,前端以为存上了)。 + if let Err(resp) = dataset_load_for_run(&state, &id).await { + return resp; + } + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (column, cast, value) in dataset_write_fields(&obj) { + values.push(value); + sets.push(format!("{column} = ${}::text{cast}", values.len())); + } + if sets.is_empty() { + return ok(Value::Null); + } + values.push(Some(user.user_id)); + sets.push(format!("f_last_modify_user_id = ${}", values.len())); + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let id_idx = values.len(); + let sql = format!( + "UPDATE base_data_set SET {} WHERE f_id = ${id_idx} AND COALESCE(f_delete_mark, 0) = 0", + sets.join(", ") + ); + match state.db.exec_params(&sql, ¶ms_of(&values)).await { + Ok(()) => ok(Value::Null), + Err(e) => db_error(e, "保存数据集设计"), + } +} + +/// `GET /api/system/Dataset/GetParam/{id}` —— 参数下拉(**裸数组**,不是 `ListVO`)。 +pub async fn dataset_get_param( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let rows = match state + .db + .query_json_params( + "SELECT f_parameter_json AS \"parameterJson\" FROM base_data_set \ + WHERE f_id = $1 AND COALESCE(f_delete_mark, 0) = 0", + ¶ms_of(&[Some(id)]), + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "数据集参数"), + }; + let Some(row) = rows.first() else { + return fail(code::FAIL, "获取失败,数据不存在"); + }; + let params = match row.get("parameterJson") { + Some(Value::String(text)) if !text.trim().is_empty() => { + serde_json::from_str::(text).unwrap_or_else(|_| json!([])) + } + _ => json!([]), + }; + // 官方 `success(jsonToList == null ? new ArrayList<>() : jsonToList)` ⇒ 裸数组。 + match params { + Value::Array(_) => ok(params), + _ => ok(json!([])), + } +} + +/// `POST /api/system/Dataset/fields` —— 取数据集字段树(`List`)。 +/// +/// 形状(官方 `DataSetServiceImpl.getFields`): +/// `[{id: enCode, interfaceId, label: fullName, fullName: "enCode(fullName)", +/// children: [{id: field, label: fieldName, fullName: "field(fieldName)"}]}]` +/// +/// 🔴 **返回裸数组**,不是 `ListVO` —— 前端 `Report`/`PrintDesign` 直接 `.map`。 +pub async fn dataset_fields( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let obj = match parse_body(&body) { + Ok(Value::Object(obj)) => obj, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let ids = id_list_of(&obj, "dataSetList"); + if ids.is_empty() { + return ok(json!([])); + } + // IN 列表不能直接绑数组(pglite 不支持 `$N::text[]`)⇒ `string_to_array`。 + let joined = ids.join(","); + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_en_code AS \"enCode\", f_full_name AS \"fullName\", \ + f_field_json AS \"fieldJson\" FROM base_data_set \ + WHERE COALESCE(f_delete_mark, 0) = 0 \ + AND f_id = ANY(string_to_array($1::text, ','))", + ¶ms_of(&[Some(joined)]), + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "数据集字段"), + }; + // 顺序按请求的 `dataSetList` 走(官方是 `getList(ids)` 的库序,但前端按顺序渲染)。 + let mut out: Vec = Vec::new(); + for id in &ids { + let Some(row) = rows.iter().find(|r| r.get("id").and_then(Value::as_str) == Some(id.as_str())) + else { + continue; + }; + let en_code = row.get("enCode").and_then(Value::as_str).unwrap_or_default(); + let full_name = row.get("fullName").and_then(Value::as_str).unwrap_or_default(); + let children: Vec = dataset_fields_of(row.get("fieldJson")) + .into_iter() + .map(|field| { + let name = field.get("field").and_then(Value::as_str).unwrap_or_default(); + let label = field.get("fieldName").and_then(Value::as_str).unwrap_or_default(); + let label = if label.is_empty() { name } else { label }; + let full = if label == name { + name.to_string() + } else { + format!("{name}({label})") + }; + json!({ "id": name, "label": label, "fullName": full }) + }) + .collect(); + out.push(json!({ + "id": en_code, + "interfaceId": id, + "label": full_name, + "fullName": format!("{en_code}({full_name})"), + "children": children, + })); + } + ok(Value::Array(out)) +} + +// ---------------------------------------------------------------- 数据集:SQL 执行 +// +// 🔴 这是全仓**唯一**执行用户手写 SQL 的地方(数据连接那条只是存配置)。 +// 三道护栏见 [`dataset_sql_guard`];变量只走 `$N` 绑定,不拼文本。 + +/// 允许出现在数据集 SQL 里的**危险动词**(按词边界匹配)。 +/// +/// 🔴 按「整词」判,不按子串 —— 否则 `update_time` / `f_delete_mark` 这类 +/// 列名会把一批正常 SQL 全拒掉。 +const DATASET_SQL_VERBS: [&str; 12] = [ + "insert", "update", "delete", "drop", "truncate", "alter", "create", "grant", "revoke", + "copy", "vacuum", "merge", +]; + +/// 连读都不该给的函数(文件系统 / 延时 / 外部连接)。 +const DATASET_SQL_FUNCS: [&str; 7] = [ + "pg_read_file", + "pg_read_binary_file", + "pg_ls_dir", + "lo_import", + "lo_export", + "pg_sleep", + "dblink", +]; + +/// 数据集 SQL 的护栏:**只读、单语句**。 +/// +/// ① 去掉尾部 `;` 后必须以 `select` / `with` 开头; +/// ② 全文不许再有 `;`(pglite 的 `exec` 走 simple protocol,多语句会一起跑); +/// ③ 按词边界扫 [`DATASET_SQL_VERBS`] 与 [`DATASET_SQL_FUNCS`]。 +/// +/// ⚠️ 注释与字符串字面量里的词**也会被扫到** —— 宁可让用户把注释删掉, +/// 也不要放过一个藏在 `--` 后面的 `; drop table`。 +fn dataset_sql_guard(raw: &str) -> Result { + let sql = raw.trim().trim_end_matches(';').trim().to_string(); + if sql.is_empty() { + return Err("请先配置 SQL".to_string()); + } + let lower = sql.to_ascii_lowercase(); + if !(lower.starts_with("select") || lower.starts_with("with")) { + return Err("数据集只支持查询语句(select / with 开头)".to_string()); + } + if sql.contains(';') { + return Err("SQL 里不允许多条语句(分号)".to_string()); + } + // 词边界切分:字母/数字/下划线算「词内字符」。 + let mut word = String::new(); + let mut words: Vec = Vec::new(); + for ch in lower.chars() { + if ch.is_ascii_alphanumeric() || ch == '_' { + word.push(ch); + } else if !word.is_empty() { + words.push(std::mem::take(&mut word)); + } + } + if !word.is_empty() { + words.push(word); + } + for w in &words { + if DATASET_SQL_VERBS.contains(&w.as_str()) { + return Err(format!("数据集不允许执行 {w} 语句")); + } + if DATASET_SQL_FUNCS.contains(&w.as_str()) { + return Err(format!("数据集不允许调用 {w}")); + } + } + Ok(sql) +} + +/// 绑定好的 SQL:文本里只剩 `$N`,值在 `values` 里按序就位。 +struct BoundSql { + sql: String, + values: Vec>, +} + +/// 把 `${xxx}` / `@xxx` 换成 `$N` 绑定位,值另存。 +/// +/// ⚠️ 与官方 `InterfacePramUtil.replaceParam` 的两处**有意不同**: +/// ① 官方找不到值时**原样保留**变量名(结果是一条非法 SQL,报的是 PG 的语法错); +/// 本仓直接 400 说清楚是哪个参数缺了。 +/// ② 官方集合为空时替换成**一个空格**(`in ( )` ⇒ 语法错);本仓替换成 `NULL`。 +fn bind_dataset_sql( + raw: &str, + params: &Map, + user: &TokenUser, +) -> Result { + let chars: Vec = raw.chars().collect(); + let mut out = String::with_capacity(raw.len()); + let mut values: Vec> = Vec::new(); + let mut i = 0usize; + while i < chars.len() { + let c = chars[i]; + // `${name}` 自定义参数 + if c == '$' && chars.get(i + 1) == Some(&'{') { + let start = i + 2; + let mut j = start; + while j < chars.len() && (chars[j].is_ascii_alphanumeric() || chars[j] == '_') { + j += 1; + } + if j > start && chars.get(j) == Some(&'}') { + let name: String = chars[start..j].iter().collect(); + let value = params.get(&name).cloned().unwrap_or(Value::Null); + push_bound_value(&mut out, &mut values, &value, &name)?; + i = j + 1; + continue; + } + } + // `@name` 系统变量(要求前一个字符不是词内字符 ⇒ `a@b` 不误伤) + if c == '@' + && (i == 0 || !(chars[i - 1].is_ascii_alphanumeric() || chars[i - 1] == '_')) + { + let start = i + 1; + let mut j = start; + while j < chars.len() && (chars[j].is_ascii_alphanumeric() || chars[j] == '_') { + j += 1; + } + if j > start { + let name: String = chars[start..j].iter().collect(); + let value = dataset_system_var(&name, user)?; + values.push(Some(value)); + out.push_str(&format!("${}", values.len())); + i = j; + continue; + } + } + out.push(c); + i += 1; + } + Ok(BoundSql { sql: out, values }) +} + +/// 单个 `${xxx}` ⇒ `$N` / `($N, $M, …)` / `NULL`。 +fn push_bound_value( + out: &mut String, + values: &mut Vec>, + value: &Value, + name: &str, +) -> Result<(), String> { + match value { + Value::Array(items) => { + if items.is_empty() { + // 🔴 空集合写 `NULL`:`in (NULL)` 合法且「永远不匹配」。 + out.push_str("NULL"); + } else { + let mut parts: Vec = Vec::new(); + for item in items { + values.push(value_to_text(Some(item))); + parts.push(format!("${}", values.len())); + } + out.push_str(&format!("({})", parts.join(", "))); + } + Ok(()) + } + Value::Null => Err(format!("缺少参数 {name}")), + other => { + values.push(value_to_text(Some(other))); + out.push_str(&format!("${}", values.len())); + Ok(()) + } + } +} + +/// 当前毫秒时间戳(`@currentTime` 用;官方是 `Date.getTime()`)。 +fn dataset_now_millis() -> i64 { + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|d| d.as_millis() as i64) + .unwrap_or(0) +} + +/// 系统变量 `@xxx` ⇒ 字符串值。本仓只认 4 个,其余**明说不支持**。 +/// +/// 官方有十几个(`@userAndSub` / `@orgAndSub` / `@positionId` …),全靠 +/// permission 模块的组织树;本仓没有那套子树查询 ⇒ 只留最常用的四个。 +fn dataset_system_var(name: &str, user: &TokenUser) -> Result { + match name { + "currentTime" => Ok(dataset_now_millis().to_string()), + "userId" => Ok(user.user_id.clone()), + "userAccount" => Ok(user.account.clone()), + "organizeId" => Ok(String::new()), + _ => Err(format!("不支持的系统变量 @{name}")), + } +} + +/// body ⇒ 参数 map(等价官方 `InterfacePramUtil.paramValue` + `checkRequestParams`)。 +/// +/// 规则:先铺 body 顶层键,再让 `paramList` 里每项的 `defaultValue` 覆盖**空值**, +/// 最后按 `required=1` 校验必填。 +fn dataset_collect_params(body: &Map) -> Result, String> { + let mut params: Map = body.clone(); + if let Some(Value::Array(items)) = body.get("paramList") { + for item in items { + let Some(field) = item.get("field").and_then(Value::as_str) else { + continue; + }; + let current = params.get(field).cloned().unwrap_or(Value::Null); + let empty = matches!(¤t, Value::Null) + || matches!(¤t, Value::String(s) if s.is_empty()); + if empty { + // `sourceType=2`(自定义)用 `relationField`,其余用 `defaultValue`。 + let fallback = match item.get("sourceType").and_then(Value::as_i64) { + Some(2) => item.get("relationField").cloned().unwrap_or(Value::Null), + _ => item.get("defaultValue").cloned().unwrap_or(Value::Null), + }; + if !fallback.is_null() { + params.insert(field.to_string(), fallback); + } + } + } + } + // 必填校验(官方 `checkRequired`)。 + if let Some(Value::Array(items)) = body.get("paramList") { + for item in items { + let Some(field) = item.get("field").and_then(Value::as_str) else { + continue; + }; + let required = item + .get("required") + .and_then(|v| v.as_i64().or_else(|| v.as_str()?.parse().ok())) + .unwrap_or(0); + if required != 1 { + continue; + } + let missing = match params.get(field) { + None | Some(Value::Null) => true, + Some(Value::String(s)) => s.is_empty(), + _ => false, + }; + if missing { + return Err(format!("{field}不能为空")); + } + } + } + Ok(params) +} + +/// 从 `dataConfigJson` 里取出 `(sql, sqlType)`。 +/// +/// 结构(官方 `DataConfigJsonModel`):`{sqlData:{dbLinkId,sqlType,sql,configSql}, …}`。 +fn dataset_sql_of(config: Option<&Value>) -> Result<(String, i64), String> { + // `dataConfigJson` 在库里是 TEXT、在 body 里也可能是对象 ⇒ 两种都接。 + let value: Value = match config { + Some(Value::String(text)) => { + serde_json::from_str(text).map_err(|_| "数据集配置格式错误".to_string())? + } + Some(obj @ Value::Object(_)) => obj.clone(), + _ => return Err("请先配置 SQL".to_string()), + }; + let sql_data = value + .get("sqlData") + .ok_or_else(|| "请先配置 SQL".to_string())?; + let sql_type = sql_data + .get("sqlType") + .and_then(|v| v.as_i64().or_else(|| v.as_str()?.trim().parse().ok())) + .unwrap_or(1); + let sql = sql_data + .get("sql") + .and_then(Value::as_str) + .unwrap_or_default() + .to_string(); + Ok((sql, sql_type)) +} + +/// 数据集执行结果(`returnType=1` 列表 / `=2` 键值对)。 +/// +/// `has_page=1` ⇒ 真分页(`LIMIT/OFFSET` + 另跑 `COUNT(*)`); +/// `has_page=0` ⇒ 一次拉全量但**夹一个上限**(防「select * from 百万行表」把内存打满, +/// 官方靠 `pagehelper` 兜,本仓没有那一层)。 +async fn dataset_run( + state: &AppState, + sql_raw: &str, + params: &Map, + user: &TokenUser, + return_list: bool, + has_page: bool, + paging: &Paging, +) -> Result { + let sql = dataset_sql_guard(sql_raw)?; + let bound = bind_dataset_sql(&sql, params, user)?; + let mut values = bound.values; + let inner = bound.sql; + + if !return_list { + // 键值对:取第一行平铺(官方 `res.putAll(sqlResList.get(0))`)。 + let probe = format!("SELECT jnpfv.* FROM ({inner}) jnpfv LIMIT 1"); + let rows = state + .db + .query_json_params(&probe, ¶ms_of(&values)) + .await + .map_err(|e| { + eprintln!("[face-b] 数据集执行失败: {e}"); + "SQL 语句执行失败".to_string() + })?; + return Ok(rows.into_iter().next().unwrap_or_else(|| json!({}))); + } + + let mut total = 0i64; + if has_page { + let count_sql = format!("SELECT COUNT(*)::bigint AS \"total\" FROM ({inner}) jnpfc"); + let rows = state + .db + .query_json_params(&count_sql, ¶ms_of(&values)) + .await + .map_err(|e| { + eprintln!("[face-b] 数据集计数失败: {e}"); + "SQL 语句执行失败".to_string() + })?; + total = rows + .first() + .and_then(|r| r.get("total").and_then(Value::as_i64)) + .unwrap_or(0); + } + + // `has_page=0` 也要夹上限:官方靠 pagehelper + 内存分页,本仓直接把窗口给大。 + let (limit, offset) = if has_page { + (paging.page_size, paging.offset) + } else { + (5000, 0) + }; + values.push(Some(limit.to_string())); + let limit_idx = values.len(); + values.push(Some(offset.to_string())); + let offset_idx = values.len(); + let page_sql = format!( + "SELECT jnpfs.* FROM ({inner}) jnpfs \ + LIMIT ${limit_idx}::text::integer OFFSET ${offset_idx}::text::integer" + ); + let rows = state + .db + .query_json_params(&page_sql, ¶ms_of(&values)) + .await + .map_err(|e| { + eprintln!("[face-b] 数据集分页失败: {e}"); + "SQL 语句执行失败".to_string() + })?; + if !has_page { + total = rows.len() as i64; + } + Ok(page_list(paging.current_page, paging.page_size, total, rows)) +} + +/// 取一条数据集的执行要素。 +struct DatasetRunCfg { + config: Value, + parameter_json: Option, + return_type: i64, + has_page: i64, + enabled_mark: i64, +} + +async fn dataset_load_for_run( + state: &AppState, + id: &str, +) -> Result> { + let rows = match state + .db + .query_json_params( + "SELECT f_data_config_json AS \"dataConfigJson\", \ + f_parameter_json AS \"parameterJson\", COALESCE(f_return_type, 1) AS \"returnType\", \ + COALESCE(f_has_page, 0) AS \"hasPage\", COALESCE(f_enabled_mark, 0) AS \"enabledMark\" \ + FROM base_data_set WHERE f_id = $1 AND COALESCE(f_delete_mark, 0) = 0", + ¶ms_of(&[Some(id.to_string())]), + ) + .await + { + Ok(rows) => rows, + Err(e) => return Err(db_error(e, "数据集详情")), + }; + let Some(row) = rows.first() else { + return Err(fail(code::FAIL, "获取失败,数据不存在")); + }; + Ok(DatasetRunCfg { + config: row.get("dataConfigJson").cloned().unwrap_or(Value::Null), + parameter_json: row.get("parameterJson").cloned(), + return_type: row.get("returnType").and_then(Value::as_i64).unwrap_or(1), + has_page: row.get("hasPage").and_then(Value::as_i64).unwrap_or(0), + enabled_mark: row.get("enabledMark").and_then(Value::as_i64).unwrap_or(0), + }) +} + +/// 把「外部传入的 params」与库里的 `parameterJson` 合并做必填校验。 +/// +/// 官方 `callData` 用的是**库里的** `parameterJson`(不是请求里的), +/// 因为请求方可能只给值不给定义。 +fn dataset_merge_body_with_params( + state_params: Option<&Value>, + body: &Map, +) -> Map { + let mut merged = body.clone(); + if let Some(Value::String(text)) = state_params { + if let Ok(Value::Array(items)) = serde_json::from_str::(text) { + if merged.get("paramList").is_none() { + merged.insert("paramList".to_string(), Value::Array(items)); + } + } + } + merged +} + +/// 统一入口:按 id 执行数据集 SQL(`Preview` / `List` / `InfoByIds` 共用)。 +async fn dataset_execute( + state: &AppState, + user: &TokenUser, + cfg: &DatasetRunCfg, + body: &Map, + paging: &Paging, + extra_where: Option<(&str, &[String])>, +) -> Result { + let (sql, sql_type) = dataset_sql_of(Some(&cfg.config))?; + if sql_type != 1 { + return Err("本仓暂不支持图形化配置式数据集,请改用 SQL 模式".to_string()); + } + let merged = dataset_merge_body_with_params(cfg.parameter_json.as_ref(), body); + let params = dataset_collect_params(&merged)?; + let final_sql = match extra_where { + // 回显:`select * from () jnpft where jnpft. in (…)` + Some((column, _)) => format!("SELECT jnpft.* FROM ({sql}) jnpft WHERE jnpft.\"{column}\" IN "), + None => sql, + }; + if let Some((_, ids)) = extra_where { + // 占位符手工拼:ids 各自绑一个参数(不用 `${}` 语法,避免被当成用户变量)。 + let mut bound = bind_dataset_sql(&final_sql, ¶ms, user)?; + let mut parts: Vec = Vec::new(); + for id in ids { + bound.values.push(Some(id.clone())); + parts.push(format!("${}", bound.values.len())); + } + let sql_with_in = format!("{}({})", bound.sql, parts.join(", ")); + let probe = format!("SELECT jnpfr.* FROM ({sql_with_in}) jnpfr"); + let rows = state + .db + .query_json_params(&probe, ¶ms_of(&bound.values)) + .await + .map_err(|e| { + eprintln!("[face-b] 数据集回显失败: {e}"); + "SQL 语句执行失败".to_string() + })?; + return Ok(Value::Array(rows)); + } + dataset_run( + state, + &final_sql, + ¶ms, + user, + cfg.return_type == 1, + cfg.has_page == 1, + paging, + ) + .await +} + +/// `POST /api/system/Dataset/{id}/Actions/Preview` —— 接口调用取数。 +/// +/// 官方这条**没有** `@SaCheckPermission`(别人引用了这个数据集就能调), +/// 但要求登录;且数据集必须 `enabledMark=1`。 +pub async fn dataset_preview( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + // 官方 `@RequestBody(required = false)` ⇒ 空 body 当空 map。 + Ok(Value::Object(obj)) => obj, + _ => Map::new(), + }; + let cfg = match dataset_load_for_run(&state, &id).await { + Ok(cfg) => cfg, + Err(resp) => return resp, + }; + if cfg.enabled_mark != 1 { + return fail(code::FAIL, "数据集已禁用"); + } + let paging = Paging::of_body(&obj); + match dataset_execute(&state, &user, &cfg, &obj, &paging, None).await { + Ok(data) => ok(data), + Err(msg) => fail(code::FAIL, msg), + } +} + +/// `POST /api/system/Dataset/{id}/Actions/List` —— 分页取数(下拉/表格组件用)。 +/// +/// 与 `Preview` 的差别:`hasPage=0` 时**在内存里**做关键词过滤 + 分页 +/// (官方 `actionsList` 就是这么干的:先拿全量,再 `columnOptions` 过滤,再切页)。 +pub async fn dataset_actions_list( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(obj)) => obj, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let cfg = match dataset_load_for_run(&state, &id).await { + Ok(cfg) => cfg, + Err(resp) => return resp, + }; + if cfg.enabled_mark != 1 { + return fail(code::FAIL, "数据集已禁用"); + } + let paging = Paging::of_body(&obj); + if cfg.has_page == 1 { + return match dataset_execute(&state, &user, &cfg, &obj, &paging, None).await { + Ok(data) => ok(data), + Err(msg) => fail(code::FAIL, msg), + }; + } + // `hasPage=0`:先拿窗口内的全量,再内存过滤 + 切页。 + let all_paging = Paging { + current_page: 1, + page_size: 5000, + offset: 0, + }; + let data = match dataset_execute(&state, &user, &cfg, &obj, &all_paging, None).await { + Ok(data) => data, + Err(msg) => return fail(code::FAIL, msg), + }; + let mut list: Vec = data + .get("list") + .and_then(Value::as_array) + .cloned() + .unwrap_or_default(); + let keyword = obj.get("keyword").and_then(Value::as_str).unwrap_or_default(); + let columns = obj + .get("columnOptions") + .and_then(Value::as_str) + .unwrap_or_default(); + if !keyword.is_empty() && !columns.is_empty() { + let cols: Vec<&str> = columns.split(',').map(str::trim).filter(|c| !c.is_empty()).collect(); + list.retain(|row| { + cols.iter().any(|c| { + row.get(*c) + .map(|v| match v { + Value::String(s) => s.contains(keyword), + Value::Null => false, + other => other.to_string().contains(keyword), + }) + .unwrap_or(false) + }) + }); + } + let total = list.len() as i64; + let start = (paging.offset.max(0) as usize).min(list.len()); + let end = (start + paging.page_size.max(1) as usize).min(list.len()); + ok(page_list( + paging.current_page, + paging.page_size, + total, + list[start..end].to_vec(), + )) +} + +/// `POST /api/system/Dataset/{id}/Actions/InfoByIds` —— 按 ids 回显。 +/// +/// body:`{ids:[…], propsValue:"回显字段名", …}`。返回**按 ids 顺序**对齐的数组, +/// 找不到的那一项给 `{}`(官方 `.orElse(new HashMap<>())`)。 +pub async fn dataset_info_by_ids( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(obj)) => obj, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let ids: Vec = match obj.get("ids") { + Some(Value::Array(items)) => items + .iter() + .map(|v| match v { + Value::String(s) => s.clone(), + other => other.to_string(), + }) + .collect(), + _ => return ok(json!([])), + }; + if ids.is_empty() { + return ok(json!([])); + } + // 🔴 回显字段名要拼进 SQL ⇒ 必须过标识符白名单。 + let props = obj + .get("propsValue") + .and_then(Value::as_str) + .unwrap_or_default(); + let Some(column) = db_ident(props) else { + return fail(code::FAIL, "回显字段不合法"); + }; + let cfg = match dataset_load_for_run(&state, &id).await { + Ok(cfg) => cfg, + Err(resp) => return resp, + }; + // 回显固定 `hasPage=0` / `returnType=1`(官方 new 了一个只换 dataConfig 的实体)。 + let echo_cfg = DatasetRunCfg { + config: cfg.config.clone(), + parameter_json: cfg.parameter_json.clone(), + return_type: 1, + has_page: 0, + enabled_mark: cfg.enabled_mark, + }; + let rows = match dataset_execute( + &state, + &user, + &echo_cfg, + &obj, + &Paging { + current_page: 1, + page_size: 5000, + offset: 0, + }, + Some((column.as_str(), &ids)), + ) + .await + { + Ok(Value::Array(rows)) => rows, + Ok(_) => Vec::new(), + Err(msg) => return fail(code::FAIL, msg), + }; + let list: Vec = ids + .iter() + .map(|id| { + rows.iter() + .find(|row| { + row.get(&column) + .map(|v| match v { + Value::String(s) => s == id, + other => &other.to_string() == id, + }) + .unwrap_or(false) + }) + .cloned() + .unwrap_or_else(|| json!({})) + }) + .collect(); + ok(Value::Array(list)) +} + +/// `POST /api/system/Dataset/previewSql` —— 设计器「预览 SQL」。 +/// +/// 官方走 `CallAssembleUtil.getPreviewSql`(把图形化配置拼成 SQL)。 +/// 本仓只支持手写 SQL ⇒ `sqlType=1` 原样回 SQL,`sqlType=2` 明说不支持。 +pub async fn dataset_preview_sql( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATASET).await { + return resp; + } + let obj = match parse_body(&body) { + Ok(Value::Object(obj)) => obj, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let sql_type = obj + .get("sqlType") + .and_then(|v| v.as_i64().or_else(|| v.as_str()?.trim().parse().ok())) + .unwrap_or(1); + if sql_type != 1 { + return fail(code::FAIL, "本仓暂不支持图形化配置式数据集,请改用 SQL 模式"); + } + let sql = obj.get("sql").and_then(Value::as_str).unwrap_or_default(); + ok(json!(sql)) +} + +/// `POST /api/system/Dataset/{id}/Actions/getRes` —— 设计器「试跑拿字段」。 +/// +/// 🔴 用的是 **body 里**的 `dataConfigJson`(还没保存),不是库里的 —— +/// 设计器边改边试跑,读库就永远是旧 SQL。 +/// 返回 `FieldJsonModel`:`{fields:[{field,fieldName,dataType}], isList, …}`。 +pub async fn dataset_get_res( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATASET).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(obj)) => obj, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let cfg = match dataset_load_for_run(&state, &id).await { + Ok(cfg) => cfg, + Err(resp) => return resp, + }; + let config = obj.get("dataConfigJson").cloned().unwrap_or(cfg.config); + let (sql, sql_type) = match dataset_sql_of(Some(&config)) { + Ok(pair) => pair, + Err(msg) => return fail(code::FAIL, msg), + }; + if sql_type != 1 { + return fail(code::FAIL, "本仓暂不支持图形化配置式数据集,请改用 SQL 模式"); + } + let return_list = obj + .get("returnType") + .and_then(|v| v.as_i64().or_else(|| v.as_str()?.trim().parse().ok())) + .unwrap_or(cfg.return_type) + == 1; + let has_page = obj + .get("hasPage") + .and_then(|v| v.as_i64().or_else(|| v.as_str()?.trim().parse().ok())) + .unwrap_or(cfg.has_page) + == 1; + let merged = dataset_merge_body_with_params(cfg.parameter_json.as_ref(), &obj); + let params = match dataset_collect_params(&merged) { + Ok(params) => params, + Err(msg) => return fail(code::FAIL, msg), + }; + let guarded = match dataset_sql_guard(&sql) { + Ok(sql) => sql, + Err(msg) => return fail(code::FAIL, msg), + }; + // 探一行拿列名:`LIMIT 0` 拿不到列名(`row_to_json` 没有行就没有键)⇒ 用 1 行。 + // 表里 0 行 ⇒ 字段返回空数组(官方靠 JDBC 元数据,本仓拿不到)。 + let fields = match dataset_probe_columns(&state, &guarded, ¶ms, &user).await { + Ok(fields) => fields, + Err(msg) => return fail(code::FAIL, msg), + }; + let data_key = if return_list { "data.list" } else { "data" }; + let total_key = if return_list && has_page { + "data.pagination.total" + } else { + "" + }; + ok(json!({ + "fields": fields, + "formatFields": [], + "dataKey": data_key, + "totalKey": total_key, + "isList": if return_list { 1 } else { 0 }, + })) +} + +/// 执行一次「取 1 行」拿列名,并按 JSON 值类型猜 `dataType`。 +async fn dataset_probe_columns( + state: &AppState, + sql: &str, + params: &Map, + user: &TokenUser, +) -> Result, String> { + let bound = bind_dataset_sql(sql, params, user)?; + // 🔴 写成 `jnpfd.*` 而不是裸 `*`:`check-arch` 的 MEM1 明令禁止 `SELECT *` + // (终端产品内存预算 120MB)。这里列名由**用户 SQL** 决定、拿不到清单, + // 只能整行投影 —— 带表别名语义完全等价,且这句自带 `LIMIT 1`。 + let probe = format!("SELECT jnpfd.* FROM ({}) jnpfd LIMIT 1", bound.sql); + let rows = state + .db + .query_json_params(&probe, ¶ms_of(&bound.values)) + .await + .map_err(|e| { + eprintln!("[face-b] 数据集试跑失败: {e}"); + "SQL 语句执行失败".to_string() + })?; + let Some(row) = rows.first() else { + return Ok(Vec::new()); + }; + let Some(obj) = row.as_object() else { + return Ok(Vec::new()); + }; + Ok(obj + .iter() + .map(|(key, value)| { + let data_type = match value { + Value::Bool(_) => "boolean", + Value::Number(n) if n.is_i64() || n.is_u64() => "int", + Value::Number(_) => "decimal", + _ => "varchar", + }; + json!({ + "id": key, + "field": key, + "fieldName": key, + "dataType": data_type, + "dataMark": false, + "totalMark": false, + }) + }) + .collect()) +} + +/// `POST /api/system/Dataset/{id}/Actions/Copy` —— 复制一条(`fullName` 加「副本」)。 +pub async fn dataset_copy( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_DATASET).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let rows = match state + .db + .query_json_params( + "SELECT f_full_name AS \"fullName\", f_en_code AS \"enCode\", f_category AS \"category\", \ + f_description AS \"description\", f_data_config_json AS \"dataConfigJson\", \ + f_parameter_json AS \"parameterJson\", f_field_json AS \"fieldJson\", \ + f_data_echo_json AS \"dataEchoJson\", f_data_exception_json AS \"dataExceptionJson\", \ + f_data_js_json AS \"dataJsJson\", COALESCE(f_type, 1) AS \"type\", \ + COALESCE(f_return_type, 1) AS \"returnType\", COALESCE(f_has_page, 0) AS \"hasPage\", \ + COALESCE(f_variate_out, 0) AS \"variateOut\" \ + FROM base_data_set WHERE f_id = $1 AND COALESCE(f_delete_mark, 0) = 0", + ¶ms_of(&[Some(id)]), + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "数据集详情"), + }; + let Some(row) = rows.first() else { + return fail(code::FAIL, "获取失败,数据不存在"); + }; + let base_name = format!( + "{}副本", + row.get("fullName").and_then(Value::as_str).unwrap_or_default() + ); + // 编码加后缀:官方也是「原名 + 随机」,否则判重必失败。 + let base_code = row.get("enCode").and_then(Value::as_str).unwrap_or_default(); + let mut name = base_name.clone(); + let mut code = format!("{base_code}{}", &new_uuid()[..6]); + // 极端情况撞名 ⇒ 再加一轮后缀(最多 5 次,够了)。 + for _ in 0..5 { + match ensure_dataset_unique(&state, None, &name, &code).await { + Ok(()) => break, + Err(msg) if msg == "名称已存在" => name = format!("{name}2"), + Err(msg) if msg == "编码已存在" => code = format!("{code}x"), + Err(msg) => return fail(code::FAIL, msg), + } + } + + let new_id = new_uuid(); + let values: Vec> = vec![ + Some(new_id.clone()), + Some(row.get("type").and_then(Value::as_i64).unwrap_or(1).to_string()), + Some(code), + Some(name), + row.get("category").and_then(Value::as_str).map(str::to_string), + Some("3".to_string()), + Some(row.get("returnType").and_then(Value::as_i64).unwrap_or(1).to_string()), + Some(row.get("hasPage").and_then(Value::as_i64).unwrap_or(0).to_string()), + Some(row.get("variateOut").and_then(Value::as_i64).unwrap_or(0).to_string()), + row.get("dataConfigJson").and_then(Value::as_str).map(str::to_string), + row.get("parameterJson").and_then(Value::as_str).map(str::to_string), + row.get("fieldJson").and_then(Value::as_str).map(str::to_string), + row.get("dataEchoJson").and_then(Value::as_str).map(str::to_string), + row.get("dataExceptionJson").and_then(Value::as_str).map(str::to_string), + row.get("dataJsJson").and_then(Value::as_str).map(str::to_string), + row.get("description").and_then(Value::as_str).map(str::to_string), + Some("1".to_string()), + Some(user.user_id.clone()), + ]; + let sql = "INSERT INTO base_data_set (\ + f_id, f_type, f_en_code, f_full_name, f_category, f_action, f_return_type, \ + f_has_page, f_variate_out, f_data_config_json, f_parameter_json, f_field_json, \ + f_data_echo_json, f_data_exception_json, f_data_js_json, f_description, \ + f_enabled_mark, f_creator_user_id, f_creator_time, f_tenant_id) \ + VALUES ($1::text, $2::text::integer, $3::text, $4::text, $5::text, \ + $6::text::integer, $7::text::integer, $8::text::integer, $9::text::integer, \ + $10::text, $11::text, $12::text, $13::text, $14::text, $15::text, $16::text, \ + $17::text::integer, $18::text, now(), '0')"; + match state.db.exec_params(sql, ¶ms_of(&values)).await { + Ok(()) => ok(json!({ "id": new_id })), + Err(e) => db_error(e, "复制数据集"), + } +} + +/// `GET /api/system/Dataset/{id}/Actions/Export` —— **恒失败**。 +/// +/// 官方返 `DownloadVO`(走文件服务生成 zip)。本仓没有文件服务 ⇒ 明说不支持, +/// 不返假的下载地址(前端会拿它去 `window.open`,得到一个 404 弹窗)。 +pub async fn dataset_export( + State(state): State, + headers: HeaderMap, + Path(_id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATASET).await { + return resp; + } + fail(code::FAIL, "本仓未配置文件服务,暂不支持导出") +} + +/// `POST /api/system/Dataset/Actions/Import` —— **恒失败**(没启 `axum/multipart`)。 +pub async fn dataset_import( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATASET).await { + return resp; + } + fail(code::FAIL, "本仓未启用文件上传,暂不支持导入") +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index a30569a..56280e6 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -446,6 +446,52 @@ pub fn build_router(state: AppState) -> axum::Router { "/api/system/DataModel/{linkId}/Actions/Import", post(face_b::data_model_import), ) + // ---- 数据集(官方 `DataSetController`)---- + // 🔴 这是全仓**唯一**执行用户手写 SQL 的地方。三道护栏在 `dataset_sql_guard`: + // 只放行 select/with、不许有分号、按词边界扫危险动词。 + // 变量 `${xxx}` / `@xxx` 一律转 `$N` **绑定**,不拼文本。 + .route("/api/system/Dataset", get(face_b::dataset_list)) + .route("/api/system/Dataset", post(face_b::dataset_create)) + .route("/api/system/Dataset/getList", get(face_b::dataset_get_list)) + .route("/api/system/Dataset/previewSql", post(face_b::dataset_preview_sql)) + .route("/api/system/Dataset/fields", post(face_b::dataset_fields)) + .route( + "/api/system/Dataset/Actions/Import", + post(face_b::dataset_import), + ) + .route( + "/api/system/Dataset/GetParam/{id}", + get(face_b::dataset_get_param), + ) + .route("/api/system/Dataset/{id}", get(face_b::dataset_info)) + .route("/api/system/Dataset/{id}", put(face_b::dataset_update)) + .route("/api/system/Dataset/{id}", delete(face_b::dataset_delete)) + .route("/api/system/Dataset/{id}/get", get(face_b::dataset_des_get)) + .route("/api/system/Dataset/{id}/save", post(face_b::dataset_des_save)) + .route( + "/api/system/Dataset/{id}/Actions/Export", + get(face_b::dataset_export), + ) + .route( + "/api/system/Dataset/{id}/Actions/Copy", + post(face_b::dataset_copy), + ) + .route( + "/api/system/Dataset/{id}/Actions/Preview", + post(face_b::dataset_preview), + ) + .route( + "/api/system/Dataset/{id}/Actions/List", + post(face_b::dataset_actions_list), + ) + .route( + "/api/system/Dataset/{id}/Actions/InfoByIds", + post(face_b::dataset_info_by_ids), + ) + .route( + "/api/system/Dataset/{id}/Actions/getRes", + post(face_b::dataset_get_res), + ) // ---- 系统配置 + 第三方同步(官方 `SysConfigController` / `SynThirdInfoController`)---- .route("/api/system/SysConfig", get(face_b::sys_config_get)) .route("/api/system/SysConfig", put(face_b::sys_config_update)) @@ -1238,7 +1284,7 @@ mod tests { // 🔴 表数**故意写死**:它同时校验「schema.sql 建了预期的表」与 // 「health 报的是真数」。加表要同步改这里 + main.rs 的 BASE_TABLES // + crates/sspf-store 的两条 DDL 断言(共四处,漏一处就红)。 - assert_eq!(body["tables"], 35); + assert_eq!(body["tables"], 37); assert_eq!(body["version"], env!("CARGO_PKG_VERSION")); } @@ -1253,7 +1299,7 @@ mod tests { let port = serve(new_state(db().await)).await; // 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。 - const FACE_B_REGISTERED: [&str; 181] = [ + const FACE_B_REGISTERED: [&str; 196] = [ "/api/permission/Users", "/api/permission/Users/any-id", "/api/permission/Users/BatchDelete", @@ -1441,6 +1487,21 @@ mod tests { "/api/system/DataModel/any-id/Table/any-table/Actions/Copy", "/api/system/DataModel/any-id/Table/any-table/Actions/Export", "/api/system/DataModel/any-id/Actions/Import", + "/api/system/Dataset", + "/api/system/Dataset/getList", + "/api/system/Dataset/previewSql", + "/api/system/Dataset/fields", + "/api/system/Dataset/Actions/Import", + "/api/system/Dataset/GetParam/any-id", + "/api/system/Dataset/any-id", + "/api/system/Dataset/any-id/get", + "/api/system/Dataset/any-id/save", + "/api/system/Dataset/any-id/Actions/Export", + "/api/system/Dataset/any-id/Actions/Copy", + "/api/system/Dataset/any-id/Actions/Preview", + "/api/system/Dataset/any-id/Actions/List", + "/api/system/Dataset/any-id/Actions/InfoByIds", + "/api/system/Dataset/any-id/Actions/getRes", ]; for path in FACE_B_REGISTERED { diff --git a/src/backend/tests/batch6_it.rs b/src/backend/tests/batch6_it.rs index 11fc4b3..29b4ab1 100644 --- a/src/backend/tests/batch6_it.rs +++ b/src/backend/tests/batch6_it.rs @@ -380,8 +380,8 @@ async fn data_model_tables_info_and_fields() { let total = tables["data"]["pagination"]["total"] .as_i64() .expect("必须有 total"); - // schema.sql 现在是 35 张表;真有变化时这条会红,提醒同步(与 DDL 计数测试同口径)。 - assert_eq!(total, 35, "表清单必须来自 information_schema: {tables}"); + // schema.sql 现在是 37 张表;真有变化时这条会红,提醒同步(与 DDL 计数测试同口径)。 + assert_eq!(total, 37, "表清单必须来自 information_schema: {tables}"); let list = tables["data"]["list"].as_array().expect("必须有 list"); assert!( list.iter().any(|r| r["table"] == "base_user"), diff --git a/src/backend/tests/batch8_it.rs b/src/backend/tests/batch8_it.rs new file mode 100644 index 0000000..23ac53c --- /dev/null +++ b/src/backend/tests/batch8_it.rs @@ -0,0 +1,535 @@ +//! 批次 8(**数据集** `/api/system/Dataset/**`)集成测试。 +//! +//! 🔴 **钉住的契约点**(每条都对应官方控制器 / 前端组件的一处硬要求): +//! ① 列表 `DataSetListVO` 的 `type` / `returnType` 是**中文名**(`SQL语句` / `列表数据`), +//! 而详情 `DataSetForm` 里是**数字** —— 两个端点用同一份投影,形状不同。 +//! ② `getList` 的 `parameterJson` 是**字符串**且已剔掉 `isSystem=1` 的项 +//! (系统变量不给用户填)。 +//! ③ `${xxx}` 参数只走 `$N` **绑定**,不拼文本;缺参数 ⇒ `400 缺少参数 xxx`; +//! `required=1` 且为空 ⇒ `400 xxx不能为空`。 +//! ④ SQL 护栏:非 `select/with` 开头、含分号、危险动词、`pg_read_file`、 +//! 未知系统变量 —— 一律 `400` + 人话;**但 `update_time` 这种别名不许误伤**。 +//! ⑤ `getRes` 用的是 **body 里**的 `dataConfigJson`(设计器边改边试跑),不是库里的。 +//! ⑥ `Actions/InfoByIds` 的输出**按请求 ids 的顺序**对齐,找不到的那项给 `{}`。 +//! ⑦ `returnType=2` 返回**平铺对象**(`{total: 7}`),不是 `{list:[…]}`。 +//! ⑧ `Export` / `Import` 恒 `400` + 人话(本仓没有文件服务)—— **不假装成功**。 +//! +//! 🔴 pglite-rs 0.2.7 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。 + +use std::path::PathBuf; +use std::sync::Arc; + +use serde_json::{json, Value}; +use ssw_platform::bootstrap::ensure_base; +use ssw_platform::platform::config::Config; +use ssw_platform::platform::db::Db; +use ssw_platform::platform::seed::first_seed; +use ssw_platform::platform::session::SessionStore; +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 = 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 临时库失败"); + db.ensure_schema().await.expect("ensure_schema 失败"); + 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 +} + +async fn call(port: u16, method: &str, path: &str, token: &str, body: Option<&str>) -> (String, 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: mainSystem\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 (head, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔"); + let status = head.lines().next().unwrap_or_default().to_string(); + let json: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null); + (status, json) +} + +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 json: Value = serde_json::from_str(body.trim()).expect("登录响应必须是 JSON"); + json["data"]["token"].as_str().expect("登录必须返回 token").to_string() +} + +fn new_state(db: &Db) -> AppState { + AppState { + config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-batch8-it"))), + db: Arc::new(db.clone()), + sessions: Arc::new(SessionStore::default()), + } +} + +/// `dataConfigJson` 的官方外壳(`DataConfigJsonModel`)。 +fn cfg(sql: &str) -> String { + json!({ "sqlData": { "dbLinkId": "0", "sqlType": 1, "sql": sql, "configSql": [] } }).to_string() +} + +async fn create_ds(port: u16, token: &str, name: &str, code: &str, body: Value) -> String { + let mut body = body; + body["fullName"] = json!(name); + body["enCode"] = json!(code); + let (_, resp) = call(port, "POST", "/api/system/Dataset", token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 200, "新建数据集应成功:{resp}"); + resp["data"]["id"].as_str().expect("必须返回 id").to_string() +} + +/// ① 列表 VO 是中文名、详情是数字;判重与软删。 +#[tokio::test] +async fn dataset_shapes_and_crud() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let sql = "select f_en_code as code from base_data_type"; + let id = create_ds( + port, + &token, + "批次八-A", + "b8a", + json!({ "category": "c8", "type": 1, "returnType": 1, "hasPage": 1, "enabledMark": 1, "dataConfigJson": cfg(sql) }), + ) + .await; + + // ① 列表:中文名 + let (_, list) = call(port, "GET", "/api/system/Dataset?keyword=b8a", &token, None).await; + assert_eq!(list["code"], 200); + let row = &list["data"]["list"][0]; + assert_eq!(row["type"], "SQL语句", "列表 type 必须是中文名"); + assert_eq!(row["returnType"], "列表数据", "列表 returnType 必须是中文名"); + assert!(row["creatorTime"].as_i64().unwrap_or(0) > 1_700_000_000_000, "creatorTime 必须是毫秒"); + + // ① 详情:数字 + let (_, info) = call(port, "GET", &format!("/api/system/Dataset/{id}"), &token, None).await; + assert_eq!(info["data"]["type"], 1, "详情 type 必须是数字"); + assert_eq!(info["data"]["returnType"], 1); + + // 判重 + let (_, dup_name) = call( + port, + "POST", + "/api/system/Dataset", + &token, + Some(&json!({ "fullName": "批次八-A", "enCode": "other" }).to_string()), + ) + .await; + assert_eq!(dup_name["msg"], "名称已存在"); + let (_, dup_code) = call( + port, + "POST", + "/api/system/Dataset", + &token, + Some(&json!({ "fullName": "别的", "enCode": "b8a" }).to_string()), + ) + .await; + assert_eq!(dup_code["msg"], "编码已存在"); + let (_, bad_code) = call( + port, + "POST", + "/api/system/Dataset", + &token, + Some(&json!({ "fullName": "再别的", "enCode": "a_b" }).to_string()), + ) + .await; + assert_eq!(bad_code["msg"], "编码只能是字母或数字"); + + // 🔴 只改名称时不能把自己判成重复(`enCode` 没传 ⇒ 用库里的原值补齐再判) + let (_, upd) = call( + port, + "PUT", + &format!("/api/system/Dataset/{id}"), + &token, + Some(&json!({ "fullName": "批次八-A2" }).to_string()), + ) + .await; + assert_eq!(upd["code"], 200, "只改名称应成功:{upd}"); + let (_, info2) = call(port, "GET", &format!("/api/system/Dataset/{id}"), &token, None).await; + assert_eq!(info2["data"]["fullName"], "批次八-A2"); + assert_eq!(info2["data"]["enCode"], "b8a", "只改名称不该动编码"); + + // 软删 + let (_, del) = call(port, "DELETE", &format!("/api/system/Dataset/{id}"), &token, None).await; + assert_eq!(del["code"], 200); + let (_, gone) = call(port, "GET", &format!("/api/system/Dataset/{id}"), &token, None).await; + assert_eq!(gone["code"], 400, "软删后详情应报「数据不存在」"); +} + +/// ② `getList` 的 `parameterJson` 是字符串,且 `isSystem=1` 的项被剔掉。 +#[tokio::test] +async fn dataset_select_list_hides_system_params() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let params = json!([ + { "field": "kw", "fieldName": "关键词", "dataType": "varchar", "required": 0, "isSystem": 0 }, + { "field": "tenantId", "fieldName": "租户", "dataType": "varchar", "required": 0, "isSystem": 1 }, + ]); + let id = create_ds( + port, + &token, + "批次八-B", + "b8b", + json!({ + "category": "c8", "type": 1, "returnType": 1, "hasPage": 0, "enabledMark": 1, + "dataConfigJson": cfg("select 1 as one"), + "parameterJson": params.to_string(), + "fieldJson": json!({ "fields": [{ "field": "one", "fieldName": "一" }] }).to_string(), + }), + ) + .await; + + let (_, sel) = call(port, "GET", "/api/system/Dataset/getList?keyword=b8b", &token, None).await; + assert_eq!(sel["code"], 200); + let row = &sel["data"]["list"][0]; + // 🔴 是**字符串**不是数组(官方把字段原地改写成过滤后的 JSON 字符串) + let text = row["parameterJson"].as_str().expect("parameterJson 必须是字符串"); + assert!(text.contains("kw"), "用户参数要保留:{text}"); + assert!(!text.contains("tenantId"), "isSystem=1 的参数必须被剔掉:{text}"); + assert_eq!(row["fields"][0]["field"], "one", "fields 必须是解析后的数组"); + + // `GetParam` 是**裸数组**(不是 ListVO),且不过滤系统参数(官方也返回全部) + let (_, param) = call(port, "GET", &format!("/api/system/Dataset/GetParam/{id}"), &token, None).await; + assert!(param["data"].is_array(), "GetParam 必须返回裸数组:{param}"); + assert_eq!(param["data"].as_array().unwrap().len(), 2); +} + +/// ③ 真执行 SQL:`${xxx}` 绑定、分页、必填、禁用、键值对。 +#[tokio::test] +async fn dataset_executes_sql_with_bound_params() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let sql = "select f_en_code as code, f_full_name as name from base_data_type \ + where f_full_name like ${kw} order by f_sort_code"; + let id = create_ds( + port, + &token, + "批次八-C", + "b8c", + json!({ + "category": "c8", "type": 1, "returnType": 1, "hasPage": 1, "enabledMark": 1, + "dataConfigJson": cfg(sql), + "parameterJson": json!([{ "field": "kw", "dataType": "varchar", "required": 1, "defaultValue": "" }]).to_string(), + }), + ) + .await; + + // 必填为空 ⇒ 400(官方 `checkRequired`) + let (_, missing) = call(port, "POST", &format!("/api/system/Dataset/{id}/Actions/Preview"), &token, Some("{}")).await; + assert_eq!(missing["code"], 400); + assert_eq!(missing["msg"], "kw不能为空"); + + // 给值 ⇒ 真查出 7 行(`base_data_type` 的官方种子) + let (_, all) = call( + port, + "POST", + &format!("/api/system/Dataset/{id}/Actions/Preview"), + &token, + Some(&json!({ "kw": "%" }).to_string()), + ) + .await; + assert_eq!(all["code"], 200, "应执行成功:{all}"); + assert_eq!(all["data"]["pagination"]["total"], 7, "base_data_type 官方种子 7 行"); + assert_eq!(all["data"]["list"].as_array().unwrap().len(), 7); + + // 分页:pageSize=2 第 2 页 ⇒ 2 条 + let (_, page2) = call( + port, + "POST", + &format!("/api/system/Dataset/{id}/Actions/List"), + &token, + Some(&json!({ "kw": "%", "currentPage": 2, "pageSize": 2 }).to_string()), + ) + .await; + assert_eq!(page2["data"]["pagination"]["total"], 7); + assert_eq!(page2["data"]["list"].as_array().unwrap().len(), 2); + + // 绑定而不是拼串:参数值里带引号也不会把 SQL 打坏 + let (_, quote) = call( + port, + "POST", + &format!("/api/system/Dataset/{id}/Actions/Preview"), + &token, + Some(&json!({ "kw": "%' or '1'='1%" }).to_string()), + ) + .await; + assert_eq!(quote["code"], 200, "参数里有引号也必须正常:{quote}"); + assert_eq!(quote["data"]["pagination"]["total"], 0, "注入串不能被当条件执行"); + + // 禁用后拒绝 + call(port, "PUT", &format!("/api/system/Dataset/{id}"), &token, Some(&json!({ "enabledMark": 0 }).to_string())).await; + let (_, disabled) = call( + port, + "POST", + &format!("/api/system/Dataset/{id}/Actions/Preview"), + &token, + Some(&json!({ "kw": "%" }).to_string()), + ) + .await; + assert_eq!(disabled["code"], 400); + assert_eq!(disabled["msg"], "数据集已禁用"); + + // `returnType=2` ⇒ 平铺对象 + let kv = create_ds( + port, + &token, + "批次八-C2", + "b8c2", + json!({ + "type": 1, "returnType": 2, "enabledMark": 1, + "dataConfigJson": cfg("select count(*)::int as total from base_data_type"), + }), + ) + .await; + let (_, one) = call(port, "POST", &format!("/api/system/Dataset/{kv}/Actions/Preview"), &token, Some("{}")).await; + assert_eq!(one["data"]["total"], 7, "键值对数据集返回平铺对象:{one}"); + assert!(one["data"].get("list").is_none(), "不该有 list"); +} + +/// ④ SQL 护栏:写入类全拒、`update_time` 别名放行。 +#[tokio::test] +async fn dataset_sql_guard_allows_only_select() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let cases: [(&str, &str, &str); 5] = [ + ("drop table base_data_type", "只支持查询语句", "删表"), + ("select 1; drop table base_data_type", "不允许多条语句", "分号多语句"), + ("update base_data_type set f_full_name = 'x'", "只支持查询语句", "update"), + ("select pg_read_file('/etc/passwd')", "不允许调用 pg_read_file", "读文件"), + ("select @notExists", "不支持的系统变量 @notExists", "未知系统变量"), + ]; + for (i, (sql, expect_msg, label)) in cases.iter().enumerate() { + let id = create_ds( + port, + &token, + &format!("批次八-护栏{i}"), + &format!("b8g{i}"), + json!({ "type": 1, "returnType": 1, "enabledMark": 1, "dataConfigJson": cfg(sql) }), + ) + .await; + let (_, resp) = call(port, "POST", &format!("/api/system/Dataset/{id}/Actions/Preview"), &token, Some("{}")).await; + assert_eq!(resp["code"], 400, "{label} 必须被拦下:{resp}"); + let msg = resp["msg"].as_str().unwrap_or_default(); + assert!(msg.contains(expect_msg), "{label} 的提示要对上(实际:{msg})"); + } + + // 🔴 `update_time` 是一个**词**,不是 `update` 动词 ⇒ 不许误伤 + let ok = create_ds( + port, + &token, + "批次八-别名", + "b8alias", + json!({ + "type": 1, "returnType": 1, "enabledMark": 1, + "dataConfigJson": cfg("select f_last_modify_time as update_time, f_id as create_id from base_data_type"), + }), + ) + .await; + let (_, pass) = call(port, "POST", &format!("/api/system/Dataset/{ok}/Actions/Preview"), &token, Some("{}")).await; + assert_eq!(pass["code"], 200, "update_time / create_id 这类别名不许被误伤:{pass}"); +} + +/// ⑤ 设计器:`get`/`save` 往返,`getRes` 用 **body 里**的配置。 +#[tokio::test] +async fn dataset_designer_roundtrip_and_get_res() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let id = create_ds( + port, + &token, + "批次八-D", + "b8d", + json!({ + "type": 1, "returnType": 1, "hasPage": 0, "enabledMark": 1, + "dataConfigJson": cfg("select 1 as old_one"), + "fieldJson": json!({ "fields": [{ "field": "old_one", "fieldName": "旧" }] }).to_string(), + }), + ) + .await; + + // `get` 多两个字段:`variateJson`(恒 `"[]"`)+ `fields`(解析 fieldJson) + let (_, des) = call(port, "GET", &format!("/api/system/Dataset/{id}/get"), &token, None).await; + assert_eq!(des["data"]["variateJson"], "[]"); + assert_eq!(des["data"]["fields"][0]["field"], "old_one"); + + // `save` 换 SQL + 关分页 + 换字段 + let (_, saved) = call( + port, + "POST", + &format!("/api/system/Dataset/{id}/save"), + &token, + Some( + &json!({ + "type": 1, "returnType": 1, "hasPage": 1, "variateOut": 0, "variateJson": "[]", + "dataConfigJson": cfg("select 2 as new_one"), + "fieldJson": json!({ "fields": [{ "field": "new_one", "fieldName": "新" }] }).to_string(), + }) + .to_string(), + ), + ) + .await; + assert_eq!(saved["code"], 200, "设计器保存应成功:{saved}"); + let (_, after) = call(port, "GET", &format!("/api/system/Dataset/{id}/get"), &token, None).await; + assert_eq!(after["data"]["hasPage"], 1, "hasPage 必须落库"); + assert_eq!(after["data"]["fields"][0]["field"], "new_one"); + + // 🔴 `getRes` 用 body 里的 config(库里的还是 `select 2`,body 给 `select 3`) + let (_, res_body) = call( + port, + "POST", + &format!("/api/system/Dataset/{id}/Actions/getRes"), + &token, + Some(&json!({ "dataConfigJson": cfg("select 3 as body_three"), "returnType": 1, "hasPage": 0 }).to_string()), + ) + .await; + assert_eq!(res_body["code"], 200, "getRes 应成功:{res_body}"); + let fields = res_body["data"]["fields"].as_array().expect("fields 必须是数组"); + assert_eq!(fields[0]["field"], "body_three", "必须用 body 里的 SQL 试跑:{res_body}"); + assert_eq!(res_body["data"]["isList"], 1); + assert_eq!(res_body["data"]["dataKey"], "data.list"); + + // 空结果集拿不到列名 ⇒ 空 fields,但**不许 500** + let empty = create_ds( + port, + &token, + "批次八-D2", + "b8d2", + json!({ "type": 1, "returnType": 1, "enabledMark": 1, "dataConfigJson": cfg("select f_id from base_data_set where 1=0") }), + ) + .await; + let (_, empty_res) = call(port, "POST", &format!("/api/system/Dataset/{empty}/Actions/getRes"), &token, Some("{}")).await; + assert_eq!(empty_res["code"], 200, "空表试跑不许报错:{empty_res}"); + assert_eq!(empty_res["data"]["fields"].as_array().unwrap().len(), 0); +} + +/// ⑥ `InfoByIds` 按 ids 顺序对齐;⑦ `Export`/`Import` 恒 400。 +#[tokio::test] +async fn dataset_info_by_ids_order_and_export_stub() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let id = create_ds( + port, + &token, + "批次八-E", + "b8e", + json!({ + "type": 1, "returnType": 1, "enabledMark": 1, + "dataConfigJson": cfg("select f_en_code as code, f_full_name as name from base_data_type"), + }), + ) + .await; + + // 顺序对齐:varchar 在 int 前 ⇒ 输出也必须是 varchar 先 + let (_, res) = call( + port, + "POST", + &format!("/api/system/Dataset/{id}/Actions/InfoByIds"), + &token, + Some(&json!({ "ids": ["varchar", "int", "no_such"], "propsValue": "code" }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "回显应成功:{res}"); + let list = res["data"].as_array().expect("必须是裸数组"); + assert_eq!(list.len(), 3); + assert_eq!(list[0]["code"], "varchar", "输出顺序必须跟请求 ids 一致"); + assert_eq!(list[1]["code"], "int"); + assert_eq!(list[2], json!({}), "找不到的那项给空对象"); + + // 回显字段名要过白名单(拼进 SQL 的东西) + let (_, bad_col) = call( + port, + "POST", + &format!("/api/system/Dataset/{id}/Actions/InfoByIds"), + &token, + Some(&json!({ "ids": ["int"], "propsValue": "code\" ; drop table base_user --" }).to_string()), + ) + .await; + assert_eq!(bad_col["code"], 400, "回显字段不许拼任意字符串:{bad_col}"); + + // ⑦ 恒失败 + let (_, export) = call(port, "GET", &format!("/api/system/Dataset/{id}/Actions/Export"), &token, None).await; + assert_eq!(export["code"], 400); + assert!(export["msg"].as_str().unwrap().contains("暂不支持"), "导出要说人话"); + let (_, import) = call(port, "POST", "/api/system/Dataset/Actions/Import", &token, Some("{}")).await; + assert_eq!(import["code"], 400); + assert!(import["msg"].as_str().unwrap().contains("暂不支持"), "导入要说人话"); + + // 图形化配置式(`sqlType=2`)明说不支持,而不是静默空结果 + let (_, preview_sql) = call( + port, + "POST", + "/api/system/Dataset/previewSql", + &token, + Some(&json!({ "sqlType": 2, "configSql": [] }).to_string()), + ) + .await; + assert_eq!(preview_sql["code"], 400); + assert!(preview_sql["msg"].as_str().unwrap().contains("图形化"), "要说清是哪条路不支持"); +}