From db0ad57921e6be86688ed713f71fa9d0c43f0b7a Mon Sep 17 00:00:00 2001 From: admin Date: Mon, 2 Nov 2026 08:24:20 +0800 Subject: [PATCH] =?UTF-8?q?feat(face-b):=20=E7=B3=BB=E7=BB=9F=E6=95=B0?= =?UTF-8?q?=E6=8D=AE=E4=B8=A4=E6=97=8F=E8=90=BD=E5=9C=B0=EF=BC=88=E9=9D=A2?= =?UTF-8?q?=20B=20=E6=89=B9=E6=AC=A1=2013=EF=BC=8C+14=20=E7=AB=AF=E7=82=B9?= =?UTF-8?q?=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 行政区划 Area(7) + 公有变量 Variate(7);新表 base_province / base_common_variate (官方 DDL 逐字)⇒ tables 53、BASE_TABLES 50。 影响:/system/Area 与 /system/Variate 页面前端可以真跑(树懒加载、子树排除、 type 是字符串、creatorUser 真填上);回归测试 tests/batch13_it.rs 12 条。 钉子测试不再手抄:删掉 routes.rs 里 255 行 FACE_B_REGISTERED,改成从契约 [ENDPOINT] 读路径(漏抄仍全绿 = 假闸门);CC7 相应只守面 A,并加「清单回来就红」。 顺手把两处写死表数改成与真值源同口径(sspf-store 常量、batch6 的表清单)。 --- crates/sspf-store/src/db.rs | 4 +- docs/contract.md | 34 +- scripts/check-contract-scan.py | 97 ++-- scripts/check-contract.sh | 2 +- src/backend/db/schema.sql | 50 ++ src/backend/src/main.rs | 7 +- src/backend/src/platform/face_b.rs | 883 +++++++++++++++++++++++++++++ src/backend/src/routes.rs | 378 ++++-------- src/backend/tests/batch13_it.rs | 681 ++++++++++++++++++++++ src/backend/tests/batch6_it.rs | 16 +- 10 files changed, 1818 insertions(+), 334 deletions(-) create mode 100644 src/backend/tests/batch13_it.rs diff --git a/crates/sspf-store/src/db.rs b/crates/sspf-store/src/db.rs index 18d858a..d7aba71 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 = 48; +pub const BASE_TABLE_COUNT: usize = 50; /// 🔴 **面 A 内嵌业务表**(留在内核 `schema.sql` 里的那几张)。 /// @@ -1224,7 +1224,7 @@ mod tests { // 🔴 **批次 12 交付物 ③:业务表的 DDL 跟着包走 ⇒ 不再手抄进 `schema.sql`。** // // ⇒ 这个文件里现在只有两类表: - // ① **平台表**(`base_*`)—— 数量**写死**(48 张):加一张平台表是 + // ① **平台表**(`base_*`)—— 数量**写死**(`BASE_TABLE_COUNT` 张):加一张平台表是 // **平台层**的责任 ⇒ 必须同时改 `main.rs` 的 `BASE_TABLES` // (闸门查「孤儿 DDL」会红 ⇒ 两处都改才算登记完成); // ② **面 A 内嵌业务表**(3 张)—— 清单**写死**(名字列表,不是数字): diff --git a/docs/contract.md b/docs/contract.md index abbfb6d..7135230 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -1511,6 +1511,23 @@ B POST /api/system/ModuleDataAuthorizeLink/saveLinkData permission.resource|appC B GET /api/system/ModuleDataAuthorizeLink/getVisualTables/{menuId}/{type} permission.resource|appConfig.appResource platform B GET /api/system/ModuleDataAuthorizeLink/getInfo/{menudId}/{type} permission.resource|appConfig.appResource platform B GET /api/system/ModuleDataAuthorizeLink/{linkId}/Tables/{tableName}/Fields/{menuType}/{dataType} permission.resource|appConfig.appResource platform +# ---- 系统数据(批次 13):行政区划 base_province / 公有变量 base_common_variate ---- +# 🔴 这 14 行是**手写**的(平台层端点),必须放在 `PACK:BEGIN` **之前** —— +# 生成段里的东西每次 `pack-sync.py` 都会被覆盖掉(放进去 = 静默消失)。 +B GET /api/system/Area/{id} sysData.area platform +B GET /api/system/Area/{id}/Selector/{ids} sysData.area platform +B GET /api/system/Area/{id}/Info sysData.area platform +B POST /api/system/Area sysData.area platform +B PUT /api/system/Area/{id} sysData.area platform +B DELETE /api/system/Area/{id} sysData.area platform +B POST /api/system/Area/GetAreaByIds sysData.area platform +B GET /api/system/Variate 登录 platform +B POST /api/system/Variate 登录 platform +B GET /api/system/Variate/selector 登录 platform +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 # 🔴 以下由 `scripts/pack-sync.py` 从 `packs/*` 生成 —— **不许手改** @@ -1535,7 +1552,7 @@ B DELETE /api/asset/DataResource/{id} permission.asset.dataResource asset [FACE] # face 条数 说明 A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条) -B 349 面 B 专属(官方 JNPF 形状) +B 363 面 B 专属(官方 JNPF 形状;批次 13 新增 Area 7 + Variate 7) AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流) [OFFICIAL] @@ -1932,6 +1949,21 @@ POST /api/system/ModuleDataAuthorizeLink/saveLinkData implemented ModuleDataAuth GET /api/system/ModuleDataAuthorizeLink/getVisualTables/{menuId}/{type} implemented ModuleDataAuthorizeLinkController.java:103 面 B 已落地:低代码(type 3/9/11)返回空;其余按 menuId+type 查 base_module_link GET /api/system/ModuleDataAuthorizeLink/getInfo/{menudId}/{type} implemented ModuleDataAuthorizeLinkController.java:154 面 B 已落地:按 menuId+type 查 base_module_link ⇒ DataAuthorizeLinkForm GET /api/system/ModuleDataAuthorizeLink/{linkId}/Tables/{tableName}/Fields/{menuType}/{dataType} implemented ModuleDataAuthorizeLinkController.java:176 面 B 已落地:返回空 PageListVO(依赖 dbTableService.getFieldList 内省,本仓无该能力) +# ---- 系统数据(批次 13):行政区划 / 公有变量 ---- +GET /api/system/Area/{nodeId} implemented AreaController.java:65 面 B 已落地:扁平子节点 + isLeaf/hasChildren(前端按标志懒加载,不是嵌套树);空库即空列表 +GET /api/system/Area/{id}/Selector/{ids} implemented AreaController.java:94 面 B 已落地:只取 enabledMark=1;{ids}≠0 时用递归 CTE 排除该节点整棵子树;isLeaf 恒 false(同官方) +GET /api/system/Area/{id}/Info implemented AreaController.java:145 面 B 已落地:9 字段 + parentName(parentId=-1 时为空,同官方) +POST /api/system/Area implemented AreaController.java:165 面 B 已落地:enCode 判重;parentId 空⇒-1;f_type=父 type+1 由服务端推导(body 传了不作数) +PUT /api/system/Area/{id} implemented AreaController.java:196 面 B 已落地:**只 SET body 里出现的键**;enCode 判重排除自己;f_type 不参与更新(同官方) +DELETE /api/system/Area/{id} implemented AreaController.java:219 面 B 已落地:**有未删子节点 ⇒ 拒绝**(SYS002),否则软删 +POST /api/system/Area/GetAreaByIds implemented AreaController.java:265 面 B 已落地:`{idsList:[[id]]}` ⇒ `[[fullName]]`;**按输入顺序回填**(IN 的返回顺序不可靠) +GET /api/system/Variate implemented CommonVariateController.java:59 面 B 已落地:PageListVO;type 精确 + keyword 对 field/description 模糊;creatorUser=realName/account;type 序列化成字符串(官方 VO 是 String) +POST /api/system/Variate implemented CommonVariateController.java:84 面 B 已落地:field 判重 ⇒「变量名已存在」;f_type 由 text CAST 成 integer +GET /api/system/Variate/{id} implemented CommonVariateController.java:112 面 B 已落地:CommonVariateVO 11 字段(含 creatorUser / 毫秒 creatorTime) +PUT /api/system/Variate/{id} implemented CommonVariateController.java:94 面 B 已落地:**只 SET body 里出现的键**(官方 copyProperties ignoreNullValue);field 判重排除自己 +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 枚举逐条抄)⇒ 不依赖表达式引擎 [RULER] # name 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败) diff --git a/scripts/check-contract-scan.py b/scripts/check-contract-scan.py index 5029561..c2d7a51 100644 --- a/scripts/check-contract-scan.py +++ b/scripts/check-contract-scan.py @@ -674,29 +674,14 @@ def parse_str_array(orig, masked, decl_re): return re.findall(r'"([^"]*)"', orig[i:j]) -def path_to_regex(pattern): - """`/a/{id}/b` ⇒ 正则(`{id}` 当通配)⇒ 用来对钉子测试里的具体路径。 +def norm_params(pattern): + """`/a/{id}/b` ⇒ `/a/any-id/b`(参数**名**归一,只比结构)。 - 🔴 **带缓存**:CC7 要在「273 条钉子路径 × 364 条平台路由」上做双向覆盖, - 每次调用都会重新拼 + 编译正则(实测 98 580 次编译 / 0.86s)。 - 路径字符串是有限的集合 ⇒ 编译一次就够。 + 🔴 为什么要归一:契约里同一位置可能叫 `{id}`、`{objectId}`、`{nodeId}`, + 而钉子测试的统一占位是 `any-id`。原先是把路由编成正则去 match, + 现在两边都归一成字符串 ⇒ 集合比较,O(n) 且出错时报得出具体是哪条。 """ - hit = _PATH_RE_CACHE.get(pattern) - if hit is not None: - return hit - parts = [] - last = 0 - for m in PARAM_RE.finditer(pattern): - parts.append(re.escape(pattern[last:m.start()])) - parts.append("[^/]+") - last = m.end() - parts.append(re.escape(pattern[last:])) - rx = re.compile("^" + "".join(parts) + "$") - _PATH_RE_CACHE[pattern] = rx - return rx - - -_PATH_RE_CACHE = {} + return PARAM_RE.sub("any-id", pattern) # ---------------------------------------------------------------- 对账 @@ -926,31 +911,53 @@ def analyze(contract_path, src_dir=None, packs_dir=None, code_snapshot=None): for d in unknown6: rep.warn("CC6", d + "(**推不出 ≠ 一致**,请人工核对)") - # ---- CC7 钉子测试清单 ↔ 代码注册路由(双向覆盖)---- - pins = [] - # 面 A 的清单叫 REGISTERED;面 B 的清单在 P0 改名后叫 FACE_B_REGISTERED - # (原 JNPF_REGISTERED,按「前端不依赖的内部标识必须改」剥离)。 - for name in ("REGISTERED", "FACE_B_REGISTERED"): - arr = parse_str_array(plat_orig, plat_masked, - r"const\s+" + name + r"\s*:\s*\[&str;\s*\d+\]\s*=") - if arr is not None: - pins.extend(arr) - # 🔴 钉子测试的**字面量清单**(`REGISTERED` / `JNPF_REGISTERED`)只覆盖**平台层**路由; - # 业务路由在钉子测试里是**遍历 `modules::ALL_ROUTES`** ⇒ 归 CC8 对账。 + # ---- CC7 钉子测试清单 ↔ 代码注册路由(双向覆盖,**只覆盖面 A**)---- + # + # 🔴 **批次 13 重新划界**。原先这一段守**两份**字面量清单:面 A 的 + # `REGISTERED` + 面 B 的 `FACE_B_REGISTERED`(255 行)。 + # 面 B 那份已经**退役**:每加一族端点就得手抄一遍,漏抄的后果是 + # **那条断言仍然全绿**(假闸门)—— 而「加了端点没注册」正好是最该被 + # 它抓住的错。现在面 B 的钉子测试(`routes.rs::face_b_route_table_is_pinned`) + # 改成**直接从契约 `[ENDPOINT]` 段读路径**(`face_b_paths_from_contract`), + # 与 CC2/CC3/CC4/CC5 同源 ⇒ 静态侧不再需要第二份事实。 + # ⇒ 本条只剩**面 A** 那份写死的清单:`/api/health`、`/api/oauth/*`、 + # `/api/ssw/sys/*` 这些**非 JNPF 契约**的路由,本就无处可推导。 + # + # 🔴 **回归闸门**:`const FACE_B_REGISTERED` 若重新出现 ⇒ 判失败。 + # 手抄清单一旦回来,就会重新长出「漏抄但全绿」这个洞。 + pins = parse_str_array(plat_orig, plat_masked, + r"const\s+REGISTERED\s*:\s*\[&str;\s*\d+\]\s*=") + backslide = re.search(r"const\s+FACE_B_REGISTERED\s*:", plat_masked) is not None + + # 平台层路由按**契约登记的 face** 分成两堆;face 用 `(method, 参数归一后的 path)` 查。 + face_of = {} + for e in eps: + face_of.setdefault((e["method"], norm_params(e["path"])), set()).add(e["face"]) plat_routes = [r for r in code if r["owner"] == "platform"] - unmatched_pin = [] - for p in pins: - if not any(path_to_regex(r["path"]).match(p) for r in plat_routes): - unmatched_pin.append(p) - unmatched_code = [] - for r in plat_routes: - if not any(path_to_regex(r["path"]).match(p) for p in pins): - unmatched_code.append("%s %s" % (r["method"], r["path"])) - ok7 = not unmatched_pin and not unmatched_code - rep.add("CC7", ok7, - "钉子测试的 %d 条路径与代码注册的 %d 条平台路由双向覆盖" % (len(pins), len(plat_routes)) - if ok7 else "钉子测试清单与代码路由对不上:清单多 %d / 代码多 %d" - % (len(unmatched_pin), len(unmatched_code))) + a_routes = [r for r in plat_routes + if face_of.get((r["method"], norm_params(r["path"])), set()) & {"A", "AB"}] + + pin_norm = set(norm_params(p) for p in (pins or [])) + code_norm_a = {} + for r in a_routes: + code_norm_a.setdefault(norm_params(r["path"]), r) + unmatched_pin = sorted(p for p in pin_norm if p not in code_norm_a) + unmatched_code = sorted("%s %s" % (r["method"], r["path"]) + for k, r in code_norm_a.items() if k not in pin_norm) + + ok7 = (pins is not None) and not backslide and not unmatched_pin and not unmatched_code + if pins is None: + msg7 = "routes.rs 里找不到 `const REGISTERED: [&str; N]` 清单(面 A 的钉子没了)" + elif backslide: + msg7 = "`FACE_B_REGISTERED` 手抄清单又回来了(已退役:面 B 钉子读契约)" + elif ok7: + msg7 = ("钉子测试的 %d 条面 A 路径与代码注册的 %d 条面 A 平台路由双向覆盖" + "(面 B %d 条由钉子测试直读契约,不在本条)" + % (len(pin_norm), len(code_norm_a), len(plat_routes) - len(a_routes))) + else: + msg7 = "面 A 钉子清单与代码路由对不上:清单多 %d / 代码多 %d" \ + % (len(unmatched_pin), len(unmatched_code)) + rep.add("CC7", ok7, msg7) for d in unmatched_pin: rep.warn("CC7", "钉子测试里的 %s 在代码里没有对应路由" % d) for d in unmatched_code: diff --git a/scripts/check-contract.sh b/scripts/check-contract.sh index 1647b1b..ca0b78d 100644 --- a/scripts/check-contract.sh +++ b/scripts/check-contract.sh @@ -21,7 +21,7 @@ # CC4 代码 → 契约:代码里没有契约未登记的端点 # CC5 **归属层**一致(platform / 业务模块代号) # CC6 **守卫**一致(面A 菜单 key / 面B 点权限编码 / 登录 / 无)——静态推导 -# CC7 钉子测试的**字面量清单**(REGISTERED / FACE_B_REGISTERED)与平台层路由双向覆盖 +# CC7 钉子测试 **面 A 的字面量清单**(REGISTERED)与面 A 平台路由双向覆盖(面 B 已退役,读契约) # CC8 业务路由**三处**一致(各模块 ROUTES 常量 / router() 注册 / ALL_ROUTES) # CC9 契约面计数**自洽**([FACE] 登记的条数 == [ENDPOINT] 里各 face 的实际条数) # CC10 **官方端点台账** ↔ 代码真实路由(双向)+ 打印「官方端点覆盖 N/M」 diff --git a/src/backend/db/schema.sql b/src/backend/db/schema.sql index c7f1cd2..76ccdd6 100644 --- a/src/backend/db/schema.sql +++ b/src/backend/db/schema.sql @@ -1360,3 +1360,53 @@ CREATE TABLE base_module_link ( f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, PRIMARY KEY (f_id, f_tenant_id) ); + +-- 行政区划 —— 列与官方 JNPF 7.0 逐字一致 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 3604 行,`base_province`) +-- 🔴 树结构:`f_parent_id` 指向父节点,根节点固定 `-1`(官方 `AreaController:170`); +-- `f_type` 存**层级序号**(根=1,子=父+1,官方 `:174`),不是枚举。 +-- 🔴 `f_en_code` 是行政区划编码,官方用它**判重**(`isExistByEnCode`)。 +CREATE TABLE base_province ( + f_id VARCHAR(50) NOT NULL, + f_parent_id VARCHAR(50), + f_en_code VARCHAR(200), + f_full_name VARCHAR(200), + f_quick_query VARCHAR(100), + f_type 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) +); + +-- 公有变量 —— 列与官方 JNPF 7.0 逐字一致 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 1081 行,`base_common_variate`) +-- 🔴 `f_field` 是变量名(官方按它**判重**,见 `CommonVariateController:86`); +-- `f_value` 与 `f_expression` 二选一:`f_type` 决定前端显示哪一种。 +CREATE TABLE base_common_variate ( + f_id VARCHAR(50) NOT NULL, + f_field VARCHAR(50), + f_description VARCHAR(500), + f_value TEXT, + f_expression TEXT, + f_type INTEGER, + f_enabled_mark INTEGER, + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_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) +); diff --git a/src/backend/src/main.rs b/src/backend/src/main.rs index 6695480..ccbec8e 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -54,7 +54,8 @@ use ssw_platform::routes; /// `base_module_button` / `base_module_column` / `base_module_form` / /// `base_advanced_query_scheme`;**数据权限三件套**(2026-11-01 批次 11) /// `base_module_authorize` / `base_module_scheme` / `base_module_link`,故清单现在是 **48 张**。 -const BASE_TABLES: [&str; 48] = [ +/// 系统数据批次(2026-11-02 批次 13)新增 `base_province` / `base_common_variate` ⇒ **50 张**。 +const BASE_TABLES: [&str; 50] = [ "base_group", "base_user", "base_role", @@ -119,6 +120,10 @@ const BASE_TABLES: [&str; 48] = [ // 任何业务模块都会用,属于引擎基础设施。 "base_visual_dev", "base_visual_release", + // 🔴 系统数据批次(2026-11-02 批次 13):行政区划 + 公有变量, + // 都是官方 DDL 逐字;`base_province` 是**树**(`f_parent_id`,根固定 `-1`)。 + "base_province", + "base_common_variate", ]; /// 命令行解析的结果(**纯数据**,便于单测)。 diff --git a/src/backend/src/platform/face_b.rs b/src/backend/src/platform/face_b.rs index b05833c..8f21907 100644 --- a/src/backend/src/platform/face_b.rs +++ b/src/backend/src/platform/face_b.rs @@ -20880,6 +20880,889 @@ pub async fn module_data_authorize_link_table_fields( // === PERMISSION CONFIG (权限配置族) SECTION END === +/// INSERT 语句的累加器 —— **参数编号与列顺序不可能错位**。 +/// +/// 🔴 为什么要它:本仓所有值都按 text 绑定 ⇒ 必须写成 `$N::cast`;而时间列要写 `now()` +/// **不占参数位**。手写时这两件事混在一起,`$N` 编号一错位,报错是 +/// 「参数类型不匹配」,看不出真因(HANDOFF 批次 11 踩过)。 +/// ⇒ 用 `param()` 自动发号、`raw()` 只写表达式,两者都往同一个 `cols` 里追加。 +#[derive(Default)] +struct Inserts { + cols: Vec<&'static str>, + exprs: Vec, + values: Vec>, +} + +impl Inserts { + /// 绑定参数列:自动分配 `$N` 并记下值。 + fn param(&mut self, col: &'static str, cast: &str, value: Option) { + self.values.push(value); + self.exprs.push(format!("${}{cast}", self.values.len())); + self.cols.push(col); + } + + /// 无参数列:`expr` 是 SQL 字面表达式(本文件只用 `now()`)。 + fn raw(&mut self, col: &'static str, expr: &str) { + self.exprs.push(expr.to_string()); + self.cols.push(col); + } + + fn finish(&self, table: &str) -> String { + format!( + "INSERT INTO {table} ({}) VALUES ({})", + self.cols.join(", "), + self.exprs.join(", ") + ) + } +} + +// ---------------------------------------------------------------- 行政区划(base_province) + +/// `@SaCheckPermission("sysData.area")`(官方 `AreaController` 的 6 处写/读)。 +const EN_AREA: &str = "sysData.area"; + +/// 列表投影(官方 `ProvinceListVO` 的 7 个字段)。 +/// +/// 🔴 `isLeaf` / `hasChildren` **不在 SQL 里算**:它们要「有没有子节点」这个第二问, +/// 而官方是 `getList(entity.getId()).isEmpty()` 逐行查(N+1)。 +/// 本仓用一条 `GROUP BY f_parent_id` 拿全集再在 Rust 里判定 ⇒ 一次查询、无 N+1。 +const AREA_LIST_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \ + f_en_code AS \"enCode\", COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\""; + +/// 详情投影(官方 `ProvinceInfoVO` 的 9 个字段里来自本表的那 8 个;`parentName` 另查)。 +const AREA_INFO_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \ + f_en_code AS \"enCode\", COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ + f_description AS \"description\", COALESCE(f_type, '') AS \"type\", \ + COALESCE(f_parent_id, '-1') AS \"parentId\", COALESCE(f_sort_code, 0) AS \"sortCode\""; + +/// 🔴 **列名只来自这张白名单**(`db/schema.sql` 的 `base_province`,官方 DDL 逐字)。 +/// +/// 第三列是 SQL 里的 CAST:本仓参数一律按 **text** 绑定(`params_of` 全是 `Option`), +/// 而整数 / 大整数列**必须先 `::text` 再转**。写成 `$1::integer` 会被 PG 把**参数本身** +/// 推断成 `int4` ⇒ 绑 `Option` 直接报 +/// `cannot convert between the Rust type Option and the Postgres type int4`。 +const AREA_WRITE_FIELDS: [(&str, &str, &str); 7] = [ + ("fullName", "f_full_name", ""), + ("enCode", "f_en_code", ""), + ("description", "f_description", ""), + ("type", "f_type", ""), + ("parentId", "f_parent_id", ""), + ("enabledMark", "f_enabled_mark", "::text::integer"), + ("sortCode", "f_sort_code", "::text::bigint"), +]; + +/// 某节点的**直接子节点 id 集合**(用来算 `isLeaf` / `hasChildren`)。 +/// +/// 返回 `(有子节点的 parent_id 集合)`。空表 ⇒ 空集合。 +async fn area_parents_with_children(db: &Db) -> Result, pglite::Error> { + let rows = db + .query_json( + "SELECT DISTINCT COALESCE(f_parent_id, '-1') AS \"pid\" FROM base_province \ + WHERE COALESCE(f_delete_mark, 0) = 0", + ) + .await?; + Ok(rows + .into_iter() + .filter_map(|r| r["pid"].as_str().map(|s| s.to_string())) + .collect()) +} + +/// `GET /api/system/Area/{id}` —— 某节点下的**直接子节点**列表(`ListVO`)。 +/// +/// 🔴 官方返回的是**扁平列表 + `isLeaf`/`hasChildren` 两个标志**,前端据此懒加载下一层 +/// (`views/sysData/area`)——**不是**嵌套 `children` 树。别自作聪明改成嵌套。 +/// +/// 🔴 官方 `ProvinceListVO.setIsLeaf(childNode)` 里的 `childNode` 其实是 +/// 「子列表为空」⇒ `isLeaf = 没有子节点`、`hasChildren = 有子节点`。 +/// +/// 🔴 官方把这个参数叫 `{nodeId}`,本仓的路径段只能写 `{id}`(与同一段上的 +/// `PUT`/`DELETE` 共用 —— matchit 不允许同位置两个参数名,见 `routes.rs` 注释)。 +pub async fn area_list( + State(state): State, + headers: HeaderMap, + Path(id): Path, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_AREA).await { + return resp; + } + let node_id = id.trim().to_string(); + let keyword = crate::platform::sys::query_param(&raw, "keyword") + .trim() + .to_string(); + let enabled = crate::platform::sys::query_param(&raw, "enabledMark") + .trim() + .to_string(); + + let mut sql = format!( + "SELECT {AREA_LIST_PROJECTION} FROM base_province \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND COALESCE(f_parent_id, '-1') = $1::text" + ); + let mut values: Vec> = vec![Some(node_id)]; + if !enabled.is_empty() { + sql.push_str(" AND COALESCE(f_enabled_mark, 0) = $2::text::integer"); + values.push(Some(enabled)); + } + if !keyword.is_empty() { + // 官方 `PaginationProvince` 的 keyword 走 `like`(默认两边模糊)。 + let n = values.len() + 1; + sql.push_str(&format!( + " AND (f_full_name LIKE ${n}::text OR f_en_code LIKE ${n}::text)" + )); + values.push(Some(format!("%{keyword}%"))); + } + sql.push_str(" ORDER BY COALESCE(f_sort_code, 0) ASC, f_full_name ASC"); + + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "行政区划列表查询"), + }; + let parents = match area_parents_with_children(&state.db).await { + Ok(s) => s, + Err(e) => return db_error(e, "行政区划子节点统计"), + }; + + let list: Vec = rows + .into_iter() + .map(|mut row| { + let id = row["id"].as_str().unwrap_or_default().to_string(); + let has_children = parents.contains(&id); + if let Value::Object(ref mut obj) = row { + obj.insert("hasChildren".into(), Value::Bool(has_children)); + obj.insert("isLeaf".into(), Value::Bool(!has_children)); + } + row + }) + .collect(); + ok(list_vo(list)) +} + +/// `GET /api/system/Area/{id}/Selector/{ids}` —— 下级下拉(官方 `AreaController:94`)。 +/// +/// 🔴 三条口径(逐条抄官方): +/// 1. 只取 `f_parent_id = {id}` 且 **`f_enabled_mark = 1`** 的子节点(停用的不出现); +/// 2. `{ids}` 不是 `"0"` 时,**递归排除该节点及其整棵子树**(防止把上级选成自己的下级); +/// 3. 每个节点的 `isLeaf` **恒 `false`**(官方也这么写死 —— 前端靠它显示「展开」箭头)。 +pub async fn area_selector( + State(state): State, + headers: HeaderMap, + Path((id, ids)): Path<(String, String)>, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_AREA).await { + return resp; + } + let id = id.trim().to_string(); + let ids = ids.trim().to_string(); + + // 递归 CTE:`{ids}` 自己 + 它的全部后代。 + let sql = "WITH RECURSIVE sub AS ( \ + SELECT f_id FROM base_province WHERE f_id = $1::text \ + UNION ALL \ + SELECT p.f_id FROM base_province p JOIN sub s ON COALESCE(p.f_parent_id, '-1') = s.f_id \ + WHERE COALESCE(p.f_delete_mark, 0) = 0 \ + ) \ + SELECT f_id AS \"id\", f_full_name AS \"fullName\", FALSE AS \"isLeaf\" \ + FROM base_province \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND COALESCE(f_parent_id, '-1') = $2::text \ + AND COALESCE(f_enabled_mark, 0) = 1 \ + AND f_id NOT IN (SELECT f_id FROM sub) \ + ORDER BY COALESCE(f_sort_code, 0) ASC, f_full_name ASC"; + let rows = match state + .db + .query_json_params(sql, ¶ms_of(&[Some(ids), Some(id)])) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "行政区划下拉查询"), + }; + ok(list_vo(rows)) +} + +/// `GET /api/system/Area/{id}/Info` —— 详情 + `parentName`(官方 `AreaController:145`)。 +pub async fn area_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_AREA).await { + return resp; + } + let id = id.trim().to_string(); + let sql = format!( + "SELECT {AREA_INFO_PROJECTION} FROM base_province \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark, 0) = 0 LIMIT 1" + ); + let row = match state.db.query_json_params(&sql, ¶ms_of(&[Some(id)])).await { + Ok(rows) => rows.into_iter().next(), + Err(e) => return db_error(e, "行政区划详情查询"), + }; + let mut row = match row { + Some(r) => r, + None => return fail(code::FAIL, "行政区划不存在"), + }; + // `parentName`:官方只在 `parentId != "-1"` 时查父节点(根节点没有父名)。 + let parent_id = row["parentId"].as_str().unwrap_or("-1").to_string(); + let mut parent_name = String::new(); + if parent_id != "-1" && !parent_id.is_empty() { + let rows = state + .db + .query_json_params( + "SELECT f_full_name AS \"n\" FROM base_province \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark, 0) = 0 LIMIT 1", + ¶ms_of(&[Some(parent_id)]), + ) + .await + .unwrap_or_default(); + parent_name = rows + .first() + .and_then(|r| r["n"].as_str()) + .unwrap_or_default() + .to_string(); + } + if let Value::Object(ref mut obj) = row { + obj.insert("parentName".into(), Value::String(parent_name)); + } + ok(row) +} + +/// 编码判重(官方 `isExistByEnCode(enCode, id)` —— 排除自己,只比未删行)。 +async fn area_en_code_taken( + db: &Db, + en_code: &str, + exclude_id: Option<&str>, +) -> Result { + let sql = "SELECT f_id AS \"id\" FROM base_province \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND f_en_code = $1::text \ + AND ($2::text IS NULL OR f_id <> $2::text) LIMIT 1"; + let rows = db + .query_json_params( + sql, + ¶ms_of(&[Some(en_code.to_string()), exclude_id.map(|s| s.to_string())]), + ) + .await?; + Ok(!rows.is_empty()) +} + +/// `POST /api/system/Area` —— 新建(官方 `AreaController:165`)。 +/// +/// 🔴 三条官方语义(别漏,都是前端看得见的): +/// 1. `enCode` 判重 ⇒ `编码已存在`(`MsgCode.SYS001`); +/// 2. `parentId` 空 ⇒ 根节点,写 `-1`; +/// 3. `f_type` = **父的 type + 1**(根 = `"1"`)—— 它是层级序号,不是枚举。 +/// 官方 `create` 里这个值是**服务端算的**,body 传了也不作数。 +pub async fn area_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_AREA).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 full_name = obj + .get("fullName") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if full_name.is_empty() { + return fail(code::FAIL, "名称不能为空"); + } + let en_code = obj + .get("enCode") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + match area_en_code_taken(&state.db, &en_code, None).await { + Ok(true) => return fail(code::FAIL, "编码已存在"), + Ok(false) => {} + Err(e) => return db_error(e, "行政区划编码判重"), + } + + let parent_id = obj + .get("parentId") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + let parent_id = if parent_id.is_empty() { + "-1".to_string() + } else { + parent_id + }; + // 层级序号:根 = 1;否则父的 type + 1(父查不到 ⇒ 1,与官方同口径)。 + let level = if parent_id == "-1" { + 1 + } else { + let rows = state + .db + .query_json_params( + "SELECT COALESCE(f_type, '1') AS \"t\" FROM base_province \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark, 0) = 0 LIMIT 1", + ¶ms_of(&[Some(parent_id.clone())]), + ) + .await + .unwrap_or_default(); + rows.first() + .and_then(|r| r["t"].as_str()) + .and_then(|s| s.parse::().ok()) + .map(|t| t + 1) + .unwrap_or(1) + }; + + let new_id = new_uuid(); + let mut ins = Inserts::default(); + ins.param("f_id", "", Some(new_id)); + ins.param("f_tenant_id", "", Some("0".to_string())); + ins.param("f_full_name", "", Some(full_name)); + ins.param("f_en_code", "", Some(en_code)); + ins.param("f_parent_id", "", Some(parent_id)); + // 层级序号由服务端推导 ⇒ 不读 body 的 `type`。 + ins.param("f_type", "", Some(level.to_string())); + for (json_key, column, cast) in AREA_WRITE_FIELDS { + // 这四列上面已单独写过(含服务端推导的 type / parentId)。 + if matches!(column, "f_full_name" | "f_en_code" | "f_parent_id" | "f_type") { + continue; + } + if obj.contains_key(json_key) { + ins.param(column, cast, value_to_text(obj.get(json_key))); + } + } + ins.param("f_creator_user_id", "", Some(user.account)); + ins.raw("f_creator_time", "now()"); + ins.param("f_delete_mark", "::text::integer", Some("0".to_string())); + + let sql = ins.finish("base_province"); + // 🔴 写语句必须走 `exec_params`:`query_json_params` 会把 SQL 包成 + // `SELECT row_to_json(q) FROM () q` —— 只认 SELECT, + // INSERT 塞进去就是 `syntax error at or near "INTO"`。 + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&ins.values)).await { + return db_error(e, "行政区划新建"); + } + ok(Value::Null) +} + +/// `PUT /api/system/Area/{id}` —— 修改(官方 `AreaController:196`)。 +/// +/// 🔴 **只 SET body 里出现的键**(`updateById` 语义,见 HANDOFF 批次 11 的坑)—— +/// 没传的列保持原值,绝不清空。`f_type` 不在白名单里:层级是服务端推导的, +/// 官方 `update` 也只 copy 表单字段(前端不送 type)。 +pub async fn area_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_AREA).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + if let Some(en_code) = obj.get("enCode").and_then(Value::as_str) { + match area_en_code_taken(&state.db, en_code.trim(), Some(&id)).await { + Ok(true) => return fail(code::FAIL, "编码已存在"), + Ok(false) => {} + Err(e) => return db_error(e, "行政区划编码判重"), + } + } + + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (json_key, column, cast) in AREA_WRITE_FIELDS { + if column == "f_type" { + continue; + } + if obj.contains_key(json_key) { + 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)); + sets.push(format!("f_last_modify_user_id = ${}", values.len())); + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let sql = format!( + "UPDATE base_province SET {} WHERE f_id = ${}::text AND COALESCE(f_delete_mark, 0) = 0", + sets.join(", "), + values.len() + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "行政区划修改"); + } + ok(Value::Null) +} + +/// `DELETE /api/system/Area/{id}` —— 删除(官方 `AreaController:219`)。 +/// +/// 🔴 **有子节点 ⇒ 拒绝删除**(`MsgCode.SYS002`)—— 这是官方行为,不是本仓加的。 +/// 判据是「未删的子节点数为 0」。 +pub async fn area_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_AREA).await { + return resp; + } + let id = id.trim().to_string(); + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_province \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND COALESCE(f_parent_id, '-1') = $1::text LIMIT 1", + ¶ms_of(&[Some(id.clone())]), + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "行政区划子节点查询"), + }; + if !rows.is_empty() { + return fail(code::FAIL, "该节点存在子节点,无法删除"); + } + let sql = "UPDATE base_province SET f_delete_mark = 1, f_delete_time = now() \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark, 0) = 0"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&[Some(id)])).await { + return db_error(e, "行政区划删除"); + } + ok(Value::Null) +} + +/// `POST /api/system/Area/GetAreaByIds` —— **id 串 → 名称串**(官方 `AreaController:265`)。 +/// +/// 入参 `{idsList: [[id,…],[id,…]]}`,出参 `[[名称,…],[名称,…]]`(**二维进、二维出**)。 +/// 🔴 官方是**逐条 `getProList`**(顺序 = 传进来的顺序)⇒ 这里也必须按输入顺序回填, +/// 不能直接用 SQL 的返回顺序(`IN (...)` 的顺序是数据库决定的)。 +pub async fn area_get_by_ids( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_AREA).await { + return resp; + } + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let groups: Vec> = obj + .get("idsList") + .and_then(Value::as_array) + .map(|outer| { + outer + .iter() + .map(|inner| { + inner + .as_array() + .map(|a| { + a.iter() + .filter_map(Value::as_str) + .map(|s| s.trim().to_string()) + .filter(|s| !s.is_empty()) + .collect::>() + }) + .unwrap_or_default() + }) + .collect() + }) + .unwrap_or_default(); + if groups.is_empty() { + return ok(Value::Array(vec![])); + } + + // 所有 id 一次查回来(`= ANY(string_to_array(...))` —— 本仓 PG 数组参数的唯一写法)。 + let all: Vec = groups.iter().flatten().cloned().collect(); + let joined = all.join(","); + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\" FROM base_province \ + WHERE f_id = ANY(string_to_array($1::text, ',')) AND COALESCE(f_delete_mark, 0) = 0", + ¶ms_of(&[Some(joined)]), + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "行政区划名称查询"), + }; + let mut names: HashMap = HashMap::new(); + for r in rows { + let id = r["id"].as_str().unwrap_or_default().to_string(); + let name = r["fullName"].as_str().unwrap_or_default().to_string(); + names.insert(id, name); + } + let out: Vec = groups + .iter() + .map(|g| { + Value::Array( + g.iter() + .filter_map(|id| names.get(id).cloned()) + .map(Value::String) + .collect(), + ) + }) + .collect(); + ok(Value::Array(out)) +} + +// ---------------------------------------------------------------- 公有变量(base_common_variate) + +/// 列表投影(官方 `CommonVariateVO` 的 11 个字段)。 +/// +/// 🔴 `type` 在官方 VO 里是 **`String`**(DB 是 `INTEGER`)⇒ Jackson 序列化成 `"1"`。 +/// 这里也 `::text` ⇒ 前端 `=== '1'` 之类的判断不会翻车。 +/// 🔴 `creatorUser` = `realName + "/" + account`(官方 `CommonVariateController:70`), +/// 用户名要 join `base_user`;查不到 ⇒ **空串**(官方 `: ""`),不是 null。 +/// 🔴 **`f_creator_user_id` 本仓存的是账号,不是 uuid**(`seed.rs:33` / `crud.rs:59` +/// 的裁决 S22)—— 所以查找条件必须**同时认 `f_id` 和 `f_account`**: +/// 只写 `u.f_id = ...` 的话,本仓自己建的变量 `creatorUser` **恒为空串**。 +/// 用**标量子查询 + `LIMIT 1`** 而不是 `LEFT JOIN ... OR ...`: +/// 后者在「某个账号恰好撞上另一个用户的 uuid」时会**把列表行翻倍**(分页静默错乱)。 +const VARIATE_PROJECTION: &str = "v.f_id AS \"id\", v.f_field AS \"field\", v.f_value AS \"value\", \ + v.f_expression AS \"expression\", v.f_description AS \"description\", \ + v.f_type::text AS \"type\", \ + (EXTRACT(EPOCH FROM v.f_creator_time) * 1000)::bigint AS \"creatorTime\", \ + v.f_creator_user_id AS \"creatorUserId\", \ + COALESCE((SELECT CASE WHEN COALESCE(u.f_real_name, '') = '' \ + THEN COALESCE(u.f_account, '') \ + ELSE u.f_real_name || '/' || COALESCE(u.f_account, '') END \ + FROM base_user u \ + WHERE u.f_id = v.f_creator_user_id OR u.f_account = v.f_creator_user_id \ + LIMIT 1), '') AS \"creatorUser\", \ + (EXTRACT(EPOCH FROM v.f_last_modify_time) * 1000)::bigint AS \"lastModifyTime\", \ + v.f_last_modify_user_id AS \"lastModifyUserId\""; + +/// 🔴 **列名只来自这张白名单**(`db/schema.sql` 的 `base_common_variate`,官方 DDL 逐字)。 +const VARIATE_WRITE_FIELDS: [(&str, &str, &str); 4] = [ + ("field", "f_field", ""), + ("value", "f_value", ""), + ("expression", "f_expression", ""), + ("description", "f_description", ""), +]; + +/// `GET /api/system/Variate` —— 分页列表(`PageListVO`)。 +/// +/// 过滤口径(官方 `CommonVariateServiceImpl:101-124`): +/// `type` 精确、`keyword` 对 **`f_field` 或 `f_description`** 模糊,`ORDER BY f_creator_time DESC`。 +/// 🔴 变量页**没有点权限**(官方 `CommonVariateController` 一处 `@SaCheckPermission` 都没有) +/// ⇒ 守卫只查登录。这是**照抄官方**,不是漏写。 +pub async fn variate_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let paging = Paging::of(&raw); + let keyword = crate::platform::sys::query_param(&raw, "keyword") + .trim() + .to_string(); + let vtype = crate::platform::sys::query_param(&raw, "type") + .trim() + .to_string(); + + let mut where_sql = String::from("WHERE COALESCE(v.f_delete_mark, 0) = 0"); + let mut values: Vec> = Vec::new(); + if !vtype.is_empty() { + values.push(Some(vtype)); + where_sql.push_str(&format!(" AND v.f_type = ${}::text::integer", values.len())); + } + if !keyword.is_empty() { + values.push(Some(format!("%{keyword}%"))); + where_sql.push_str(&format!( + " AND (v.f_field LIKE ${n}::text OR v.f_description LIKE ${n}::text)", + n = values.len() + )); + } + + let count_sql = format!("SELECT count(*)::bigint AS \"c\" FROM base_common_variate v {where_sql}"); + 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, "公有变量计数"), + }; + let sql = format!( + "SELECT {VARIATE_PROJECTION} FROM base_common_variate v {where_sql} \ + ORDER BY v.f_creator_time DESC NULLS LAST \ + LIMIT {page_size} OFFSET {offset}", + page_size = paging.page_size, + offset = paging.offset + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "公有变量列表查询"), + }; + ok(page_list(paging.current_page, paging.page_size, total, rows)) +} + +/// `GET /api/system/Variate/{id}` —— 详情(`CommonVariateVO`)。 +pub async fn variate_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let id = id.trim().to_string(); + let sql = format!( + "SELECT {VARIATE_PROJECTION} FROM base_common_variate v \ + WHERE v.f_id = $1::text AND COALESCE(v.f_delete_mark, 0) = 0 LIMIT 1" + ); + match state.db.query_json_params(&sql, ¶ms_of(&[Some(id)])).await { + Ok(rows) => match rows.into_iter().next() { + Some(row) => ok(row), + None => fail(code::FAIL, "变量不存在"), + }, + Err(e) => db_error(e, "公有变量详情查询"), + } +} + +/// 变量名判重(官方 `checkName(field, id)` —— 排除自己)。 +async fn variate_field_taken( + db: &Db, + field: &str, + exclude_id: Option<&str>, +) -> Result { + let rows = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_common_variate \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND f_field = $1::text \ + AND ($2::text IS NULL OR f_id <> $2::text) LIMIT 1", + ¶ms_of(&[Some(field.to_string()), exclude_id.map(|s| s.to_string())]), + ) + .await?; + Ok(!rows.is_empty()) +} + +/// `POST /api/system/Variate` —— 新建(官方 `CommonVariateController:84`)。 +/// +/// 🔴 判重失败 ⇒ `变量名已存在`(官方返回 `ActionResult.fail("变量名已存在")`)。 +pub async fn variate_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match require_login_face_b(&state, &headers).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() + .trim() + .to_string(); + if field.is_empty() { + return fail(code::FAIL, "变量名不能为空"); + } + match variate_field_taken(&state.db, &field, None).await { + Ok(true) => return fail(code::FAIL, "变量名已存在"), + Ok(false) => {} + Err(e) => return db_error(e, "变量名判重"), + } + + let mut ins = Inserts::default(); + ins.param("f_id", "", Some(new_uuid())); + ins.param("f_tenant_id", "", Some("0".to_string())); + ins.param("f_field", "", Some(field)); + for (json_key, column, cast) in VARIATE_WRITE_FIELDS { + if column == "f_field" { + continue; + } + if obj.contains_key(json_key) { + ins.param(column, cast, value_to_text(obj.get(json_key))); + } + } + // `f_type`:官方 VO 是 String、DB 是 INTEGER ⇒ 显式 CAST(**先 `::text`**, + // 让 PG 按 text 推断参数类型;只写 `::integer` 会绑不上 `Option`)。 + if obj.contains_key("type") { + 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.raw("f_creator_time", "now()"); + ins.param("f_delete_mark", "::text::integer", Some("0".to_string())); + + let sql = ins.finish("base_common_variate"); + // 🔴 同 `area_create`:INSERT 只能走 `exec_params`(`query_json_params` 是 SELECT 专用)。 + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&ins.values)).await { + return db_error(e, "公有变量新建"); + } + ok(Value::Null) +} + +/// `PUT /api/system/Variate/{id}` —— 修改。 +/// +/// 🔴 **只 SET body 里出现的键**(官方 `BeanUtil.copyProperties(..., ignoreNullValue=true)`)。 +pub async fn variate_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + if let Some(field) = obj.get("field").and_then(Value::as_str) { + match variate_field_taken(&state.db, field.trim(), Some(&id)).await { + Ok(true) => return fail(code::FAIL, "变量名已存在"), + Ok(false) => {} + Err(e) => return db_error(e, "变量名判重"), + } + } + + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (json_key, column, cast) in VARIATE_WRITE_FIELDS { + if obj.contains_key(json_key) { + values.push(value_to_text(obj.get(json_key))); + sets.push(format!("{column} = ${}{cast}", values.len())); + } + } + if obj.contains_key("type") { + values.push(value_to_text(obj.get("type"))); + sets.push(format!("f_type = ${}::text::integer", values.len())); + } + if sets.is_empty() { + return ok(Value::Null); + } + values.push(Some(user.account)); + sets.push(format!("f_last_modify_user_id = ${}", values.len())); + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let sql = format!( + "UPDATE base_common_variate SET {} \ + WHERE f_id = ${}::text AND COALESCE(f_delete_mark, 0) = 0", + sets.join(", "), + values.len() + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "公有变量修改"); + } + ok(Value::Null) +} + +/// `DELETE /api/system/Variate/{id}` —— 软删(幂等)。 +pub async fn variate_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let id = id.trim().to_string(); + let sql = "UPDATE base_common_variate SET f_delete_mark = 1, f_delete_time = now() \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark, 0) = 0"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&[Some(id)])).await { + return db_error(e, "公有变量删除"); + } + ok(Value::Null) +} + +/// `GET /api/system/Variate/selector` —— 下拉(官方 `CommonVariateController:159`)。 +/// +/// 官方 `getAllList()` 是**不分页全量**,`keyword` 对 `f_description` / `f_field` 模糊 +/// (大小写不敏感 —— 官方 `toUpperCase().contains(...)`)。返回 `ListVO`(**裸列表**)。 +pub async fn variate_selector( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let keyword = crate::platform::sys::query_param(&raw, "keyword") + .trim() + .to_string(); + let mut sql = "SELECT f_id AS \"id\", f_field AS \"field\", f_value AS \"value\", \ + f_expression AS \"expression\", f_description AS \"description\", \ + f_type::text AS \"type\" FROM base_common_variate \ + WHERE COALESCE(f_delete_mark, 0) = 0" + .to_string(); + let mut values: Vec> = Vec::new(); + if !keyword.is_empty() { + values.push(Some(format!("%{}%", keyword.to_uppercase()))); + sql.push_str(&format!( + " AND (upper(COALESCE(f_description, '')) LIKE ${n}::text \ + OR upper(COALESCE(f_field, '')) LIKE ${n}::text)", + n = values.len() + )); + } + sql.push_str(" ORDER BY f_creator_time DESC NULLS LAST"); + match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => ok(list_vo(rows)), + Err(e) => db_error(e, "公有变量下拉查询"), + } +} + +/// `GET /api/system/Variate/sysfunccategory` —— 函数分类列表(官方 `FunctionCategory` 枚举)。 +/// +/// 🔴 **本仓没有表达式引擎**,但这一条只回**分类目录**(11 个固定枚举)⇒ 可以真实现, +/// 不需要假装。返回 `ListVO<{field, description}>`,顺序 = 枚举声明顺序(`ALL` 在最前)。 +pub async fn variate_sys_func_category( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let list: Vec = VARIATE_FUNC_CATEGORIES + .iter() + .map(|(field, name)| json!({ "field": field, "description": name })) + .collect(); + ok(list_vo(list)) +} + +/// 官方 `FunctionCategory` 枚举(`jnpf-system-entity/.../variate/FunctionCategory.java:12-23`)。 +const VARIATE_FUNC_CATEGORIES: [(&str, &str); 11] = [ + ("ALL", "全部函数"), + ("ENCRYPTION", "加解密函数"), + ("MASKING", "脱敏函数"), + ("OBJECT", "对象函数"), + ("MATH", "数学函数"), + ("COMMON", "常用函数"), + ("TIME", "时间函数"), + ("CONVERSION", "转换函数"), + ("COLLECTION", "集合函数"), + ("TEXT", "文本函数"), + ("LOGIC", "逻辑函数"), +]; + +// === SYSTEM DATA (系统数据族) SECTION END === + #[cfg(test)] mod tests { use super::*; diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index f7307d0..6783634 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -1061,6 +1061,42 @@ pub fn build_router(state: AppState) -> axum::Router { .route("/api/permission/Action/{id}", get(face_b::action_info)) .route("/api/permission/Action/{id}", put(face_b::action_update)) .route("/api/permission/Action/{id}", delete(face_b::action_delete)) + // ---- 行政区划(`system/Area`,`base_province`)---- + // 🔴 官方 `AreaController` 是**树 + 懒加载**:`GET /{nodeId}` 返回该节点的 + // 直接子节点(扁平 + `isLeaf`/`hasChildren`),不是嵌套树。 + // 🔴 **官方叫 `{nodeId}`,这里必须写 `{id}`**:`GET /{nodeId}`(子节点列表)与 + // `PUT|DELETE /{id}` 是**同一段位置**,而 matchit **不允许同位置两个参数名** + // (重名会在启动时 panic:`Insertion failed due to conflict with previously + // registered route`)。同一条坑在批次 9 的 `Log/{id}` 上踩过(HANDOFF 有记)。 + // URL 本身不受影响(参数名只是占位符),契约 `[ENDPOINT]` 同步写 `{id}`; + // 官方台账 `[OFFICIAL]` 保留 `{nodeId}`,CC10 会把参数归一后对账。 + // 🔴 `GetAreaByIds` 与 `/{id}` 同层:静态段优先于参数段,方法也不同(POST vs GET)。 + .route("/api/system/Area/{id}", get(face_b::area_list)) + .route( + "/api/system/Area/{id}/Selector/{ids}", + get(face_b::area_selector), + ) + .route("/api/system/Area/{id}/Info", get(face_b::area_info)) + .route("/api/system/Area", post(face_b::area_create)) + .route("/api/system/Area/{id}", put(face_b::area_update)) + .route("/api/system/Area/{id}", delete(face_b::area_delete)) + .route( + "/api/system/Area/GetAreaByIds", + post(face_b::area_get_by_ids), + ) + // ---- 公有变量(`system/Variate`,`base_common_variate`)---- + // 🔴 这一族**没有点权限**(官方 `CommonVariateController` 零 `@SaCheckPermission`) + // ⇒ 守卫只查登录。照抄官方,别「顺手加上」——加了官方前端反而会 403。 + .route("/api/system/Variate", get(face_b::variate_list)) + .route("/api/system/Variate", post(face_b::variate_create)) + .route("/api/system/Variate/selector", get(face_b::variate_selector)) + .route( + "/api/system/Variate/sysfunccategory", + get(face_b::variate_sys_func_category), + ) + .route("/api/system/Variate/{id}", get(face_b::variate_info)) + .route("/api/system/Variate/{id}", put(face_b::variate_update)) + .route("/api/system/Variate/{id}", delete(face_b::variate_delete)) // ---- 业务模块的路由(demo / shop / books)由业务层自带 ⇒ 这里只 merge ---- .merge(modules::router()) // ---- 业务包的路由(面 B 官方形状)由**业务包自带** ⇒ 按声明生成 ---- @@ -1609,289 +1645,23 @@ mod tests { // ---- 面 B(官方 JNPF 契约面)---- - /// 🔴 **面 B 的 5 条官方路由必须已注册**(错方法 ⇒ 405)—— 逐字钉死。 + /// 🔴 **契约里的每条面 B 路由都必须真的注册了**(错方法 ⇒ 405)。 /// - /// 🔴 **面 A 的 27 条路由表一个字都没动**(见上面的 `route_table_is_pinned`)—— - /// 面 B 全部是**新增**路径,唯一共用的是 `CurrentUser` / `Authority/Data`。 + /// 🔴 **不写死清单**(批次 13 改):原来这里是一段 255 行的 `const [&str; 255]`, + /// 每加一族端点就得手抄一遍 —— 漏抄的后果是**这条断言仍然全绿**(假闸门), + /// 而「加了端点没注册」正好是最该被它抓住的错。 + /// 现在直接读契约的 `[ENDPOINT]` 段:**与 `check-contract.sh` 的 CC10 同源** + /// (CC10 做静态双向对账,这里补一次**运行时**探活)。 #[tokio::test] async fn face_b_route_table_is_pinned() { let port = serve(new_state(db().await)).await; - - // 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。 - const FACE_B_REGISTERED: [&str; 255] = [ - "/api/permission/Users", - "/api/permission/Users/any-id", - "/api/permission/Users/BatchDelete", - "/api/permission/Users/BatchUpdateState", - "/api/permission/Users/any-id/GetPosition", - "/api/permission/Users/any-id/Actions/ResetPassword", - "/api/permission/Users/any-id/Actions/unlock", - "/api/permission/Role", - "/api/permission/Organize/AsyncList/0", - "/api/system/Menu/ModuleBySystem", - "/api/permission/Authority/Data/any-id/Values", - "/api/oauth/Logout", - "/api/system/BaseLang/LangJson", - "/api/permission/Group", - "/api/permission/Group/any-id", - "/api/permission/Group/any-id/Actions/AddUser", - "/api/permission/Group/any-id/Actions/DeleteUser", - "/api/permission/Users/SetPositionBatch", - "/api/permission/Users/workHandover", - "/api/permission/Users/any-id/SetPosition", - "/api/permission/Users/any-id/SelectorByUserPosId", - "/api/system/System/getDevUser", - "/api/permission/socials/any-id", - "/api/permission/Organize", - "/api/permission/Organize/any-id", - "/api/permission/Organize/Selector", - "/api/permission/Organize/AsyncPosList", - "/api/permission/Role/Selector", - "/api/permission/Role/RoleCondition", - "/api/permission/Role/any-id", - "/api/permission/Position", - "/api/permission/Position/Selector", - "/api/permission/Position/SelectorTree", - "/api/permission/Position/PositionCondition", - "/api/permission/Position/SelectedList", - "/api/permission/Position/any-id", - "/api/permission/Position/any-id/Actions/DutyPosition", - "/api/permission/Position/any-id/Actions/DutyUser", - "/api/permission/Group/Selector", - "/api/system/Menu", - "/api/system/Menu/any-id", - "/api/system/Menu/Selector/All", - "/api/system/Menu/Selector/Form", - "/api/system/Menu/Selector/Page", - "/api/system/Menu/Selector/any-id", - "/api/system/Menu/SelectorFilter/any-id", - "/api/system/Menu/getSystemMenu", - "/api/system/Menu/any-id/Actions/Export", - "/api/system/Menu/getPermissionGroup/any-id", - "/api/system/Menu/getPermission/any-id/any-id", - "/api/system/DictionaryType", - "/api/system/DictionaryType/any-id", - "/api/system/DictionaryType/Selector/any-id", - "/api/system/DictionaryData", - "/api/system/DictionaryData/any-id", - "/api/system/DictionaryData/any-id/Info", - "/api/system/DictionaryData/any-id/Data/Selector", - "/api/system/DictionaryData/any-id/Selector/any-id", - "/api/system/DictionaryData/any-id/Actions/Export", - "/api/permission/Users/Selector", - "/api/permission/Users/getUserList", - "/api/permission/Users/getSelectedList", - "/api/permission/Users/getSelectedUserList", - "/api/permission/Users/ReceiveUserList", - "/api/permission/Users/getAllPermission", - "/api/permission/Users/Authorize", - "/api/permission/Authority/any-id/any-id", - "/api/permission/RoleRelation/roleList", - "/api/permission/RoleRelation/addRoles", - "/api/permission/RoleRelation/deleteRoles", - "/api/permission/RoleRelation/delete", - "/api/permission/UserRelation", - "/api/permission/UserRelation/delete", - "/api/permission/UserRelation/userList", - "/api/system/DictionaryData/All", - "/api/system/HomeData", - "/api/system/MenuData/useModuleNum/any-id", - "/api/oauth/getLoginConfig", - "/api/oauth/getConfig/admin", - "/api/permission/Users/Current/BaseInfo", - "/api/permission/Users/Current/Avatar", - "/api/permission/Users/Current/SystemTheme", - "/api/permission/Users/Current/SystemLanguage", - "/api/permission/Users/Current/Actions/ModifyPassword", - "/api/permission/Users/Current/Subordinate/any-id", - "/api/permission/Users/Current/SystemLog", - "/api/permission/Users/Current/getUserOrganizes", - "/api/permission/Users/Current/getUserPositions", - "/api/permission/Users/Current/getUserRoles", - "/api/permission/Users/Current/major", - "/api/permission/Users/Current/SignImg", - "/api/permission/Users/Current/any-id/SignImg", - "/api/permission/Users/Current/getAppSecret", - "/api/permission/Users/Current/saveAppSecret", - "/api/permission/Users/Current/saasList", - "/api/permission/Users/Current/saasinfo", - "/api/permission/Users/Current/saasTenantName/any-id", - "/api/permission/Users/Current/saasjoin", - "/api/permission/Users/Current/any-id/saas", - "/api/permission/Standing", - "/api/permission/Standing/list", - "/api/permission/Standing/any-id", - "/api/permission/Standing/any-id/Actions/AddObject", - "/api/permission/Standing/any-id/Actions/DeleteObject", - "/api/permission/PermissionGroup", - "/api/permission/PermissionGroup/any-id", - "/api/permission/PermissionGroup/any-id/Actions/Copy", - "/api/permission/PermissionGroup/PermissionMember/any-id", - "/api/permission/Action", - "/api/permission/Action/any-id", - // —— 应用中心 + 系统配置(批次 3)—— - "/api/system/System", - "/api/system/System/Selector", - "/api/system/System/userAuthList", - "/api/system/System/actionTop", - "/api/system/System/getAppAuthorization/any-id", - "/api/system/System/saveAppAuthorization", - "/api/system/System/changeAppAuthorization", - "/api/system/System/any-id", - "/api/system/System/any-id/Actions/Copy", - "/api/system/System/preferenceSave/any-id", - "/api/system/SysConfig", - "/api/system/SysConfig/socials", - "/api/system/SysConfig/getAdminList", - "/api/system/SysConfig/setAdminList", - "/api/system/SysConfig/any-type/testQyWebChatConnect", - "/api/system/SysConfig/testDingTalkConnect", - "/api/system/SynThirdInfo", - "/api/system/SynThirdInfo/getSynThirdTotal/any-type", - "/api/system/SynThirdInfo/clearAllSyn", - "/api/system/SynThirdInfo/getHandleNum", - "/api/system/Tag", - "/api/system/Tag/selector", - "/api/system/Tag/any-id", - // —— 消息业务分类 + 站内消息 + 公告(批次 4)—— - "/api/system/BusinessCategory", - "/api/system/BusinessCategory/treeList", - "/api/system/BusinessCategory/selector", - "/api/system/BusinessCategory/any-id", - "/api/message", - "/api/message/Actions/ReadAll", - "/api/message/ReadInfo/any-id", - "/api/message/Record", - "/api/message/Reply/any-id", - "/api/message/Notice/List", - "/api/message/Notice", - "/api/message/Notice/any-id", - "/api/message/Notice/any-id/Actions/Release", - "/api/message/Notice/any-id/ReplyUserList", - // —— 系统日志 + 审批常用语 + 单据规则(批次 5)—— - // 🔴 `/Log/any-id` 一条覆盖两个方法(GET 详情 / DELETE 按分类清空)。 - "/api/system/Log", - "/api/system/Log/deleteLoginLog", - "/api/system/Log/ModuleName", - "/api/system/Log/any-id", - "/api/system/CommonWords", - "/api/system/CommonWords/Selector", - "/api/system/CommonWords/UsesNum", - "/api/system/CommonWords/any-id", - "/api/system/BillRule", - "/api/system/BillRule/Selector", - "/api/system/BillRule/BillNumber/any-param", - "/api/system/BillRule/Actions/Import", - "/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", - "/api/system/DataModel/any-id/Table", - "/api/system/DataModel/any-id/addFields", - "/api/system/DataModel/any-id/deleteAllTable", - "/api/system/DataModel/any-id/Table/any-table/Actions/Copy", - "/api/system/DataModel/any-id/Table/any-table/Actions/Export", - "/api/system/DataModel/any-id/Actions/Import", - "/api/system/Dataset", - "/api/system/Dataset/getList", - "/api/system/Dataset/previewSql", - "/api/system/Dataset/fields", - "/api/system/Dataset/Actions/Import", - "/api/system/Dataset/GetParam/any-id", - "/api/system/Dataset/any-id", - "/api/system/Dataset/any-id/get", - "/api/system/Dataset/any-id/save", - "/api/system/Dataset/any-id/Actions/Export", - "/api/system/Dataset/any-id/Actions/Copy", - "/api/system/Dataset/any-id/Actions/Preview", - "/api/system/Dataset/any-id/Actions/List", - "/api/system/Dataset/any-id/Actions/InfoByIds", - "/api/system/Dataset/any-id/Actions/getRes", - // ---- 数据接口(批次 9)---- - "/api/system/DataInterface", - "/api/system/DataInterface/getList", - "/api/system/DataInterface/GetParam/any-id", - "/api/system/DataInterface/any-id", - "/api/system/DataInterface/any-id/get", - "/api/system/DataInterface/any-id/save", - "/api/system/DataInterface/any-id/Actions/Copy", - "/api/system/DataInterface/any-id/Actions/Export", - "/api/system/DataInterface/any-id/Actions/Preview", - // ---- 接口认证(批次 9)---- - "/api/system/InterfaceOauth", - "/api/system/InterfaceOauth/getAppId", - "/api/system/InterfaceOauth/getInterfaceList", - "/api/system/InterfaceOauth/dataInterfaceLog/any-id", - "/api/system/InterfaceOauth/interfaceSelector", - "/api/system/InterfaceOauth/SaveUserList", - "/api/system/InterfaceOauth/any-id", - // ---- 打印模板(批次 9)---- - "/api/system/printDev", - "/api/system/printDev/Selector", - "/api/system/printDev/WorkSelector", - "/api/system/printDev/getListOptions", - "/api/system/printDev/any-id", - "/api/system/printDev/any-id/Actions/Copy", - "/api/system/printDev/any-id/Actions/Export", - "/api/system/printDev/any-id/Actions/Preview", - "/api/system/printDev/BatchData", - "/api/system/printDev/Save", - "/api/system/printDev/Info/any-id", - "/api/system/printDev/Version/any-id", - // ---- 电子签章(批次 10)---- - "/api/system/Signature", - "/api/system/Signature/Selector", - "/api/system/Signature/ListByIds", - "/api/system/Signature/any-id", - // ---- 按钮权限(批次 10)---- - "/api/system/ModuleButton", - "/api/system/ModuleButton/selectActions/any-id", - "/api/system/ModuleButton/any-id/List", - "/api/system/ModuleButton/any-id/Selector", - "/api/system/ModuleButton/any-id", - // ---- 列表权限(批次 10)---- - "/api/system/ModuleColumn", - "/api/system/ModuleColumn/Actions/Batch", - "/api/system/ModuleColumn/any-id/Fields", - "/api/system/ModuleColumn/any-id", - // ---- 表单权限(批次 10)---- - "/api/system/ModuleForm", - "/api/system/ModuleForm/Actions/Batch", - "/api/system/ModuleForm/any-id/Fields", - "/api/system/ModuleForm/any-id", - // ---- 高级查询方案(批次 10)---- - "/api/system/AdvancedQuery", - "/api/system/AdvancedQuery/any-id/List", - "/api/system/AdvancedQuery/any-id", - // ---- 数据权限三件套(批次 11)---- - "/api/system/ModuleDataAuthorize", - "/api/system/ModuleDataAuthorize/any-id/List", - "/api/system/ModuleDataAuthorize/any-id/FieldList", - "/api/system/ModuleDataAuthorize/any-id", - "/api/system/ModuleDataAuthorizeScheme", - "/api/system/ModuleDataAuthorizeScheme/any-id/List", - "/api/system/ModuleDataAuthorizeScheme/any-id", - "/api/system/ModuleDataAuthorizeLink/saveLinkData", - "/api/system/ModuleDataAuthorizeLink/getVisualTables/any-id/1", - "/api/system/ModuleDataAuthorizeLink/getInfo/any-id/1", - "/api/system/ModuleDataAuthorizeLink/any-id/Tables/tbl/Fields/1/1", - ]; - - for path in FACE_B_REGISTERED { + let paths = face_b_paths_from_contract(); + assert!( + paths.len() > 100, + "契约里的面 B 路径数异常少({} 条)⇒ 大概率是 [ENDPOINT] 段被改坏了", + paths.len() + ); + for path in &paths { let raw = raw(port, &patch(path)).await; assert!( raw.starts_with("HTTP/1.1 405 Method Not Allowed"), @@ -1900,6 +1670,56 @@ mod tests { } } + /// 从 `docs/contract.md` 的 `[ENDPOINT]` 段读出**面 B / 共用**的全部路径。 + /// + /// 🔴 路径参数一律换成 `any-id`(axum 0.8 的 `{param}` 位置随便填什么都匹配)。 + fn face_b_paths_from_contract() -> Vec { + let file = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("..") + .join("..") + .join("docs") + .join("contract.md"); + let text = std::fs::read_to_string(&file) + .unwrap_or_else(|e| panic!("读契约失败 {}: {e}", file.display())); + let mut out: Vec = Vec::new(); + let mut inside = false; + for line in text.lines() { + let trimmed = line.trim(); + if trimmed == "[ENDPOINT]" { + inside = true; + continue; + } + if inside && trimmed.starts_with('[') { + break; // 下一段 + } + if !inside || trimmed.is_empty() || trimmed.starts_with('#') { + continue; + } + let cols: Vec<&str> = line.split('\t').collect(); + if cols.len() < 3 || (cols[0] != "B" && cols[0] != "AB") { + continue; + } + // `{nodeId}` / `{id}` / `{param}` ⇒ `any-id` + let mut path = String::new(); + let mut in_param = false; + for ch in cols[2].trim().chars() { + match ch { + '{' => in_param = true, + '}' => { + in_param = false; + path.push_str("any-id"); + } + c if !in_param => path.push(c), + _ => {} + } + } + if !out.contains(&path) { + out.push(path); + } + } + out + } + /// 🔴 **面 A 与面 B 的 `Authority/Data` 必须共存**: /// - 面 A:`PUT /api/permission/Authority/Data/{objectId}`; /// - 面 B:`POST /api/permission/Authority/Data/{objectId}/Values`。 diff --git a/src/backend/tests/batch13_it.rs b/src/backend/tests/batch13_it.rs new file mode 100644 index 0000000..9efe498 --- /dev/null +++ b/src/backend/tests/batch13_it.rs @@ -0,0 +1,681 @@ +//! 批次 13(**系统数据两族**)集成测试: +//! `Area`(7) + `Variate`(7) = 14 端点,2 张表(`base_province` / `base_common_variate`)。 +//! +//! 🔴 **钉住的契约点**(每条都是「照抄官方会翻车 / 不照抄也会翻车」的地方): +//! ① 行政区划是**树**:`f_parent_id` 空 ⇒ 根写 `-1`;`f_type` 是**层级序号** +//! (根 `"1"`、子 = 父 + 1),**服务端推导 —— body 传了不作数**。 +//! ② 列表返回**扁平 + `isLeaf`/`hasChildren`**(不是嵌套 `children`)—— 前端靠它懒加载。 +//! ③ `enCode` 判重:新建撞码 / 修改撞别人的码 ⇒ `编码已存在`;改自己(码没变)⇒ 放行。 +//! ④ 删除:**有未删子节点 ⇒ 拒绝**(`该节点存在子节点,无法删除`),叶子节点软删。 +//! ⑤ 下拉 `Selector`:只出 `enabledMark=1` 的子节点;`{ids}` 非 `0` 时**递归排除该节点 +//! 及其整棵子树**;每个节点 `isLeaf` 恒 `false`(官方写死,前端据此显示展开箭头)。 +//! ⑥ `GetAreaByIds`:**二维进二维出**(`idsList`),且**按输入顺序回填** —— +//! `IN (...)` 的返回顺序由数据库决定,直接用会乱序;查不到的 id 直接丢弃。 +//! ⑦ 公有变量 `type` 在 VO 里是 **`String`**(DB 是 `INTEGER`)⇒ JSON 里必须是 `"2"` 不是 `2`。 +//! ⑧ `creatorUser` = `realName + "/" + account`,且本仓 `f_creator_user_id` 存的是**账号** +//! ⇒ 查找必须同时认 `f_id` 与 `f_account`(只认 `f_id` 会恒空)。 +//! ⑨ 变量族**零 `@SaCheckPermission`**(官方一处都没写)⇒ 守卫只查登录,**不能顺手加**。 +//! ⑩ 更新**只 SET body 里出现的键**(`updateById` 语义)—— 没传的列保持原值,绝不清空。 +//! +//! 🔴 pglite-rs 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。 +//! 两个族的行各用**自己的 enCode / field 前缀**(`b13_`),断言一律按 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-batch13-it"))), + db: Arc::new(db.clone()), + sessions: Arc::new(SessionStore::default()), + } +} + +/// 按编码取行政区划 id(官方 `create` 返 `null`,拿不到 id ⇒ 只能查库)。 +async fn area_id(en_code: &str) -> String { + let code = en_code.to_string(); + let rows = Db::query_json_params( + db().await, + "SELECT f_id AS \"id\" FROM base_province WHERE f_en_code = $1::text LIMIT 1", + &[&code], + ) + .await + .expect("查行政区划失败"); + assert_eq!(rows.len(), 1, "库里应恰有一行 en_code={en_code}"); + rows[0]["id"].as_str().expect("必须有 id").to_string() +} + +/// 按变量名取 id(同上,`create` 返 `null`)。 +async fn variate_id(field: &str) -> String { + let f = field.to_string(); + let rows = Db::query_json_params( + db().await, + "SELECT f_id AS \"id\" FROM base_common_variate WHERE f_field = $1::text LIMIT 1", + &[&f], + ) + .await + .expect("查公有变量失败"); + assert_eq!(rows.len(), 1, "库里应恰有一行 f_field={field}"); + rows[0]["id"].as_str().expect("必须有 id").to_string() +} + +/// 建一个行政区划,返回它的 id。`parent` 传 `None` ⇒ 根节点。 +async fn mk_area(port: u16, token: &str, en_code: &str, full_name: &str, parent: Option<&str>) -> String { + let body = json!({ + "fullName": full_name, + "enCode": en_code, + "parentId": parent.unwrap_or(""), + "enabledMark": 1, + "sortCode": 1, + "description": "批次13" + }); + let (_, resp) = call(port, "POST", "/api/system/Area", token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 200, "建行政区划 {en_code} 应成功:{resp}"); + area_id(en_code).await +} + +/// 建一个公有变量,返回它的 id。 +async fn mk_variate(port: u16, token: &str, field: &str, vtype: i64, desc: &str) -> String { + let body = json!({ + "field": field, + "value": format!("{field}-值"), + "expression": format!("{field}-表达式"), + "description": desc, + "type": vtype + }); + let (_, resp) = call(port, "POST", "/api/system/Variate", token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 200, "建公有变量 {field} 应成功:{resp}"); + variate_id(field).await +} + +// ---------------------------------------------------------------- 行政区划 + +/// ① ② 树的建法与读法:层级序号服务端推导、列表是**扁平 + 两个标志**。 +#[tokio::test] +async fn area_tree_create_derives_type_and_list_flags() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + // 根:body 里塞了 `"type":"9"` —— 必须被服务端推导覆盖成 "1"。 + let r = mk_area(port, &token, "b13_t_root", "批次13根", None).await; + let c = mk_area(port, &token, "b13_t_child", "批次13子", Some(&r)).await; + let g = mk_area(port, &token, "b13_t_grand", "批次13孙", Some(&c)).await; + + let code = "b13_t_root".to_string(); + #[allow(clippy::type_complexity)] + let rows = Db::query_json_params( + db().await, + "SELECT f_type AS \"t\", COALESCE(f_parent_id,'') AS \"p\" FROM base_province \ + WHERE f_en_code = $1::text", + &[&code], + ) + .await + .expect("查库失败"); + assert_eq!(rows[0]["t"], json!("1"), "根节点 f_type 必须由服务端推导为 1(body 的 9 不作数):{rows:?}"); + assert_eq!(rows[0]["p"], json!("-1"), "parentId 空 ⇒ 必须写 -1:{rows:?}"); + + // 子 / 孙的层级序号 = 父 + 1。 + for (en, want) in [("b13_t_child", "2"), ("b13_t_grand", "3")] { + let code = en.to_string(); + let rows = Db::query_json_params( + db().await, + "SELECT f_type AS \"t\" FROM base_province WHERE f_en_code = $1::text", + &[&code], + ) + .await + .expect("查库失败"); + assert_eq!(rows[0]["t"], json!(want), "{en} 的 f_type 应为 {want}:{rows:?}"); + } + + // ② 列表:根下面只有子;子是「有子节点」。 + let (_, resp) = call(port, "GET", &format!("/api/system/Area/{r}"), &token, None).await; + assert_eq!(resp["code"], 200, "列表应成功:{resp}"); + let list = resp["data"]["list"].as_array().expect("必须是 ListVO"); + assert_eq!(list.len(), 1, "根下应只有一个直接子节点:{resp}"); + assert_eq!(list[0]["id"], json!(c), "根下应是子节点:{resp}"); + assert_eq!(list[0]["hasChildren"], json!(true), "子节点有孙 ⇒ hasChildren=true:{resp}"); + assert_eq!(list[0]["isLeaf"], json!(false), "子节点有孙 ⇒ isLeaf=false:{resp}"); + assert_eq!(list[0]["enabledMark"], json!(1), "enabledMark 必须是数字:{resp}"); + assert!(list[0].get("children").is_none(), "官方是扁平列表,**不能**带 children:{resp}"); + + // ② 孙是叶子。 + let (_, resp) = call(port, "GET", &format!("/api/system/Area/{c}"), &token, None).await; + let list = resp["data"]["list"].as_array().expect("必须是 ListVO"); + assert_eq!(list.len(), 1, "子下应只有一个孙:{resp}"); + assert_eq!(list[0]["id"], json!(g), "{resp}"); + assert_eq!(list[0]["isLeaf"], json!(true), "孙没有子节点 ⇒ isLeaf=true:{resp}"); + assert_eq!(list[0]["hasChildren"], json!(false), "{resp}"); + + // ② 孙下面为空。 + let (_, resp) = call(port, "GET", &format!("/api/system/Area/{g}"), &token, None).await; + assert_eq!(resp["code"], 200, "{resp}"); + assert!(resp["data"]["list"].as_array().unwrap().is_empty(), "孙下面应为空:{resp}"); +} + +/// ③ `enCode` 判重:新建撞码 / 改别人的码 ⇒ 400;改自己(码没变)⇒ 放行。 +#[tokio::test] +async fn area_en_code_unique_on_create_and_update() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + mk_area(port, &token, "b13_dup_a", "批次13甲", None).await; + let b = mk_area(port, &token, "b13_dup_b", "批次13乙", None).await; + + // 新建撞码。 + let body = json!({ "fullName": "又一个甲", "enCode": "b13_dup_a", "parentId": "" }); + let (_, resp) = call(port, "POST", "/api/system/Area", &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 400, "撞码必须失败:{resp}"); + assert_eq!(resp["msg"], "编码已存在", "撞码文案:{resp}"); + + // 改别人的码。 + let body = json!({ "fullName": "批次13乙改", "enCode": "b13_dup_a" }); + let (_, resp) = call(port, "PUT", &format!("/api/system/Area/{b}"), &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 400, "改成别人的码必须失败:{resp}"); + assert_eq!(resp["msg"], "编码已存在", "改码撞车文案:{resp}"); + + // 改自己(码没变)⇒ 放行(判重要排除自己)。 + let body = json!({ "fullName": "批次13乙再改", "enCode": "b13_dup_b" }); + let (_, resp) = call(port, "PUT", &format!("/api/system/Area/{b}"), &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 200, "改自己不该被判重:{resp}"); + let code = "b13_dup_b".to_string(); + let rows = Db::query_json_params( + db().await, + "SELECT f_full_name AS \"n\" FROM base_province WHERE f_en_code = $1::text", + &[&code], + ) + .await + .expect("查库失败"); + assert_eq!(rows[0]["n"], json!("批次13乙再改"), "名称应被改掉:{rows:?}"); +} + +/// ④ 删除:有子节点 ⇒ 拒绝;叶子 ⇒ 软删(不再出现在父的列表里)。 +#[tokio::test] +async fn area_delete_refuses_children_then_soft_deletes_leaf() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let r = mk_area(port, &token, "b13_del_r", "待删根", None).await; + let c = mk_area(port, &token, "b13_del_c", "待删子", Some(&r)).await; + + // 有子 ⇒ 拒绝。 + let (_, resp) = call(port, "DELETE", &format!("/api/system/Area/{r}"), &token, None).await; + assert_eq!(resp["code"], 400, "有子节点必须拒绝删除:{resp}"); + assert_eq!(resp["msg"], "该节点存在子节点,无法删除", "拒删文案:{resp}"); + + // 叶子 ⇒ 通过,且是**软删**。 + let (_, resp) = call(port, "DELETE", &format!("/api/system/Area/{c}"), &token, None).await; + assert_eq!(resp["code"], 200, "叶子应可删:{resp}"); + let rows = Db::query_json_params( + db().await, + "SELECT COALESCE(f_delete_mark, 0) AS \"m\" FROM base_province WHERE f_id = $1::text", + &[&c], + ) + .await + .expect("查库失败"); + assert_eq!(rows[0]["m"], json!(1), "必须是软删(f_delete_mark=1):{rows:?}"); + + // 删完 ⇒ 父的列表里没有它了。 + let (_, resp) = call(port, "GET", &format!("/api/system/Area/{r}"), &token, None).await; + let list = resp["data"]["list"].as_array().expect("必须是 ListVO"); + assert!( + list.iter().all(|x| x["id"] != json!(c)), + "软删的子节点不能再出现:{resp}" + ); +} + +/// ⑤ 下拉:停用的子节点不出现;`{ids}` 递归排除整棵子树;`isLeaf` 恒 false。 +#[tokio::test] +async fn area_selector_hides_disabled_and_excludes_subtree() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let r = mk_area(port, &token, "b13_sel_r", "下拉根", None).await; + let c1 = mk_area(port, &token, "b13_sel_c1", "下拉子一", Some(&r)).await; + let c2 = mk_area(port, &token, "b13_sel_c2", "下拉子二", Some(&r)).await; + let g1 = mk_area(port, &token, "b13_sel_g1", "下拉孙一", Some(&c1)).await; + + // 停用 c2(写语句只能走 `exec_params`:`query_json_params` 会包成子查询,只认 SELECT)。 + Db::exec_params( + db().await, + "UPDATE base_province SET f_enabled_mark = 0 WHERE f_id = $1::text", + &[&c2], + ) + .await + .expect("停用失败"); + + // `-1` ⇒ 只出 c1(c2 停用被滤掉)。 + let (_, resp) = call(port, "GET", &format!("/api/system/Area/{r}/Selector/-1"), &token, None).await; + assert_eq!(resp["code"], 200, "下拉应成功:{resp}"); + let list = resp["data"]["list"].as_array().expect("必须是 ListVO"); + assert_eq!(list.len(), 1, "停用的子节点不该出现:{resp}"); + assert_eq!(list[0]["id"], json!(c1), "{resp}"); + assert_eq!(list[0]["isLeaf"], json!(false), "官方的 Selector 里 isLeaf 恒 false:{resp}"); + + // `{ids}=c1` ⇒ c1 及其整棵子树被排除,剩下只有停用的 c2 ⇒ 空。 + let (_, resp) = call( + port, + "GET", + &format!("/api/system/Area/{r}/Selector/{c1}"), + &token, + None, + ) + .await; + assert_eq!(resp["code"], 200, "{resp}"); + assert!( + resp["data"]["list"].as_array().unwrap().is_empty(), + "c1 及其子树必须被排除、c2 停用 ⇒ 空列表:{resp}" + ); + + // `{ids}=g1` ⇒ 只排除 g1(它不在 r 的直接子节点里) ⇒ c1 仍然出现。 + let (_, resp) = call( + port, + "GET", + &format!("/api/system/Area/{r}/Selector/{g1}"), + &token, + None, + ) + .await; + let list = resp["data"]["list"].as_array().expect("必须是 ListVO"); + assert_eq!(list.len(), 1, "排除 g1 不影响 c1:{resp}"); + assert_eq!(list[0]["id"], json!(c1), "{resp}"); +} + +/// ⑥ 详情:`parentName` 只在有父节点时查;不存在 ⇒ 400。 +#[tokio::test] +async fn area_info_parent_name_and_not_found() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let r = mk_area(port, &token, "b13_info_r", "详情根", None).await; + let c = mk_area(port, &token, "b13_info_c", "详情子", Some(&r)).await; + + let (_, resp) = call(port, "GET", &format!("/api/system/Area/{c}/Info"), &token, None).await; + assert_eq!(resp["code"], 200, "详情应成功:{resp}"); + assert_eq!(resp["data"]["parentId"], json!(r), "{resp}"); + assert_eq!(resp["data"]["parentName"], json!("详情根"), "parentName 要查父节点名称:{resp}"); + assert_eq!(resp["data"]["fullName"], json!("详情子"), "{resp}"); + assert_eq!(resp["data"]["type"], json!("2"), "子节点层级序号是 2:{resp}"); + + // 根节点 ⇒ 没有父名(空串,不是 null)。 + let (_, resp) = call(port, "GET", &format!("/api/system/Area/{r}/Info"), &token, None).await; + assert_eq!(resp["code"], 200, "{resp}"); + assert_eq!(resp["data"]["parentId"], json!("-1"), "{resp}"); + assert_eq!(resp["data"]["parentName"], json!(""), "根节点 parentName 应是空串:{resp}"); + + // 不存在 ⇒ 400。 + let (_, resp) = call(port, "GET", "/api/system/Area/no_such_area/Info", &token, None).await; + assert_eq!(resp["code"], 400, "不存在的行必须失败:{resp}"); + assert_eq!(resp["msg"], "行政区划不存在", "文案:{resp}"); +} + +/// ⑥ `GetAreaByIds`:二维进二维出,**按输入顺序**回填,查不到的直接丢。 +#[tokio::test] +async fn area_get_by_ids_keeps_input_order() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let x = mk_area(port, &token, "b13_ids_x", "区X", None).await; + let y = mk_area(port, &token, "b13_ids_y", "区Y", None).await; + let z = mk_area(port, &token, "b13_ids_z", "区Z", None).await; + + // 第一组故意倒序(z, x),第二组带一个不存在的 id。 + let body = json!({ "idsList": [[z, x], [y, "no_such_area"]] }); + let (_, resp) = call(port, "POST", "/api/system/Area/GetAreaByIds", &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 200, "GetAreaByIds 应成功:{resp}"); + assert_eq!( + resp["data"], + json!([["区Z", "区X"], ["区Y"]]), + "必须二维出、按输入顺序、丢弃查不到的 id:{resp}" + ); + + // 空入参 ⇒ 空数组(不是 400)。 + let body = json!({ "idsList": [] }); + let (_, resp) = call(port, "POST", "/api/system/Area/GetAreaByIds", &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 200, "{resp}"); + assert_eq!(resp["data"], json!([]), "空入参应返回空数组:{resp}"); +} + +// ---------------------------------------------------------------- 公有变量 + +/// ⑦ ⑧ 建/读:`type` 必须是字符串、`creatorUser` 必须真的填上、默认启用。 +#[tokio::test] +async fn variate_crud_type_is_text_and_creator_user_is_filled() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let id = mk_variate(port, &token, "b13_v_main", 2, "主变量").await; + + // 库里的形态:type 是整数、enabledMark 默认 1、creator 存**账号**。 + let rows = Db::query_json_params( + db().await, + "SELECT COALESCE(f_type, -1) AS \"t\", COALESCE(f_enabled_mark, -1) AS \"e\", \ + COALESCE(f_creator_user_id, '') AS \"u\", COALESCE(f_delete_mark, 0) AS \"d\" \ + FROM base_common_variate WHERE f_id = $1::text", + &[&id], + ) + .await + .expect("查库失败"); + assert_eq!(rows[0]["t"], json!(2), "f_type 落库应是整数 2:{rows:?}"); + assert_eq!(rows[0]["e"], json!(1), "新建默认启用:{rows:?}"); + assert_eq!(rows[0]["u"], json!("admin"), "f_creator_user_id 存的是账号:{rows:?}"); + assert_eq!(rows[0]["d"], json!(0), "新建不该是已删:{rows:?}"); + + // 列表:type 是**字符串**、creatorUser = realName/account。 + let (_, resp) = call(port, "GET", "/api/system/Variate?keyword=b13_v_main", &token, None).await; + assert_eq!(resp["code"], 200, "列表应成功:{resp}"); + assert_eq!(resp["data"]["pagination"]["total"], json!(1), "关键词应只命中一条:{resp}"); + let item = &resp["data"]["list"][0]; + assert_eq!(item["id"], json!(id), "{resp}"); + assert_eq!(item["type"], json!("2"), "VO 里 type 必须是字符串 \"2\"(前端判 === '2'):{item}"); + assert_eq!( + item["creatorUser"], + json!("管理员/admin"), + "creatorUser 必须是 realName/account(只认 f_id 会恒空):{item}" + ); + assert_eq!(item["creatorUserId"], json!("admin"), "{item}"); + assert!( + item["creatorTime"].as_i64().unwrap_or(0) > 0, + "creatorTime 应是毫秒时间戳:{item}" + ); + assert_eq!(item["value"], json!("b13_v_main-值"), "{item}"); + assert_eq!(item["expression"], json!("b13_v_main-表达式"), "{item}"); + + // 详情同形。 + let (_, resp) = call(port, "GET", &format!("/api/system/Variate/{id}"), &token, None).await; + assert_eq!(resp["code"], 200, "{resp}"); + assert_eq!(resp["data"]["type"], json!("2"), "{resp}"); + assert_eq!(resp["data"]["creatorUser"], json!("管理员/admin"), "{resp}"); + + // 不存在 ⇒ 400。 + let (_, resp) = call(port, "GET", "/api/system/Variate/no_such_variate", &token, None).await; + assert_eq!(resp["code"], 400, "不存在的变量必须失败:{resp}"); + assert_eq!(resp["msg"], "变量不存在", "文案:{resp}"); +} + +/// ⑨ 列表:`type` 精确 + `keyword` 模糊 field/description + 分页形状。 +#[tokio::test] +async fn variate_list_type_keyword_and_paging() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + mk_variate(port, &token, "b13_pg_a", 1, "pgone").await; + mk_variate(port, &token, "b13_pg_b", 1, "pgtwo").await; + mk_variate(port, &token, "b13_pg_c", 2, "pgthree").await; + + // type 精确 + keyword 命中 field。 + let (_, resp) = call(port, "GET", "/api/system/Variate?keyword=b13_pg&type=1", &token, None).await; + assert_eq!(resp["code"], 200, "{resp}"); + assert_eq!(resp["data"]["pagination"]["total"], json!(2), "type=1 应命中 2 条:{resp}"); + for item in resp["data"]["list"].as_array().expect("必须是 PageListVO") { + assert_eq!(item["type"], json!("1"), "type 过滤必须精确:{item}"); + } + + // keyword 命中 **description**(不是 field)。 + let (_, resp) = call(port, "GET", "/api/system/Variate?keyword=pgthree", &token, None).await; + let list = resp["data"]["list"].as_array().expect("必须是 PageListVO"); + assert_eq!(list.len(), 1, "keyword 也要搜 description:{resp}"); + assert_eq!(list[0]["field"], json!("b13_pg_c"), "{resp}"); + + // 分页:pageSize=2 + 第 2 页 ⇒ 剩 1 条,total 仍是 3。 + let (_, resp) = call( + port, + "GET", + "/api/system/Variate?keyword=b13_pg&pageSize=2¤tPage=2", + &token, + None, + ) + .await; + assert_eq!(resp["code"], 200, "{resp}"); + assert_eq!(resp["data"]["pagination"]["total"], json!(3), "{resp}"); + assert_eq!(resp["data"]["pagination"]["currentPage"], json!(2), "{resp}"); + assert_eq!(resp["data"]["pagination"]["pageSize"], json!(2), "{resp}"); + assert_eq!( + resp["data"]["list"].as_array().unwrap().len(), + 1, + "第 2 页应剩 1 条:{resp}" + ); +} + +/// ③ ⑩ 变量名判重 + 更新**只写 body 里出现的键**。 +#[tokio::test] +async fn variate_field_unique_and_update_only_present_keys() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + mk_variate(port, &token, "b13_uniq_a", 1, "判重甲").await; + let b = mk_variate(port, &token, "b13_uniq_b", 1, "判重乙").await; + + // 新建撞名。 + let body = json!({ "field": "b13_uniq_a", "value": "x", "type": 1 }); + let (_, resp) = call(port, "POST", "/api/system/Variate", &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 400, "撞名必须失败:{resp}"); + assert_eq!(resp["msg"], "变量名已存在", "撞名文案:{resp}"); + + // 改成别人的名字 ⇒ 400;改自己的名字(没变)⇒ 200。 + let body = json!({ "field": "b13_uniq_a" }); + let (_, resp) = call(port, "PUT", &format!("/api/system/Variate/{b}"), &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 400, "改成别人的变量名必须失败:{resp}"); + let body = json!({ "field": "b13_uniq_b" }); + let (_, resp) = call(port, "PUT", &format!("/api/system/Variate/{b}"), &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 200, "改自己不该被判重:{resp}"); + + // ⑩ 只传 description ⇒ 其余列原样保留。 + let id = mk_variate(port, &token, "b13_patch", 1, "原描述").await; + let body = json!({ "description": "改过的描述" }); + let (_, resp) = call(port, "PUT", &format!("/api/system/Variate/{id}"), &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 200, "局部更新应成功:{resp}"); + + let (_, resp) = call(port, "GET", &format!("/api/system/Variate/{id}"), &token, None).await; + assert_eq!(resp["data"]["description"], json!("改过的描述"), "{resp}"); + assert_eq!(resp["data"]["field"], json!("b13_patch"), "没传的 field 不能被清空:{resp}"); + assert_eq!(resp["data"]["value"], json!("b13_patch-值"), "没传的 value 不能被清空:{resp}"); + assert_eq!( + resp["data"]["expression"], + json!("b13_patch-表达式"), + "没传的 expression 不能被清空:{resp}" + ); + assert_eq!(resp["data"]["type"], json!("1"), "没传的 type 不能被清空:{resp}"); + assert_eq!( + resp["data"]["lastModifyUserId"], + json!("admin"), + "改过之后要记最后修改人:{resp}" + ); + + // ⑩ 只传 type ⇒ 只动 type。 + let body = json!({ "type": 3 }); + let (_, resp) = call(port, "PUT", &format!("/api/system/Variate/{id}"), &token, Some(&body.to_string())).await; + assert_eq!(resp["code"], 200, "{resp}"); + let (_, resp) = call(port, "GET", &format!("/api/system/Variate/{id}"), &token, None).await; + assert_eq!(resp["data"]["type"], json!("3"), "type 应改成 3(仍是字符串):{resp}"); + assert_eq!( + resp["data"]["description"], + json!("改过的描述"), + "只改 type 时描述不能被回退:{resp}" + ); +} + +/// 软删 + 幂等:删两次都 200,列表里消失。 +#[tokio::test] +async fn variate_delete_is_soft_and_idempotent() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let id = mk_variate(port, &token, "b13_del_v", 1, "待删变量").await; + + let (_, resp) = call(port, "DELETE", &format!("/api/system/Variate/{id}"), &token, None).await; + assert_eq!(resp["code"], 200, "删除应成功:{resp}"); + let rows = Db::query_json_params( + db().await, + "SELECT COALESCE(f_delete_mark, 0) AS \"m\" FROM base_common_variate WHERE f_id = $1::text", + &[&id], + ) + .await + .expect("查库失败"); + assert_eq!(rows[0]["m"], json!(1), "必须是软删:{rows:?}"); + + let (_, resp) = call(port, "GET", "/api/system/Variate?keyword=b13_del_v", &token, None).await; + assert_eq!(resp["data"]["pagination"]["total"], json!(0), "删掉的不该再出现:{resp}"); + + // 幂等:再删一次也 200(不是 400)。 + let (_, resp) = call(port, "DELETE", &format!("/api/system/Variate/{id}"), &token, None).await; + assert_eq!(resp["code"], 200, "重复删除应幂等:{resp}"); +} + +/// 下拉(大小写不敏感)+ 函数分类(11 个固定枚举)。 +#[tokio::test] +async fn variate_selector_case_insensitive_and_func_category() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + mk_variate(port, &token, "b13_MyVar", 1, "大小写").await; + + // 小写关键词 ⇒ 命中大写的变量名(官方用 toUpperCase 比)。 + let (_, resp) = call(port, "GET", "/api/system/Variate/selector?keyword=b13_myvar", &token, None).await; + assert_eq!(resp["code"], 200, "下拉应成功:{resp}"); + let list = resp["data"]["list"].as_array().expect("必须是 ListVO"); + let hit = list + .iter() + .find(|x| x["field"] == json!("b13_MyVar")) + .unwrap_or_else(|| panic!("大小写不敏感的关键词应命中:{resp}")); + assert_eq!(hit["value"], json!("b13_MyVar-值"), "{hit}"); + assert_eq!(hit["type"], json!("1"), "下拉里 type 也是字符串:{hit}"); + assert!( + hit.get("creatorUser").is_none(), + "下拉不返回 creatorUser(官方 selector 只给 6 个字段):{hit}" + ); + + // 函数分类:11 条固定枚举,ALL 在最前。 + let (_, resp) = call(port, "GET", "/api/system/Variate/sysfunccategory", &token, None).await; + assert_eq!(resp["code"], 200, "函数分类应成功:{resp}"); + let cats = resp["data"]["list"].as_array().expect("必须是 ListVO"); + assert_eq!(cats.len(), 11, "官方 FunctionCategory 是 11 个:{resp}"); + assert_eq!(cats[0]["field"], json!("ALL"), "ALL 必须在最前:{resp}"); + assert_eq!(cats[0]["description"], json!("全部函数"), "{resp}"); + assert_eq!(cats[10]["field"], json!("LOGIC"), "{resp}"); + assert_eq!(cats[10]["description"], json!("逻辑函数"), "{resp}"); +} + +/// ⑨ 未登录:两族都必须 602(面 B 判据 —— 600 会让前端卡死不跳登录)。 +#[tokio::test] +async fn area_and_variate_require_login_602() { + let _g = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + + for path in [ + "/api/system/Area/-1", + "/api/system/Area/x/Selector/-1", + "/api/system/Variate", + "/api/system/Variate/selector", + "/api/system/Variate/sysfunccategory", + ] { + let (status, resp) = call(port, "GET", path, "", None).await; + assert!(status.contains("200"), "业务失败恒 HTTP 200({path}):{status}"); + assert_eq!(resp["code"], 602, "{path} 未登录必须是 602:{resp}"); + } +} diff --git a/src/backend/tests/batch6_it.rs b/src/backend/tests/batch6_it.rs index 8b03e98..60fed8b 100644 --- a/src/backend/tests/batch6_it.rs +++ b/src/backend/tests/batch6_it.rs @@ -382,11 +382,17 @@ async fn data_model_tables_info_and_fields() { let total = tables["data"]["pagination"]["total"] .as_i64() .expect("必须有 total"); - // schema.sql 现在是 52 张表(批次 9 新增 6 张:数据接口 + 接口认证 + 打印模板/版本; - // 批次 10 新增 6 张:签章 + 签章授权人 + 按钮/列表/表单权限 + 高级查询方案; - // 批次 11 新增 3 张:base_module_authorize / base_module_scheme / base_module_link); - // 真有变化时这条会红,提醒同步(与 DDL 计数测试同口径)。 - assert_eq!(total, 52, "表清单必须来自 information_schema: {tables}"); + // 🔴 **不写死表数**(批次 13 改):库里真实的表 = `schema.sql` 建的 + **业务包自带**的 + // (`packs//schema/*.sql`,启动时按包执行)。写死一个数字 ⇒ 加一张表 / 加一个包 + // 就要改这条测试 ⇒ 把「内核测试」和「业务包」错耦合,而真正要守的是 + // 「清单来自 information_schema、不是别处抄来的清单」—— 用同一个推导源比才对得上 + // (与 `routes.rs::health_reports_ok_tables_and_version` 同口径)。 + let expected = ssw_platform::platform::db::ddl_tables().len() + + ssw_platform::bootstrap::packs().map(|r| r.ddls.len()).unwrap_or(0); + assert_eq!( + total as usize, expected, + "表清单必须来自 information_schema(应为 ddl_tables + 包表 = {expected}): {tables}" + ); let list = tables["data"]["list"].as_array().expect("必须有 list"); assert!( list.iter().any(|r| r["table"] == "base_user"),