diff --git a/crates/sspf-store/src/db.rs b/crates/sspf-store/src/db.rs index d7aba71..d88163c 100644 --- a/crates/sspf-store/src/db.rs +++ b/crates/sspf-store/src/db.rs @@ -50,7 +50,7 @@ pub const SCHEMA_SQL: &str = include_str!("../../../src/backend/db/schema.sql"); /// (闸门查「孤儿 DDL」会红 ⇒ 两处都改才算登记完成)⇒ 数量写死是**有意的护栏**; /// - 业务表 = **业务包**的责任 ⇒ 住 `packs//schema/*.sql` /// ⇒ 加包**不该**改内核 ⇒ 数量写死是**错误的耦合**。 -pub const BASE_TABLE_COUNT: usize = 50; +pub const BASE_TABLE_COUNT: usize = 54; /// 🔴 **面 A 内嵌业务表**(留在内核 `schema.sql` 里的那几张)。 /// diff --git a/docs/contract.md b/docs/contract.md index 7135230..49bf0b2 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -1528,6 +1528,36 @@ B GET /api/system/Variate/sysfunccategory 登录 platform B GET /api/system/Variate/{id} 登录 platform B PUT /api/system/Variate/{id} 登录 platform B DELETE /api/system/Variate/{id} 登录 platform +# ---- 数据中心(批次 14):基准类型 / 控件映射 / 数据库 / 字段类型映射 / 常用字段 / 数据同步 ---- +B GET /api/system/BasicDataType/{id} dataCenter.basicDataType platform +B POST /api/system/BasicDataType dataCenter.basicDataType platform +B PUT /api/system/BasicDataType/{id} dataCenter.basicDataType platform +B DELETE /api/system/BasicDataType/{id} dataCenter.basicDataType platform +B GET /api/system/DataTypeMapping dataCenter.dataTypeMapping platform +B GET /api/system/DataTypeMapping/getKeyList dataCenter.dataTypeMapping|onlineDev.formDesign platform +B GET /api/system/DataTypeMapping/{id} dataCenter.dataTypeMapping platform +B POST /api/system/DataTypeMapping dataCenter.dataTypeMapping platform +B PUT /api/system/DataTypeMapping/{id} dataCenter.dataTypeMapping platform +B DELETE /api/system/DataTypeMapping/{id} dataCenter.dataTypeMapping platform +B GET /api/system/DataBase 登录 platform +B GET /api/system/DataBase/{id} dataCenter.database platform +B POST /api/system/DataBase dataCenter.database platform +B PUT /api/system/DataBase/{id} dataCenter.database platform +B DELETE /api/system/DataBase/{id} dataCenter.database platform +B GET /api/system/DataTypeRelation dataCenter.database platform +B GET /api/system/DataTypeRelation/{id} dataCenter.database platform +B POST /api/system/DataTypeRelation dataCenter.database platform +B PUT /api/system/DataTypeRelation/{id} dataCenter.database platform +B DELETE /api/system/DataTypeRelation/{id} dataCenter.database platform +B GET /api/system/CommonFields/{id} dataCenter.basicField platform +B POST /api/system/CommonFields dataCenter.basicField platform +B PUT /api/system/CommonFields/{id} dataCenter.basicField platform +B DELETE /api/system/CommonFields/{id} dataCenter.basicField platform +B POST /api/system/DataSync systemData.dataSync platform +B POST /api/system/DataSync/Actions/checkDbLink systemData.dataSync platform +B POST /api/system/DataSync/Actions/Execute systemData.dataSync platform +B POST /api/system/DataSync/Actions/batchExecute systemData.dataSync platform +B GET /api/system/DataInterfaceVariate/Selector dataCenter.dataset|dataCenter.dataService platform # 🔴 以下由 `scripts/pack-sync.py` 从 `packs/*` 生成 —— **不许手改** @@ -1552,7 +1582,7 @@ B DELETE /api/asset/DataResource/{id} permission.asset.dataResource asset [FACE] # face 条数 说明 A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条) -B 363 面 B 专属(官方 JNPF 形状;批次 13 新增 Area 7 + Variate 7) +B 392 面 B 专属(官方 JNPF 形状;批次 13 新增 Area 7 + Variate 7;批次 14 新增数据中心 29) AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流) [OFFICIAL] @@ -1964,6 +1994,35 @@ PUT /api/system/Variate/{id} implemented CommonVariateController.java:94 面 B DELETE /api/system/Variate/{id} implemented CommonVariateController.java:105 面 B 已落地:软删,幂等 GET /api/system/Variate/selector implemented CommonVariateController.java:159 面 B 已落地:全量 ListVO(不分页);keyword 大小写不敏感(upper LIKE,同官方 toUpperCase.contains) GET /api/system/Variate/sysfunccategory implemented CommonVariateController.java:134 面 B 已落地:11 个固定分类(官方 FunctionCategory 枚举逐条抄)⇒ 不依赖表达式引擎 +GET /api/system/BasicDataType/{id} implemented DataTypeController.java:118 面 B 已落地:DataTypeVo 的 5 个字段 +POST /api/system/BasicDataType implemented DataTypeController.java:58 面 B 已落地:enCode 与 fullName **双判重**;新建恒为自定义(type=2),内置不可造 +PUT /api/system/BasicDataType/{id} implemented DataTypeController.java:79 面 B 已落地:只 SET 出现的键;**type 不进白名单**(否则可把自定义改成内置逃过删除保护) +DELETE /api/system/BasicDataType/{id} implemented DataTypeController.java:99 面 B 已落地:内置(type=1)拒绝;被控件映射/字段类型映射/常用字段引用 ⇒ 拒绝 +GET /api/system/DataTypeMapping implemented DataTypeMappingController.java:55 面 B 已落地:ListVO 不分页(前端 `pagination:false`);`typeId` 被**覆盖成名称**(官方 :60-68) +GET /api/system/DataTypeMapping/getKeyList implemented DataTypeMappingController.java:127 面 B 已落地:`[{dataType, jnpfKeyList}]`;权限是 **OR**(dataTypeMapping / formDesign) +GET /api/system/DataTypeMapping/{id} implemented DataTypeMappingController.java:115 面 B 已落地:这里返回**真 typeId**(列表返回的是名称)⇒ 编辑表单靠这条 +POST /api/system/DataTypeMapping implemented DataTypeMappingController.java:76 面 B 已落地:白名单 jnpfKey/typeId/sortCode +PUT /api/system/DataTypeMapping/{id} implemented DataTypeMappingController.java:90 面 B 已落地:只 SET 出现的键 +DELETE /api/system/DataTypeMapping/{id} implemented DataTypeMappingController.java:103 面 B 已落地:软删 +GET /api/system/DataBase implemented DataBaseController.java:44 面 B 已落地:ListVO;**登录即可**(官方 list 无权限注解,只有增删改有) +GET /api/system/DataBase/{id} implemented DataBaseController.java:101 面 B 已落地:DataBaseVo 的 7 个字段 +POST /api/system/DataBase implemented DataBaseController.java:56 面 B 已落地:按 `dbType` **单列判重**(官方 existByDbType) +PUT /api/system/DataBase/{id} implemented DataBaseController.java:73 面 B 已落地:只 SET 出现的键;dbType 判重排除自己 +DELETE /api/system/DataBase/{id} implemented DataBaseController.java:89 面 B 已落地:软删 +GET /api/system/DataTypeRelation implemented DataTypeRelationController.java:53 面 B 已落地:PageListVO 分页;支持 baseId 过滤;`typeId` 同样覆盖成名称 +GET /api/system/DataTypeRelation/{id} implemented DataTypeRelationController.java:120 面 B 已落地:真 typeId + 6 个长度/精度上限 +POST /api/system/DataTypeRelation implemented DataTypeRelationController.java:73 面 B 已落地:判重是**二元组 enCode+baseId**(同 enCode 在不同库下可各一条) +PUT /api/system/DataTypeRelation/{id} implemented DataTypeRelationController.java:91 面 B 已落地:只 SET 出现的键 +DELETE /api/system/DataTypeRelation/{id} implemented DataTypeRelationController.java:108 面 B 已落地:软删 +GET /api/system/CommonFields/{id} implemented ComFieldsController.java:86 面 B 已落地:常用字段详情(含 dataTypeName) +POST /api/system/CommonFields implemented ComFieldsController.java:102 面 B 已落地:**先挡 SQL/Java 保留字**再判重(列名要拿去建表);判重是 field+category +PUT /api/system/CommonFields/{id} implemented ComFieldsController.java:129 面 B 已落地:同样挡保留字;只 SET 出现的键 +DELETE /api/system/CommonFields/{id} implemented ComFieldsController.java:158 面 B 已落地:软删 +POST /api/system/DataSync partial DbSyncController.java:166 **本仓无跨库能力**:官方走 JDBC 真连两个库;本仓是进程内嵌 PG(pglite/WASM,无驱动层)⇒ 四条 DataSync 一律返回明确业务失败(不假装成功,同 `DataSource/Actions/Test`) +POST /api/system/DataSync/Actions/checkDbLink partial DbSyncController.java:118 同上:能力不存在,端点存在且明确拒绝 +POST /api/system/DataSync/Actions/Execute partial DbSyncController.java:191 同上:能力不存在,端点存在且明确拒绝 +POST /api/system/DataSync/Actions/batchExecute partial DbSyncController.java:212 同上:能力不存在,端点存在且明确拒绝 +GET /api/system/DataInterfaceVariate/Selector implemented DataInterfaceVariateController.java:107 面 B 已落地:两级树(数据集 type=0 → 变量 type=1);变量 fullName = `数据集enCode.变量名`;只出启用的数据集;权限 OR(dataset / dataService) [RULER] # name 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败) diff --git a/scripts/check-contract-scan.py b/scripts/check-contract-scan.py index c2d7a51..aa76665 100644 --- a/scripts/check-contract-scan.py +++ b/scripts/check-contract-scan.py @@ -211,6 +211,26 @@ def _find_fn_body_uncached(masked, fname): return brace_span(masked, i) +def paren_span(masked, start): + """从 `start`(`(` 的位置)开始做括号配对 ⇒ 返回 `)` 的下标(失败返回末位)。 + + 🔴 在 `masked` 上跑:字符串字面量已被挖空 ⇒ 参数里的 `(` / `)` 不会干扰配对。 + """ + depth = 0 + i = start + n = len(masked) + while i < n: + c = masked[i] + if c == "(": + depth += 1 + elif c == ")": + depth -= 1 + if depth == 0: + return i + i += 1 + return n - 1 + + def scan_routes(path, owner): """扫一个源文件里的 `.route(...)` ⇒ [{path, method, handler_mod, handler_fn, closure}]。""" orig = read(path) @@ -237,34 +257,52 @@ def scan_routes(path, owner): p += 1 while p < len(orig) and orig[p] in " \t\r\n": p += 1 - mm = re.match(r"(get|post|put|delete)\s*\(", orig[p:]) - if not mm: - continue - if masked[p:p + len(mm.group(1))] != mm.group(1): - continue # 方法名其实落在字符串里(误报) - method = mm.group(1).upper() - after = p + mm.end() if route.startswith(TEST_PATH_PREFIX): continue # 仅测试构建存在的端点 ⇒ 不在契约端点表里 - rest = orig[after:after + 240] - hm = HANDLER_RE.match(rest) - mod, fn, closure = None, None, True - if hm and hm.group(2): - mod, fn = hm.group(1), hm.group(2) - closure = False - out.append({ - "path": route, - "method": method, - "mod": mod, - "fn": fn, - "closure": closure, - "owner": owner, - # 🔴 `source` 区分「路由住在哪」:平台层 / 业务模块(面 A)/ 业务包(面 B)。 - # owner 会撞(包与模块同 app_code)⇒ 守卫推导与台账范围**必须**看这个。 - "source": "platform" if owner == "platform" else "module", - "const": None, - "file": path, - }) + # 🔴 一条 `.route(path, …)` 里可能有**多个**方法:`.route(p, get(a).post(b))` + # —— axum 对同一 path **只准 `.route()` 一次**(重复会 panic + # `Overlapping method route`),所以「列表 GET + 新建 POST」必然链在一起。 + # 老实现只取**第一个**方法 ⇒ 后面的方法**静默消失**:契约里写 implemented, + # 却报「代码里没有这条路由」(批次 14 踩到)。 + cursor = p + while True: + mm = re.match(r"(get|post|put|delete)\s*\(", orig[cursor:]) + if not mm: + break + if masked[cursor:cursor + len(mm.group(1))] != mm.group(1): + break # 方法名其实落在字符串里(误报) + method = mm.group(1).upper() + name_start = cursor + mm.end() + close = paren_span(masked, cursor + mm.end() - 1) + rest = orig[name_start:name_start + 240] + hm = HANDLER_RE.match(rest) + mod, fn, closure = None, None, True + if hm and hm.group(2): + mod, fn = hm.group(1), hm.group(2) + closure = False + out.append({ + "path": route, + "method": method, + "mod": mod, + "fn": fn, + "closure": closure, + "owner": owner, + # 🔴 `source` 区分「路由住在哪」:平台层 / 业务模块(面 A)/ 业务包(面 B)。 + # owner 会撞(包与模块同 app_code)⇒ 守卫推导与台账范围**必须**看这个。 + "source": "platform" if owner == "platform" else "module", + "const": None, + "file": path, + }) + # 顺着 `.` 走到下一个方法;遇到 `,` / `)` / 文件尾就停。 + cursor = close + 1 + while cursor < len(orig) and orig[cursor] in " \t\r\n": + cursor += 1 + if cursor < len(orig) and orig[cursor] == ".": + cursor += 1 + while cursor < len(orig) and orig[cursor] in " \t\r\n": + cursor += 1 + continue + break return out, orig, masked diff --git a/scripts/fe-gap.py b/scripts/fe-gap.py index dee15a4..0d54b03 100644 --- a/scripts/fe-gap.py +++ b/scripts/fe-gap.py @@ -71,20 +71,23 @@ def read_backend() -> tuple[set[tuple[str, str]], list[str]]: # `.route(\n "/api/x",\n get(h),\n)` 这种折行写法)。 # 🔴 不能见 `"/api/..."` 就收 —— `routes.rs` 里还有大量「期望路径」字符串 # 数组(自检用),照收会把未实现的路由误判成已实现。 - lines = text.splitlines() - for i, line in enumerate(lines): - if "route(" not in line: - continue - window = "\n".join(lines[i : i + 4]) - m = ROUTE_LIT.search(window) + # 🔴 按 `.route(` **切块**再逐块取路径与方法:一条 `.route()` 里可以链多个方法 + # (`.route(p, get(a).post(b))` —— axum 同一个 path 只准注册一次,所以 + # 「列表 GET + 新建 POST」必然链在一起)。 + # 旧实现只看 4 行窗口里的**第一个**方法 ⇒ 后半段方法被漏掉, + # 已实现的端点仍被报成缺口。 + for chunk in text.split(".route(")[1:]: + m = ROUTE_LIT.search(chunk) if not m: continue path = m.group(1) - mm = METHOD_CALL.search(window[m.end() :]) - if not mm: - warns.append(f"{f.relative_to(ROOT)}:{i + 1} 路径 {path} 找不到方法") + rest = chunk[m.end() :] + methods = {mm.group(1).upper() for mm in METHOD_CALL.finditer(rest)} + if not methods: + warns.append(f"{f.relative_to(ROOT)} 路径 {path} 找不到方法") continue - found.add((mm.group(1).upper(), norm(path))) + for meth in methods: + found.add((meth, norm(path))) return found, warns diff --git a/src/backend/db/schema.sql b/src/backend/db/schema.sql index 76ccdd6..38e8508 100644 --- a/src/backend/db/schema.sql +++ b/src/backend/db/schema.sql @@ -1410,3 +1410,97 @@ CREATE TABLE base_common_variate ( f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, PRIMARY KEY (f_id, f_tenant_id) ); + +-- 基准数据类型 ↔ 控件映射 —— 列与官方 JNPF 7.0 逐字一致 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 1520 行,`base_data_type_mapping`) +-- 🔴 一条映射 = 「某个 jnpfKey 控件支持某种基准数据类型」; +-- 官方 `DataTypeMappingController:131` 的 getKeyList 是**按 typeId 反查** jnpfKey 列表。 +CREATE TABLE base_data_type_mapping ( + f_id VARCHAR(50) NOT NULL, + f_jnpf_key VARCHAR(50), + f_type_id VARCHAR(50), + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); + +-- 数据库管理(数据中心的「目标库类型」登记表)—— 列与官方逐字一致 +-- (官方第 1480 行附近,`base_data_base`) +-- 🔴 `f_db_type` 是**驱动类型编码**(官方按它判重,`DataBaseController:59`), +-- 不是显示名;`f_db_url` 只是模板串(如 `jdbc:mysql://...`),不存真实凭据。 +CREATE TABLE base_data_base ( + f_id VARCHAR(50) NOT NULL, + f_full_name VARCHAR(50), + f_icon VARCHAR(255), + f_db_type VARCHAR(50) DEFAULT '0', + f_db_drive VARCHAR(255), + f_db_url VARCHAR(255), + f_type INTEGER, + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); + +-- 数据库字段类型映射(某库下「本平台类型 → 目标库类型」)—— 列与官方逐字一致 +-- (官方第 1549 行,`base_data_type_relation`) +-- 🔴 判重是**三元组**:`enCode + baseId`(官方 `existByEncode(id, enCode, baseId)`), +-- 同一个 enCode 在不同库下可以各有一条。 +CREATE TABLE base_data_type_relation ( + f_id VARCHAR(50) NOT NULL, + f_base_id VARCHAR(50), + f_en_code VARCHAR(50), + f_type_id VARCHAR(50), + f_type INTEGER, + f_length_default INTEGER, + f_length_max INTEGER, + f_length_min INTEGER, + f_precision_default INTEGER, + f_precision_max INTEGER, + f_precision_min 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) +); + +-- 数据接口变量(接口的可变参数)—— 列与官方 JNPF 7.0 逐字一致 +-- (官方第 1362 行,`base_data_interface_variate`) +-- 🔴 `f_interface_id` 是**必填**(官方 NOT NULL)⇒ 没有「游离变量」。 +CREATE TABLE base_data_interface_variate ( + f_id VARCHAR(50) NOT NULL, + f_interface_id VARCHAR(50) NOT NULL, + f_full_name VARCHAR(200), + f_expression VARCHAR(500), + f_value TEXT, + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + f_field VARCHAR(50), + PRIMARY KEY (f_id, f_tenant_id) +); diff --git a/src/backend/src/main.rs b/src/backend/src/main.rs index ccbec8e..e750e8d 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -55,7 +55,9 @@ use ssw_platform::routes; /// `base_advanced_query_scheme`;**数据权限三件套**(2026-11-01 批次 11) /// `base_module_authorize` / `base_module_scheme` / `base_module_link`,故清单现在是 **48 张**。 /// 系统数据批次(2026-11-02 批次 13)新增 `base_province` / `base_common_variate` ⇒ **50 张**。 -const BASE_TABLES: [&str; 50] = [ +/// 数据中心批次(2026-11-02 批次 14)新增 `base_data_type_mapping` / `base_data_base` / +/// `base_data_type_relation` / `base_data_interface_variate` ⇒ **54 张**。 +const BASE_TABLES: [&str; 54] = [ "base_group", "base_user", "base_role", @@ -124,6 +126,12 @@ const BASE_TABLES: [&str; 50] = [ // 都是官方 DDL 逐字;`base_province` 是**树**(`f_parent_id`,根固定 `-1`)。 "base_province", "base_common_variate", + // 🔴 数据中心批次(2026-11-02 批次 14):基准类型映射 / 目标库登记 / + // 字段类型映射 / 接口变量,都是官方 DDL 逐字(`base_data_type` 早在批次 5 已登记)。 + "base_data_type_mapping", + "base_data_base", + "base_data_type_relation", + "base_data_interface_variate", ]; /// 命令行解析的结果(**纯数据**,便于单测)。 diff --git a/src/backend/src/platform/face_b.rs b/src/backend/src/platform/face_b.rs index 8f21907..2addeaf 100644 --- a/src/backend/src/platform/face_b.rs +++ b/src/backend/src/platform/face_b.rs @@ -1207,7 +1207,7 @@ pub async fn user_create( values.push(Some("0".to_string())); columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); // 审计列直接用 SQL 自己的 `now()`,**不占参数位**(不受客户端时区影响,也少一个绑定)。 columns.push("f_creator_time"); let mut marks: Vec = (0..values.len()) @@ -1669,7 +1669,7 @@ pub async fn group_create( } columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -1735,7 +1735,7 @@ pub async fn group_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -1774,7 +1774,7 @@ pub async fn group_delete( return db_error(e, "删除分组"); } // 关系行同步软删(否则树删了、成员还在 ⇒ 下次同 id 建组会「复活」旧成员)。 - let rel = [Some(user.account), Some(id)]; + let rel = [Some(user.account.clone()), Some(id)]; if let Err(e) = state .db .exec_params( @@ -2416,7 +2416,7 @@ pub async fn organize_create( } columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -2482,7 +2482,7 @@ pub async fn organize_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -2511,7 +2511,7 @@ pub async fn organize_delete( Err(resp) => return resp, }; let id = id.trim().to_string(); - let values = [Some(user.account), Some(id)]; + let values = [Some(user.account.clone()), Some(id)]; let sql = "UPDATE base_organize SET f_delete_mark = 1, f_delete_time = now(), \ f_delete_user_id = $1::text WHERE f_id = $2::text \ AND COALESCE(f_delete_mark,0) = 0"; @@ -2712,7 +2712,7 @@ pub async fn position_create( values.push(Some(new_id.clone())); columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -2777,7 +2777,7 @@ pub async fn position_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -2803,7 +2803,7 @@ pub async fn position_delete( Err(resp) => return resp, }; let id = id.trim().to_string(); - let values = [Some(user.account), Some(id)]; + let values = [Some(user.account.clone()), Some(id)]; let sql = "UPDATE base_position SET f_delete_mark = 1, f_delete_time = now(), \ f_delete_user_id = $1::text WHERE f_id = $2::text \ AND COALESCE(f_delete_mark,0) = 0"; @@ -3100,7 +3100,7 @@ pub async fn role_create( } columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -3165,7 +3165,7 @@ pub async fn role_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -3191,7 +3191,7 @@ pub async fn role_delete( Err(resp) => return resp, }; let id = id.trim().to_string(); - let values = [Some(user.account), Some(id)]; + let values = [Some(user.account.clone()), Some(id)]; let sql = "UPDATE base_role SET f_delete_mark = 1, f_delete_time = now(), \ f_delete_user_id = $1::text WHERE f_id = $2::text \ AND COALESCE(f_delete_mark,0) = 0"; @@ -3395,7 +3395,7 @@ pub async fn menu_create( } columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -3460,7 +3460,7 @@ pub async fn menu_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -3486,7 +3486,7 @@ pub async fn menu_delete( Err(resp) => return resp, }; let id = id.trim().to_string(); - let values = [Some(user.account), Some(id)]; + let values = [Some(user.account.clone()), Some(id)]; let sql = "UPDATE base_module SET f_delete_mark = 1, f_delete_time = now(), \ f_delete_user_id = $1::text WHERE f_id = $2::text \ AND COALESCE(f_delete_mark,0) = 0"; @@ -3866,7 +3866,7 @@ pub async fn dict_type_create( } columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -3930,7 +3930,7 @@ pub async fn dict_type_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -3956,7 +3956,7 @@ pub async fn dict_type_delete( Err(resp) => return resp, }; let id = id.trim().to_string(); - let values = [Some(user.account), Some(id)]; + let values = [Some(user.account.clone()), Some(id)]; let sql = "UPDATE base_dictionary_type SET f_delete_mark = 1, f_delete_time = now(), \ f_delete_user_id = $1::text WHERE f_id = $2::text \ AND COALESCE(f_delete_mark,0) = 0"; @@ -4107,7 +4107,7 @@ pub async fn dict_data_create( } columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -4171,7 +4171,7 @@ pub async fn dict_data_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -4197,7 +4197,7 @@ pub async fn dict_data_delete( Err(resp) => return resp, }; let id = id.trim().to_string(); - let values = [Some(user.account), Some(id)]; + let values = [Some(user.account.clone()), Some(id)]; let sql = "UPDATE base_dictionary_data SET f_delete_mark = 1, f_delete_time = now(), \ f_delete_user_id = $1::text WHERE f_id = $2::text \ AND COALESCE(f_delete_mark,0) = 0"; @@ -6004,7 +6004,7 @@ pub async fn permission_group_create( } columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -6073,7 +6073,7 @@ pub async fn permission_group_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -6115,7 +6115,7 @@ pub async fn permission_group_delete( // 官方 `PermissionGroupController.delete` 还会删掉该组的授权关系。 // 🔴 `$1` 必须**真的被用到**(PG 会拒「无法确定 $1 类型」)⇒ // 这里把 `f_delete_user_id = $1` 一起写上(既是审计列,也用掉了参数)。 - let rel = [Some(user.account), Some(id)]; + let rel = [Some(user.account.clone()), Some(id)]; if let Err(e) = state .db .exec_params( @@ -6323,7 +6323,7 @@ pub async fn permission_group_member_save( let member = ids.join(","); let values = [ Some(member), - Some(user.account), + Some(user.account.clone()), Some(id), ]; let sql = "UPDATE base_permission_group SET f_permission_member = $1::text, \ @@ -6515,7 +6515,7 @@ pub async fn action_create( } columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -6585,7 +6585,7 @@ pub async fn action_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -6611,7 +6611,7 @@ pub async fn action_delete( Err(resp) => return resp, }; let id = id.trim().to_string(); - let values = [Some(user.account), Some(id)]; + let values = [Some(user.account.clone()), Some(id)]; let sql = "UPDATE base_action SET f_delete_mark = 1, f_delete_time = now(), \ f_delete_user_id = $1::text WHERE f_id = $2::text \ AND COALESCE(f_delete_mark,0) = 0"; @@ -6795,7 +6795,7 @@ pub async fn standing_create( values.push(Some("2".to_string())); columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -6861,7 +6861,7 @@ pub async fn standing_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -6906,7 +6906,7 @@ pub async fn standing_delete( let rel = [ Some(STANDING_ITEM_TYPE.to_string()), Some(id), - Some(user.account), + Some(user.account.clone()), ]; if let Err(e) = state .db @@ -7527,7 +7527,7 @@ pub async fn system_create( values.push(Some("0".to_string())); columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -7624,7 +7624,7 @@ pub async fn system_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -7683,7 +7683,7 @@ pub async fn system_delete( Ok(_) => {} Err(e) => return db_error(e, "应用菜单检查"), } - let values = [Some(user.account), Some(id)]; + let values = [Some(user.account.clone()), Some(id)]; if let Err(e) = state .db .exec_params( @@ -7752,7 +7752,7 @@ pub async fn system_copy( Some(new_id), Some(format!("{src_name}(副本)")), Some(en_code), - Some(user.account), + Some(user.account.clone()), Some(id), ]; if let Err(e) = state @@ -7876,7 +7876,7 @@ pub async fn system_preference_save( Err(resp) => return resp, }; let pref = value_to_text(obj.get("preferenceJson")); - let values = [pref, Some(user.account), Some(id.clone())]; + let values = [pref, Some(user.account.clone()), Some(id.clone())]; if let Err(e) = state .db .exec_params( @@ -8030,7 +8030,7 @@ async fn system_app_auth_write( values.push(Some(create_user)); sets.push(format!("f_creator_user_id = ${}::text", values.len())); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(system_id)); @@ -8367,7 +8367,7 @@ pub async fn sys_config_admin_set( return fail(code::FAIL, "请选择超级管理员"); } let joined = ids.join(","); - let values = [Some(joined), Some(user.account)]; + let values = [Some(joined), Some(user.account.clone())]; if let Err(e) = state .db .exec_params( @@ -8669,7 +8669,7 @@ pub async fn tag_create( } columns.push("f_creator_user_id"); casts.push(""); - values.push(Some(user.account)); + values.push(Some(user.account.clone())); columns.push("f_delete_mark"); casts.push("::integer"); values.push(Some("0".to_string())); @@ -8764,7 +8764,7 @@ pub async fn tag_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -8789,7 +8789,7 @@ pub async fn tag_delete( Ok(u) => u, Err(resp) => return resp, }; - let values = [Some(user.account), Some(id.trim().to_string())]; + let values = [Some(user.account.clone()), Some(id.trim().to_string())]; if let Err(e) = state .db .exec_params( @@ -9269,7 +9269,7 @@ pub async fn business_category_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -9294,7 +9294,7 @@ pub async fn business_category_delete( Ok(u) => u, Err(resp) => return resp, }; - let values = [Some(user.account), Some(id.trim().to_string())]; + let values = [Some(user.account.clone()), Some(id.trim().to_string())]; if let Err(e) = state .db .exec_params( @@ -9758,7 +9758,7 @@ pub async fn message_record_delete( if ids.is_empty() { return fail(code::FAIL, "请选择要删除的消息"); } - let values = [Some(user.account), Some(ids.join(",")), Some(user.user_id)]; + let values = [Some(user.account.clone()), Some(ids.join(",")), Some(user.user_id)]; if let Err(e) = state .db .exec_params( @@ -10084,7 +10084,7 @@ pub async fn notice_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -10180,7 +10180,7 @@ pub async fn notice_delete( Ok(u) => u, Err(resp) => return resp, }; - let values = [Some(user.account), Some(id.trim().to_string())]; + let values = [Some(user.account.clone()), Some(id.trim().to_string())]; if let Err(e) = state .db .exec_params( @@ -21235,7 +21235,7 @@ pub async fn area_create( ins.param(column, cast, value_to_text(obj.get(json_key))); } } - ins.param("f_creator_user_id", "", Some(user.account)); + ins.param("f_creator_user_id", "", Some(user.account.clone())); ins.raw("f_creator_time", "now()"); ins.param("f_delete_mark", "::text::integer", Some("0".to_string())); @@ -21292,7 +21292,7 @@ pub async fn area_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -21604,7 +21604,7 @@ pub async fn variate_create( ins.param("f_type", "::text::integer", value_to_text(obj.get("type"))); } ins.param("f_enabled_mark", "::text::integer", Some("1".to_string())); - ins.param("f_creator_user_id", "", Some(user.account)); + ins.param("f_creator_user_id", "", Some(user.account.clone())); ins.raw("f_creator_time", "now()"); ins.param("f_delete_mark", "::text::integer", Some("0".to_string())); @@ -21658,7 +21658,7 @@ pub async fn variate_update( if sets.is_empty() { return ok(Value::Null); } - values.push(Some(user.account)); + values.push(Some(user.account.clone())); sets.push(format!("f_last_modify_user_id = ${}", values.len())); sets.push("f_last_modify_time = now()".to_string()); values.push(Some(id)); @@ -21763,6 +21763,1154 @@ const VARIATE_FUNC_CATEGORIES: [(&str, &str); 11] = [ // === SYSTEM DATA (系统数据族) SECTION END === +// === DATA CENTER (数据中心族) SECTION BEGIN === +// +// 覆盖 `systemData` 目录下「基准数据类型 / 控件映射 / 数据库 / 字段类型映射 / 常用字段」 +// 五族共 25 条端点 + 数据同步 4 条 + 接口变量下拉 1 条。 +// +// 🔴 这五族的形状完全一样(扁平表 + 分页/不分页 + 判重 + 软删),所以**不再逐族手抄** +// —— 每族只写一份 [`Flat`] 声明 + 五个薄壳 handler。声明里的表名/列名/权限码 +// 全是编译期常量,SQL 拼接面里没有任何请求可控的标识符。 + +/// SQL / Java 保留字(官方 `GenerateConstant.getSqlKeyword() + getJavaKeyword()` 的常用子集)。 +/// +/// 🔴 常用字段是**建表用的列名模板** ⇒ 叫 `select` / `order` / `class` 会让后续 DDL 直接失败, +/// 官方在 `ComFieldsController:104` 同样先挡这一层。这里只收**真会撞**的那些, +/// 不追求与 Java 那份 300 项清单逐字一致(那份里大半是 `abstract`/`assert` 之类)。 +const RESERVED_COLUMNS: [&str; 30] = [ + "add", "all", "and", "as", "asc", "between", "by", "case", "check", "class", "column", + "create", "delete", "desc", "distinct", "drop", "else", "from", "group", "having", "in", + "index", "insert", "into", "join", "like", "not", "null", "order", "select", +]; + +/// 列名是否撞保留字(大小写不敏感)。 +fn is_reserved_column(field: &str) -> bool { + let lower = field.trim().to_ascii_lowercase(); + !lower.is_empty() && RESERVED_COLUMNS.contains(&lower.as_str()) +} + +/// 一族「扁平 CRUD」的声明。 +struct Flat { + /// 物理表名。 + table: &'static str, + /// 中文名(拼错误文案)。 + label: &'static str, + /// 列表的 SELECT 投影(**不含** `SELECT` 关键字)。 + projection: &'static str, + /// 列表在 `FROM <表> t` 之后追加的片段(`LEFT JOIN …`),空串 ⇒ 无。 + from_extra: &'static str, + /// 详情的 SELECT 投影。空串 ⇒ 复用 [`Self::projection`]。 + /// + /// 🔴 只有「**列表把 id 覆盖成名字**」的族才需要单独写(控件映射 / 字段类型映射)—— + /// 官方那两个列表把 `typeId` 换成名称,但 `GET /{id}` 返回**真 id**(编辑表单靠它)。 + /// 详情里若也用名称,前端保存时会把「名称」当外键写回去 ⇒ 静默写坏数据。 + info_projection: &'static str, + /// 详情在 `FROM <表> t` 之后追加的片段。空串 ⇒ 复用 [`Self::from_extra`]。 + info_from_extra: &'static str, + /// `keyword` 模糊匹配的列(空 ⇒ 该族不认 `keyword`)。 + keyword_cols: &'static [&'static str], + /// 等值过滤:(query 参数名, 列, cast)。 + eq_filters: &'static [(&'static str, &'static str, &'static str)], + /// 写列白名单:(JSON 键, 列, cast)。**只认这里面的键**。 + fields: &'static [(&'static str, &'static str, &'static str)], + /// 唯一约束,**每个元素是一组「联合唯一」的列**(非空值才参与,排除自己)。 + /// + /// - 各列**分别**唯一 ⇒ 拆成多个单列组: + /// `&[&[("enCode","f_en_code")], &[("fullName","f_full_name")]]` + /// - **组合**唯一(例如「同库下同编码」)⇒ 一组多列: + /// `&[&[("enCode","f_en_code"), ("baseId","f_base_id")]]` + /// + /// 🔴 两者不是一回事:写成一组多列会把「同编码不同名」放过去(批次 14 踩到)。 + unique_groups: &'static [&'static [(&'static str, &'static str)]], + /// `ORDER BY` 子句(**不含** `ORDER BY`)。 + order_by: &'static str, + /// 是否按 `f_delete_mark` 软删。 + soft_delete: bool, + /// 是否返回 `{pagination,list}`;`false` ⇒ `{list}`。 + paged: bool, +} + +impl Flat { + /// 详情投影(空 ⇒ 复用列表的)。 + fn info_proj(&self) -> &'static str { + if self.info_projection.is_empty() { + self.projection + } else { + self.info_projection + } + } + + /// 详情 join(空 ⇒ 复用列表的)。 + fn info_from(&self) -> &'static str { + if self.info_from_extra.is_empty() { + self.from_extra + } else { + self.info_from_extra + } + } + + /// 拼接 `WHERE`(软删 + 等值过滤 + keyword),返回 (SQL 片段, 参数)。 + /// + /// 🔴 列名一律带**主表别名 `t.`** —— 五族里有三族要 `LEFT JOIN` 取名字, + /// 裸列名在 join 后可能歧义(或更糟:静默取到另一张表的同名错误列)。 + /// 🔴 `keyword` 的**列名来自声明**,参数走 `$N` ⇒ 无注入面。 + fn where_of(&self, raw: &RawQuery) -> (String, Vec>) { + let mut sql = String::new(); + let mut values: Vec> = Vec::new(); + if self.soft_delete { + sql.push_str(" WHERE COALESCE(t.f_delete_mark, 0) = 0"); + } else { + sql.push_str(" WHERE 1 = 1"); + } + for (param, column, cast) in self.eq_filters { + let v = crate::platform::sys::query_param(raw, param).trim().to_string(); + if v.is_empty() { + continue; + } + values.push(Some(v)); + sql.push_str(&format!(" AND t.{column} = ${}{cast}", values.len())); + } + let keyword = crate::platform::sys::query_param(raw, "keyword") + .trim() + .to_string(); + if !keyword.is_empty() && !self.keyword_cols.is_empty() { + values.push(Some(format!("%{keyword}%"))); + let n = values.len(); + let ors: Vec = self + .keyword_cols + .iter() + .map(|c| format!("t.{c} LIKE ${n}::text")) + .collect(); + sql.push_str(&format!(" AND ({})", ors.join(" OR "))); + } + (sql, values) + } +} + +/// 五族共用的列表实现。 +async fn flat_list(state: &AppState, raw: &RawQuery, spec: &Flat) -> Json { + let (where_sql, values) = spec.where_of(raw); + + let rows = if spec.paged { + let paging = Paging::of(raw); + let count_sql = format!( + "SELECT count(*)::bigint AS \"c\" FROM {} t{} {where_sql}", + spec.table, spec.from_extra + ); + let total = match state.db.query_json_params(&count_sql, ¶ms_of(&values)).await { + Ok(rows) => rows.first().and_then(|r| r["c"].as_i64()).unwrap_or(0), + Err(e) => return db_error(e, spec.label), + }; + let sql = format!( + "SELECT {} FROM {} t{} {where_sql} ORDER BY {} LIMIT {} OFFSET {}", + spec.projection, + spec.table, + spec.from_extra, + spec.order_by, + paging.page_size, + paging.offset + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, spec.label), + }; + return ok(page_list(paging.current_page, paging.page_size, total, rows)); + } else { + let sql = format!( + "SELECT {} FROM {} t{} {where_sql} ORDER BY {}", + spec.projection, spec.table, spec.from_extra, spec.order_by + ); + match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, spec.label), + } + }; + ok(list_vo(rows)) +} + +/// 五族共用的详情实现。 +async fn flat_info(state: &AppState, id: &str, spec: &Flat) -> Json { + let mut sql = format!( + "SELECT {} FROM {} t{} WHERE t.f_id = $1::text", + spec.info_proj(), + spec.table, + spec.info_from() + ); + if spec.soft_delete { + sql.push_str(" AND COALESCE(t.f_delete_mark, 0) = 0"); + } + sql.push_str(" LIMIT 1"); + match state + .db + .query_json_params(&sql, ¶ms_of(&[Some(id.trim().to_string())])) + .await + { + Ok(rows) => match rows.into_iter().next() { + Some(row) => ok(row), + None => fail(code::FAIL, format!("{}不存在", spec.label)), + }, + Err(e) => db_error(e, spec.label), + } +} + +/// 判重:`uniques` 里出现且非空的键,必须唯一(排除 `exclude_id`)。 +/// +/// 返回 `Some(重复的 JSON 键)`。 +async fn flat_taken( + db: &Db, + spec: &Flat, + obj: &Map, + exclude_id: Option<&str>, +) -> Result, pglite::Error> { + // 🔴 **逐组**判:一组的列全部有值才算这一组成立(联合唯一)。 + // 单列唯一就是「每组一个列」;写成一组多列会把「同码不同名」放过去。 + for group in spec.unique_groups { + let mut conds: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + let mut first_key: Option<&'static str> = None; + for (json_key, column) in *group { + let Some(v) = value_to_text(obj.get(*json_key)) else { + continue; + }; + if v.trim().is_empty() { + continue; + } + values.push(Some(v)); + conds.push(format!("t.{column} = ${}::text", values.len())); + if first_key.is_none() { + first_key = Some(json_key); + } + } + // 组内任一列没给 ⇒ 该组判不了(前端局部更新时只传改动的键是常态)。 + if conds.is_empty() || conds.len() != group.len() { + continue; + } + values.push(exclude_id.map(|s| s.to_string())); + let n = values.len(); + let sql = format!( + "SELECT t.f_id AS \"id\" FROM {} t{} WHERE {} AND (${n}::text IS NULL OR t.f_id <> ${n}::text) LIMIT 1", + spec.table, + spec.from_extra, + format!( + "{}{}", + if spec.soft_delete { + "COALESCE(t.f_delete_mark, 0) = 0 AND " + } else { + "" + }, + conds.join(" AND ") + ), + ); + let rows = db.query_json_params(&sql, ¶ms_of(&values)).await?; + if !rows.is_empty() { + return Ok(first_key); + } + } + Ok(None) +} + +/// 五族共用的新建实现。 +async fn flat_create( + state: &AppState, + user: &TokenUser, + body: &Bytes, + spec: &Flat, +) -> Json { + let obj = match parse_body(body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + match flat_taken(&state.db, spec, &obj, None).await { + Ok(Some(key)) => return fail(code::FAIL, format!("{}已存在", label_of_key(spec, key))), + Ok(None) => {} + Err(e) => return db_error(e, spec.label), + } + + let mut ins = Inserts::default(); + ins.param("f_id", "", Some(new_uuid())); + ins.param("f_tenant_id", "", Some("0".to_string())); + for (json_key, column, cast) in spec.fields { + if obj.contains_key(*json_key) { + ins.param(column, cast, value_to_text(obj.get(*json_key))); + } + } + if spec.soft_delete { + ins.param("f_delete_mark", "::text::integer", Some("0".to_string())); + } + ins.param("f_creator_user_id", "", Some(user.account.clone())); + ins.raw("f_creator_time", "now()"); + let sql = ins.finish(spec.table); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&ins.values)).await { + return db_error(e, spec.label); + } + ok(Value::Null) +} + +/// 五族共用的更新实现 —— **只 SET body 里出现的键**。 +async fn flat_update( + state: &AppState, + user: &TokenUser, + id: &str, + body: &Bytes, + spec: &Flat, +) -> Json { + let obj = match parse_body(body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + match flat_taken(&state.db, spec, &obj, Some(&id)).await { + Ok(Some(key)) => return fail(code::FAIL, format!("{}已存在", label_of_key(spec, key))), + Ok(None) => {} + Err(e) => return db_error(e, spec.label), + } + + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (json_key, column, cast) in spec.fields { + if !obj.contains_key(*json_key) { + continue; + } + values.push(value_to_text(obj.get(*json_key))); + sets.push(format!("{column} = ${}{cast}", values.len())); + } + if sets.is_empty() { + return ok(Value::Null); + } + values.push(Some(user.account.clone())); + sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let sql = format!( + "UPDATE {} SET {} WHERE f_id = ${}::text", + spec.table, + sets.join(", "), + values.len() + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, spec.label); + } + ok(Value::Null) +} + +/// 五族共用的删除实现(软删)。 +async fn flat_delete( + state: &AppState, + user: &TokenUser, + id: &str, + spec: &Flat, +) -> Json { + let id = id.trim().to_string(); + // 🔴 软删与硬删的**参数个数不同**:tokio-postgres 会校验 `$N` 的个数, + // 多传一个参数直接报错(不是「忽略多余」)⇒ 两条分支各拼各的。 + let result = if spec.soft_delete { + state + .db + .exec_params( + &format!( + "UPDATE {} t SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $2::text WHERE t.f_id = $1::text", + spec.table + ), + ¶ms_of(&[Some(id), Some(user.account.clone())]), + ) + .await + } else { + state + .db + .exec_params( + &format!("DELETE FROM {} t WHERE t.f_id = $1::text", spec.table), + ¶ms_of(&[Some(id)]), + ) + .await + }; + if let Err(e) = result { + return db_error(e, spec.label); + } + ok(Value::Null) +} + +/// 判重键的**中文名**(拼「名称已存在」用)。 +fn label_of_key(spec: &Flat, key: &str) -> &'static str { + match (spec.label, key) { + (_, "enCode") => "编码", + (_, "fullName") => "名称", + (_, "field") => "字段名", + (_, "dbType") => "数据库类型", + _ => "名称", + } +} + +// ---- 基准数据类型(`system/BasicDataType`,`base_data_type`)---- + +const EN_BASIC_DATA_TYPE: &str = "dataCenter.basicDataType"; + +const BASIC_DATA_TYPE: Flat = Flat { + table: "base_data_type", + label: "基准数据类型", + projection: "t.f_id AS \"id\", t.f_full_name AS \"fullName\", t.f_en_code AS \"enCode\", \ + t.f_jnpf_key AS \"jnpfKey\", COALESCE(t.f_type, 0)::bigint AS \"type\"", + from_extra: "", + info_projection: "", + info_from_extra: "", + keyword_cols: &[], + eq_filters: &[], + fields: &[ + ("fullName", "f_full_name", ""), + ("enCode", "f_en_code", ""), + ("jnpfKey", "f_jnpf_key", ""), + ("type", "f_type", "::text::integer"), + ("sortCode", "f_sort_code", "::text::bigint"), + ], + // 🔴 两列**各自**唯一 ⇒ 两个单列组(写成一组会把「同码不同名」放过去)。 + unique_groups: &[&[("enCode", "f_en_code")], &[("fullName", "f_full_name")]], + order_by: "t.f_sort_code ASC NULLS LAST, t.f_creator_time DESC", + soft_delete: true, + paged: false, +}; + +/// `GET /api/system/BasicDataType/{id}`。 +/// +/// 🔴 列表 `GET /api/system/BasicDataType` 早在「数据模型」批次就已实现并注册 +/// (见本文件上方 `basic_data_type_list`)—— 这里只补**缺的四个方法**。 +pub async fn basic_data_type_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_BASIC_DATA_TYPE).await { + return resp; + } + flat_info(&state, &id, &BASIC_DATA_TYPE).await +} + +/// `POST /api/system/BasicDataType`。 +/// +/// 🔴 官方 `DataTypeForm` 的 `type` **不在表单里** ⇒ 新建恒为「自定义(2)」, +/// `1` 是内置(种子数据),前端不能造。 +pub async fn basic_data_type_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_BASIC_DATA_TYPE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let mut obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + obj.insert("type".to_string(), json!(2)); + let bytes = Bytes::from(serde_json::to_vec(&Value::Object(obj)).unwrap_or_default()); + flat_create(&state, &user, &bytes, &BASIC_DATA_TYPE).await +} + +/// `PUT /api/system/BasicDataType/{id}`。 +/// +/// 🔴 `type` **不进写白名单**:它是「系统内置 / 自定义」的判别位,官方 `DataTypeForm` +/// 里根本没有这个字段 ⇒ 允许改就等于允许把自定义类型伪装成内置(删不掉)。 +pub async fn basic_data_type_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_BASIC_DATA_TYPE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let mut obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + obj.remove("type"); + let bytes = Bytes::from(serde_json::to_vec(&Value::Object(obj)).unwrap_or_default()); + flat_update(&state, &user, &id, &bytes, &BASIC_DATA_TYPE).await +} + +/// `DELETE /api/system/BasicDataType/{id}` —— 官方两条硬约束: +/// 内置类型(`type = 1`)不可删;被「控件映射 / 字段类型映射 / 常用字段」引用不可删。 +pub async fn basic_data_type_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_BASIC_DATA_TYPE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let rows = match state + .db + .query_json_params( + "SELECT COALESCE(f_type, 0)::text::integer AS \"type\" FROM base_data_type \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark, 0) = 0 LIMIT 1", + ¶ms_of(&[Some(id.clone())]), + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "基准数据类型详情查询"), + }; + let Some(row) = rows.into_iter().next() else { + return fail(code::FAIL, "基准数据类型不存在"); + }; + if row["type"].as_i64() == Some(1) { + return fail(code::FAIL, "系统内置类型不允许删除"); + } + match data_type_in_use(&state.db, &id).await { + Ok(true) => return fail(code::FAIL, "该类型已被使用,不允许删除"), + Ok(false) => {} + Err(e) => return db_error(e, "基准数据类型引用检查"), + } + flat_delete(&state, &user, &id, &BASIC_DATA_TYPE).await +} + +/// 官方 `isUsed` —— 被三张表引用就不许删。 +async fn data_type_in_use(db: &Db, id: &str) -> Result { + let rows = db + .query_json_params( + "SELECT 1 AS \"hit\" FROM base_data_type_mapping \ + WHERE f_type_id = $1::text AND COALESCE(f_delete_mark, 0) = 0 \ + UNION ALL \ + SELECT 1 FROM base_data_type_relation \ + WHERE f_type_id = $1::text AND COALESCE(f_delete_mark, 0) = 0 \ + UNION ALL \ + SELECT 1 FROM base_common_fields \ + WHERE f_data_type = (SELECT f_en_code FROM base_data_type WHERE f_id = $1::text) \ + AND COALESCE(f_delete_mark, 0) = 0 \ + LIMIT 1", + ¶ms_of(&[Some(id.to_string())]), + ) + .await?; + Ok(!rows.is_empty()) +} + +// ---- 控件映射(`system/DataTypeMapping`,`base_data_type_mapping`)---- + +const EN_DATA_TYPE_MAPPING: &str = "dataCenter.dataTypeMapping"; + +const DATA_TYPE_MAPPING: Flat = Flat { + table: "base_data_type_mapping", + label: "控件映射", + // 🔴 官方 `DataTypeMappingController:60-68` 把 `typeId` **覆盖成基准类型的名称** + // (前端表格这一列直接显示 `typeId`);编辑时再走 `GET /{id}` 拿真 id。 + projection: "t.f_id AS \"id\", t.f_jnpf_key AS \"jnpfKey\", \ + COALESCE(d.f_full_name, t.f_type_id) AS \"typeId\", \ + COALESCE(t.f_sort_code, 0) AS \"sortCode\"", + from_extra: " LEFT JOIN base_data_type d \ + ON d.f_id = t.f_type_id AND COALESCE(d.f_delete_mark, 0) = 0", + // 🔴 详情给**真 id**:列表那份 `typeId` 是名称,编辑表单如果把名称当外键存回去 + // 就会把 `f_type_id` 写成中文名(静默坏数据)。 + info_projection: "t.f_id AS \"id\", t.f_jnpf_key AS \"jnpfKey\", \ + t.f_type_id AS \"typeId\", COALESCE(t.f_sort_code, 0) AS \"sortCode\"", + info_from_extra: "", + keyword_cols: &[], + eq_filters: &[("jnpfKey", "f_jnpf_key", "::text")], + fields: &[ + ("jnpfKey", "f_jnpf_key", ""), + ("typeId", "f_type_id", ""), + ("sortCode", "f_sort_code", "::text::bigint"), + ], + unique_groups: &[], + order_by: "t.f_sort_code ASC NULLS LAST, t.f_creator_time DESC", + soft_delete: true, + paged: false, +}; + +/// `GET /api/system/DataTypeMapping` —— 列表(官方 `ListVO`,**不分页**)。 +pub async fn data_type_mapping_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_TYPE_MAPPING).await { + return resp; + } + flat_list(&state, &raw, &DATA_TYPE_MAPPING).await +} + +/// `GET /api/system/DataTypeMapping/{id}`。 +pub async fn data_type_mapping_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_TYPE_MAPPING).await { + return resp; + } + flat_info(&state, &id, &DATA_TYPE_MAPPING).await +} + +/// `POST /api/system/DataTypeMapping`。 +pub async fn data_type_mapping_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATA_TYPE_MAPPING).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_create(&state, &user, &body, &DATA_TYPE_MAPPING).await +} + +/// `PUT /api/system/DataTypeMapping/{id}`。 +pub async fn data_type_mapping_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATA_TYPE_MAPPING).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_update(&state, &user, &id, &body, &DATA_TYPE_MAPPING).await +} + +/// `DELETE /api/system/DataTypeMapping/{id}`。 +pub async fn data_type_mapping_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_DATA_TYPE_MAPPING).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_delete(&state, &user, &id, &DATA_TYPE_MAPPING).await +} + +/// `GET /api/system/DataTypeMapping/getKeyList` —— 「哪种控件支持哪些基准类型」。 +/// +/// 官方 `DataTypeMappingController:127-150`:按 `base_data_type` 逐条聚合, +/// 返回 `[{dataType: enCode, jnpfKeyList: [jnpfKey…]}]`。 +/// 🔴 权限是 **OR**:`dataCenter.dataTypeMapping` 或 `onlineDev.formDesign`。 +pub async fn data_type_mapping_key_list( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = + guard_any(&state, &headers, &[EN_DATA_TYPE_MAPPING, EN_FORM_DESIGN]).await + { + return resp; + } + let sql = "SELECT d.f_en_code AS \"dataType\", m.f_jnpf_key AS \"jnpfKey\" \ + FROM base_data_type d \ + LEFT JOIN base_data_type_mapping m \ + ON m.f_type_id = d.f_id AND COALESCE(m.f_delete_mark, 0) = 0 \ + WHERE COALESCE(d.f_delete_mark, 0) = 0 \ + ORDER BY d.f_sort_code ASC NULLS LAST, m.f_sort_code ASC NULLS LAST"; + let rows = match state.db.query_json(&sql).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "控件映射键列表"), + }; + let mut order: Vec = Vec::new(); + let mut groups: HashMap> = HashMap::new(); + for row in rows { + let Some(data_type) = row["dataType"].as_str() else { + continue; + }; + if !groups.contains_key(data_type) { + order.push(data_type.to_string()); + groups.insert(data_type.to_string(), Vec::new()); + } + if let Some(key) = row["jnpfKey"].as_str() { + if !key.is_empty() { + groups + .get_mut(data_type) + .expect("刚插入过") + .push(Value::String(key.to_string())); + } + } + } + let list: Vec = order + .into_iter() + .map(|data_type| { + let keys = groups.remove(&data_type).unwrap_or_default(); + json!({ "dataType": data_type, "jnpfKeyList": keys }) + }) + .collect(); + ok(Value::Array(list)) +} + +// ---- 数据库管理(`system/DataBase`,`base_data_base`)---- + +const EN_DATABASE: &str = "dataCenter.database"; + +const DATA_BASE: Flat = Flat { + table: "base_data_base", + label: "数据库", + projection: "t.f_id AS \"id\", t.f_full_name AS \"fullName\", t.f_icon AS \"icon\", \ + t.f_db_type AS \"dbType\", t.f_db_drive AS \"dbDrive\", \ + t.f_db_url AS \"dbUrl\", COALESCE(t.f_type, 0) AS \"type\"", + from_extra: "", + info_projection: "", + info_from_extra: "", + keyword_cols: &[], + eq_filters: &[], + fields: &[ + ("fullName", "f_full_name", ""), + ("icon", "f_icon", ""), + ("dbType", "f_db_type", ""), + ("dbDrive", "f_db_drive", ""), + ("dbUrl", "f_db_url", ""), + ("type", "f_type", "::text::integer"), + ], + unique_groups: &[&[("dbType", "f_db_type")]], + order_by: "t.f_sort_code ASC NULLS LAST, t.f_creator_time DESC", + soft_delete: true, + paged: false, +}; + +/// `GET /api/system/DataBase` —— 列表(官方 `ListVO`,不分页)。 +/// +/// 🔴 官方 `DataBaseController.list()` **没有** `@SaCheckPermission`(登录即可), +/// 增删改才有 —— 照抄,别顺手加。 +pub async fn data_base_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + flat_list(&state, &raw, &DATA_BASE).await +} + +/// `GET /api/system/DataBase/{id}`。 +pub async fn data_base_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATABASE).await { + return resp; + } + flat_info(&state, &id, &DATA_BASE).await +} + +/// `POST /api/system/DataBase` —— 官方按 `dbType` 判重(`DataBaseController:59`)。 +pub async fn data_base_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATABASE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_create(&state, &user, &body, &DATA_BASE).await +} + +/// `PUT /api/system/DataBase/{id}`。 +pub async fn data_base_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATABASE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_update(&state, &user, &id, &body, &DATA_BASE).await +} + +/// `DELETE /api/system/DataBase/{id}`。 +pub async fn data_base_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_DATABASE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_delete(&state, &user, &id, &DATA_BASE).await +} + +// ---- 字段类型映射(`system/DataTypeRelation`,`base_data_type_relation`)---- + +const DATA_TYPE_RELATION: Flat = Flat { + table: "base_data_type_relation", + label: "字段类型映射", + // 🔴 与控件映射同款:列表里 `typeId` 被**覆盖成名称**,编辑走 `GET /{id}`。 + projection: "t.f_id AS \"id\", t.f_base_id AS \"baseId\", t.f_en_code AS \"enCode\", \ + COALESCE(d.f_full_name, t.f_type_id) AS \"typeId\", \ + COALESCE(t.f_type, 0) AS \"type\", \ + COALESCE(t.f_length_default, 0) AS \"lengthDefault\", \ + COALESCE(t.f_length_max, 0) AS \"lengthMax\", \ + COALESCE(t.f_length_min, 0) AS \"lengthMin\", \ + COALESCE(t.f_precision_default, 0) AS \"precisionDefault\", \ + COALESCE(t.f_precision_max, 0) AS \"precisionMax\", \ + COALESCE(t.f_precision_min, 0) AS \"precisionMin\"", + from_extra: " LEFT JOIN base_data_type d \ + ON d.f_id = t.f_type_id AND COALESCE(d.f_delete_mark, 0) = 0", + // 🔴 同控件映射:列表 `typeId` 是名称、详情必须是真 id。 + info_projection: "t.f_id AS \"id\", t.f_base_id AS \"baseId\", t.f_en_code AS \"enCode\", \ + t.f_type_id AS \"typeId\", COALESCE(t.f_type, 0) AS \"type\", \ + COALESCE(t.f_length_default, 0) AS \"lengthDefault\", \ + COALESCE(t.f_length_max, 0) AS \"lengthMax\", \ + COALESCE(t.f_length_min, 0) AS \"lengthMin\", \ + COALESCE(t.f_precision_default, 0) AS \"precisionDefault\", \ + COALESCE(t.f_precision_max, 0) AS \"precisionMax\", \ + COALESCE(t.f_precision_min, 0) AS \"precisionMin\"", + info_from_extra: "", + keyword_cols: &[], + eq_filters: &[("baseId", "f_base_id", "::text")], + fields: &[ + ("baseId", "f_base_id", ""), + ("enCode", "f_en_code", ""), + ("typeId", "f_type_id", ""), + ("type", "f_type", "::text::integer"), + ("lengthDefault", "f_length_default", "::text::integer"), + ("lengthMax", "f_length_max", "::text::integer"), + ("lengthMin", "f_length_min", "::text::integer"), + ("precisionDefault", "f_precision_default", "::text::integer"), + ("precisionMax", "f_precision_max", "::text::integer"), + ("precisionMin", "f_precision_min", "::text::integer"), + ], + // 官方判重是**二元组**:同一个 enCode 在不同库里可以各有一条(⇒ 一组两列)。 + unique_groups: &[&[("enCode", "f_en_code"), ("baseId", "f_base_id")]], + order_by: "t.f_length_default DESC NULLS LAST, t.f_creator_time DESC", + soft_delete: true, + paged: true, +}; + +/// `GET /api/system/DataTypeRelation` —— 分页列表(官方 `PageListVO`)。 +pub async fn data_type_relation_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATABASE).await { + return resp; + } + flat_list(&state, &raw, &DATA_TYPE_RELATION).await +} + +/// `GET /api/system/DataTypeRelation/{id}`。 +pub async fn data_type_relation_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATABASE).await { + return resp; + } + flat_info(&state, &id, &DATA_TYPE_RELATION).await +} + +/// `POST /api/system/DataTypeRelation`。 +pub async fn data_type_relation_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATABASE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_create(&state, &user, &body, &DATA_TYPE_RELATION).await +} + +/// `PUT /api/system/DataTypeRelation/{id}`。 +pub async fn data_type_relation_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_DATABASE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_update(&state, &user, &id, &body, &DATA_TYPE_RELATION).await +} + +/// `DELETE /api/system/DataTypeRelation/{id}`。 +pub async fn data_type_relation_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_DATABASE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_delete(&state, &user, &id, &DATA_TYPE_RELATION).await +} + +// ---- 常用字段(`system/CommonFields`,`base_common_fields`)---- + +const EN_COMMON_FIELDS: &str = "dataCenter.basicField"; + +const COMMON_FIELDS: Flat = Flat { + table: "base_common_fields", + label: "常用字段", + // 与上方已实现的 `common_fields_list` 保持同一组键(多一个 `dataTypeName` 由本族 + // 的 info 也照给,前端两处共用一套表格列)。 + projection: "t.f_id AS \"id\", t.f_field_name AS \"fieldName\", \ + t.f_data_type AS \"dataType\", \ + COALESCE(d.f_full_name, t.f_data_type) AS \"dataTypeName\", \ + COALESCE(t.f_data_length, '') AS \"dataLength\", \ + COALESCE(t.f_allow_null, 1)::integer AS \"allowNull\", \ + t.f_field AS \"field\", \ + COALESCE(t.f_category, '1') AS \"category\", \ + COALESCE(t.f_type, 1)::integer AS \"type\", \ + COALESCE(t.f_allow_delete, 1)::integer AS \"allowDelete\", \ + (EXTRACT(EPOCH FROM t.f_creator_time) * 1000)::bigint AS \"creatorTime\"", + from_extra: " LEFT JOIN base_data_type d \ + ON d.f_en_code = t.f_data_type AND COALESCE(d.f_delete_mark, 0) = 0", + // 详情也带 `dataTypeName`(前端编辑表单与列表共用一套字段) + info_projection: "", + info_from_extra: "", + keyword_cols: &[], + eq_filters: &[("category", "f_category", "::text")], + fields: &[ + ("fieldName", "f_field_name", ""), + ("field", "f_field", ""), + ("dataType", "f_data_type", ""), + ("dataLength", "f_data_length", ""), + ("allowNull", "f_allow_null", "::text::integer"), + ("category", "f_category", ""), + ("type", "f_type", "::text::integer"), + ("allowDelete", "f_allow_delete", "::text::integer"), + ], + // 官方 `isExistByFullName(field, id, category)` ⇒ 同分组内列名唯一(一组两列)。 + unique_groups: &[&[("field", "f_field"), ("category", "f_category")]], + order_by: "t.f_creator_time DESC", + soft_delete: true, + paged: false, +}; + +/// `GET /api/system/CommonFields/{id}`。 +pub async fn common_fields_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_COMMON_FIELDS).await { + return resp; + } + flat_info(&state, &id, &COMMON_FIELDS).await +} + +/// `POST /api/system/CommonFields`。 +/// +/// 🔴 官方 `ComFieldsController:104` 先挡 **SQL / Java 保留字** 再判重 —— +/// 常用字段是给「建表」用的,列名叫 `select` / `order` 会让后续 DDL 直接爆。 +pub async fn common_fields_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_COMMON_FIELDS).await { + Ok(u) => u, + 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 field = obj.get("field").and_then(Value::as_str).unwrap_or_default(); + if is_reserved_column(field) { + return fail(code::FAIL, format!("列名{field}为保留字")); + } + flat_create(&state, &user, &body, &COMMON_FIELDS).await +} + +/// `PUT /api/system/CommonFields/{id}`。 +pub async fn common_fields_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_COMMON_FIELDS).await { + Ok(u) => u, + 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 field = obj.get("field").and_then(Value::as_str).unwrap_or_default(); + if is_reserved_column(field) { + return fail(code::FAIL, format!("列名{field}为保留字")); + } + flat_update(&state, &user, &id, &body, &COMMON_FIELDS).await +} + +/// `DELETE /api/system/CommonFields/{id}`。 +pub async fn common_fields_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_COMMON_FIELDS).await { + Ok(u) => u, + Err(resp) => return resp, + }; + flat_delete(&state, &user, &id, &COMMON_FIELDS).await +} + +// ---- 数据同步(`system/DataSync`)---- +// +// 🔴 **本仓不具备跨库能力,四条端点一律明确拒绝(不是假成功)**。 +// 官方这四条走 JDBC:`PrepSqlDTO.getConn(dbLink)` 拿真实 `Connection`,再 +// `getMetaData()` 读表结构、`CREATE TABLE` + 批量 `INSERT` 搬数据。 +// 本仓的数据库是**进程内嵌 PG(pglite/WASM)**:没有 libpq、没有驱动层、 +// 连不到任何外部实例 ⇒ 「同步到 B 库」在物理上无法发生。 +// +// 这与 `data_source_test`(`POST /api/system/DataSource/Actions/Test`)**同一档处理**: +// 端点必须有、必须能应答,但**绝不能假装成功** —— 假装成功会让用户以为数据搬过去了。 +// 契约 `[OFFICIAL]` 里这四条标 `partial`,理由写在这里。 + +const EN_DATA_SYNC: &str = "systemData.dataSync"; + +/// 四条数据同步端点的统一拒绝。 +fn data_sync_unsupported() -> Json { + fail( + code::FAIL, + "本仓为内嵌单实例数据库,不支持跨库数据同步", + ) +} + +/// `POST /api/system/DataSync/Actions/checkDbLink`。 +pub async fn data_sync_check_db_link( + State(state): State, + headers: HeaderMap, + _body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_SYNC).await { + return resp; + } + data_sync_unsupported() +} + +/// `POST /api/system/DataSync` —— 官方语义是「同步前校验」,同样拒绝。 +pub async fn data_sync_check( + State(state): State, + headers: HeaderMap, + _body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_SYNC).await { + return resp; + } + data_sync_unsupported() +} + +/// `POST /api/system/DataSync/Actions/Execute`。 +pub async fn data_sync_execute( + State(state): State, + headers: HeaderMap, + _body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_SYNC).await { + return resp; + } + data_sync_unsupported() +} + +/// `POST /api/system/DataSync/Actions/batchExecute`。 +pub async fn data_sync_batch_execute( + State(state): State, + headers: HeaderMap, + _body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_SYNC).await { + return resp; + } + data_sync_unsupported() +} + +// ---- 数据接口变量下拉(`system/DataInterfaceVariate/Selector`)---- + +/// `GET /api/system/DataInterfaceVariate/Selector` —— 两级树: +/// 数据集(`type=0`,`parentId="-1"`)→ 它下面的变量(`type=1`,`parentId` = 数据集 id)。 +/// +/// 官方 `DataInterfaceVariateController:107-140`: +/// - 只出 `enabledMark = 1` 的**数据集**; +/// - 变量的 `fullName` 是 **`数据集enCode.变量名`**(前端拿它当表达式里的引用); +/// - `name` 两边都取 `fullName`。 +pub async fn data_interface_variate_selector( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = guard_any(&state, &headers, &[EN_DATASET, EN_DATA_INTERFACE]).await { + return resp; + } + let sql = "SELECT s.f_id AS \"setId\", s.f_full_name AS \"setName\", \ + s.f_en_code AS \"setEnCode\", \ + v.f_id AS \"variateId\", v.f_full_name AS \"variateName\" \ + FROM base_data_set s \ + LEFT JOIN base_data_interface_variate v \ + ON v.f_interface_id = s.f_id AND COALESCE(v.f_delete_mark, 0) = 0 \ + WHERE COALESCE(s.f_delete_mark, 0) = 0 AND COALESCE(s.f_enabled_mark, 1) = 1 \ + ORDER BY s.f_sort_code ASC NULLS LAST, v.f_sort_code ASC NULLS LAST"; + let rows = match state.db.query_json(sql).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "数据接口变量下拉"), + }; + let mut order: Vec = Vec::new(); + let mut parents: HashMap = HashMap::new(); + let mut children: HashMap> = HashMap::new(); + for row in rows { + let Some(set_id) = row["setId"].as_str() else { + continue; + }; + if !parents.contains_key(set_id) { + order.push(set_id.to_string()); + let name = row["setName"].as_str().unwrap_or_default(); + parents.insert( + set_id.to_string(), + json!({ + "id": set_id, + "parentId": "-1", + "type": 0, + "name": name, + "fullName": name, + }), + ); + children.insert(set_id.to_string(), Vec::new()); + } + let Some(variate_id) = row["variateId"].as_str() else { + continue; + }; + let variate_name = row["variateName"].as_str().unwrap_or_default(); + let set_en_code = row["setEnCode"].as_str().unwrap_or_default(); + children.entry(set_id.to_string()).or_default().push(json!({ + "id": variate_id, + "parentId": set_id, + "type": 1, + "name": variate_name, + "fullName": format!("{set_en_code}.{variate_name}"), + })); + } + let list: Vec = order + .into_iter() + .map(|set_id| { + let mut node = parents.remove(&set_id).unwrap_or(Value::Null); + let kids = children.remove(&set_id).unwrap_or_default(); + node["children"] = Value::Array(kids); + node + }) + .collect(); + ok(Value::Array(list)) +} + +// === DATA CENTER (数据中心族) SECTION END === + #[cfg(test)] mod tests { use super::*; diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index 6783634..3501d97 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -385,8 +385,85 @@ pub fn build_router(state: AppState) -> axum::Router { // ---- 数据建模的查询面(官方 `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)) + // ---- 数据中心(批次 14):基准类型 / 控件映射 / 数据库 / 字段类型映射 / 常用字段 ---- + // 🔴 这两族的**列表**在批次 5(数据模型)就接上了,本轮补齐 info/增删改; + // 列表与新建合并进同一行(同一个 `MethodRouter`)。 + // ⚠️ 同一 path 只能 `.route()` **一次** —— axum 对重复注册会 panic + // (`Overlapping method route`)⇒ create 不能另起一行。 + .route( + "/api/system/BasicDataType", + get(face_b::basic_data_type_list).post(face_b::basic_data_type_create), + ) + .route( + "/api/system/BasicDataType/{id}", + get(face_b::basic_data_type_info) + .put(face_b::basic_data_type_update) + .delete(face_b::basic_data_type_delete), + ) + .route( + "/api/system/DataTypeMapping", + get(face_b::data_type_mapping_list).post(face_b::data_type_mapping_create), + ) + // 🔴 静态段 `getKeyList` 必须**先于**参数段 `/{id}` 注册的直觉仍然成立 + // (axum/matchit 本身是静态优先,这里按可读性排)。 + .route( + "/api/system/DataTypeMapping/getKeyList", + get(face_b::data_type_mapping_key_list), + ) + .route( + "/api/system/DataTypeMapping/{id}", + get(face_b::data_type_mapping_info) + .put(face_b::data_type_mapping_update) + .delete(face_b::data_type_mapping_delete), + ) + .route( + "/api/system/DataBase", + get(face_b::data_base_list).post(face_b::data_base_create), + ) + .route( + "/api/system/DataBase/{id}", + get(face_b::data_base_info) + .put(face_b::data_base_update) + .delete(face_b::data_base_delete), + ) + .route( + "/api/system/DataTypeRelation", + get(face_b::data_type_relation_list).post(face_b::data_type_relation_create), + ) + .route( + "/api/system/DataTypeRelation/{id}", + get(face_b::data_type_relation_info) + .put(face_b::data_type_relation_update) + .delete(face_b::data_type_relation_delete), + ) + .route( + "/api/system/CommonFields", + get(face_b::common_fields_list).post(face_b::common_fields_create), + ) + .route( + "/api/system/CommonFields/{id}", + get(face_b::common_fields_info) + .put(face_b::common_fields_update) + .delete(face_b::common_fields_delete), + ) + // ---- 数据同步(四条一律明确拒绝:本仓无跨库能力,见 `face_b` 的注释)---- + .route("/api/system/DataSync", post(face_b::data_sync_check)) + .route( + "/api/system/DataSync/Actions/checkDbLink", + post(face_b::data_sync_check_db_link), + ) + .route( + "/api/system/DataSync/Actions/Execute", + post(face_b::data_sync_execute), + ) + .route( + "/api/system/DataSync/Actions/batchExecute", + post(face_b::data_sync_batch_execute), + ) + .route( + "/api/system/DataInterfaceVariate/Selector", + get(face_b::data_interface_variate_selector), + ) .route( "/api/system/DataModel/{linkId}/Tables", get(face_b::data_model_tables), diff --git a/src/backend/tests/batch14_it.rs b/src/backend/tests/batch14_it.rs new file mode 100644 index 0000000..7e04868 --- /dev/null +++ b/src/backend/tests/batch14_it.rs @@ -0,0 +1,627 @@ +//! 批次 14(**数据中心五族 + 数据同步**)集成测试: +//! `BasicDataType`(4) + `DataTypeMapping`(6) + `DataBase`(5) + `DataTypeRelation`(5) +//! + `CommonFields`(4) + `DataSync`(4) + `DataInterfaceVariate`(1) = 29 端点, +//! 4 张表(`base_data_type_mapping` / `base_data_base` / `base_data_type_relation` / +//! `base_data_interface_variate`)。 +//! +//! 🔴 **钉住的契约点**(每条都是「照抄官方会翻车 / 不照抄也会翻车」的地方): +//! ① `BasicDataType` 是 **`enCode` 与 `fullName` 双判重** —— 只判一个就能造出 +//! 「同码不同名」的影子类型,前端下拉按 enCode 反查会拿到两行。 +//! ② `type` **不进写白名单**:官方 `DataTypeForm` 里没有这个字段。允许 PUT 改它 +//! = 允许把自定义类型伪装成内置(`type=1`),而内置是**删不掉**的。 +//! ③ 删除保护两层:内置(`type=1`)拒;被控件映射 / 字段类型映射 / 常用字段引用拒。 +//! ④ 🔴 **控件映射与字段类型映射的列表把 `typeId` 覆盖成「名字」**,而 +//! `GET /{id}` 返回**真 id**(官方 `DataTypeMappingController:60-68`)—— +//! 这是官方最反直觉的一处:同一字段,列表里是 `字符串名称`,详情里是 `id`。 +//! ⑤ `DataTypeRelation` 的判重是**二元组 `enCode + baseId`**:同一个 enCode +//! 在不同目标库下可以各有一条(只按 enCode 判重会让第二个库配不了)。 +//! ⑥ 常用字段先挡 **SQL/Java 保留字**(列名要拿去建表),再判 `field + category`。 +//! ⑦ 数据同步四条**一律明确业务失败**(`code=400`)—— 本仓是内嵌单实例 PG, +//! 没有驱动层。**不能返回成功**:那会让用户以为数据搬过去了。 +//! ⑧ 接口变量下拉是**两级树**:数据集 `type=0` / 变量 `type=1`, +//! 变量的 `fullName` 是 `数据集enCode.变量名`(前端拿它当表达式引用)。 +//! +//! 🔴 pglite-rs 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。 +//! 断言一律按 id 定位,不数「列表里有几条」—— 同一个库里还有别的用例造的行。 + +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 临时库失败"); + ssw_platform::bootstrap::ensure_schema_all(&db) + .await + .expect("ensure_schema_all 失败"); + 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-batch14-it"))), + db: Arc::new(db.clone()), + sessions: Arc::new(SessionStore::default()), + } +} + +/// 按表 + 列取值(`create` 返 `null` ⇒ 拿不到 id,只能查库)。 +async fn id_of(table: &str, column: &str, value: &str) -> String { + let v = value.to_string(); + let sql = format!("SELECT f_id AS \"id\" FROM {table} WHERE {column} = $1::text LIMIT 1"); + let rows = Db::query_json_params(db().await, &sql, &[&v]) + .await + .expect("查 id 失败"); + assert_eq!(rows.len(), 1, "库里应恰有一行 {table}.{column}={value}"); + rows[0]["id"].as_str().expect("必须有 id").to_string() +} + +/// 起服务 + 登录,返回 (port, token)。 +async fn boot() -> (u16, String) { + let state = new_state(db().await); + let port = serve(state).await; + let token = login(port).await; + (port, token) +} + +// ---------------------------------------------------------------- 基准数据类型 + +/// ① 双判重 + ② `type` 不可改 + ③ 删除保护。 +#[tokio::test] +async fn basic_data_type_double_unique_and_type_is_immutable() { + let _guard = LOCK.lock().await; + let (port, token) = boot().await; + + // 建一条自定义类型。 + let (_, res) = call( + port, + "POST", + "/api/system/BasicDataType", + &token, + Some(r#"{"fullName":"B14类型甲","enCode":"b14_type_a","jnpfKey":"input"}"#), + ) + .await; + assert_eq!(res["code"], 200, "新建应成功: {res}"); + let id = id_of("base_data_type", "f_en_code", "b14_type_a").await; + + // ① 同 enCode 不同名 ⇒ 拒(报编码)。 + let (_, res) = call( + port, + "POST", + "/api/system/BasicDataType", + &token, + Some(r#"{"fullName":"B14类型乙","enCode":"b14_type_a","jnpfKey":"input"}"#), + ) + .await; + assert_eq!(res["code"], 400, "同 enCode 必须拒: {res}"); + assert!( + res["msg"].as_str().unwrap_or_default().contains("编码"), + "应报「编码已存在」: {res}" + ); + + // ① 同名不同 enCode ⇒ 也拒(报名称)。 + let (_, res) = call( + port, + "POST", + "/api/system/BasicDataType", + &token, + Some(r#"{"fullName":"B14类型甲","enCode":"b14_type_b","jnpfKey":"input"}"#), + ) + .await; + assert_eq!(res["code"], 400, "同名必须拒: {res}"); + assert!( + res["msg"].as_str().unwrap_or_default().contains("名称"), + "应报「名称已存在」: {res}" + ); + + // 新建恒为自定义(type=2)。 + let (_, info) = call(port, "GET", &format!("/api/system/BasicDataType/{id}"), &token, None).await; + assert_eq!(info["code"], 200, "详情应成功: {info}"); + assert_eq!(info["data"]["type"], 2, "新建必须落成自定义(2): {info}"); + + // ② PUT 带 type=1 也不生效(type 不在写白名单里)。 + let (_, res) = call( + port, + "PUT", + &format!("/api/system/BasicDataType/{id}"), + &token, + Some(r#"{"fullName":"B14类型甲改","enCode":"b14_type_a","jnpfKey":"input","type":1}"#), + ) + .await; + assert_eq!(res["code"], 200, "更新应成功: {res}"); + let rows = Db::query_json_params( + db().await, + "SELECT COALESCE(f_type, 0)::bigint AS \"type\" FROM base_data_type WHERE f_id = $1::text", + &[&id], + ) + .await + .expect("查 type 失败"); + assert_eq!(rows[0]["type"], 2, "type 必须仍是 2(白名单挡住)"); + + // ③ 被控件映射引用 ⇒ 拒删。 + let (_, res) = call( + port, + "POST", + "/api/system/DataTypeMapping", + &token, + Some(&format!( + r#"{{"jnpfKey":"b14_key_x","typeId":"{id}","sortCode":1}}"# + )), + ) + .await; + assert_eq!(res["code"], 200, "建映射应成功: {res}"); + let (_, res) = call( + port, + "DELETE", + &format!("/api/system/BasicDataType/{id}"), + &token, + None, + ) + .await; + assert_eq!(res["code"], 400, "被引用必须拒删: {res}"); + assert!( + res["msg"].as_str().unwrap_or_default().contains("已被使用"), + "应报「已被使用」: {res}" + ); +} + +// ---------------------------------------------------------------- 控件映射 + +/// ④ 列表 `typeId` 是**名称**、详情 `typeId` 是**真 id**;⑤ getKeyList 分组。 +#[tokio::test] +async fn data_type_mapping_list_shows_name_but_info_returns_id() { + let _guard = LOCK.lock().await; + let (port, token) = boot().await; + + let (_, res) = call( + port, + "POST", + "/api/system/BasicDataType", + &token, + Some(r#"{"fullName":"B14映射类型","enCode":"b14_map_type","jnpfKey":"input"}"#), + ) + .await; + assert_eq!(res["code"], 200, "建基准类型失败: {res}"); + let type_id = id_of("base_data_type", "f_en_code", "b14_map_type").await; + + let (_, res) = call( + port, + "POST", + "/api/system/DataTypeMapping", + &token, + Some(&format!( + r#"{{"jnpfKey":"b14_widget","typeId":"{type_id}","sortCode":7}}"# + )), + ) + .await; + assert_eq!(res["code"], 200, "建映射失败: {res}"); + let mapping_id = id_of("base_data_type_mapping", "f_type_id", &type_id).await; + + // ④ 列表:typeId 被覆盖成「名称」。 + let (_, list) = call(port, "GET", "/api/system/DataTypeMapping", &token, None).await; + assert_eq!(list["code"], 200, "列表失败: {list}"); + let row = list["data"]["list"] + .as_array() + .expect("必须是 ListVO") + .iter() + .find(|r| r["id"] == json!(mapping_id)) + .expect("列表里应有刚建的那条"); + assert_eq!( + row["typeId"], "B14映射类型", + "列表里的 typeId 必须是**名称**(官方 :60-68 覆盖): {row}" + ); + + // ④ 详情:typeId 是**真 id**(编辑表单靠这条)。 + let (_, info) = call( + port, + "GET", + &format!("/api/system/DataTypeMapping/{mapping_id}"), + &token, + None, + ) + .await; + assert_eq!(info["code"], 200, "详情失败: {info}"); + assert_eq!( + info["data"]["typeId"], type_id, + "详情里的 typeId 必须是**真 id**: {info}" + ); + + // ⑤ getKeyList:按基准类型聚合,jnpfKey 在数组里。 + let (_, keys) = call( + port, + "GET", + "/api/system/DataTypeMapping/getKeyList", + &token, + None, + ) + .await; + assert_eq!(keys["code"], 200, "getKeyList 失败: {keys}"); + let group = keys["data"] + .as_array() + .expect("必须是数组") + .iter() + .find(|g| g["dataType"] == "b14_map_type") + .expect("应有刚建类型的分组"); + assert!( + group["jnpfKeyList"] + .as_array() + .expect("jnpfKeyList 必须是数组") + .contains(&json!("b14_widget")), + "分组里应含 b14_widget: {group}" + ); +} + +// ---------------------------------------------------------------- 数据库管理 + +/// ⑥ `dbType` 单列判重;列表**登录即可**(官方 list 无权限注解)。 +#[tokio::test] +async fn data_base_unique_by_db_type() { + let _guard = LOCK.lock().await; + let (port, token) = boot().await; + + let (_, res) = call( + port, + "POST", + "/api/system/DataBase", + &token, + Some( + r#"{"fullName":"B14库甲","icon":"icon-a","dbType":"b14_dbtype","dbDrive":"org.postgresql.Driver","dbUrl":"jdbc:postgresql://h/db"}"#, + ), + ) + .await; + assert_eq!(res["code"], 200, "建库失败: {res}"); + + // 同 dbType、改名也不行(判重只看 dbType)。 + let (_, res) = call( + port, + "POST", + "/api/system/DataBase", + &token, + Some( + r#"{"fullName":"B14库乙","icon":"icon-b","dbType":"b14_dbtype","dbDrive":"x","dbUrl":"y"}"#, + ), + ) + .await; + assert_eq!(res["code"], 400, "同 dbType 必须拒: {res}"); + assert!( + res["msg"].as_str().unwrap_or_default().contains("数据库类型"), + "应报「数据库类型已存在」: {res}" + ); + + // 列表能查到(登录即可,返回 ListVO)。 + let (_, list) = call(port, "GET", "/api/system/DataBase", &token, None).await; + assert_eq!(list["code"], 200, "列表失败: {list}"); + assert!( + list["data"]["list"] + .as_array() + .expect("必须是 ListVO") + .iter() + .any(|r| r["dbType"] == "b14_dbtype"), + "列表里应有刚建的库: {list}" + ); +} + +// ---------------------------------------------------------------- 字段类型映射 + +/// ⑦ 判重是**二元组 enCode+baseId**(同 enCode 换库 ⇒ 允许);列表分页。 +#[tokio::test] +async fn data_type_relation_unique_is_pair_en_code_and_base_id() { + let _guard = LOCK.lock().await; + let (port, token) = boot().await; + + for (db_type, name) in [("b14_rel_db1", "B14关系库一"), ("b14_rel_db2", "B14关系库二")] { + let (_, res) = call( + port, + "POST", + "/api/system/DataBase", + &token, + Some(&format!( + r#"{{"fullName":"{name}","icon":"i","dbType":"{db_type}","dbDrive":"d","dbUrl":"u"}}"# + )), + ) + .await; + assert_eq!(res["code"], 200, "建库失败: {res}"); + } + let base1 = id_of("base_data_base", "f_db_type", "b14_rel_db1").await; + let base2 = id_of("base_data_base", "f_db_type", "b14_rel_db2").await; + + // 库 1 建一条 enCode=b14_col。 + let (_, res) = call( + port, + "POST", + "/api/system/DataTypeRelation", + &token, + Some(&format!( + r#"{{"baseId":"{base1}","enCode":"b14_col","type":1,"lengthDefault":64,"lengthMax":255,"lengthMin":1}}"# + )), + ) + .await; + assert_eq!(res["code"], 200, "库1建映射失败: {res}"); + + // 库 1 再建同 enCode ⇒ 拒。 + let (_, res) = call( + port, + "POST", + "/api/system/DataTypeRelation", + &token, + Some(&format!( + r#"{{"baseId":"{base1}","enCode":"b14_col","type":2}}"# + )), + ) + .await; + assert_eq!(res["code"], 400, "同库同 enCode 必须拒: {res}"); + + // 库 2 建同 enCode ⇒ **允许**(二元组判重)。 + let (_, res) = call( + port, + "POST", + "/api/system/DataTypeRelation", + &token, + Some(&format!( + r#"{{"baseId":"{base2}","enCode":"b14_col","type":3}}"# + )), + ) + .await; + assert_eq!(res["code"], 200, "换库同 enCode 必须放行: {res}"); + + // 列表是 PageListVO(有 pagination)。 + let (_, page) = call( + port, + "GET", + &format!("/api/system/DataTypeRelation?baseId={base1}¤tPage=1&pageSize=10"), + &token, + None, + ) + .await; + assert_eq!(page["code"], 200, "列表失败: {page}"); + assert!( + page["data"]["pagination"].is_object(), + "必须是 PageListVO(带 pagination): {page}" + ); + assert_eq!( + page["data"]["pagination"]["total"], 1, + "库1应有 1 条: {page}" + ); +} + +// ---------------------------------------------------------------- 常用字段 + +/// ⑧ 保留字先挡(列名要建表);判重是 field+category。 +#[tokio::test] +async fn common_fields_rejects_reserved_words() { + let _guard = LOCK.lock().await; + let (port, token) = boot().await; + + // 保留字 ⇒ 拒(大小写不敏感)。 + let (_, res) = call( + port, + "POST", + "/api/system/CommonFields", + &token, + Some(r#"{"fieldName":"生僻","field":" select ","dataType":"varchar","dataLength":"50","category":"b14_cat","type":2}"#), + ) + .await; + assert_eq!(res["code"], 400, "保留字必须拒: {res}"); + assert!( + res["msg"].as_str().unwrap_or_default().contains("保留字"), + "应报保留字: {res}" + ); + + // 正常列名 ⇒ 成功。 + let (_, res) = call( + port, + "POST", + "/api/system/CommonFields", + &token, + Some(r#"{"fieldName":"B14列","field":"b14_col","dataType":"varchar","dataLength":"50","category":"b14_cat","type":2}"#), + ) + .await; + assert_eq!(res["code"], 200, "正常列名应成功: {res}"); + let id = id_of("base_common_fields", "f_field", "b14_col").await; + + // 同 category 同 field ⇒ 拒。 + let (_, res) = call( + port, + "POST", + "/api/system/CommonFields", + &token, + Some(r#"{"fieldName":"B14列2","field":"b14_col","dataType":"varchar","dataLength":"50","category":"b14_cat","type":2}"#), + ) + .await; + assert_eq!(res["code"], 400, "同分组同列名必须拒: {res}"); + + // 换分组 ⇒ 允许。 + let (_, res) = call( + port, + "POST", + "/api/system/CommonFields", + &token, + Some(r#"{"fieldName":"B14列3","field":"b14_col","dataType":"varchar","dataLength":"50","category":"b14_cat2","type":2}"#), + ) + .await; + assert_eq!(res["code"], 200, "换分组应放行: {res}"); + + // 详情带 dataTypeName(联合基准类型取名称)。 + let (_, info) = call( + port, + "GET", + &format!("/api/system/CommonFields/{id}"), + &token, + None, + ) + .await; + assert_eq!(info["code"], 200, "详情失败: {info}"); + assert_eq!(info["data"]["field"], "b14_col", "详情字段不对: {info}"); +} + +// ---------------------------------------------------------------- 数据同步 + +/// ⑦ 四条一律**明确失败**(不能返回 200 假装同步成功)。 +#[tokio::test] +async fn data_sync_endpoints_refuse_explicitly() { + let _guard = LOCK.lock().await; + let (port, token) = boot().await; + + for path in [ + "/api/system/DataSync", + "/api/system/DataSync/Actions/checkDbLink", + "/api/system/DataSync/Actions/Execute", + "/api/system/DataSync/Actions/batchExecute", + ] { + let (status, res) = call(port, "POST", path, &token, Some("{}")).await; + assert!( + status.contains("200"), + "{path} 的业务失败必须是 HTTP 200(信封决定成败): {status}" + ); + assert_eq!( + res["code"], 400, + "{path} 必须明确失败(否则用户以为数据搬过去了): {res}" + ); + assert!( + res["msg"].as_str().unwrap_or_default().contains("跨库"), + "{path} 的错误文案要说明是「跨库不支持」: {res}" + ); + } +} + +// ---------------------------------------------------------------- 接口变量下拉 + +/// ⑧ 两级树:数据集 type=0 / 变量 type=1,变量 fullName = `enCode.变量名`。 +#[tokio::test] +async fn data_interface_variate_selector_is_two_level_tree() { + let _guard = LOCK.lock().await; + let (port, token) = boot().await; + + // 直接写库造一条数据集 + 两条变量(本批次不补 DataSet 的增删改,它早就有)。 + let set_id = "b14-set-0001"; + let sql = format!( + "INSERT INTO base_data_set (f_id, f_full_name, f_en_code, f_enabled_mark, f_delete_mark, f_tenant_id) \ + VALUES ('{set_id}', 'B14数据集', 'b14Dataset', 1, 0, '0')" + ); + Db::exec_params(db().await, &sql, &[]).await.expect("造数据集失败"); + for (vid, name) in [("b14-var-0001", "变量甲"), ("b14-var-0002", "变量乙")] { + let sql = format!( + "INSERT INTO base_data_interface_variate \ + (f_id, f_interface_id, f_full_name, f_field, f_delete_mark, f_sort_code, f_tenant_id) \ + VALUES ('{vid}', '{set_id}', '{name}', 'f_{vid}', 0, 1, '0')" + ); + Db::exec_params(db().await, &sql, &[]).await.expect("造变量失败"); + } + + let (_, res) = call( + port, + "GET", + "/api/system/DataInterfaceVariate/Selector", + &token, + None, + ) + .await; + assert_eq!(res["code"], 200, "下拉失败: {res}"); + let node = res["data"] + .as_array() + .expect("必须是数组") + .iter() + .find(|n| n["id"] == json!(set_id)) + .expect("应有刚造的数据集节点"); + assert_eq!(node["type"], 0, "数据集节点 type=0: {node}"); + assert_eq!(node["parentId"], "-1", "数据集 parentId=-1: {node}"); + let kids = node["children"].as_array().expect("必须有 children"); + assert_eq!(kids.len(), 2, "应有 2 个变量: {node}"); + let first = &kids[0]; + assert_eq!(first["type"], 1, "变量 type=1: {first}"); + assert_eq!(first["parentId"], set_id, "变量 parentId=数据集 id: {first}"); + assert_eq!( + first["fullName"], "b14Dataset.变量甲", + "变量 fullName 必须是 `enCode.变量名`: {first}" + ); +}