feat(face-b): 系统数据两族落地(面 B 批次 13,+14 端点)

行政区划 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 的表清单)。
This commit is contained in:
admin committed 2026-11-02 08:24:20 +08:00
1 parent 21c69ee85d
commit db0ad57921
10 files changed
+1818 -334

No files matched your search

+2 -2
View File
@@ -50,7 +50,7 @@ pub const SCHEMA_SQL: &str = include_str!("../../../src/backend/db/schema.sql");
/// (闸门查「孤儿 DDL」会红 ⇒ 两处都改才算登记完成)⇒ 数量写死是**有意的护栏**;
/// - 业务表 = **业务包**的责任 ⇒ 住 `packs/<app>/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 张)—— 清单**写死**(名字列表,不是数字):
+33 -1
View File
@@ -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
<!-- PACK:BEGIN -->
# 🔴 以下由 `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 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败)
+52 -45
View File
@@ -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:
+1 -1
View File
@@ -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」
+50
View File
@@ -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)
);
+6 -1
View File
@@ -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",
];
/// 命令行解析的结果(**纯数据**,便于单测)。
+883
View File
@@ -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<String>,
values: Vec<Option<String>>,
}
impl Inserts {
/// 绑定参数列:自动分配 `$N` 并记下值。
fn param(&mut self, col: &'static str, cast: &str, value: Option<String>) {
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<String>`),
/// 而整数 / 大整数列**必须先 `::text` 再转**。写成 `$1::integer` 会被 PG 把**参数本身**
/// 推断成 `int4` ⇒ 绑 `Option<String>` 直接报
/// `cannot convert between the Rust type Option<String> 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<HashSet<String>, 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<ProvinceListVO>`)。
///
/// 🔴 官方返回的是**扁平列表 + `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<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
raw: RawQuery,
) -> Json<ActionResult> {
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<Option<String>> = 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, &params_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<Value> = 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<AppState>,
headers: HeaderMap,
Path((id, ids)): Path<(String, String)>,
) -> Json<ActionResult> {
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, &params_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<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
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, &params_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",
&params_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<bool, pglite::Error> {
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,
&params_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<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
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",
&params_of(&[Some(parent_id.clone())]),
)
.await
.unwrap_or_default();
rows.first()
.and_then(|r| r["t"].as_str())
.and_then(|s| s.parse::<i64>().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 (<inner>) q` —— 只认 SELECT,
// INSERT 塞进去就是 `syntax error at or near "INTO"`。
if let Err(e) = state.db.exec_params(&sql, &params_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<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
body: Bytes,
) -> Json<ActionResult> {
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<String> = Vec::new();
let mut values: Vec<Option<String>> = 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, &params_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<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
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",
&params_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, &params_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<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
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<Vec<String>> = 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::<Vec<_>>()
})
.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<String> = 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",
&params_of(&[Some(joined)]),
)
.await
{
Ok(rows) => rows,
Err(e) => return db_error(e, "行政区划名称查询"),
};
let mut names: HashMap<String, String> = 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<Value> = 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<CommonVariateVO>`)。
///
/// 过滤口径(官方 `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<AppState>,
headers: HeaderMap,
raw: RawQuery,
) -> Json<ActionResult> {
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<Option<String>> = 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, &params_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, &params_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<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
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, &params_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<bool, pglite::Error> {
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",
&params_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<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
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<String>`)。
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, &params_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<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
body: Bytes,
) -> Json<ActionResult> {
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<String> = Vec::new();
let mut values: Vec<Option<String>> = 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, &params_of(&values)).await {
return db_error(e, "公有变量修改");
}
ok(Value::Null)
}
/// `DELETE /api/system/Variate/{id}` —— 软删(幂等)。
pub async fn variate_delete(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
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, &params_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<AppState>,
headers: HeaderMap,
raw: RawQuery,
) -> Json<ActionResult> {
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<Option<String>> = 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, &params_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<AppState>,
headers: HeaderMap,
) -> Json<ActionResult> {
if let Err(resp) = require_login_face_b(&state, &headers).await {
return resp;
}
let list: Vec<Value> = 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::*;
+99 -279
View File
@@ -1061,6 +1061,42 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
.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<String> {
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<String> = 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`。
+681
View File
@@ -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<Db> = OnceCell::const_new();
static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
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&currentPage=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}");
}
}
+11 -5
View File
@@ -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/<app>/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"),