diff --git a/.workbuddy/memory/2026-11-01.md b/.workbuddy/memory/2026-11-01.md index 8e33007..b037c63 100644 --- a/.workbuddy/memory/2026-11-01.md +++ b/.workbuddy/memory/2026-11-01.md @@ -44,3 +44,42 @@ `DataModel/{}/Tables`(被 12 个页面共用,收益最高);其次 `extend`(53) / `systemData`(91), 但这两块多半是「本仓没这个模块」的恒空 stub,先看 §0-bis 的判断再动手。 `visualdev/OnlineDev/{}/Config`(10) 属低代码域,后置。 + +--- + +## 面 B 批次 6 —— 数据连接 + 数据建模只读面(16 条) + +新增 `base_db_link`(22 列) / `base_data_type` / `base_common_fields`,tables **32 → 35**; +`routes.rs` 加 16 条路由、`FACE_B_REGISTERED` 162 → **175**;`[FACE] B 219 → 235`(合计 265)。 +两张平台字典照官方初始库逐字灌:`seed.rs::DATA_TYPES` 7 行 + `COMMON_FIELDS` 10 行。 + +### 踩到的坑(都写进了 HANDOFF §1「批次 6」) + +- **`Preview` 绝不能 `SELECT *`**:`query_json_params` 会把 `f_*` 归一成 camelCase + (`f_en_code` ⇒ `enCode`),而 `Preview.vue:62` 取 `record[column.field.toLowerCase()]` + (原样列名)⇒ 表**整张空白且不报错**。必须逐列 `"col" AS "col"`(双引号别名 = 权威名, + 归一逻辑一个字都不动)。这是本批唯一"看起来能跑其实全错"的地方。 +- **`DataSource/Selector` 第一组第一项必须是合成「默认数据库」(`id="0"`)**: + `dataModel/index.vue:158-166` 取 `list[0].children[0]` 当默认连接 ⇒ 少了它 `dbType` undefined。 +- **`hasTableData` 要 `EXISTS` 真探测**:前端据此把已有字段锁成不可改,`false` ⇒ 用户在有数据的表上删列。 +- **密码两条规矩**:详情恒空串(不回明文);`update` 传空串 = 不改(前端编辑时密码框本来就是空的)。 +- **`Actions/Test` 恒失败**:本仓只有内嵌 PG,没有驱动层 —— 不假装连上了。 +- **`base_db_link` 没有 `f_enabled_mark` 列**(官方 `DbLinkCreUpForm.enabledMark` 必填但落库时被丢弃) + ⇒ 接受不落库,读回恒 1。 +- **尺子补了一种守卫**:`check-contract-scan.py` 原先只认 `guard(…, CONST)`, + 新增 `guard_any(…, &[A, B])` 推导(契约写 `A|B`,**顺序即代码顺序**)。 + 不加的话官方 `mode=OR` 那几处只能打「推不出」警告。 +- **路由段名要与契约逐字一致**:`{table}` vs `{tableName}` 会让 CC3/CC4 各报 4 条漂移 —— 统一成官方的 `{tableName}`。 + +### 数字(批次 6 收尾) + +`cargo test --workspace` **513**(+5)| `fe-gap` **229/900 = 25.4%** +(system 84/196、**systemData 29/106 = 27.4%**,本批从 0 起) +| 契约端点 **265 条(面 B 235)** | 官方覆盖 **254/261(implemented 236 / partial 18 / absent 7)** +| 十二道闸门全绿 | 空载内存 7 MB + +### 下一个(批次 7) + +数据建模**写面** 8 条(`CREATE/ALTER/DROP TABLE` + `addFields` + `Copy` + `Export`/`Import`)。 +动真 DDL 前先立两条护栏:① `base_*` 平台表禁止 ALTER/DROP(只允许看); +② 表名/列名一律过 `db_ident` 白名单再拼 SQL。 diff --git a/HANDOFF.md b/HANDOFF.md index 502f262..db3c7e7 100644 --- a/HANDOFF.md +++ b/HANDOFF.md @@ -55,8 +55,12 @@ 顺手把 `DictionaryData/All` 从「恒空」改成真读字典 + 灌 `businessType` 13 行种子。 详见 §1「批次 5」小节。 -**下一个(批次 6)建议**:`DataModel/{}/Tables`(12 页共用,最高优先) + -`extend`/`systemData` 那几个恒空 stub;`visualdev/OnlineDev/{}/Config`(10) 属低代码域,后置。 +**下一个(批次 7)建议**:数据建模的**写面**(`POST/PUT/DELETE /DataModel/{linkId}/Table…` ++ `addFields` + `Copy` + `Export`/`Import`,共 8 条)—— 这批要动**真 DDL** +(`CREATE TABLE` / `ALTER TABLE` / `DROP TABLE`),必须先立两条护栏: +① `base_*` 平台表**禁止** ALTER/DROP(只允许看);② 表名/列名一律过白名单再拼 SQL。 +做完这三页(`/dataCenter/dataModel`、`/dataCenter/dataSource`、`/dataCenter/basicField`) +就真正可用了。再往后是 `systemData` 的 `Dataset`/`DataInterface`/`DataSource` 其余族。 **2026-11-01 实测**(`python3 scripts/fe-gap.py`):合计 **215 / 900**(23.9%); `permission` 111/137(81.0%)、`system` **84/196(42.9%,批次 4 47→66、批次 5 66→84)**; @@ -65,16 +69,16 @@ --- -## 1. 一句话现状(2026-11-01 批次 5 收尾) +## 1. 一句话现状(2026-11-01 批次 6 收尾) **📌 当前数字(以此为准,下面各批的「当时数字」仅存档)**: -- 契约端点 **249 条**(面 A 28 + 面 B **219** + 两面共用 2);`tables` → **32**。 -- `cargo test --offline --workspace` = **508 passed / 0 failed**。 -- 十二道闸门全绿;`check-contract` `PASS=10 FAIL=0`,官方端点覆盖 **238/245** - (implemented 225 / partial 13 / absent 7)。 -- `python3 scripts/fe-gap.py`:合计 **215 / 900(23.9%)**,`permission` 111/137(81.0%)、 - `system` **84/196(42.9%)**。 +- 契约端点 **265 条**(面 A 28 + 面 B **235** + 两面共用 2);`tables` → **35**。 +- `cargo test --offline --workspace` = **513 passed / 0 failed**。 +- 十二道闸门全绿;`check-contract` `PASS=10 FAIL=0`,官方端点覆盖 **254/261** + (implemented 236 / partial 18 / absent 7)。 +- `python3 scripts/fe-gap.py`:合计 **229 / 900(25.4%)**,`permission` 111/137(81.0%)、 + `system` 84/196(42.9%)、**`systemData` 29/106(27.4%,本批从 0 起)**。 **✅ 后端已拆成 workspace 多 crate,业务包可独立编译;八道闸门全绿;空载内存 7 MB。** @@ -210,6 +214,38 @@ - 回归测试 `tests/batch5_it.rs`(**6 条**):登录落日志双读者一致、三条删除路径语义不同、 常用语 CRUD + 计数、单号时间格式 + 跨天归零、规则守卫、随机/UUID 分支。 +### 批次 6(2026-11-01)—— 数据连接 + 数据建模只读面 + +**16 条面 B 端点**:`/api/system/DataSource`(8:列表/分组/下拉树/详/增/改/删/测试连接) ++ `/api/system/BasicDataType`(1:基准类型列表)+ `/api/system/CommonFields`(1:常用字段列表) ++ `/api/system/DataModel/**`(6:表清单 / 表+视图 / 表信息 / 字段 / 字段下拉 / 数据预览)。 + +- 新表三张(官方 DDL 逐字):`base_db_link`(22 列)/ `base_data_type` / `base_common_fields`;tables 32 → **35**。 +- 两张**平台字典**照官方初始库逐字灌(`seed.rs`):`DATA_TYPES` 7 行 + `COMMON_FIELDS` 10 行。 + 🔴 前者是数据建模表单的**类型下拉唯一数据源**,空了表单虽能开但**建不出表**(不报错)。 +- 🔴 **`DataSource/Selector` 的第一组第一项必须是合成的「默认数据库」(`id="0"`)**: + `dataCenter/dataModel/index.vue:158-166` 取 `list[0].children[0]` 当默认连接, + 少了它 `dbType` 是 `undefined` ⇒ 建表表单判不出库类型。本仓只有一个库 ⇒ **`linkId` 一律忽略**。 +- 🔴 **`Preview` 绝对不能写 `SELECT *`**:`query_json_params` 会把 `f_*` 列名归一成 camelCase + (`f_en_code` ⇒ `enCode`),而 `Preview.vue:62` 取的是 `record[column.field.toLowerCase()]` + (**原样列名**)⇒ 整张表会**空白且不报错**。必须逐列 `"col" AS "col"`(双引号别名是权威名)。 +- 🔴 **`hasTableData` 必须真探测**(`EXISTS(SELECT 1 …)`):前端据此把已有字段**锁成不可改** + (`Form.vue:113-115`),给 `false` 会让用户在**有数据**的表上删列 ⇒ 直接丢数据。 +- 🔴 **详情不回明文密码**(`password` 恒空串);`update` 传空串 = **不改密码**(前端编辑时密码框本来就空)。 + `Actions/Test` **恒业务失败**(本仓没有外部驱动层)—— 刻意不假装连上了。 +- 表名/列名收窄成 `[A-Za-z_][A-Za-z0-9_]*`([`db_ident`],比 `valid_table` 宽一点:官方允许 `_` 开头), + 只有 `Preview` 会把表名拼进 SQL ⇒ 这段白名单 + 双引号是唯二的注入防线。 +- 已知 `partial`:`dbType` 保持编码原样(官方换字典中文名,本仓没灌「系统数据连接」字典); + `CommonFields` 只校验登录(官方要 `dataCenter.dataModel|dataCenter.basicField` 任一, + 本仓后者还没登记成点权限);`tableName`/`fieldName` 取 PG 注释,**本仓 schema.sql 没写 + `COMMENT ON` ⇒ 全是空串**(数据建模页「说明」列会空,想改就补 `COMMENT ON`)。 +- 🔴 **尺子也改了一处**:`check-contract-scan.py` 原先只认 `guard(&state,&headers,CONST)`, + 新增 `guard_any(&state,&headers,&[A,B])` 的推导(契约里写 `A|B`,**顺序即代码里的顺序**) + —— 官方 `@SaCheckPermission(..., mode=OR)` 那几处就靠它,否则整条只能打「推不出」警告。 +- 回归测试 `tests/batch6_it.rs`(**5 条**):连接的增删改查 + 默认库契约 + 软删三处一致、 + 两张字典的 7/10 行与 `dataTypeName` 联查、表清单分页/关键词/字段归一/`hasTableData`、 + 预览分页与单字段模糊、未登录 602。 + ### 🔴 上一批(第一批)踩到并解决的 4 个真 bug 1. `CurrentUser` 的 `preferenceJson` 必须是**字符串** `"{}"` —— 给对象会让前端 @@ -365,8 +401,11 @@ xop run --secret GU=git_local_user --secret GP=git_local_pass -- bash -c ' 5. ~~`system/Log`(5) + `system/CommonWords`(6) + `system/BillRule`(8)~~ ✅ **批次 5 做完(实际 21 条)**——新表 `base_sys_log` / `base_common_words` / `base_bill_rule`; 登录落日志 + 常用语 CRUD + 单据规则与单号生成器。 -6. `DataModel/{}/Tables`(12 页共用) / `extend`(53) / `systemData`(91) / `file`(32) / 低代码模块 - ⇒ **下一个**(`file` / `extend` / 低代码多半是恒空 stub,见 §0-bis 的判断) +6. ~~`DataModel/{}/Tables`(12 页共用) + `DataSource` + `BasicDataType` + `CommonFields`~~ + ✅ **批次 6 做完(实际 16 条)**——新表 `base_db_link` / `base_data_type` / `base_common_fields`; + 数据建模**只读面**(表清单/字段/预览)+ 数据连接 CRUD。**写面(真 DDL)留给批次 7**。 +7. `DataModel` 写面 8 条(`CREATE/ALTER/DROP TABLE` + `addFields` + `Copy` + `Export`/`Import`) + + `systemData` 的 `Dataset`/`DataInterface`/`DataSource` 其余族 ⇒ **下一个** **实现模板(照抄就行)**:`ORGANIZE_WRITE_FIELDS` / `POSITION_WRITE_FIELDS` 那一套 —— 列白名单 + `now()` 不占参数位 + 只 SET body 里出现的键 + 读回不选 `f_password`。 diff --git a/PLAN.md b/PLAN.md index 54e8061..52cfceb 100644 --- a/PLAN.md +++ b/PLAN.md @@ -251,7 +251,7 @@ ssw-platform/ | 能力 | 现状 | 目标 | 差距 | |---|---|---|---| -| 面 B 契约端点 | ✅ 219 条 | 全量(含 lowcode/flow/file/message) | 补 ~250 条(多在 lowcode 域) | +| 面 B 契约端点 | ✅ 235 条 | 全量(含 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 f0f1498..adbf8b6 100644 --- a/crates/sspf-store/src/db.rs +++ b/crates/sspf-store/src/db.rs @@ -1203,30 +1203,31 @@ mod tests { #[test] fn schema_sql_has_expected_table_count() { - // schema.sql 必须包含 32 张表的 CREATE TABLE - // (27 张 base_*:8 张官方 + base_system + base_group + base_position + // schema.sql 必须包含 35 张表的 CREATE TABLE + // (30 张 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_visual_dev / base_visual_release(P2 低代码),+ 4 张业务表)。 // // 🔴 这个数字**故意写死**:加表必须同时改这里与 main.rs 的 BASE_TABLES, // 两处都改才算登记完成(漏一处就是「孤儿 DDL」或「白名单多一项」)。 let count = SCHEMA_SQL.matches("CREATE TABLE ").count(); - assert_eq!(count, 32, "schema.sql 的 CREATE TABLE 数量应为 32"); + assert_eq!(count, 35, "schema.sql 的 CREATE TABLE 数量应为 35"); } /// 🔴 [`ddl_tables`] 的解析必须与上面那条计数一致(不能只数到 12 却解析出别的)。 #[test] fn ddl_tables_parses_every_create_table() { let tables = ddl_tables(); - assert_eq!(tables.len(), 32, "ddl_tables 应解析出 32 张表"); + assert_eq!(tables.len(), 35, "ddl_tables 应解析出 35 张表"); assert!(tables.iter().all(|t| !t.is_empty())); assert_eq!( tables.iter().collect::>().len(), - 32, + 35, "表名不许重复" ); // 基础 base_* 必须都在(业务表由业务层 spec 派生,不在本文件写死)。 @@ -1248,6 +1249,9 @@ mod tests { "base_sys_log", "base_common_words", "base_bill_rule", + "base_db_link", + "base_data_type", + "base_common_fields", ] { assert!( tables.iter().any(|t| t == base), diff --git a/docs/contract.md b/docs/contract.md index 23a3b02..27fecbf 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -1374,6 +1374,22 @@ B PUT /api/system/BillRule/{id} templateCenter.billRule platform B DELETE /api/system/BillRule/{id} templateCenter.billRule platform B PUT /api/system/BillRule/{id}/Actions/State templateCenter.billRule platform B GET /api/system/BillRule/{id}/Actions/Export templateCenter.billRule platform +B GET /api/system/DataSource dataCenter.dataSource platform +B POST /api/system/DataSource dataCenter.dataSource platform +B GET /api/system/DataSource/Selector 登录 platform +B GET /api/system/DataSource/getGroup 登录 platform +B POST /api/system/DataSource/Actions/Test dataCenter.dataSource platform +B GET /api/system/DataSource/{id} dataCenter.dataSource platform +B PUT /api/system/DataSource/{id} dataCenter.dataSource platform +B DELETE /api/system/DataSource/{id} dataCenter.dataSource platform +B GET /api/system/BasicDataType 登录 platform +B GET /api/system/CommonFields 登录 platform +B GET /api/system/DataModel/{linkId}/Tables 登录 platform +B GET /api/system/DataModel/{linkId}/TableAll 登录 platform +B GET /api/system/DataModel/{linkId}/Table/{tableName} dataCenter.dataModel|onlineDev.formDesign platform +B GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields 登录 platform +B GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields/Selector 登录 platform +B GET /api/system/DataModel/{linkId}/Table/{tableName}/Preview dataCenter.dataModel 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 @@ -1390,7 +1406,7 @@ A DELETE /api/ssw/asset/DataResource/Delete asset/DataResource asset [FACE] # face 条数 说明 A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条) -B 219 面 B 专属(官方 JNPF 形状) +B 235 面 B 专属(官方 JNPF 形状) AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流) [OFFICIAL] @@ -1658,6 +1674,23 @@ DELETE /api/system/BillRule/{id} implemented BillRuleController.java:267 面 B GET /api/system/BillRule/{id}/Actions/Export partial BillRuleController.java:291 面 B 已落地但**恒失败**:官方走 `DataFileExport` 写文件服务,本仓无文件服务 ⇒ `400` + 人话(不假装成功) POST /api/system/BillRule/Actions/Import partial BillRuleController.java:310 面 B 已落地但**恒失败**:同上,multipart 导入依赖文件服务 ⇒ `400` + 人话 +GET /api/system/DataSource/Selector partial DbLinkController.java:81 面 B 已落地:第一组是**合成**「默认数据库」(`id="0"`、`dbType=PostgreSQL`)—— 前端 `dataModel/index.vue:158` 靠 `list[0].children[0]` 取默认连接;真实连接按 `dbType` 分组(官方按「系统数据连接」字典目录分组,本仓没灌那本字典) +GET /api/system/DataSource partial DbLinkController.java:135 面 B 已落地:PageListVO + `creatorUser`=`姓名/账号` + `port` 字符串 + `creatorTime` 毫秒;`dbType` 保持**编码原样**(官方换字典中文名,本仓查不到就是空串 ⇒ 原样更有信息量) +GET /api/system/DataSource/getGroup implemented DbLinkController.java:183 面 B 已落地:按 `host` 分组 `[{host, options:[…]}]` +GET /api/system/DataSource/{id} partial DbLinkController.java:210 面 B 已落地;**`password` 恒空串**:官方回 AES 密文,本仓存明文 ⇒ 绝不外吐 +POST /api/system/DataSource implemented DbLinkController.java:224 面 B 已落地:名称判重(`名称已存在`);`enabledMark` 接受但不落库(`base_db_link` 没这列) +PUT /api/system/DataSource/{id} implemented DbLinkController.java:244 面 B 已落地:只 SET body 出现的键;**`password` 空串 = 不改** +DELETE /api/system/DataSource/{id} implemented DbLinkController.java:268 面 B 已落地:软删(官方物理删,本仓保守) +POST /api/system/DataSource/Actions/Test partial DbLinkController.java:288 面 B 已落地但**恒失败**:本仓只有内嵌 PG,没有驱动层 ⇒ `400` + 人话(不假装连上了) +GET /api/system/BasicDataType implemented DataTypeController.java:46 面 B 已落地:`base_data_type` 官方初始库 7 行(`seed.rs::DATA_TYPES` 逐字灌),`ListVO` +GET /api/system/CommonFields partial ComFieldsController.java:64 面 B 已落地:`base_common_fields` 官方 10 行 + `dataTypeName` 联查;官方要求 `dataCenter.dataModel|dataCenter.basicField`,本仓后者未登记成点权限 ⇒ **只校验登录** +GET /api/system/DataModel/{linkId}/Tables implemented DbTableController.java:124 面 B 已落地:真读 `pg_class`(`current_schema()`)+ `obj_description` 注释,PageListVO + keyword/分页;`linkId` **忽略**(本仓只有一个库) +GET /api/system/DataModel/{linkId}/TableAll implemented DbTableController.java:147 面 B 已落地:表 + 视图 + 物化视图(`relkind IN r,v,m`),裸 `ListVO` +GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields implemented DbTableController.java:212 面 B 已落地:`information_schema.columns` + 主键子查询;`dataType` 归一成官方 7 编码,`dataTypeReal` 保留 `udt_name` +GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields/Selector implemented DbTableController.java:186 面 B 已落地:与 `Fields` 同源同形(官方也是同一个 `getFieldList`) +GET /api/system/DataModel/{linkId}/Table/{tableName} implemented DbTableController.java:251 面 B 已落地:`DbTableInfoVO`;`hasTableData` 用 `EXISTS` 真探测(判错会让前端在**有数据**的表上删列) +GET /api/system/DataModel/{linkId}/Table/{tableName}/Preview implemented DbTableController.java:168 面 B 已落地:逐列 `"col" AS "col"` 投影 —— **不能用 `SELECT *`**(`f_*` 会被归一成 camelCase,前端按原样列名取值 ⇒ 整表空白) + [RULER] # name 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败) # 43 = react 版对齐的 32 条 + 真实业务模块 asset/DataResource 9 条 + 多应用 2 条 diff --git a/scripts/check-contract-scan.py b/scripts/check-contract-scan.py index 3c2f471..4311e59 100644 --- a/scripts/check-contract-scan.py +++ b/scripts/check-contract-scan.py @@ -253,6 +253,16 @@ def guard_of_platform(plat_files, mod, fn): m = re.search(r"guard\(\s*&state\s*,\s*&headers\s*,\s*([A-Z_][A-Z0-9_]*)\s*\)", body) if m: return resolve_const(orig, masked, m.group(1)) + # 🔴 官方的 `@SaCheckPermission(value={A,B}, mode=OR)` ⇒ 本仓 `guard_any(&[A,B])`: + # 契约里写成 `A|B`(同一个分隔符,**顺序即代码里的顺序**)。 + m = re.search(r"guard_any\(\s*&state\s*,\s*&headers\s*,\s*&\[([^\]]*)\]", body) + if m: + codes = [] + for name in re.findall(r"\b[A-Z_][A-Z0-9_]*\b", m.group(1)): + value = resolve_const(orig, masked, name) + if value: + codes.append(value) + return "|".join(codes) if codes else None if re.search(r"require_login_(jnpf|face_b)\s*\(", body): return "登录" return None diff --git a/src/backend/db/schema.sql b/src/backend/db/schema.sql index 7cecd0d..0cc8ff5 100644 --- a/src/backend/db/schema.sql +++ b/src/backend/db/schema.sql @@ -707,6 +707,99 @@ CREATE TABLE base_bill_rule ( PRIMARY KEY (f_id, f_tenant_id) ); +-- ---------------------------------------------------------------------------- +-- 数据连接(`/api/system/DataSource`)—— 列与官方 JNPF 7.0 逐字一致。 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 1594 行,表名是 `base_db_link`) +-- 🔴 **只登记「外部库」**:本仓自己的库不占一行 —— 官方也是这么做的, +-- `DbLinkController.selectorList` 先塞一个**合成**的「默认数据库」(id = `"0"`, +-- dbType 取当前租户库的类型),再拼真实连接。前端 `dataModel/index.vue` 默认 +-- `linkId='0'`,取到的就是这条合成项 ⇒ 本仓 `linkId` 一律**忽略**(只有本机一个库)。 +-- 🔴 `f_password` 官方存 AES 密文(`EncryptUtil.encryptByAes`);本仓无该密钥体系 +-- ⇒ 原样存取、读回时**不回传明文**(`password` 恒空串),见 `[OFFICIAL]` 的 partial。 +-- ---------------------------------------------------------------------------- +CREATE TABLE base_db_link ( + f_id VARCHAR(50) NOT NULL, + f_full_name VARCHAR(200), + f_db_type VARCHAR(50), + f_host VARCHAR(50), + f_port INTEGER, + f_user_name VARCHAR(50), + f_password VARCHAR(100), + f_service_name VARCHAR(50), + f_description VARCHAR(500), + f_db_schema VARCHAR(50), + f_table_space VARCHAR(50), + f_oracle_param VARCHAR(500), + f_oracle_extend INTEGER, + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); + +-- ---------------------------------------------------------------------------- +-- 基准数据类型(`/api/system/BasicDataType`)—— 列与官方 JNPF 7.0 逐字一致。 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 1487 行,`base_data_type`) +-- 🔴 **这是平台字典,不是用户数据**:官方初始库 7 行(int / float / decimal / +-- datetime / varchar / text / bigint),本仓在 `platform/seed.rs::DATA_TYPES` +-- 逐字灌同样的 7 行(id 也用官方雪花 id:数据建模表单按 `enCode` 反查)。 +-- 🔴 `f_type`:1 系统 / 2 自定义 —— 系统行不允许删(前端也不给删按钮)。 +-- ---------------------------------------------------------------------------- +CREATE TABLE base_data_type ( + f_id VARCHAR(50) NOT NULL, + f_full_name VARCHAR(50), + f_en_code VARCHAR(50), + f_jnpf_key VARCHAR(255), + f_type INTEGER DEFAULT 0, + 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) +); + +-- ---------------------------------------------------------------------------- +-- 常用表字段(`/api/system/CommonFields`)—— 列与官方 JNPF 7.0 逐字一致。 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 1036 行,`base_common_fields`) +-- 🔴 `f_category`:1 缺省字段 / 2 常用字段;官方初始库 10 行全是 `'2'`(常用字段), +-- 本仓 `platform/seed.rs::COMMON_FIELDS` 逐字照抄这 10 行(含官方雪花 id)。 +-- 🔴 `f_type`:1 系统 / 2 自定义;`f_allow_delete`:1 允许 / 0 不允许(官方种子是 NULL)。 +-- ---------------------------------------------------------------------------- +CREATE TABLE base_common_fields ( + f_id VARCHAR(50) NOT NULL, + f_category VARCHAR(50), + f_type INTEGER, + f_field_name VARCHAR(50), + f_data_type VARCHAR(50), + f_data_length VARCHAR(50), + f_allow_null INTEGER, + f_allow_delete INTEGER, + f_field VARCHAR(50), + f_description VARCHAR(500), + f_enabled_mark INTEGER, + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + 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 d1df0fc..9a60d2b 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -45,8 +45,9 @@ use ssw_platform::routes; /// `base_visual_release`(功能定义与发布快照);应用中心/系统配置批次新增 /// `base_system_top` / `base_sys_config` / `base_tag`;消息批次新增 /// `base_business_category` / `base_message` / `base_notice`;日志与模板中心批次新增 -/// `base_sys_log` / `base_common_words` / `base_bill_rule`,故清单现在是 **28 张**。 -const BASE_TABLES: [&str; 28] = [ +/// `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_group", "base_user", "base_role", @@ -77,6 +78,11 @@ const BASE_TABLES: [&str; 28] = [ "base_sys_log", "base_common_words", "base_bill_rule", + // 🔴 数据建模批次(2026-11-01):数据连接 + 基准数据类型 + 常用表字段。 + // 后两张是**平台字典**(官方初始库各灌 7 / 10 行),不是用户数据。 + "base_db_link", + "base_data_type", + "base_common_fields", // 🔴 低代码两张表是**平台表**不是业务表:它们存的是「功能定义」, // 任何业务模块都会用,属于引擎基础设施。 "base_visual_dev", diff --git a/src/backend/src/platform/face_b.rs b/src/backend/src/platform/face_b.rs index 5bd0b17..c96eb7f 100644 --- a/src/backend/src/platform/face_b.rs +++ b/src/backend/src/platform/face_b.rs @@ -11927,6 +11927,1048 @@ pub async fn bill_rule_import( fail(code::FAIL, "本仓未配置文件服务,暂不支持导入") } +// ---------------------------------------------------------------- 数据连接(DataSource) + +/// 官方 `@SaCheckPermission("dataCenter.dataSource")`。 +const EN_DATA_SOURCE: &str = "dataCenter.dataSource"; +/// 官方 `@SaCheckPermission("dataCenter.dataModel")`。 +const EN_DATA_MODEL: &str = "dataCenter.dataModel"; +/// 官方 `DbTableController.get` / `addField` 的 **OR 分支之一** +/// (`@SaCheckPermission(value={"onlineDev.formDesign","dataCenter.dataModel"}, mode=OR)`)。 +const EN_FORM_DESIGN: &str = "onlineDev.formDesign"; + +/// 面 B 的「任一权限」守卫 —— 官方用 `@SaCheckPermission(..., mode = SaMode.OR)` 的地方。 +async fn guard_any( + state: &AppState, + headers: &HeaderMap, + en_codes: &[&str], +) -> Result> { + let user = require_login_face_b(state, headers).await?; + let system_id = + system::resolve_system_id(&state.db, system::app_code_of(headers).as_deref()).await; + for en_code in en_codes { + if has_en_code_permission(&state.db, &user.user_id, user.is_admin, en_code, &system_id).await + { + return Ok(user); + } + } + Err(fail(code::NO_PERMISSION, "无权限")) +} + +/// `base_db_link` 的**可写**字段(camelCase ⇒ 列 + CAST)。 +/// +/// 🔴 `enabledMark` **故意不在清单里**:`base_db_link` 没有 `f_enabled_mark` 列。 +/// 官方 `DbLinkCreUpForm.enabledMark` 是必填 Boolean,但 `getDbLinkEntity` 之后 +/// 并没有落到实体上(实体没这个属性)⇒ 本仓同样**只接受、不落库**。 +/// 🔴 `password` 原样存取。官方存 AES 密文(`EncryptUtil.encryptByAes`),本仓没有 +/// 那套密钥体系 ⇒ 见 [`data_source_info`]:**读回恒空串**,不往外吐明文。 +const DB_LINK_WRITE_FIELDS: [(&str, &str, &str); 10] = [ + ("fullName", "f_full_name", ""), + ("dbType", "f_db_type", ""), + ("host", "f_host", ""), + ("userName", "f_user_name", ""), + ("password", "f_password", ""), + ("serviceName", "f_service_name", ""), + ("description", "f_description", ""), + ("dbSchema", "f_db_schema", ""), + ("tableSpace", "f_table_space", ""), + ("sortCode", "f_sort_code", "::bigint"), +]; + +/// 数据连接投影(面 B)—— 时间列一律**毫秒数**(官方 `DbLinkListVO.creatorTime` 是 `Long`)。 +const DB_LINK_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \ + f_db_type AS \"dbType\", f_host AS \"host\", f_port::text AS \"port\", \ + COALESCE(f_sort_code, 0)::bigint AS \"sortCode\", \ + (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\", \ + f_creator_user_id AS \"creatorUserId\", \ + (EXTRACT(EPOCH FROM f_last_modify_time) * 1000)::bigint AS \"lastModifyTime\", \ + f_last_modify_user_id AS \"lastModifyUserId\""; + +/// `port` 只收纯数字(`f_port` 是 INTEGER ⇒ 空串/非数字直接 `::integer` 会 22P02)。 +fn normalized_port(obj: &Map) -> Option { + let raw = value_to_text(obj.get("port"))?; + let raw = raw.trim(); + if raw.is_empty() || !raw.chars().all(|c| c.is_ascii_digit()) { + return None; + } + Some(raw.to_string()) +} + +/// 分页查数据连接 —— 列表与 `getGroup` **共用**这一条。 +async fn data_source_page( + state: &AppState, + raw: &RawQuery, +) -> Result, Json> { + let mut conds = vec!["COALESCE(f_delete_mark, 0) = 0".to_string()]; + let mut values: Vec> = Vec::new(); + let keyword = crate::platform::sys::query_param(raw, "keyword") + .trim() + .to_string(); + if !keyword.is_empty() { + values.push(Some(format!("%{keyword}%"))); + let n = values.len(); + conds.push(format!( + "(COALESCE(f_full_name, '') ILIKE ${n}::text \ + OR COALESCE(f_host, '') ILIKE ${n}::text \ + OR COALESCE(f_db_type, '') ILIKE ${n}::text)" + )); + } + let db_type = crate::platform::sys::query_param(raw, "dbType") + .trim() + .to_string(); + if !db_type.is_empty() { + values.push(Some(db_type)); + conds.push(format!("f_db_type = ${}::text", values.len())); + } + let where_sql = conds.join(" AND "); + let sql = format!( + "SELECT {DB_LINK_PROJECTION} FROM base_db_link WHERE {where_sql} \ + ORDER BY f_sort_code ASC NULLS LAST, f_full_name ASC" + ); + match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => Ok(rows), + Err(e) => Err(db_error(e, "数据连接列表")), + } +} + +/// 给连接行补 `enabledMark`(恒 1 —— 表里没有这列)与创建/修改人姓名。 +fn shape_db_link_row(row: &mut Value, labels: &HashMap) { + let Some(obj) = row.as_object_mut() else { + return; + }; + obj.insert("enabledMark".to_string(), json!(1)); + for (key, out) in [ + ("creatorUserId", "creatorUser"), + ("lastModifyUserId", "lastModifyUser"), + ] { + let id = obj.get(key).and_then(Value::as_str).unwrap_or_default(); + let label = labels + .get(id) + .cloned() + .unwrap_or_else(|| id.to_string()); + if !label.is_empty() { + obj.insert(out.to_string(), Value::String(label)); + } + } +} + +/// `GET /api/system/DataSource` —— 分页列表(`PageListVO`)。 +/// +/// 🔴 官方把 `dbType` **换成字典中文名**再返回(`DictionaryDataEnum.SYSTEM_DBLINK`)。 +/// 本仓没灌「系统数据连接」字典 ⇒ 保持编码原样(`PostgreSQL` / `MySQL` …), +/// 这比换成空串诚实(官方查不到字典时会返回 `""`,列表里那列全空)。 +pub async fn data_source_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_SOURCE).await { + return resp; + } + let paging = Paging::of(&raw); + let rows = match data_source_page(&state, &raw).await { + Ok(rows) => rows, + Err(resp) => return resp, + }; + let total = rows.len() as i64; + let ids: Vec = rows + .iter() + .flat_map(|r| { + ["creatorUserId", "lastModifyUserId"] + .iter() + .filter_map(|k| r.get(*k).and_then(Value::as_str).map(str::to_string)) + }) + .collect(); + let labels = user_labels(&state, &ids).await; + let start = paging.offset.max(0) as usize; + let list: Vec = rows + .into_iter() + .skip(start) + .take(paging.page_size.max(0) as usize) + .map(|mut row| { + shape_db_link_row(&mut row, &labels); + row + }) + .collect(); + ok(page_list(paging.current_page, paging.page_size, total, list)) +} + +/// `GET /api/system/DataSource/getGroup` —— 按 `host` 分组(数据连接页的「分组视图」)。 +/// +/// 官方返回 `[{host, options:[…]}]`,`options` 是**同一份 `DbLinkListVO`**。 +/// 🔴 官方这个方法**没有** `@SaCheckPermission`(它内部复用无守卫的 `getList`) +/// ⇒ 本仓同样只校验登录。 +pub async fn data_source_group( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let rows = match data_source_page(&state, &raw).await { + Ok(rows) => rows, + Err(resp) => return resp, + }; + let ids: Vec = rows + .iter() + .flat_map(|r| { + ["creatorUserId", "lastModifyUserId"] + .iter() + .filter_map(|k| r.get(*k).and_then(Value::as_str).map(str::to_string)) + }) + .collect(); + let labels = user_labels(&state, &ids).await; + // 按 host 分组,host 升序(官方 `Comparator.comparing(DbLinkListVO::getHost)`)。 + let mut hosts: Vec = rows + .iter() + .map(|r| r.get("host").and_then(Value::as_str).unwrap_or_default().to_string()) + .collect(); + hosts.sort(); + hosts.dedup(); + let mut groups = Vec::new(); + for host in hosts { + let mut options = Vec::new(); + for row in rows.iter().filter(|r| { + r.get("host").and_then(Value::as_str).unwrap_or_default() == host + }) { + let mut row = row.clone(); + shape_db_link_row(&mut row, &labels); + options.push(row); + } + groups.push(json!({ "host": host, "options": options })); + } + ok(Value::Array(groups)) +} + +/// 本仓唯一的那个库的类型名(`DbLinkController.selectorList` 里 +/// `TenantDataSourceUtil.getDataSourceConfig().getDbType()` 的等价物)。 +const MAIN_DB_TYPE: &str = "PostgreSQL"; + +/// `GET /api/system/DataSource/Selector` —— 数据连接下拉树。 +/// +/// 🔴 **第一项永远是合成的「默认数据库」(`id = "0"`)**:官方 `dataModel/index.vue` +/// 把 `linkId` 默认成 `'0'`,并取 `list[0].children[0]` 当默认连接 ⇒ 少了它 +/// 数据建模页会拿不到 `dbType`(`list[0].dbType` 为 undefined ⇒ 表单判不出库类型)。 +/// 本仓所有表都在这一个库里 ⇒ `linkId` 一律**忽略**(见各 handler 的 `_link_id`)。 +/// 🔴 第二项起是**真实连接按 `dbType` 分组**(官方按字典目录分组,本仓没那本字典 +/// ⇒ 直接用 `dbType` 当组名)。 +pub async fn data_source_selector( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let rows = match state + .db + .query_json( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_db_type AS \"dbType\", \ + f_host AS \"host\", f_port::text AS \"port\" \ + FROM base_db_link WHERE COALESCE(f_delete_mark, 0) = 0 \ + ORDER BY f_full_name ASC", + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "数据连接下拉"), + }; + let mut list = vec![json!({ + "fullName": "", + "children": [{ + "id": "0", + "fullName": "默认数据库", + "dbType": MAIN_DB_TYPE, + "sortCode": 0, + "enabledMark": 1, + }], + })]; + let mut db_types: Vec = rows + .iter() + .map(|r| r.get("dbType").and_then(Value::as_str).unwrap_or_default().to_string()) + .collect(); + db_types.sort(); + db_types.dedup(); + for db_type in db_types { + let children: Vec = rows + .iter() + .filter(|r| r.get("dbType").and_then(Value::as_str).unwrap_or_default() == db_type) + .cloned() + .collect(); + list.push(json!({ + "id": db_type, + "fullName": db_type, + "parentId": "-1", + "num": children.len(), + "children": children, + })); + } + ok(list_vo(list)) +} + +/// `GET /api/system/DataSource/{id}` —— 详情(`DbLinkInfoVO`)。 +/// +/// 🔴 **`password` 恒返回空串**:官方回的是 AES 密文(前端不显示,只做「不改就提交空」), +/// 本仓既然存的是明文就绝不往外吐。前端表单的密码框留空 = 不修改(见 `update`)。 +pub async fn data_source_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_SOURCE).await { + return resp; + } + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_db_type AS \"dbType\", \ + f_host AS \"host\", f_port::text AS \"port\", f_user_name AS \"userName\", \ + f_service_name AS \"serviceName\", f_description AS \"description\", \ + f_db_schema AS \"dbSchema\", f_table_space AS \"tableSpace\", \ + COALESCE(f_sort_code, 0)::bigint AS \"sortCode\", \ + COALESCE(f_oracle_extend, 0)::integer AS \"oracleExtend\" \ + FROM base_db_link WHERE f_id = $1::text LIMIT 1", + &[&id], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "数据连接详情"), + }; + let Some(mut row) = rows.into_iter().next() else { + return fail(code::FAIL, "获取失败,数据不存在"); + }; + if let Some(obj) = row.as_object_mut() { + obj.insert("password".to_string(), Value::String(String::new())); + obj.insert("enabledMark".to_string(), json!(1)); + obj.insert("oracleExtend".to_string(), json!(false)); + } + ok(row) +} + +/// 连接名唯一(官方 `isExistByFullName` ⇒ `EXIST001 名称已存在`)。 +async fn ensure_db_link_unique( + state: &AppState, + full_name: &str, + exclude_id: Option<&str>, +) -> Result<(), Json> { + let exclude = exclude_id.map(str::to_string); + match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_db_link \ + WHERE f_full_name = $1::text AND COALESCE(f_delete_mark, 0) = 0 \ + AND ($2::text IS NULL OR f_id <> $2::text) LIMIT 1", + &[&full_name.to_string(), &exclude], + ) + .await + { + Ok(rows) if rows.is_empty() => Ok(()), + Ok(_) => Err(fail(code::FAIL, "名称已存在")), + Err(e) => { + eprintln!("[face-b] 数据连接判重失败: {e}"); + Err(fail(code::EXCEPTION, "系统异常,请联系管理员")) + } + } +} + +/// `POST /api/system/DataSource` —— 新建数据连接。 +pub async fn data_source_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATA_SOURCE).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let full_name = value_to_text(obj.get("fullName")) + .unwrap_or_default() + .trim() + .to_string(); + if full_name.is_empty() { + return fail(code::FAIL, "连接名称不能为空"); + } + if let Err(resp) = ensure_db_link_unique(&state, &full_name, None).await { + return resp; + } + let new_id = new_uuid(); + let mut columns: Vec<&str> = vec!["f_id", "f_tenant_id"]; + let mut casts: Vec<&str> = vec!["", ""]; + let mut values: Vec> = vec![Some(new_id), Some("0".to_string())]; + for (json_key, column, cast) in DB_LINK_WRITE_FIELDS { + if !obj.contains_key(json_key) { + continue; + } + columns.push(column); + casts.push(cast); + values.push(value_to_text(obj.get(json_key))); + } + if let Some(port) = normalized_port(&obj) { + columns.push("f_port"); + casts.push("::integer"); + values.push(Some(port)); + } + columns.push("f_creator_user_id"); + casts.push(""); + values.push(Some(user.user_id)); + columns.push("f_delete_mark"); + casts.push("::integer"); + values.push(Some("0".to_string())); + columns.push("f_creator_time"); + let mut marks: Vec = (0..values.len()) + .map(|i| placeholder(i + 1, casts[i])) + .collect(); + marks.push("now()".to_string()); + let sql = format!( + "INSERT INTO base_db_link ({}) VALUES ({})", + columns.join(", "), + marks.join(", ") + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "新建数据连接"); + } + ok(Value::Null) +} + +/// `PUT /api/system/DataSource/{id}` —— 修改(只 SET body 里出现的键)。 +/// +/// 🔴 **`password` 传空串 = 不改**:官方前端编辑时密码框是空的(详情不回明文), +/// 用户不动它就提交 `""`。照着空串覆盖会把已有密码清掉 ⇒ 显式跳过空值。 +pub async fn data_source_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATA_SOURCE).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + if let Some(full_name) = value_to_text(obj.get("fullName")) { + let full_name = full_name.trim().to_string(); + if full_name.is_empty() { + return fail(code::FAIL, "连接名称不能为空"); + } + if let Err(resp) = ensure_db_link_unique(&state, &full_name, Some(&id)).await { + return resp; + } + } + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (json_key, column, cast) in DB_LINK_WRITE_FIELDS { + if !obj.contains_key(json_key) { + continue; + } + if column == "f_password" && value_to_text(obj.get(json_key)).unwrap_or_default().is_empty() { + continue; + } + values.push(value_to_text(obj.get(json_key))); + sets.push(format!("{column} = {}", placeholder(values.len(), cast))); + } + if let Some(port) = normalized_port(&obj) { + values.push(Some(port)); + sets.push(format!("f_port = {}", placeholder(values.len(), "::integer"))); + } + if sets.is_empty() { + return ok(Value::Null); + } + values.push(Some(user.user_id)); + let user_n = values.len(); + values.push(Some(id)); + let id_n = values.len(); + let sql = format!( + "UPDATE base_db_link SET {}, f_last_modify_user_id = ${user_n}::text, \ + f_last_modify_time = now() WHERE f_id = ${id_n}::text", + sets.join(", ") + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "修改数据连接"); + } + ok(Value::Null) +} + +/// `DELETE /api/system/DataSource/{id}` —— 软删(本仓保守:官方物理删)。 +pub async fn data_source_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_DATA_SOURCE).await { + Ok(user) => user, + Err(resp) => return resp, + }; + let params: [&(dyn ToSql + Sync); 2] = [&id, &user.user_id]; + if let Err(e) = state + .db + .exec_params( + "UPDATE base_db_link SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $2::text WHERE f_id = $1::text", + ¶ms, + ) + .await + { + return db_error(e, "删除数据连接"); + } + ok(Value::Null) +} + +/// `POST /api/system/DataSource/Actions/Test` —— 测试连接。 +/// +/// 🔴 **恒业务失败**:本仓只有内嵌 PG 一个库,没有 JDBC/驱动层 ⇒ 连不到外部库。 +/// 刻意不假装成功 —— 假装成功会让用户以为「连上了」,然后建表全落到本机库上。 +pub async fn data_source_test( + State(state): State, + headers: HeaderMap, + _body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_SOURCE).await { + return resp; + } + fail(code::FAIL, "本仓仅内置数据库,不支持连接外部数据源") +} + +// ---------------------------------------------------------------- 基准数据类型 / 常用字段 + +/// `GET /api/system/BasicDataType` —— 基准数据类型列表(`ListVO`,官方 7 行)。 +/// +/// 🔴 官方 `DataTypeController.list()` **没有** `@SaCheckPermission`(登录即可)。 +/// 🔴 `type` 是 `Long`(1 系统 / 2 自定义);`jnpfKey` 官方种子是 NULL ⇒ 这里给 null。 +pub async fn basic_data_type_list( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let rows = match state + .db + .query_json( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ + f_jnpf_key AS \"jnpfKey\", COALESCE(f_type, 0)::bigint AS \"type\" \ + FROM base_data_type WHERE COALESCE(f_delete_mark, 0) = 0 \ + ORDER BY f_sort_code ASC NULLS LAST, f_full_name ASC", + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "基准数据类型"), + }; + ok(list_vo(rows)) +} + +/// `GET /api/system/CommonFields?category=` —— 常用表字段列表(`ListVO`)。 +/// +/// 🔴 官方 `@SaCheckPermission({"dataCenter.dataModel","dataCenter.basicField"}, OR)`; +/// 本仓 `dataCenter.basicField` 还没登记成菜单点权限 ⇒ 只校验登录(放宽,见 `[OFFICIAL]`)。 +/// 🔴 `dataTypeName` 由 `base_data_type` 的 `enCode → fullName` 现拼(官方同款)。 +pub async fn common_fields_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let mut conds = vec!["COALESCE(f_delete_mark, 0) = 0".to_string()]; + let mut values: Vec> = Vec::new(); + let category = crate::platform::sys::query_param(&raw, "category") + .trim() + .to_string(); + if !category.is_empty() { + values.push(Some(category)); + conds.push(format!("f_category = ${}::text", values.len())); + } + let where_sql = conds.join(" AND "); + let sql = format!( + "SELECT f_id AS \"id\", f_field_name AS \"fieldName\", f_data_type AS \"dataType\", \ + COALESCE(f_data_length, '') AS \"dataLength\", \ + COALESCE(f_allow_null, 1)::integer AS \"allowNull\", f_field AS \"field\", \ + COALESCE(f_category, '1') AS \"category\", \ + COALESCE(f_type, 1)::integer AS \"type\", \ + COALESCE(f_allow_delete, 1)::integer AS \"allowDelete\", \ + (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\" \ + FROM base_common_fields WHERE {where_sql} \ + ORDER BY COALESCE(f_sort_code, 0) ASC, f_creator_time ASC NULLS LAST" + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "常用字段列表"), + }; + // 只需要 `base_data_type` 的 `enCode → fullName`(官方 `typeMap` 同款)。 + let type_map = data_type_names(&state).await; + let list: Vec = rows + .into_iter() + .map(|mut row| { + let key = row + .get("dataType") + .and_then(Value::as_str) + .unwrap_or_default() + .to_string(); + if let Some(obj) = row.as_object_mut() { + obj.insert( + "dataTypeName".to_string(), + type_map.get(&key).cloned().map(Value::String).unwrap_or(Value::Null), + ); + } + row + }) + .collect(); + ok(list_vo(list)) +} + +// ---------------------------------------------------------------- 数据建模(DataModel) + +/// 表/列名白名单(**比 [`crate::platform::db::valid_table`] 宽一点**)。 +/// +/// 官方允许表名以 `_` 开头(前端校验正则 `/(^_([A-Z0-9]_?)*$)|(^[A-Z](_?[A-Z0-9])*_?$)/i`), +/// 而 `valid_table` 要求首字符是字母 ⇒ 单独写一条。收 `[A-Za-z_][A-Za-z0-9_]*`、≤63 字节。 +/// +/// 🔴 这段是**唯一**把路径参数拼进 SQL 的地方(`Preview` 的 `FROM "t"`)—— +/// 收窄到这个字符集 + 双引号包裹 ⇒ 不存在标识符注入。 +fn db_ident(raw: &str) -> Option { + let name = raw.trim(); + if name.is_empty() || name.len() > 63 { + return None; + } + let mut chars = name.chars(); + match chars.next() { + Some(c) if c.is_ascii_alphabetic() || c == '_' => {} + _ => return None, + } + if !chars.all(|c| c.is_ascii_alphanumeric() || c == '_') { + return None; + } + Some(name.to_string()) +} + +/// 表清单的 `FROM/WHERE` 骨架 —— 列表(`Tables`)与 `TableAll` 共用。 +/// +/// 🔴 `current_schema()` 而不是写死 `public`:pglite 每次起来 schema 可能不同名。 +/// 🔴 排除系统表(`pg_%` / `information_schema`)—— 官方也只列用户表。 +const DB_TABLE_FROM: &str = "FROM pg_class c \ + JOIN pg_namespace n ON n.oid = c.relnamespace \ + WHERE n.nspname = current_schema() AND c.relname NOT LIKE 'pg\\_%'"; + +/// 表清单投影 —— `{table, tableName}`(官方 `DbTableFieldModel` 就这两个键被前端用)。 +const DB_TABLE_PROJECTION: &str = + "c.relname AS \"table\", COALESCE(obj_description(c.oid, 'pg_class'), '') AS \"tableName\""; + +/// 分页查表清单。`kinds` 是 `relkind` 白名单(`r` 表 / `v` 视图 / `m` 物化视图)。 +async fn db_table_page( + state: &AppState, + raw: &RawQuery, + kinds: &str, + paging: Option<&Paging>, +) -> Result<(Vec, i64), Json> { + let mut conds = vec![format!("c.relkind IN ({kinds})")]; + let mut values: Vec> = Vec::new(); + let keyword = crate::platform::sys::query_param(raw, "keyword") + .trim() + .to_string(); + if !keyword.is_empty() { + values.push(Some(format!("%{keyword}%"))); + let n = values.len(); + conds.push(format!( + "(c.relname ILIKE ${n}::text \ + OR COALESCE(obj_description(c.oid, 'pg_class'), '') ILIKE ${n}::text)" + )); + } + let where_sql = conds.join(" AND "); + let count_sql = format!("SELECT COUNT(*)::text AS \"n\" {DB_TABLE_FROM} AND {where_sql}"); + let total: i64 = match state.db.query_json_params(&count_sql, ¶ms_of(&values)).await { + Ok(rows) => rows + .first() + .and_then(|r| r.get("n")) + .and_then(Value::as_str) + .and_then(|s| s.parse::().ok()) + .unwrap_or(0), + Err(e) => return Err(db_error(e, "表清单计数")), + }; + let mut list_values = values.clone(); + let mut tail = String::new(); + if let Some(paging) = paging { + list_values.push(Some(paging.page_size.to_string())); + let limit_n = list_values.len(); + list_values.push(Some(paging.offset.to_string())); + let offset_n = list_values.len(); + tail = format!(" LIMIT ${limit_n}::text::integer OFFSET ${offset_n}::text::integer"); + } + let sql = format!( + "SELECT {DB_TABLE_PROJECTION} {DB_TABLE_FROM} AND {where_sql} \ + ORDER BY c.relname ASC{tail}" + ); + match state + .db + .query_json_params(&sql, ¶ms_of(&list_values)) + .await + { + Ok(rows) => Ok((rows, total)), + Err(e) => Err(db_error(e, "表清单查询")), + } +} + +/// `GET /api/system/DataModel/{id}/Tables` —— 当前库的表清单(`DbTableListVO`)。 +/// +/// 🔴 官方 `linkId` 决定「连哪个库」;本仓只有一个内置库 ⇒ **忽略 `linkId`**。 +pub async fn data_model_tables( + State(state): State, + headers: HeaderMap, + Path(_link_id): Path, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let paging = Paging::of(&raw); + match db_table_page(&state, &raw, "'r'", Some(&paging)).await { + Ok((rows, total)) => ok(page_list( + paging.current_page, + paging.page_size, + total, + rows, + )), + Err(resp) => resp, + } +} + +/// `GET /api/system/DataModel/{id}/TableAll` —— 表 + 视图(`ListVO`,不分页)。 +pub async fn data_model_table_all( + State(state): State, + headers: HeaderMap, + Path(_link_id): Path, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + match db_table_page(&state, &raw, "'r', 'v', 'm'", None).await { + Ok((rows, _)) => ok(list_vo(rows)), + Err(resp) => resp, + } +} + +/// 单表的字段清单(原始行,未整形)—— `Fields` / `Fields/Selector` / `Table/{t}` 共用。 +/// +/// 🔴 `information_schema.columns` 给出**声明类型**(`character varying` + 长度), +/// `udt_name` 给出**真实类型**(`varchar`)⇒ `dataType` 归一成官方那 7 个编码, +/// `dataTypeReal` 保留 `udt_name`(官方「原数据类型」就是这个意思)。 +async fn db_field_rows(state: &AppState, table: &str) -> Result, pglite::Error> { + state + .db + .query_json_params( + "SELECT c.column_name AS \"field\", \ + COALESCE(col_description(to_regclass(format('%I.%I', c.table_schema, c.table_name)), \ + c.ordinal_position), '') AS \"fieldName\", \ + CASE \ + WHEN c.data_type = 'character varying' THEN 'varchar' \ + WHEN c.data_type = 'text' THEN 'text' \ + WHEN c.data_type IN ('integer', 'smallint', 'boolean') THEN 'int' \ + WHEN c.data_type = 'bigint' THEN 'bigint' \ + WHEN c.data_type = 'numeric' THEN 'decimal' \ + WHEN c.data_type IN ('real', 'double precision') THEN 'float' \ + WHEN c.data_type LIKE 'timestamp%' OR c.data_type = 'date' \ + OR c.data_type LIKE 'time%' THEN 'datetime' \ + ELSE 'varchar' END AS \"dataType\", \ + c.udt_name AS \"dataTypeReal\", \ + CASE WHEN c.character_maximum_length IS NOT NULL \ + THEN c.character_maximum_length::text \ + WHEN c.data_type = 'numeric' AND c.numeric_precision IS NOT NULL \ + THEN c.numeric_precision::text \ + ELSE '0' END AS \"dataLength\", \ + CASE WHEN c.is_nullable = 'YES' THEN 1 ELSE 0 END AS \"allowNull\", \ + CASE WHEN c.is_identity = 'YES' \ + OR COALESCE(c.column_default, '') LIKE 'nextval%' THEN 1 ELSE 0 END \ + AS \"identity\", \ + COALESCE(c.column_default, '') AS \"defaults\", \ + (SELECT 1 FROM information_schema.table_constraints tc \ + JOIN information_schema.key_column_usage kc \ + ON tc.constraint_name = kc.constraint_name \ + AND tc.table_schema = kc.table_schema \ + WHERE tc.constraint_type = 'PRIMARY KEY' \ + AND tc.table_schema = c.table_schema \ + AND tc.table_name = c.table_name \ + AND kc.column_name = c.column_name LIMIT 1) AS \"pk\" \ + FROM information_schema.columns c \ + WHERE c.table_schema = current_schema() AND c.table_name = $1::text \ + ORDER BY c.ordinal_position ASC", + &[&table.to_string()], + ) + .await +} + +/// 把字段原始行整形成官方 `DbFieldVO`(`primaryKey` / `identity` 都归一成 1/0)。 +fn shape_field_row(mut row: Value, type_map: &HashMap) -> Value { + let pk = row.get("pk").map(|v| !v.is_null()).unwrap_or(false); + let key = row + .get("dataType") + .and_then(Value::as_str) + .unwrap_or_default() + .to_string(); + let Some(obj) = row.as_object_mut() else { + return row; + }; + obj.remove("pk"); + obj.insert("primaryKey".to_string(), json!(if pk { 1 } else { 0 })); + let identity = obj + .get("identity") + .and_then(Value::as_i64) + .unwrap_or_default(); + obj.insert("autoIncrement".to_string(), json!(identity)); + obj.insert("identity".to_string(), json!(identity)); + obj.insert( + "columnName".to_string(), + obj.get("field").cloned().unwrap_or(Value::Null), + ); + obj.insert( + "dataTypeName".to_string(), + type_map + .get(&key) + .cloned() + .map(Value::String) + .unwrap_or(Value::Null), + ); + row +} + +/// `enCode → fullName` 映射(`base_data_type`)。 +async fn data_type_names(state: &AppState) -> HashMap { + match state + .db + .query_json( + "SELECT f_en_code AS \"enCode\", f_full_name AS \"fullName\" FROM base_data_type \ + WHERE COALESCE(f_delete_mark, 0) = 0", + ) + .await + { + Ok(rows) => rows + .iter() + .filter_map(|r| { + Some(( + r.get("enCode").and_then(Value::as_str)?.to_string(), + r.get("fullName").and_then(Value::as_str)?.to_string(), + )) + }) + .collect(), + Err(e) => { + eprintln!("[face-b] 基准数据类型映射失败(降级为空): {e}"); + HashMap::new() + } + } +} + +/// 字段列表的公共实现(`Fields` 与 `Fields/Selector` 共用)。 +/// +/// 🔴 字段为空 ⇒ 官方返 `DB018`「表不存在或字段为空」的**业务失败**(不是空列表)。 +async fn fields_payload(state: &AppState, table: &str) -> Json { + let Some(table) = db_ident(table) else { + return fail(code::FAIL, "表名不合法"); + }; + let rows = match db_field_rows(state, &table).await { + Ok(rows) => rows, + Err(e) => { + eprintln!("[face-b] 表字段查询失败: {e}"); + return fail(code::FAIL, "获取失败,表不存在"); + } + }; + if rows.is_empty() { + return fail(code::FAIL, "表不存在或字段为空"); + } + let names = data_type_names(state).await; + ok(list_vo( + rows.into_iter() + .map(|row| shape_field_row(row, &names)) + .collect(), + )) +} + +/// `GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields?type=` —— 字段列表(`ListVO`)。 +pub async fn data_model_fields( + State(state): State, + headers: HeaderMap, + Path((_link_id, table)): Path<(String, String)>, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + fields_payload(&state, &table).await +} + +/// `GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields/Selector` —— 同上一份数据。 +/// +/// 官方两个端点走的是**同一个** `getFieldList`,只是 `Selector` 不补 `dataTypeName`; +/// 本仓保持一致(形状相同,多一个 `dataTypeName` 不影响下拉)。 +pub async fn data_model_fields_selector( + State(state): State, + headers: HeaderMap, + Path((_link_id, table)): Path<(String, String)>, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + fields_payload(&state, &table).await +} + +/// `GET /api/system/DataModel/{dbLinkId}/Table/{table}` —— 表信息 + 字段(`DbTableInfoVO`)。 +/// +/// 🔴 `hasTableData` 是**这张表有没有数据**(`EXISTS`),前端据此把已有字段**锁成不可改** +/// (`Form.vue:113-115`)。给 `false` 会让用户在**有数据**的表上删列 ⇒ 直接丢数据。 +pub async fn data_model_info( + State(state): State, + headers: HeaderMap, + Path((_link_id, table)): Path<(String, String)>, +) -> Json { + if let Err(resp) = guard_any(&state, &headers, &[EN_DATA_MODEL, EN_FORM_DESIGN]).await { + return resp; + } + let Some(table) = db_ident(&table) else { + return fail(code::FAIL, "表名不合法"); + }; + let rows = match state + .db + .query_json_params( + "SELECT c.relname AS \"table\", COALESCE(obj_description(c.oid, 'pg_class'), '') \ + AS \"tableName\" \ + FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace \ + WHERE n.nspname = current_schema() AND c.relname = $1::text LIMIT 1", + &[&table], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "表信息"), + }; + let Some(table_info) = rows.into_iter().next() else { + return fail(code::FAIL, "获取失败,表不存在"); + }; + let fields = match db_field_rows(&state, &table).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "表字段"), + }; + let has_data = match state + .db + .query_json_params( + &format!("SELECT EXISTS(SELECT 1 FROM \"{table}\" LIMIT 1) AS \"x\""), + &[], + ) + .await + { + Ok(rows) => rows + .first() + .and_then(|r| r.get("x")) + .and_then(Value::as_bool) + .unwrap_or(false), + Err(e) => { + // 表存在但读不出来(权限/损坏)⇒ 保守当成「有数据」,宁可不让改结构。 + eprintln!("[face-b] 表数据探测失败(保守判为有数据): {e}"); + true + } + }; + let names = data_type_names(&state).await; + ok(json!({ + "tableInfo": table_info, + "tableFieldList": fields.into_iter().map(|r| shape_field_row(r, &names)).collect::>(), + "hasTableData": has_data, + })) +} + +/// `GET /api/system/DataModel/{linkId}/Table/{table}/Preview` —— 表数据预览(`PageListVO`)。 +/// +/// 🔴 前端只按 `field` + `keyword` 过滤(`Preview.vue` 的搜索表单就这两个), +/// `field` 为空时**不加条件**(空关键词不能塞参数,否则 PG 报「bind supplies 1 params」)。 +pub async fn data_model_preview( + State(state): State, + headers: HeaderMap, + Path((_link_id, table)): Path<(String, String)>, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_MODEL).await { + return resp; + } + let Some(table) = db_ident(&table) else { + return fail(code::FAIL, "表名不合法"); + }; + let paging = Paging::of(&raw); + // 🔴 **不能写 `SELECT *`**:`query_json_params` 会把 `f_*` 列名归一成 camelCase + // (`f_en_code` ⇒ `enCode`),而前端 `Preview.vue:62` 取的是 + // `record[column.field.toLowerCase()]`(**原样列名**)⇒ `SELECT *` 会让整张表**空白**。 + // 逐个写成 `"col" AS "col"`:双引号别名是权威名,归一逻辑一个字都不动。 + let columns: Vec = match db_field_rows(&state, &table).await { + Ok(rows) => rows + .iter() + .filter_map(|r| r.get("field").and_then(Value::as_str).map(str::to_string)) + .collect(), + Err(e) => { + eprintln!("[face-b] 预览取字段失败: {e}"); + return fail(code::FAIL, "获取失败,表不存在"); + } + }; + if columns.is_empty() { + return fail(code::FAIL, "表不存在或字段为空"); + } + let projection = columns + .iter() + .map(|c| format!("\"{c}\" AS \"{c}\"")) + .collect::>() + .join(", "); + let keyword = crate::platform::sys::query_param(&raw, "keyword") + .trim() + .to_string(); + let field = crate::platform::sys::query_param(&raw, "field"); + let mut values: Vec> = Vec::new(); + let mut conds: Vec = Vec::new(); + if let (Some(column), false) = (db_ident(&field), keyword.is_empty()) { + values.push(Some(format!("%{keyword}%"))); + conds.push(format!( + "(\"{column}\")::text ILIKE ${}::text", + values.len() + )); + } + let where_sql = if conds.is_empty() { + String::new() + } else { + format!(" WHERE {}", conds.join(" AND ")) + }; + let count_sql = format!("SELECT COUNT(*)::text AS \"n\" FROM \"{table}\"{where_sql}"); + let total: i64 = match state.db.query_json_params(&count_sql, ¶ms_of(&values)).await { + Ok(rows) => rows + .first() + .and_then(|r| r.get("n")) + .and_then(Value::as_str) + .and_then(|s| s.parse::().ok()) + .unwrap_or(0), + Err(e) => return db_error(e, "表数据计数"), + }; + let mut list_values = values.clone(); + list_values.push(Some(paging.page_size.to_string())); + let limit_n = list_values.len(); + list_values.push(Some(paging.offset.to_string())); + let offset_n = list_values.len(); + let sql = format!( + "SELECT {projection} FROM \"{table}\"{where_sql} \ + LIMIT ${limit_n}::text::integer OFFSET ${offset_n}::text::integer" + ); + let rows = match state + .db + .query_json_params(&sql, ¶ms_of(&list_values)) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "表数据查询"), + }; + ok(page_list(paging.current_page, paging.page_size, total, rows)) +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/backend/src/platform/seed.rs b/src/backend/src/platform/seed.rs index 4ac8512..30ef592 100644 --- a/src/backend/src/platform/seed.rs +++ b/src/backend/src/platform/seed.rs @@ -163,6 +163,11 @@ pub async fn ensure_base(db: &Db, extra_menus: &[MenuSpec]) -> Result<(), pglite // 🔴 `businessType` 字典:单据规则(模板中心)的「业务分类」列/下拉的唯一数据源。 // 同样是「缺了不报错、只是全空」的那类,一并种在这里。 ensure_business_type_dict(db, &now).await?; + // 🔴 数据建模的两张平台字典:基准数据类型 + 常用表字段。 + // 数据建模的新建表表单**完全依赖**前者(类型下拉),后者是「一键插入常用列」。 + // 同样是「缺了不报错、下拉全空」⇒ 一起种在这里。 + ensure_data_type(db, &now).await?; + ensure_common_fields(db, &now).await?; Ok(()) } @@ -452,6 +457,143 @@ pub async fn ensure_business_type_dict(db: &Db, now: &str) -> Result<(), pglite: Ok(()) } +/// 基准数据类型(`base_data_type`)—— 官方初始库的 7 行原样。 +/// +/// 真源:`jnpf-database/PostgreSQL/jnpf_db_init.sql` 里 `base_data_type` 的 7 条 INSERT。 +/// 元组是 `(f_id, f_full_name, f_en_code)`,`f_type = 1`(系统)、`f_jnpf_key = NULL`。 +/// +/// 🔴 **为什么要灌它**:数据建模的「新建表」表单把类型下拉写死成 +/// `getBasicDataTypeList().map(o => ({fullName: o.fullName, id: o.enCode}))` +/// ⇒ 这张表为空时下拉**一个选项都没有**,表单虽然能打开但根本建不出表。 +/// 🔴 id 沿用官方雪花 id:`base_data_type_mapping` / `base_data_type_relation` +/// 都按这个 id 关联(本仓暂未建那两张,但先对齐,省得以后迁移对不上)。 +const DATA_TYPES: [(&str, &str, &str); 7] = [ + ("804009215168379011", "整型", "int"), + ("804009215168379013", "浮点型", "float"), + ("804009215168379014", "小数类型", "decimal"), + ("804009215168379016", "日期类型", "datetime"), + ("804009215168379017", "字符串", "varchar"), + ("804009215168379018", "文本", "text"), + ("804009215168379019", "长整形", "bigint"), +]; + +/// 常用表字段(`base_common_fields`)—— 官方初始库的 10 行原样。 +/// +/// 真源:`jnpf_db_init.sql` 里 `base_common_fields` 的 10 条 INSERT。 +/// 元组是 `(f_id, f_field_name, f_data_type, f_data_length, f_allow_null, f_field)`。 +/// +/// 🔴 官方这 10 行全是 `f_category = '2'`(**常用字段**)+ `f_type = 2`(自定义)+ +/// `f_enabled_mark = 1` + `f_allow_delete = NULL`(不是 0 —— 前端按 +/// `allowDelete === 0` 判「不许删」⇒ NULL 与 1 等价,都允许删)。 +const COMMON_FIELDS: [(&str, &str, &str, &str, &str, &str); 10] = [ + ("804368984903285110", "主键", "varchar", "50", "0", "f_id"), + ("804368984903285111", "描述", "varchar", "500", "1", "f_description"), + ("804368984903285112", "排序码", "bigint", "50", "1", "f_sort_code"), + ("804368984903285113", "有效标志", "int", "50", "1", "f_enabled_mark"), + ("804368984903285114", "创建时间", "datetime", "50", "1", "f_creator_time"), + ("804368984903285115", "创建用户", "varchar", "50", "1", "f_creator_user_id"), + ("804368984903285116", "修改时间", "datetime", "50", "1", "f_last_modify_time"), + ("804368984903285117", "修改用户", "varchar", "50", "1", "f_last_modify_user_id"), + ("804368984903285118", "删除时间", "datetime", "50", "1", "f_delete_time"), + ("804368984903285119", "删除用户", "varchar", "50", "1", "f_delete_user_id"), +]; + +/// 灌基准数据类型(7 行)—— 幂等,按 `f_id` 判存在。 +/// +/// 🔴 与其它种子同一口径:**不看 `f_delete_mark`**(管理员删掉的不会复活)。 +pub async fn ensure_data_type(db: &Db, now: &str) -> Result<(), pglite::Error> { + let now = now.to_string(); + let tenant_id = "0".to_string(); + let type_system = "1".to_string(); + let delete_mark = "0".to_string(); + for (index, (id, full_name, en_code)) in DATA_TYPES.iter().enumerate() { + let (id, full_name, en_code) = (id.to_string(), full_name.to_string(), en_code.to_string()); + let sort_code = index.to_string(); + let existed = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_data_type WHERE f_id = $1::text LIMIT 1", + &[&id], + ) + .await?; + if !existed.is_empty() { + continue; + } + let params: [&(dyn ToSql + Sync); 8] = [ + &id, + &full_name, + &en_code, + &type_system, + &sort_code, + &delete_mark, + &tenant_id, + &now, + ]; + db.exec_params( + "INSERT INTO base_data_type \ + (f_id, f_full_name, f_en_code, f_type, f_sort_code, f_delete_mark, f_tenant_id, \ + f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text::integer, $5::text::bigint, \ + $6::text::integer, $7::text, $8::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + +/// 灌常用表字段(10 行)—— 幂等,按 `f_id` 判存在。 +pub async fn ensure_common_fields(db: &Db, now: &str) -> Result<(), pglite::Error> { + let now = now.to_string(); + let tenant_id = "0".to_string(); + let category = "2".to_string(); + let type_custom = "2".to_string(); + let enabled_mark = "1".to_string(); + let delete_mark = "0".to_string(); + for (index, (id, field_name, data_type, data_length, allow_null, field)) in + COMMON_FIELDS.iter().enumerate() + { + let (id, field_name, data_type) = (id.to_string(), field_name.to_string(), data_type.to_string()); + let (data_length, allow_null, field) = + (data_length.to_string(), allow_null.to_string(), field.to_string()); + let sort_code = index.to_string(); + let existed = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_common_fields WHERE f_id = $1::text LIMIT 1", + &[&id], + ) + .await?; + if !existed.is_empty() { + continue; + } + let params: [&(dyn ToSql + Sync); 13] = [ + &id, + &category, + &type_custom, + &field_name, + &data_type, + &data_length, + &allow_null, + &field, + &enabled_mark, + &sort_code, + &delete_mark, + &tenant_id, + &now, + ]; + db.exec_params( + "INSERT INTO base_common_fields \ + (f_id, f_category, f_type, f_field_name, f_data_type, f_data_length, f_allow_null, \ + f_field, f_enabled_mark, f_sort_code, f_delete_mark, f_tenant_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text::integer, $4::text, $5::text, $6::text, \ + $7::text::integer, $8::text, $9::text::integer, $10::text::bigint, \ + $11::text::integer, $12::text, $13::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + /// 把一个 `App-Code`(`base_system.f_en_code`)解析成系统 id(`base_system.f_id`)。 /// /// 🔴 用于把菜单种进正确的系统(`f_system_id`)—— 平台层**不认**具体 app 名, diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index 17cdd59..307437e 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -356,6 +356,61 @@ pub fn build_router(state: AppState) -> axum::Router { "/api/system/BillRule/{id}/Actions/Export", get(face_b::bill_rule_export), ) + // ---- 数据连接(官方 `DbLinkController`,路由前缀 `DataSource`)---- + // 🔴 `Selector` / `getGroup` 是**静态段**,`{id}` 是参数段 —— matchit 静态优先, + // 两者不冲突(`/DataSource/getGroup` 不会被 `/DataSource/{id}` 抢走)。 + .route("/api/system/DataSource", get(face_b::data_source_list)) + .route("/api/system/DataSource", post(face_b::data_source_create)) + .route( + "/api/system/DataSource/Selector", + get(face_b::data_source_selector), + ) + .route( + "/api/system/DataSource/getGroup", + get(face_b::data_source_group), + ) + .route( + "/api/system/DataSource/Actions/Test", + post(face_b::data_source_test), + ) + .route("/api/system/DataSource/{id}", get(face_b::data_source_info)) + .route( + "/api/system/DataSource/{id}", + put(face_b::data_source_update), + ) + .route( + "/api/system/DataSource/{id}", + delete(face_b::data_source_delete), + ) + // ---- 数据建模的查询面(官方 `DbTableController`,路由前缀 `DataModel`)---- + // 🔴 `{linkId}` 一律**忽略**(本仓只有一个内置库);保留段位是为了让 + // 官方前端的 URL 形状原样命中。 + .route("/api/system/BasicDataType", get(face_b::basic_data_type_list)) + .route("/api/system/CommonFields", get(face_b::common_fields_list)) + .route( + "/api/system/DataModel/{linkId}/Tables", + get(face_b::data_model_tables), + ) + .route( + "/api/system/DataModel/{linkId}/TableAll", + get(face_b::data_model_table_all), + ) + .route( + "/api/system/DataModel/{linkId}/Table/{tableName}", + get(face_b::data_model_info), + ) + .route( + "/api/system/DataModel/{linkId}/Tables/{tableName}/Fields", + get(face_b::data_model_fields), + ) + .route( + "/api/system/DataModel/{linkId}/Tables/{tableName}/Fields/Selector", + get(face_b::data_model_fields_selector), + ) + .route( + "/api/system/DataModel/{linkId}/Table/{tableName}/Preview", + get(face_b::data_model_preview), + ) // ---- 系统配置 + 第三方同步(官方 `SysConfigController` / `SynThirdInfoController`)---- .route("/api/system/SysConfig", get(face_b::sys_config_get)) .route("/api/system/SysConfig", put(face_b::sys_config_update)) @@ -1148,7 +1203,7 @@ mod tests { // 🔴 表数**故意写死**:它同时校验「schema.sql 建了预期的表」与 // 「health 报的是真数」。加表要同步改这里 + main.rs 的 BASE_TABLES // + crates/sspf-store 的两条 DDL 断言(共四处,漏一处就红)。 - assert_eq!(body["tables"], 32); + assert_eq!(body["tables"], 35); assert_eq!(body["version"], env!("CARGO_PKG_VERSION")); } @@ -1163,7 +1218,7 @@ mod tests { let port = serve(new_state(db().await)).await; // 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。 - const FACE_B_REGISTERED: [&str; 162] = [ + const FACE_B_REGISTERED: [&str; 175] = [ "/api/permission/Users", "/api/permission/Users/any-id", "/api/permission/Users/BatchDelete", @@ -1330,6 +1385,21 @@ mod tests { "/api/system/BillRule/any-id", "/api/system/BillRule/any-id/Actions/State", "/api/system/BillRule/any-id/Actions/Export", + // —— 数据连接 + 数据建模(批次 6)—— + // 🔴 `Selector` / `getGroup` / `Actions/Test` 都是静态段,与 `any-id` 并存不冲突。 + "/api/system/DataSource", + "/api/system/DataSource/Selector", + "/api/system/DataSource/getGroup", + "/api/system/DataSource/Actions/Test", + "/api/system/DataSource/any-id", + "/api/system/BasicDataType", + "/api/system/CommonFields", + "/api/system/DataModel/any-id/Tables", + "/api/system/DataModel/any-id/TableAll", + "/api/system/DataModel/any-id/Table/any-table", + "/api/system/DataModel/any-id/Tables/any-table/Fields", + "/api/system/DataModel/any-id/Tables/any-table/Fields/Selector", + "/api/system/DataModel/any-id/Table/any-table/Preview", ]; for path in FACE_B_REGISTERED { diff --git a/src/backend/tests/batch6_it.rs b/src/backend/tests/batch6_it.rs new file mode 100644 index 0000000..11fc4b3 --- /dev/null +++ b/src/backend/tests/batch6_it.rs @@ -0,0 +1,631 @@ +//! 批次 6(数据连接 `/api/system/DataSource` + 基准数据类型 `/api/system/BasicDataType` + +//! 常用表字段 `/api/system/CommonFields` + 数据建模只读面 `/api/system/DataModel/**`)集成测试。 +//! +//! 🔴 **钉住的契约点**(每条都对应官方控制器 / 前端页面的一处硬要求): +//! ① `DataSource/Selector` 的**第一组第一项必须是合成「默认数据库」(`id="0"`)** —— +//! `dataCenter/dataModel/index.vue:158-166` 拿 `list[0].children[0]` 当默认连接, +//! 少了它 `dbType` 是 `undefined` ⇒ 建表表单判不出库类型。 +//! ② `DataSource` 列表里 `creatorUser` 是 **`真实姓名/账号`**(官方 `UserService` 同款), +//! `port` 是**字符串**、`creatorTime` 是**毫秒数**(官方 VO 的 `String` / `Long`)。 +//! ③ 详情**绝不回传明文密码**(`password` 恒空串);`update` 传空串 = **不改密码**。 +//! ④ `Actions/Test` 恒业务失败(本仓没有外部驱动层)—— **不假装成功**。 +//! ⑤ 基准数据类型 7 行、常用字段 10 行是**平台字典**,`dataTypeName` 由两张表联查拼出。 +//! ⑥ 数据建模的字段列表要给出 `primaryKey` / `allowNull` / `identity` 三个 **1/0** 标记, +//! 且 `dataType` 归一成官方那 7 个编码(DB 里是 `character varying` / `integer`)。 +//! ⑦ `Table/{t}` 的 `hasTableData` 决定前端**锁不锁已有字段** +//! (`Form.vue:113-115`)⇒ 有数据必须 `true`,判错会让用户在**有数据**的表上删列。 +//! +//! 🔴 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 +} + +/// 面 B 请求(带 `Vue-Version: 3`;`token` 为空串 ⇒ 未登录)。 +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(10), + 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(10), + 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-batch6-it"))), + db: Arc::new(db.clone()), + sessions: Arc::new(SessionStore::default()), + } +} + +/// 取库里某列(用于验证「空密码不覆盖旧密码」这类**看不见**的行为)。 +async fn scalar(db: &Db, sql: &str) -> String { + let rows = db.query_json_params(sql, &[]).await.expect("查询失败"); + rows.first() + .and_then(|r| r.get("v")) + .and_then(Value::as_str) + .unwrap_or_default() + .to_string() +} + +// ---------------------------------------------------------------- 数据连接 + +/// 数据连接 CRUD + 下拉树的「默认数据库」契约。 +#[tokio::test] +async fn data_source_crud_and_selector_default_group() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + // ① 下拉树第一组第一项 = 合成「默认数据库」,id 必须是 "0"(前端 linkId 默认值)。 + let (_, sel) = call(port, "GET", "/api/system/DataSource/Selector", &token, None).await; + assert_eq!(sel["code"], 200, "下拉树失败: {sel}"); + let groups = sel["data"]["list"].as_array().expect("必须是 ListVO"); + let first_child = &groups[0]["children"][0]; + assert_eq!(first_child["id"], "0", "默认库 id 必须是 0: {sel}"); + assert_eq!(first_child["fullName"], "默认数据库", "{sel}"); + assert_eq!(first_child["dbType"], "PostgreSQL", "默认库类型: {sel}"); + + // ② 新建(`enabledMark` 落库时被丢弃 ⇒ 表里没有这列,但不该报错)。 + let (_, created) = call( + port, + "POST", + "/api/system/DataSource", + &token, + Some( + &json!({ + "fullName": "测试库", "dbType": "MySQL", "host": "192.168.1.9", + "port": "3306", "userName": "root", "password": "p@ss", + "serviceName": "demo", "sortCode": 1, "enabledMark": true + }) + .to_string(), + ), + ) + .await; + assert_eq!(created["code"], 200, "新建失败: {created}"); + + // ③ 同名再建 ⇒ `400 名称已存在`。 + let (_, dup) = call( + port, + "POST", + "/api/system/DataSource", + &token, + Some(&json!({"fullName": "测试库", "dbType": "MySQL"}).to_string()), + ) + .await; + assert_eq!(dup["code"], 400, "同名必须拒: {dup}"); + assert_eq!(dup["msg"], "名称已存在", "{dup}"); + + // ④ 列表:PageListVO + `creatorUser` 换成「姓名/账号」+ `port` 是字符串。 + let (_, listed) = call(port, "GET", "/api/system/DataSource", &token, None).await; + assert_eq!(listed["code"], 200, "{listed}"); + assert_eq!(listed["data"]["pagination"]["total"], 1, "{listed}"); + let row = &listed["data"]["list"][0]; + assert_eq!(row["fullName"], "测试库", "{row}"); + assert_eq!(row["port"], "3306", "port 必须是字符串: {row}"); + assert_eq!(row["creatorUser"], "管理员/admin", "{row}"); + assert_eq!(row["enabledMark"], 1, "表里没有这列 ⇒ 恒 1: {row}"); + assert!( + row["creatorTime"].as_i64().unwrap_or(0) > 1_600_000_000_000, + "creatorTime 必须是毫秒数: {row}" + ); + let id = row["id"].as_str().expect("必须有 id").to_string(); + + // ⑤ 详情:**绝不回传明文密码**。 + let (_, info) = call( + port, + "GET", + &format!("/api/system/DataSource/{id}"), + &token, + None, + ) + .await; + assert_eq!(info["code"], 200, "{info}"); + assert_eq!(info["data"]["password"], "", "不能回传明文密码: {info}"); + assert_eq!(info["data"]["userName"], "root", "{info}"); + + // ⑥ 修改:`password: ""` = **不改密码**(前端编辑时密码框本来就是空的)。 + let (_, updated) = call( + port, + "PUT", + &format!("/api/system/DataSource/{id}"), + &token, + Some(&json!({"fullName": "测试库2", "port": "3307", "password": ""}).to_string()), + ) + .await; + assert_eq!(updated["code"], 200, "修改失败: {updated}"); + let stored = scalar( + db().await, + &format!("SELECT f_password AS \"v\" FROM base_db_link WHERE f_id = '{id}'"), + ) + .await; + assert_eq!(stored, "p@ss", "空密码不能把旧密码冲掉"); + let port_value = scalar( + db().await, + &format!("SELECT f_port::text AS \"v\" FROM base_db_link WHERE f_id = '{id}'"), + ) + .await; + assert_eq!(port_value, "3307", "端口要真的改了"); + + // ⑦ 下拉树要能看到这一个真实连接(第二组,组名 = dbType)。 + let (_, sel2) = call(port, "GET", "/api/system/DataSource/Selector", &token, None).await; + let groups = sel2["data"]["list"].as_array().expect("必须是 ListVO"); + assert_eq!(groups.len(), 2, "默认库 + MySQL 一组: {sel2}"); + assert_eq!(groups[1]["fullName"], "MySQL", "{sel2}"); + assert_eq!(groups[1]["num"], 1, "{sel2}"); + + // ⑧ 分组视图按 host 分组。 + let (_, grouped) = call(port, "GET", "/api/system/DataSource/getGroup", &token, None).await; + assert_eq!(grouped["code"], 200, "{grouped}"); + assert_eq!(grouped["data"][0]["host"], "192.168.1.9", "{grouped}"); + assert_eq!(grouped["data"][0]["options"][0]["fullName"], "测试库2", "{grouped}"); + + // ⑨ 测试连接**恒失败**(本仓没有外部驱动层,刻意不假装成功)。 + let (_, tested) = call( + port, + "POST", + "/api/system/DataSource/Actions/Test", + &token, + Some(&json!({"dbType": "MySQL", "host": "192.168.1.9"}).to_string()), + ) + .await; + assert_eq!(tested["code"], 400, "测试连接必须明确失败: {tested}"); + + // ⑩ 删除是**软删** ⇒ 列表/分组/下拉三处同时看不到(但库里那行还在)。 + let (_, deleted) = call( + port, + "DELETE", + &format!("/api/system/DataSource/{id}"), + &token, + None, + ) + .await; + assert_eq!(deleted["code"], 200, "{deleted}"); + let (_, after) = call(port, "GET", "/api/system/DataSource", &token, None).await; + assert_eq!(after["data"]["pagination"]["total"], 0, "{after}"); + let (_, grouped) = call(port, "GET", "/api/system/DataSource/getGroup", &token, None).await; + assert!( + grouped["data"].as_array().map(Vec::is_empty).unwrap_or(false), + "软删后分组必须空: {grouped}" + ); + let (_, sel3) = call(port, "GET", "/api/system/DataSource/Selector", &token, None).await; + assert_eq!( + sel3["data"]["list"].as_array().map(Vec::len), + Some(1), + "软删后只剩默认库: {sel3}" + ); + let mark = scalar( + db().await, + &format!("SELECT f_delete_mark::text AS \"v\" FROM base_db_link WHERE f_id = '{id}'"), + ) + .await; + assert_eq!(mark, "1", "必须是软删(f_delete_mark=1)"); +} + +// ---------------------------------------------------------------- 两张平台字典 + +/// 基准数据类型 7 行 + 常用字段 10 行(官方初始库逐字),`dataTypeName` 联查得出。 +#[tokio::test] +async fn basic_data_type_and_common_fields_are_seeded() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + // ① 基准数据类型:7 行,`enCode` 是数据建模表单里的 value。 + let (_, types) = call(port, "GET", "/api/system/BasicDataType", &token, None).await; + assert_eq!(types["code"], 200, "{types}"); + let list = types["data"]["list"].as_array().expect("必须是 ListVO"); + assert_eq!(list.len(), 7, "官方初始库 7 行: {types}"); + let codes: Vec<&str> = list + .iter() + .map(|r| r["enCode"].as_str().unwrap_or_default()) + .collect(); + for code in ["int", "float", "decimal", "datetime", "varchar", "text", "bigint"] { + assert!(codes.contains(&code), "缺少 {code}: {types}"); + } + assert_eq!(list[0]["type"], 1, "系统行 f_type=1: {}", list[0]); + + // ② 常用字段:10 行,`dataTypeName` 必须由 `base_data_type` 拼出来(不是空)。 + let (_, fields) = call(port, "GET", "/api/system/CommonFields", &token, None).await; + assert_eq!(fields["code"], 200, "{fields}"); + let list = fields["data"]["list"].as_array().expect("必须是 ListVO"); + assert_eq!(list.len(), 10, "官方初始库 10 行: {fields}"); + let primary = list + .iter() + .find(|r| r["field"] == "f_id") + .expect("必须有主键字段"); + assert_eq!(primary["allowNull"], 0, "主键不允许空: {primary}"); + assert_eq!(primary["dataTypeName"], "字符串", "varchar 的中文名: {primary}"); + assert_eq!(primary["category"], "2", "官方种子全是常用字段: {primary}"); + // `f_allow_delete` 官方种子是 NULL ⇒ 读成 1(允许删),不是 0。 + assert_eq!(primary["allowDelete"], 1, "{primary}"); + + // ③ `category` 过滤生效(1 = 缺省字段,本仓没灌 ⇒ 空)。 + let (_, empty) = call( + port, + "GET", + "/api/system/CommonFields?category=1", + &token, + None, + ) + .await; + assert_eq!(empty["code"], 200, "{empty}"); + assert!( + empty["data"]["list"].as_array().map(Vec::is_empty).unwrap_or(false), + "category=1 应为空: {empty}" + ); +} + +// ---------------------------------------------------------------- 数据建模只读面 + +/// 表清单 / 表信息 / 字段 / 下拉 四个读端点的形状与语义。 +#[tokio::test] +async fn data_model_tables_info_and_fields() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + // ① 表清单:`DbTableListVO`(list + pagination),分页真的生效。 + let (_, tables) = call( + port, + "GET", + "/api/system/DataModel/0/Tables?currentPage=1&pageSize=100", + &token, + None, + ) + .await; + assert_eq!(tables["code"], 200, "{tables}"); + let total = tables["data"]["pagination"]["total"] + .as_i64() + .expect("必须有 total"); + // schema.sql 现在是 35 张表;真有变化时这条会红,提醒同步(与 DDL 计数测试同口径)。 + assert_eq!(total, 35, "表清单必须来自 information_schema: {tables}"); + let list = tables["data"]["list"].as_array().expect("必须有 list"); + assert!( + list.iter().any(|r| r["table"] == "base_user"), + "表清单里必须有 base_user: {tables}" + ); + // `tableName` 取 PG 注释(本仓 schema.sql 没写 COMMENT ON ⇒ 空串,不是 null)。 + assert_eq!(list[0]["tableName"], "", "注释为空时给空串: {}", list[0]); + + // ② 分页:pageSize=5 只回 5 行,第 2 页与第 1 页不重叠。 + let (_, page1) = call( + port, + "GET", + "/api/system/DataModel/0/Tables?currentPage=1&pageSize=5", + &token, + None, + ) + .await; + let (_, page2) = call( + port, + "GET", + "/api/system/DataModel/0/Tables?currentPage=2&pageSize=5", + &token, + None, + ) + .await; + let p1: Vec<&str> = page1["data"]["list"] + .as_array() + .expect("list") + .iter() + .map(|r| r["table"].as_str().unwrap_or_default()) + .collect(); + let p2: Vec<&str> = page2["data"]["list"] + .as_array() + .expect("list") + .iter() + .map(|r| r["table"].as_str().unwrap_or_default()) + .collect(); + assert_eq!(p1.len(), 5, "pageSize 必须生效: {page1}"); + assert_eq!(p2.len(), 5, "{page2}"); + assert!( + p1.iter().all(|t| !p2.contains(t)), + "两页不许重叠: {p1:?} vs {p2:?}" + ); + + // ③ keyword 过滤(表名 ILIKE)。 + let (_, filtered) = call( + port, + "GET", + "/api/system/DataModel/0/Tables?keyword=bill_rule", + &token, + None, + ) + .await; + let hits = filtered["data"]["list"].as_array().expect("list"); + assert_eq!(hits.len(), 1, "keyword 必须进 SQL: {filtered}"); + assert_eq!(hits[0]["table"], "base_bill_rule", "{filtered}"); + + // ④ TableAll 是**裸 ListVO**(没有 pagination)。 + let (_, all) = call(port, "GET", "/api/system/DataModel/0/TableAll", &token, None).await; + assert_eq!(all["code"], 200, "{all}"); + assert!( + all["data"]["pagination"].is_null(), + "TableAll 不许带 pagination: {all}" + ); + assert!( + all["data"]["list"] + .as_array() + .map(|l| l.len() >= 35) + .unwrap_or(false), + "{all}" + ); + + // ⑤ 字段列表:三个 1/0 标记 + `dataType` 归一 + `dataTypeName` 联查。 + let (_, fields) = call( + port, + "GET", + "/api/system/DataModel/0/Tables/base_user/Fields?type=0", + &token, + None, + ) + .await; + assert_eq!(fields["code"], 200, "{fields}"); + let list = fields["data"]["list"].as_array().expect("ListVO"); + assert!(!list.is_empty(), "{fields}"); + let id_col = list + .iter() + .find(|r| r["field"] == "f_id") + .expect("base_user.f_id 必须在"); + assert_eq!(id_col["primaryKey"], 1, "主键标记: {id_col}"); + assert_eq!(id_col["allowNull"], 0, "主键非空: {id_col}"); + assert_eq!(id_col["identity"], 0, "不是自增: {id_col}"); + // DB 里是 `character varying(50)` ⇒ 归一成 `varchar` / `50`。 + assert_eq!(id_col["dataType"], "varchar", "{id_col}"); + assert_eq!(id_col["dataLength"], "50", "{id_col}"); + assert_eq!(id_col["dataTypeName"], "字符串", "{id_col}"); + assert_eq!(id_col["columnName"], "f_id", "官方 VO 的 columnName: {id_col}"); + + // ⑥ `Fields/Selector` 走同一份数据。 + let (_, selector) = call( + port, + "GET", + "/api/system/DataModel/0/Tables/base_user/Fields/Selector", + &token, + None, + ) + .await; + assert_eq!(selector["code"], 200, "{selector}"); + assert_eq!( + selector["data"]["list"].as_array().map(Vec::len), + Some(list.len()), + "Selector 与 Fields 必须同源: {selector}" + ); + + // ⑦ 表信息:`tableInfo` + `tableFieldList` + `hasTableData`(有数据 ⇒ true)。 + let (_, info) = call( + port, + "GET", + "/api/system/DataModel/0/Table/base_user", + &token, + None, + ) + .await; + assert_eq!(info["code"], 200, "{info}"); + assert_eq!(info["data"]["tableInfo"]["table"], "base_user", "{info}"); + assert_eq!(info["data"]["hasTableData"], true, "有数据必须 true: {info}"); + assert!( + info["data"]["tableFieldList"] + .as_array() + .map(|l| !l.is_empty()) + .unwrap_or(false), + "{info}" + ); + + // ⑧ 表名不存在 / 不合法 ⇒ 业务失败(不是空列表、更不是 500)。 + let (_, missing) = call( + port, + "GET", + "/api/system/DataModel/0/Table/no_such_table", + &token, + None, + ) + .await; + assert_eq!(missing["code"], 400, "{missing}"); + let (_, bad) = call( + port, + "GET", + "/api/system/DataModel/0/Tables/no_such_table/Fields", + &token, + None, + ) + .await; + assert_eq!(bad["code"], 400, "{bad}"); + let (_, illegal) = call( + port, + "GET", + "/api/system/DataModel/0/Table/a%22b%3Bdrop", + &token, + None, + ) + .await; + assert_eq!(illegal["code"], 400, "标识符白名单必须拦住: {illegal}"); + assert_eq!(illegal["msg"], "表名不合法", "{illegal}"); +} + +/// 表数据预览:分页 + 单字段模糊(`Preview.vue` 的搜索表单就这两个参数)。 +#[tokio::test] +async fn data_model_preview_paginates_and_filters() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + // 拿一张**行数稳定**的表:`base_data_type` 恰好是种子灌的 7 行。 + let (_, p1) = call( + port, + "GET", + "/api/system/DataModel/0/Table/base_data_type/Preview?currentPage=1&pageSize=3", + &token, + None, + ) + .await; + assert_eq!(p1["code"], 200, "{p1}"); + assert_eq!(p1["data"]["pagination"]["total"], 7, "{p1}"); + assert_eq!(p1["data"]["list"].as_array().map(Vec::len), Some(3), "{p1}"); + + let (_, p3) = call( + port, + "GET", + "/api/system/DataModel/0/Table/base_data_type/Preview?currentPage=3&pageSize=3", + &token, + None, + ) + .await; + assert_eq!( + p3["data"]["list"].as_array().map(Vec::len), + Some(1), + "第 3 页只剩 1 行: {p3}" + ); + + // 单字段模糊:`f_en_code ILIKE '%varchar%'` ⇒ 只剩「字符串」那一行。 + let (_, filtered) = call( + port, + "GET", + "/api/system/DataModel/0/Table/base_data_type/Preview?field=f_en_code&keyword=varchar", + &token, + None, + ) + .await; + assert_eq!(filtered["code"], 200, "{filtered}"); + assert_eq!(filtered["data"]["pagination"]["total"], 1, "{filtered}"); + let row = &filtered["data"]["list"][0]; + assert_eq!(row["f_en_code"], "varchar", "行键必须是真实列名: {row}"); + assert_eq!(row["f_full_name"], "字符串", "{row}"); + + // 只给 keyword、不给 field ⇒ **不加条件**(官方同款:空 field 不过滤)。 + let (_, no_field) = call( + port, + "GET", + "/api/system/DataModel/0/Table/base_data_type/Preview?keyword=varchar", + &token, + None, + ) + .await; + assert_eq!(no_field["data"]["pagination"]["total"], 7, "{no_field}"); +} + +/// 未登录 ⇒ 面 B 的 `602`(不是 600,也不是 401)。 +#[tokio::test] +async fn data_model_and_data_source_require_login() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + + for path in [ + "/api/system/DataModel/0/Tables", + "/api/system/DataModel/0/Table/base_user", + "/api/system/DataSource", + "/api/system/DataSource/Selector", + "/api/system/BasicDataType", + "/api/system/CommonFields", + ] { + let (status, body) = call(port, "GET", path, "", None).await; + assert!( + status.contains("200"), + "业务失败恒 HTTP 200({path}): {status}" + ); + assert_eq!(body["code"], 602, "{path} 未登录必须是 602: {body}"); + } +}