feat(face-b): 数据权限三件套落地(面 B 批次 11,+15 端点)

ModuleDataAuthorize(6) + ModuleDataAuthorizeScheme(5) + ModuleDataAuthorizeLink(4)
= 15 端点 / 3 张新表(base_module_authorize / base_module_scheme / base_module_link)。

- enCode 前缀化:type=3 菜单 + bindTable 非空 ⇒ 落库存 bindTable.enCode,读回剥前缀;
  create 用 fieldRule!=0、update 用 fieldRule==1(对齐官方两处判据)。
- delete 前遍历方案 conditionJson 比对 field(带前缀、equalsIgnoreCase)⇒ SYS020 拦截。
- 方案双判重(EXIST001/EXIST002)、列表仅需登录、allData==1 ⇒ SYS021 拦截。
- 诚实降级:FieldList 与表字段端点依赖低代码表单/数据库内省 ⇒ 返回空数组/空 PageListVO。

顺手修 4 个真 bug:
- b10_insert 把 None 当 now() 绑定 ⇒ 整型列类型错(f_all_data / f_type / f_field_rule ×2)。
- 写路径补齐「只 SET body 里出现的键」:enCode / linkId / linkTables 缺省时保持原值。
- getVisualTables / getInfo 查 f_type(int4)缺 ::text::integer CAST ⇒ 协议类型错。
- batch10 测试跨用例污染:列表权限批量断言写死 0 ⇒ 改为基线相对。
This commit is contained in:
admin committed 2026-11-01 19:06:44 +08:00
1 parent 2c12091d55
commit 4b14ecd96f
9 files changed
+1457 -18

No files matched your search

+72
View File
@@ -1298,3 +1298,75 @@ CREATE TABLE base_advanced_query_scheme (
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- 🔴 数据权限三件套(批次 11,2026-11-01):官方 DDL 逐字(base_module_authorize /
-- base_module_scheme / base_module_link)。注意表名与控制器名不一致:控制器叫
-- ModuleDataAuthorize*,但实体 @TableName 是 base_module_authorize / base_module_scheme /
-- base_module_link(不是 base_module_data_authorize_*)。
CREATE TABLE base_module_authorize (
f_id VARCHAR(50) NOT NULL,
f_full_name VARCHAR(200),
f_en_code VARCHAR(200),
f_type VARCHAR(50),
f_condition_symbol VARCHAR(500),
f_condition_text VARCHAR(500),
f_property_json TEXT,
f_module_id VARCHAR(50),
f_field_rule INTEGER,
f_child_table_key VARCHAR(50),
f_bind_table VARCHAR(50),
f_format VARCHAR(20),
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)
);
CREATE TABLE base_module_scheme (
f_id VARCHAR(50) NOT NULL,
f_en_code VARCHAR(200),
f_full_name VARCHAR(100),
f_condition_json TEXT,
f_condition_text VARCHAR(500),
f_description VARCHAR(500),
f_module_id VARCHAR(50),
f_all_data INTEGER,
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_match_logic VARCHAR(50),
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)
);
CREATE TABLE base_module_link (
f_id VARCHAR(50) NOT NULL,
f_link_id VARCHAR(50),
f_link_tables VARCHAR(200),
f_module_id VARCHAR(50),
f_type INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
+9 -2
View File
@@ -52,8 +52,9 @@ use ssw_platform::routes;
/// `base_data_interface_log` / `base_print_template` / `base_print_version`;
/// 权限配置批次(2026-11-01)新增 `base_signature` / `base_signature_user` /
/// `base_module_button` / `base_module_column` / `base_module_form` /
/// `base_advanced_query_scheme`,故清单现在是 **45 张**。
const BASE_TABLES: [&str; 45] = [
/// `base_advanced_query_scheme`;**数据权限三件套**(2026-11-01 批次 11)
/// `base_module_authorize` / `base_module_scheme` / `base_module_link`,故清单现在是 **48 张**。
const BASE_TABLES: [&str; 48] = [
"base_group",
"base_user",
"base_role",
@@ -108,6 +109,12 @@ const BASE_TABLES: [&str; 45] = [
"base_module_column",
"base_module_form",
"base_advanced_query_scheme",
// 🔴 数据权限三件套(2026-11-01 批次 11):表名与控制器名不一致
// (ModuleDataAuthorize* → base_module_authorize / base_module_scheme / base_module_link),
// 都是官方 DDL 逐字,属于平台权限基础设施。
"base_module_authorize",
"base_module_scheme",
"base_module_link",
// 🔴 低代码两张表是**平台表**不是业务表:它们存的是「功能定义」,
// 任何业务模块都会用,属于引擎基础设施。
"base_visual_dev",
+814 -2
View File
@@ -19438,7 +19438,8 @@ pub async fn module_column_batch_create(
("f_module_id", "", Some(module_id.clone())),
("f_bind_table", "", Some(bind_table.clone())),
("f_bind_table_name", "", Some(bind_table_name.clone())),
("f_field_rule", "::integer", field_rule.map(|v| v.to_string())),
// 🔴 缺省按官方默认 0;`None` 会被 `b10_insert` 当 `now()` 绑定 ⇒ 整型列类型错。
("f_field_rule", "::integer", Some(field_rule.unwrap_or(0).to_string())),
("f_child_table_key", "", Some(child_table_key.clone())),
("f_enabled_mark", "::integer", Some("1".to_string())),
("f_sort_code", "::bigint", Some(sort_code.to_string())),
@@ -19829,7 +19830,8 @@ pub async fn module_form_batch_create(
("f_description", "", Some(description.clone())),
("f_module_id", "", Some(module_id.clone())),
("f_bind_table", "", Some(bind_table.clone())),
("f_field_rule", "::integer", field_rule.map(|v| v.to_string())),
// 🔴 缺省按官方默认 0;`None` 会被 `b10_insert` 当 `now()` 绑定 ⇒ 整型列类型错。
("f_field_rule", "::integer", Some(field_rule.unwrap_or(0).to_string())),
("f_child_table_key", "", Some(child_table_key.clone())),
("f_enabled_mark", "::integer", Some("1".to_string())),
("f_sort_code", "::bigint", Some(sort_code.to_string())),
@@ -20066,6 +20068,816 @@ pub async fn advanced_query_delete(
ok(Value::Null)
}
// ============================================================ 数据权限三件套(批次 11)
// 官方表:base_module_authorize / base_module_scheme / base_module_link
// 官方控制器:ModuleDataAuthorizeController / ModuleDataAuthorizeSchemeController /
// ModuleDataAuthorizeLinkController
// 🔴 点权限判据:除「方案列表」只需登录外,其余均 OR 两码 `{"permission.resource","appConfig.appResource"}`。
// 🔴 表名与控制器名不一致:控制器 `ModuleDataAuthorize*` ⇒ 实体 `base_module_authorize/scheme/link`。
const MODULE_DATA_AUTHORIZE_COLUMNS: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \
f_format AS \"format\", f_en_code AS \"enCode\", f_type AS \"type\", \
f_condition_symbol AS \"conditionSymbol\", f_condition_text AS \"conditionText\", \
COALESCE(f_field_rule, 0) AS \"fieldRule\", f_bind_table AS \"bindTable\", \
f_child_table_key AS \"childTableKey\"";
const MODULE_DATA_AUTHORIZE_INFO_COLUMNS: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \
f_en_code AS \"enCode\", f_type AS \"type\", f_condition_symbol AS \"conditionSymbol\", \
f_condition_text AS \"conditionText\", f_module_id AS \"moduleId\", \
f_description AS \"description\", COALESCE(f_field_rule, 0) AS \"fieldRule\", \
f_bind_table AS \"bindTable\", f_child_table_key AS \"childTableKey\", f_format AS \"format\"";
const MODULE_DATA_AUTHORIZE_SCHEME_COLUMNS: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \
f_condition_text AS \"conditionText\", f_en_code AS \"enCode\", \
COALESCE(f_all_data, 0) AS \"allData\", f_match_logic AS \"matchLogic\"";
const MODULE_DATA_AUTHORIZE_SCHEME_INFO_COLUMNS: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \
f_condition_text AS \"conditionText\", f_condition_json AS \"conditionJson\", \
f_module_id AS \"moduleId\", f_en_code AS \"enCode\", COALESCE(f_all_data, 0) AS \"allData\", \
f_match_logic AS \"matchLogic\"";
/// 官方 `SearchMethodEnum` 解码(conditionSymbol → 中文名);找不到 ⇒ `None`(官方跳过不拼)。
fn b11_search_method_name_opt(symbol: &str) -> Option<&'static str> {
match symbol {
"==" => Some("等于"),
"between" => Some("介于"),
"<>" => Some("不等于"),
">" => Some("大于"),
">=" => Some("大于等于"),
"<" => Some("小于"),
"<=" => Some("小于等于"),
"in" => Some("包含任意一个"),
"notIn" => Some("不包含任意一个"),
"null" => Some("为空"),
"notNull" => Some("不为空"),
"like" => Some("包含"),
"notLike" => Some("不包含"),
"and" => Some("并且"),
"or" => Some("或者"),
_ => None,
}
}
/// 官方 `AuthorizeConditionEnum` 解码(conditionText → 中文名);找不到 ⇒ `None`(官方跳过不拼)。
fn b11_authorize_condition_name(cond: &str) -> Option<&'static str> {
match cond {
"@formId" => Some("表单主键"),
"@userId" => Some("当前用户"),
"@userAndSub" => Some("当前用户及下属"),
"@userAndProgeny" => Some("当前用户及子孙下属"),
"@organizeId" => Some("当前组织"),
"@organizeAndSub" => Some("当前组织及子组织"),
"@organizeAndProgeny" => Some("当前组织及子组织"),
"@positionId" => Some("当前岗位"),
"@positionAndSub" => Some("当前岗位及子岗位"),
"@positionAndProgeny" => Some("当前岗位及子岗位"),
"@currentTime" => Some("当前时间"),
"input" => Some("任意文本"),
"datePicker" => Some("日期选择"),
"inputNumber" => Some("数字输入"),
"organizeSelect" => Some("组织选择"),
"depSelect" => Some("部门选择"),
"posSelect" => Some("岗位选择"),
"roleSelect" => Some("角色选择"),
"groupSelect" => Some("分组选择"),
"userSelect" => Some("用户选择"),
_ => None,
}
}
/// 官方列表/详情里**剥掉** `bindTable + "."` 前缀(仅当 bindTable 非空)。
fn b11_strip_bind_prefix(en_code: &str, bind_table: Option<&str>) -> String {
match bind_table {
Some(bt) if !bt.is_empty() => en_code.replace(&format!("{}.", bt), ""),
_ => en_code.to_string(),
}
}
/// 把逗号分隔的枚举值(conditionSymbol / conditionText)解码为逗号分隔的中文名。
fn b11_decode_joined(raw: &str, decode: fn(&str) -> Option<&'static str>) -> String {
if raw.is_empty() {
return String::new();
}
raw.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.filter_map(decode)
.collect::<Vec<_>>()
.join(",")
}
/// 菜单类型(`base_module.f_type`);菜单不存在 ⇒ `None`。
async fn b11_module_type_of(state: &AppState, module_id: &str) -> Option<i64> {
if module_id.is_empty() {
return None;
}
state
.db
.query_json_params(
"SELECT COALESCE(f_type, 0) AS \"t\" FROM base_module WHERE f_id = $1 \
AND COALESCE(f_delete_mark, 0) = 0 LIMIT 1",
&params_of(&[Some(module_id.to_string())]),
)
.await
.ok()
.and_then(|rows| rows.into_iter().next())
.and_then(|r| r.get("t").and_then(Value::as_i64))
}
/// 数据权限字段可写字段(`DataAuthorizeCrForm` / `DataAuthorizeUpForm`)。
/// 🔴 `f_property_json` 存的是 `childTableKey`(官方 create 把它写进 `propertyJson`)。
/// 🔴 **值为 JSON null / 缺省 ⇒ 整个键跳过**(对齐官方 Mybatis 的 NOT_NULL 策略):
/// `b10_insert` 会把 `None` 当 `now()` 绑定 ⇒ 文本/整型列会类型错;
/// `b10_update` 则是「保持原值」,与官方「null 字段不参与 SET」一致。
fn b11_authorize_write(obj: &Map<String, Value>) -> Vec<(&'static str, &'static str, Option<String>)> {
let mut out = Vec::new();
for (json_key, column, cast) in [
("fullName", "f_full_name", ""),
("enCode", "f_en_code", ""),
("type", "f_type", ""),
("conditionSymbol", "f_condition_symbol", ""),
("conditionText", "f_condition_text", ""),
("description", "f_description", ""),
("moduleId", "f_module_id", ""),
("fieldRule", "f_field_rule", "::integer"),
("bindTable", "f_bind_table", ""),
("format", "f_format", ""),
("childTableKey", "f_child_table_key", ""),
] {
if let Some(v) = value_to_text(obj.get(json_key)) {
out.push((column, cast, Some(v)));
}
}
if let Some(v) = value_to_text(obj.get("childTableKey")) {
out.push(("f_property_json", "", Some(v)));
}
out
}
/// 数据权限方案「名称」判重(官方 `isExistByFullName`)。
async fn b11_scheme_name_exists(
state: &AppState,
module_id: &str,
name: &str,
id: Option<&str>,
) -> Result<bool, String> {
let rows = state
.db
.query_json_params(
"SELECT COUNT(*)::bigint AS \"total\" FROM base_module_scheme \
WHERE COALESCE(f_delete_mark, 0) = 0 AND f_module_id = $1 AND f_full_name = $2 \
AND ($3::text IS NULL OR f_id <> $3::text)",
&params_of(&[Some(module_id.to_string()), Some(name.to_string()), id.map(str::to_string)]),
)
.await
.map_err(|e| e.to_string())?;
Ok(rows
.first()
.and_then(|r| r.get("total").and_then(Value::as_i64))
.unwrap_or(0)
> 0)
}
/// 数据权限方案「编码」判重(官方 `isExistByEnCode`)。
async fn b11_scheme_code_exists(
state: &AppState,
module_id: &str,
code: &str,
id: Option<&str>,
) -> Result<bool, String> {
let rows = state
.db
.query_json_params(
"SELECT COUNT(*)::bigint AS \"total\" FROM base_module_scheme \
WHERE COALESCE(f_delete_mark, 0) = 0 AND f_module_id = $1 AND f_en_code = $2 \
AND ($3::text IS NULL OR f_id <> $3::text)",
&params_of(&[Some(module_id.to_string()), Some(code.to_string()), id.map(str::to_string)]),
)
.await
.map_err(|e| e.to_string())?;
Ok(rows
.first()
.and_then(|r| r.get("total").and_then(Value::as_i64))
.unwrap_or(0)
> 0)
}
/// 删除数据权限字段时,检查是否被某方案引用(官方 `delete` 的 SYS020 逻辑)。
/// 返回 `Some(方案名)` 表示被引用;`None` 表示安全。
async fn b11_authorize_scheme_references(
state: &AppState,
module_id: &str,
en_code: &str,
) -> Result<Option<String>, String> {
let rows = state
.db
.query_json_params(
"SELECT f_full_name AS \"fullName\", f_condition_json AS \"conditionJson\" \
FROM base_module_scheme WHERE COALESCE(f_delete_mark, 0) = 0 AND f_module_id = $1",
&params_of(&[Some(module_id.to_string())]),
)
.await
.map_err(|e| e.to_string())?;
for scheme in &rows {
let full_name = scheme
.get("fullName")
.and_then(Value::as_str)
.unwrap_or_default()
.to_string();
let Some(condition_json) = scheme.get("conditionJson").and_then(Value::as_str) else {
continue;
};
let Ok(models) = serde_json::from_str::<Vec<Value>>(condition_json) else {
continue;
};
for model in &models {
let Some(groups) = model.get("groups").and_then(Value::as_array) else {
continue;
};
for item in groups {
let Some(field) = item.get("field").and_then(Value::as_str) else {
continue;
};
if field.eq_ignore_ascii_case(en_code) {
return Ok(Some(full_name));
}
}
}
}
Ok(None)
}
// ---- 数据权限字段(ModuleDataAuthorize)----
/// 数据权限字段列表(官方 `GET /{moduleId}/List` ⇒ `ListVO<DataAuthorizeListVO>`)。
pub async fn module_data_authorize_list(
State(state): State<AppState>,
headers: HeaderMap,
Path(module_id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
return resp;
}
let rows = match state
.db
.query_json_params(
&format!(
"SELECT {MODULE_DATA_AUTHORIZE_COLUMNS} FROM base_module_authorize \
WHERE COALESCE(f_delete_mark, 0) = 0 AND f_module_id = $1 \
ORDER BY f_sort_code ASC, f_creator_time DESC"
),
&params_of(&[Some(module_id)]),
)
.await
{
Ok(rows) => rows,
Err(e) => return db_error(e, "数据权限字段列表"),
};
let list: Vec<Value> = rows
.iter()
.map(|r| {
let mut v = r.clone();
let symbol = r.get("conditionSymbol").and_then(Value::as_str).unwrap_or_default();
let cond = r.get("conditionText").and_then(Value::as_str).unwrap_or_default();
v["conditionSymbolName"] =
Value::String(b11_decode_joined(symbol, b11_search_method_name_opt));
v["conditionName"] = Value::String(b11_decode_joined(cond, b11_authorize_condition_name));
let raw_code = r.get("enCode").and_then(Value::as_str).unwrap_or_default();
let bind_table = r.get("bindTable").and_then(Value::as_str);
v["enCode"] = Value::String(b11_strip_bind_prefix(raw_code, bind_table));
v
})
.collect();
ok(list_vo(list))
}
/// 数据权限字段下拉(官方 `GET /{moduleId}/FieldList` ⇒ `List<Map>`)。
/// 🔴 官方依赖低代码表单字段解析(visualdevServiceImpl + 递归表单),本仓无该能力 ⇒ 诚实返回空数组。
pub async fn module_data_authorize_field_list(
State(state): State<AppState>,
headers: HeaderMap,
Path(_module_id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
return resp;
}
ok(json!([]))
}
/// 数据权限字段详情(官方 `GET /{id}` ⇒ `DataAuthorizeInfoVO`)。
pub async fn module_data_authorize_info(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
return resp;
}
let row = match b10_fetch(&state, "base_module_authorize", MODULE_DATA_AUTHORIZE_INFO_COLUMNS, &id).await {
Ok(row) => row,
Err(e) => return b10_error(e, "查询数据权限字段"),
};
let Some(mut row) = row else {
return fail(code::FAIL, "数据不存在");
};
let raw_code = row.get("enCode").and_then(Value::as_str).unwrap_or_default().to_string();
let bind_table = row.get("bindTable").and_then(Value::as_str).map(str::to_string);
row["enCode"] = Value::String(b11_strip_bind_prefix(&raw_code, bind_table.as_deref()));
ok(row)
}
/// 新建数据权限字段(官方 `POST` ⇒ `MsgCode.SU001`)。
pub async fn module_data_authorize_create(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
Ok(user) => user,
Err(resp) => return resp,
};
let obj = match parse_body(&body) {
Ok(Value::Object(obj)) => obj,
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
let module_id = b10_str_of(&obj, "moduleId");
let module_type = b11_module_type_of(&state, &module_id).await;
// 🔴 前缀化:module.type==3 && fieldRule != 0 && bindTable 非空 ⇒ enCode = bindTable + "." + enCode
let mut final_en_code = b10_str_of(&obj, "enCode");
if module_type == Some(3) {
let field_rule = b10_int_of(&obj, "fieldRule").unwrap_or(0);
let bind_table = b10_str_of(&obj, "bindTable");
if field_rule != 0 && !bind_table.is_empty() {
final_en_code = format!("{}.{}", bind_table, final_en_code);
}
}
let id = new_uuid();
let mut cols: Vec<(&'static str, &'static str, Option<String>)> = vec![
("f_id", "", Some(id.clone())),
("f_creator_user_id", "", Some(user.user_id.clone())),
("f_creator_time", "", None),
];
cols.extend(b11_authorize_write(&obj));
cols.retain(|(c, _, _)| *c != "f_en_code");
cols.push(("f_en_code", "", Some(final_en_code)));
if let Err(e) = b10_insert(&state, "base_module_authorize", &cols).await {
return b10_error(e, "新建数据权限字段");
}
ok(json!({ "id": id }))
}
/// 更新数据权限字段(官方 `PUT /{id}` ⇒ `FA002 / SU004`)。
pub async fn module_data_authorize_update(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
Ok(user) => user,
Err(resp) => return resp,
};
let obj = match parse_body(&body) {
Ok(Value::Object(obj)) => obj,
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
let exists = match b10_fetch(&state, "base_module_authorize", "f_id AS \"id\"", &id).await {
Ok(row) => row.is_some(),
Err(e) => return b10_error(e, "查询数据权限字段"),
};
if !exists {
return fail(code::FAIL, "更新失败,数据不存在");
}
let module_id = b10_str_of(&obj, "moduleId");
let module_type = b11_module_type_of(&state, &module_id).await;
let mut sets = b11_authorize_write(&obj);
sets.retain(|(c, _, _)| *c != "f_en_code");
// 🔴 官方是 `updateById(entity)`(Mybatis 只 SET **实体里非 null** 的字段)⇒
// body 没带 `enCode` 时**保持原值**,不能写成空串。
if obj.contains_key("enCode") {
// 🔴 前缀化:module.type==3 && fieldRule == 1 && bindTable 非空 ⇒ enCode = bindTable + "." + enCode
let mut final_en_code = b10_str_of(&obj, "enCode");
if module_type == Some(3) {
let field_rule = b10_int_of(&obj, "fieldRule").unwrap_or(0);
let bind_table = b10_str_of(&obj, "bindTable");
if field_rule == 1 && !bind_table.is_empty() {
final_en_code = format!("{}.{}", bind_table, final_en_code);
}
}
sets.push(("f_en_code", "", Some(final_en_code)));
}
if let Err(e) = b10_update(&state, "base_module_authorize", &id, &sets, &user.user_id).await {
return b10_error(e, "修改数据权限字段");
}
ok(Value::Null)
}
/// 删除数据权限字段(官方 `DELETE /{id}` ⇒ `SYS020 / SU003`)。
pub async fn module_data_authorize_delete(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
let user = match guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
Ok(user) => user,
Err(resp) => return resp,
};
let row = match b10_fetch(
&state,
"base_module_authorize",
"f_id AS \"id\", f_module_id AS \"moduleId\", f_en_code AS \"enCode\"",
&id,
)
.await
{
Ok(row) => row,
Err(e) => return b10_error(e, "查询数据权限字段"),
};
let Some(row) = row else {
return fail(code::FAIL, "删除失败,数据不存在");
};
let module_id = row.get("moduleId").and_then(Value::as_str).unwrap_or_default().to_string();
let en_code = row.get("enCode").and_then(Value::as_str).unwrap_or_default().to_string();
// 🔴 比对用**原始带前缀** enCode(库里存的就是带前缀的)
match b11_authorize_scheme_references(&state, &module_id, &en_code).await {
Ok(Some(scheme_name)) => {
return fail(code::FAIL, format!("该字段在方案{}中已被使用", scheme_name));
}
Ok(None) => {}
Err(e) => return b10_error(e, "删除数据权限字段"),
}
if let Err(e) = b10_soft_delete(&state, "base_module_authorize", &id, &user.user_id).await {
return b10_error(e, "删除数据权限字段");
}
ok(Value::Null)
}
// ---- 数据权限方案(ModuleDataAuthorizeScheme)----
/// 数据权限方案列表(官方 `GET /{moduleId}/List` ⇒ `PageListVO<DataAuthorizeSchemeListVO>`)。
/// 🔴 官方该端点**无** `@SaCheckPermission`,只需登录。
pub async fn module_data_authorize_scheme_list(
State(state): State<AppState>,
headers: HeaderMap,
Path(module_id): Path<String>,
raw: RawQuery,
) -> Json<ActionResult> {
if let Err(resp) = require_login_face_b(&state, &headers).await {
return resp;
}
let paging = Paging::of(&raw);
let total = match state
.db
.query_json_params(
"SELECT COUNT(*)::bigint AS \"total\" FROM base_module_scheme \
WHERE COALESCE(f_delete_mark, 0) = 0 AND f_module_id = $1",
&params_of(&[Some(module_id.clone())]),
)
.await
{
Ok(rows) => rows
.first()
.and_then(|r| r.get("total").and_then(Value::as_i64))
.unwrap_or(0),
Err(e) => return db_error(e, "数据权限方案列表"),
};
let mut list_values: Vec<Option<String>> = vec![Some(module_id)];
list_values.push(Some(format!("{}", paging.page_size)));
list_values.push(Some(format!("{}", paging.offset)));
let sql = format!(
"SELECT {MODULE_DATA_AUTHORIZE_SCHEME_COLUMNS} FROM base_module_scheme \
WHERE COALESCE(f_delete_mark, 0) = 0 AND f_module_id = $1 \
ORDER BY f_sort_code ASC, f_creator_time DESC \
LIMIT ${}::text::integer OFFSET ${}::text::integer",
list_values.len() - 1,
list_values.len()
);
let rows = match state.db.query_json_params(&sql, &params_of(&list_values)).await {
Ok(rows) => rows,
Err(e) => return db_error(e, "数据权限方案列表"),
};
ok(page_list(paging.current_page, paging.page_size, total, rows))
}
/// 数据权限方案详情(官方 `GET /{id}` ⇒ `DataAuthorizeSchemeInfoVO`)。
pub async fn module_data_authorize_scheme_info(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
return resp;
}
let row = match b10_fetch(&state, "base_module_scheme", MODULE_DATA_AUTHORIZE_SCHEME_INFO_COLUMNS, &id).await {
Ok(row) => row,
Err(e) => return b10_error(e, "查询数据权限方案"),
};
let Some(row) = row else {
return fail(code::FAIL, "数据不存在");
};
ok(row)
}
/// 新建数据权限方案(官方 `POST` ⇒ `EXIST001 / EXIST002 / SU001`)。
pub async fn module_data_authorize_scheme_create(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
Ok(user) => user,
Err(resp) => return resp,
};
let obj = match parse_body(&body) {
Ok(Value::Object(obj)) => obj,
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
let full_name = b10_str_of(&obj, "fullName");
let en_code = b10_str_of(&obj, "enCode");
let module_id = b10_str_of(&obj, "moduleId");
if full_name.is_empty() || en_code.is_empty() || module_id.is_empty() {
return fail(code::FAIL, "必填");
}
match b11_scheme_name_exists(&state, &module_id, &full_name, None).await {
Ok(true) => return fail(code::FAIL, "名称不能重复"),
Ok(false) => {}
Err(e) => return b10_error(e, "查询数据权限方案"),
}
match b11_scheme_code_exists(&state, &module_id, &en_code, None).await {
Ok(true) => return fail(code::FAIL, "编码不能重复"),
Ok(false) => {}
Err(e) => return b10_error(e, "查询数据权限方案"),
}
let id = new_uuid();
let cols: Vec<(&'static str, &'static str, Option<String>)> = vec![
("f_id", "", Some(id.clone())),
("f_en_code", "", Some(en_code)),
("f_full_name", "", Some(full_name)),
("f_condition_json", "", Some(b10_str_of(&obj, "conditionJson"))),
("f_condition_text", "", Some(b10_str_of(&obj, "conditionText"))),
("f_module_id", "", Some(module_id)),
// 🔴 `allData` 缺省按官方默认 0(全量数据);否则 `b10_insert` 会把 None 当 `now()` 绑定 ⇒ 类型错。
("f_all_data", "::integer", Some(b10_int_of(&obj, "allData").unwrap_or(0).to_string())),
("f_match_logic", "", Some(b10_str_of(&obj, "matchLogic"))),
("f_creator_user_id", "", Some(user.user_id.clone())),
("f_creator_time", "", None),
];
if let Err(e) = b10_insert(&state, "base_module_scheme", &cols).await {
return b10_error(e, "新建数据权限方案");
}
ok(json!({ "id": id }))
}
/// 更新数据权限方案(官方 `PUT /{id}` ⇒ `SYS021 / EXIST001 / EXIST002 / FA002 / SU004`)。
pub async fn module_data_authorize_scheme_update(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
Ok(user) => user,
Err(resp) => return resp,
};
let obj = match parse_body(&body) {
Ok(Value::Object(obj)) => obj,
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
// 🔴 allData == 1 ⇒ SYS021(该方案不允许编辑)
if b10_int_of(&obj, "allData").unwrap_or(0) == 1 {
return fail(code::FAIL, "修改失败,该方案不允许编辑");
}
let full_name = b10_str_of(&obj, "fullName");
let en_code = b10_str_of(&obj, "enCode");
let module_id = b10_str_of(&obj, "moduleId");
if full_name.is_empty() || en_code.is_empty() || module_id.is_empty() {
return fail(code::FAIL, "必填");
}
match b11_scheme_name_exists(&state, &module_id, &full_name, Some(&id)).await {
Ok(true) => return fail(code::FAIL, "名称不能重复"),
Ok(false) => {}
Err(e) => return b10_error(e, "查询数据权限方案"),
}
match b11_scheme_code_exists(&state, &module_id, &en_code, Some(&id)).await {
Ok(true) => return fail(code::FAIL, "编码不能重复"),
Ok(false) => {}
Err(e) => return b10_error(e, "查询数据权限方案"),
}
let exists = match b10_fetch(&state, "base_module_scheme", "f_id AS \"id\"", &id).await {
Ok(row) => row.is_some(),
Err(e) => return b10_error(e, "查询数据权限方案"),
};
if !exists {
return fail(code::FAIL, "更新失败,数据不存在");
}
let mut sets: Vec<(&'static str, &'static str, Option<String>)> = Vec::new();
if obj.contains_key("fullName") {
sets.push(("f_full_name", "", Some(b10_str_of(&obj, "fullName"))));
}
if obj.contains_key("enCode") {
sets.push(("f_en_code", "", Some(b10_str_of(&obj, "enCode"))));
}
if obj.contains_key("conditionJson") {
sets.push(("f_condition_json", "", Some(b10_str_of(&obj, "conditionJson"))));
}
if obj.contains_key("conditionText") {
sets.push(("f_condition_text", "", Some(b10_str_of(&obj, "conditionText"))));
}
if obj.contains_key("moduleId") {
sets.push(("f_module_id", "", Some(b10_str_of(&obj, "moduleId"))));
}
if obj.contains_key("allData") {
sets.push(("f_all_data", "::integer", b10_int_of(&obj, "allData").map(|v| v.to_string())));
}
if obj.contains_key("matchLogic") {
sets.push(("f_match_logic", "", Some(b10_str_of(&obj, "matchLogic"))));
}
if let Err(e) = b10_update(&state, "base_module_scheme", &id, &sets, &user.user_id).await {
return b10_error(e, "修改数据权限方案");
}
ok(Value::Null)
}
/// 删除数据权限方案(官方 `DELETE /{id}` ⇒ `FA003 / SU003`)。
pub async fn module_data_authorize_scheme_delete(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
let user = match guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
Ok(user) => user,
Err(resp) => return resp,
};
let exists = match b10_fetch(&state, "base_module_scheme", "f_id AS \"id\"", &id).await {
Ok(row) => row.is_some(),
Err(e) => return b10_error(e, "查询数据权限方案"),
};
if !exists {
return fail(code::FAIL, "删除失败,数据不存在");
}
if let Err(e) = b10_soft_delete(&state, "base_module_scheme", &id, &user.user_id).await {
return b10_error(e, "删除数据权限方案");
}
ok(Value::Null)
}
// ---- 数据权限连接(ModuleDataAuthorizeLink)----
/// 保存/编辑数据连接(官方 `POST /saveLinkData` ⇒ `SU002 / SU004`)。
pub async fn module_data_authorize_link_save(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
Ok(user) => user,
Err(resp) => return resp,
};
let obj = match parse_body(&body) {
Ok(Value::Object(obj)) => obj,
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
let module_id = b10_str_of(&obj, "moduleId");
if module_id.is_empty() {
return fail(code::FAIL, "必填");
}
let id = b10_str_of(&obj, "id");
let link_id = b10_str_of(&obj, "linkId");
let link_tables = b10_str_of(&obj, "linkTables");
let data_type = b10_int_of(&obj, "dataType");
if id.is_empty() {
let new_id = new_uuid();
let cols: Vec<(&'static str, &'static str, Option<String>)> = vec![
("f_id", "", Some(new_id.clone())),
("f_module_id", "", Some(module_id)),
("f_link_id", "", Some(link_id)),
("f_link_tables", "", Some(link_tables)),
// 🔴 缺省按官方默认 0;`None` 会被 `b10_insert` 当 `now()` 绑定 ⇒ 整型列类型错。
("f_type", "::integer", Some(data_type.unwrap_or(0).to_string())),
("f_creator_user_id", "", Some(user.user_id.clone())),
("f_creator_time", "", None),
];
if let Err(e) = b10_insert(&state, "base_module_link", &cols).await {
return b10_error(e, "保存数据连接");
}
ok(json!({ "id": new_id }))
} else {
// 🔴 官方是 `updateById(entity)`(Mybatis 只 SET **实体里非 null** 的字段)⇒
// body 没带的键**保持原值**,不能一律 SET 空串。
let mut sets: Vec<(&'static str, &'static str, Option<String>)> = Vec::new();
if obj.contains_key("moduleId") {
sets.push(("f_module_id", "", Some(module_id)));
}
if obj.contains_key("linkId") {
sets.push(("f_link_id", "", Some(link_id)));
}
if obj.contains_key("linkTables") {
sets.push(("f_link_tables", "", Some(link_tables)));
}
if obj.contains_key("dataType") {
sets.push(("f_type", "::integer", Some(data_type.unwrap_or(0).to_string())));
}
if let Err(e) = b10_update(&state, "base_module_link", &id, &sets, &user.user_id).await {
return b10_error(e, "保存数据连接");
}
ok(Value::Null)
}
}
/// 获取表名(官方 `GET /getVisualTables/{menuId}/{type}` ⇒ `DataAuthorizeTableNameVO`)。
pub async fn module_data_authorize_link_visual_tables(
State(state): State<AppState>,
headers: HeaderMap,
Path((menu_id, data_type)): Path<(String, i64)>,
) -> Json<ActionResult> {
if let Err(resp) = guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
return resp;
}
// 🔴 低代码菜单(type 3/9/11)依赖 visualdevServiceImpl 解析表单 ⇒ 本仓无该能力,返回空。
if data_type == 3 || data_type == 9 || data_type == 11 {
return ok(json!({ "linkId": "", "linkTables": [] }));
}
let row = match state
.db
.query_json_params(
"SELECT f_link_id AS \"linkId\", f_link_tables AS \"linkTables\" FROM base_module_link \
WHERE COALESCE(f_delete_mark, 0) = 0 AND f_module_id = $1::text \
AND f_type = $2::text::integer LIMIT 1",
&params_of(&[Some(menu_id), Some(data_type.to_string())]),
)
.await
{
Ok(rows) => rows.into_iter().next(),
Err(e) => return db_error(e, "数据连接表名"),
};
match row {
Some(r) => {
let link_id = r.get("linkId").and_then(Value::as_str).unwrap_or_default().to_string();
let tables_raw = r.get("linkTables").and_then(Value::as_str).unwrap_or_default();
let link_tables: Vec<String> = if tables_raw.is_empty() {
Vec::new()
} else {
tables_raw
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect()
};
ok(json!({ "linkId": link_id, "linkTables": link_tables }))
}
None => ok(json!({ "linkId": "", "linkTables": [] })),
}
}
/// 数据连接信息(官方 `GET /getInfo/{menudId}/{type}` ⇒ `DataAuthorizeLinkForm`)。
pub async fn module_data_authorize_link_info(
State(state): State<AppState>,
headers: HeaderMap,
Path((menud_id, data_type)): Path<(String, i64)>,
) -> Json<ActionResult> {
if let Err(resp) = guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
return resp;
}
let row = match state
.db
.query_json_params(
"SELECT f_id AS \"id\", f_module_id AS \"moduleId\", f_link_id AS \"linkId\", \
f_link_tables AS \"linkTables\", f_type AS \"dataType\" FROM base_module_link \
WHERE COALESCE(f_delete_mark, 0) = 0 AND f_module_id = $1::text \
AND f_type = $2::text::integer LIMIT 1",
&params_of(&[Some(menud_id), Some(data_type.to_string())]),
)
.await
{
Ok(rows) => rows.into_iter().next(),
Err(e) => return db_error(e, "数据连接信息"),
};
match row {
Some(r) => ok(r),
None => ok(Value::Null),
}
}
/// 表名获取字段(官方 `GET /{linkId}/Tables/{tableName}/Fields/{menuType}/{dataType}` ⇒ `PageListVO<DbFieldVO>`)。
/// 🔴 依赖 dbTableService.getFieldList(数据库内省)⇒ 本仓无该能力,返回空 PageListVO。
pub async fn module_data_authorize_link_table_fields(
State(state): State<AppState>,
headers: HeaderMap,
Path((_link_id, _table_name, _menu_type, _data_type)): Path<(String, String, i64, i64)>,
raw: RawQuery,
) -> Json<ActionResult> {
if let Err(resp) = guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
return resp;
}
let paging = Paging::of(&raw);
ok(page_list(paging.current_page, paging.page_size, 0, vec![]))
}
// === PERMISSION CONFIG (权限配置族) SECTION END ===
#[cfg(test)]
+74 -4
View File
@@ -730,9 +730,67 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
"/api/system/AdvancedQuery/{id}",
put(face_b::advanced_query_update),
)
.route(
"/api/system/AdvancedQuery/{id}",
delete(face_b::advanced_query_delete),
)
// ---- 数据权限三件套(官方 `ModuleDataAuthorize(Controller/Scheme/Link)Controller`)----
.route(
"/api/system/AdvancedQuery/{id}",
delete(face_b::advanced_query_delete),
"/api/system/ModuleDataAuthorize",
post(face_b::module_data_authorize_create),
)
.route(
"/api/system/ModuleDataAuthorize/{moduleId}/List",
get(face_b::module_data_authorize_list),
)
.route(
"/api/system/ModuleDataAuthorize/{moduleId}/FieldList",
get(face_b::module_data_authorize_field_list),
)
.route("/api/system/ModuleDataAuthorize/{id}", get(face_b::module_data_authorize_info))
.route(
"/api/system/ModuleDataAuthorize/{id}",
put(face_b::module_data_authorize_update),
)
.route(
"/api/system/ModuleDataAuthorize/{id}",
delete(face_b::module_data_authorize_delete),
)
.route(
"/api/system/ModuleDataAuthorizeScheme",
post(face_b::module_data_authorize_scheme_create),
)
.route(
"/api/system/ModuleDataAuthorizeScheme/{moduleId}/List",
get(face_b::module_data_authorize_scheme_list),
)
.route(
"/api/system/ModuleDataAuthorizeScheme/{id}",
get(face_b::module_data_authorize_scheme_info),
)
.route(
"/api/system/ModuleDataAuthorizeScheme/{id}",
put(face_b::module_data_authorize_scheme_update),
)
.route(
"/api/system/ModuleDataAuthorizeScheme/{id}",
delete(face_b::module_data_authorize_scheme_delete),
)
.route(
"/api/system/ModuleDataAuthorizeLink/saveLinkData",
post(face_b::module_data_authorize_link_save),
)
.route(
"/api/system/ModuleDataAuthorizeLink/getVisualTables/{menuId}/{type}",
get(face_b::module_data_authorize_link_visual_tables),
)
.route(
"/api/system/ModuleDataAuthorizeLink/getInfo/{menudId}/{type}",
get(face_b::module_data_authorize_link_info),
)
.route(
"/api/system/ModuleDataAuthorizeLink/{linkId}/Tables/{tableName}/Fields/{menuType}/{dataType}",
get(face_b::module_data_authorize_link_table_fields),
)
// ---- 系统配置 + 第三方同步(官方 `SysConfigController` / `SynThirdInfoController`)----
.route("/api/system/SysConfig", get(face_b::sys_config_get))
@@ -1526,7 +1584,7 @@ mod tests {
// 🔴 表数**故意写死**:它同时校验「schema.sql 建了预期的表」与
// 「health 报的是真数」。加表要同步改这里 + main.rs 的 BASE_TABLES
// + crates/sspf-store 的两条 DDL 断言(共四处,漏一处就红)。
assert_eq!(body["tables"], 49);
assert_eq!(body["tables"], 52);
assert_eq!(body["version"], env!("CARGO_PKG_VERSION"));
}
@@ -1541,7 +1599,7 @@ mod tests {
let port = serve(new_state(db().await)).await;
// 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。
const FACE_B_REGISTERED: [&str; 244] = [
const FACE_B_REGISTERED: [&str; 255] = [
"/api/permission/Users",
"/api/permission/Users/any-id",
"/api/permission/Users/BatchDelete",
@@ -1800,6 +1858,18 @@ mod tests {
"/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 {
+21 -3
View File
@@ -557,6 +557,22 @@ async fn module_column_batch_rejects_duplicate_in_batch() {
let token = login(port).await;
let menu_id = any_menu_id().await;
// 🔴 **基线要按「改之前有多少行」算,不能写死 0** —— 本文件共用一个 pglite 临时库,
// `any_menu_id()` 对每个测试都返回**同一个**菜单 ⇒ 别的测试已经建过列表权限行。
// 断言的语义是「失败时**不新增**行」,不是「这个菜单下必须为空」。
let before = call(
port,
"GET",
&format!("/api/system/ModuleColumn/{menu_id}/Fields"),
&token,
None,
)
.await
.1["data"]["list"]
.as_array()
.expect("必须是 PageListVO")
.len();
// 批内两条同 code ⇒ 失败,且一条都不落库。
let body = json!({
"moduleId": menu_id,
@@ -587,7 +603,7 @@ async fn module_column_batch_rejects_duplicate_in_batch() {
)
.await;
let count = resp["data"]["list"].as_array().unwrap().len();
assert_eq!(count, 0, "失败时一条都不许落库:{resp}");
assert_eq!(count, before, "失败时一条都不许落库:{before} → {count}");
// 不撞码 ⇒ 全部落库。
let body = json!({
@@ -616,10 +632,12 @@ async fn module_column_batch_rejects_duplicate_in_batch() {
None,
)
.await;
// 🔴 同样是「相对基线 +2」(这个菜单下别的测试可能已建过行)。
assert_eq!(
resp["data"]["list"].as_array().unwrap().len(),
2,
"应落库 2 条:{resp}"
before + 2,
"应落库 2 条:{before} → {}",
resp["data"]["list"].as_array().unwrap().len()
);
}
+426
View File
@@ -0,0 +1,426 @@
//! 批次 11(**数据权限三件套**)集成测试:
//! `ModuleDataAuthorize`(6) + `ModuleDataAuthorizeScheme`(5) + `ModuleDataAuthorizeLink`(4)
//! = 15 端点,3 张表(`base_module_authorize` / `base_module_scheme` / `base_module_link`)。
//!
//! 🔴 **钉住的契约点**(每条对应官方控制器的一处硬要求):
//! ① 数据权限字段 `enCode` **前缀化**:建于 `type=3` 菜单 + `fieldRule!=0` + `bindTable` 非空 ⇒
//! 库里存 `bindTable.enCode`;读回(list / info)**剥掉**前缀。
//! create 用 `fieldRule!=0`、update 用 `fieldRule==1`(与官方两处判据一致)。
//! ② 数据权限字段 `FieldList` ⇒ 诚实返回空数组 `[]`(官方依赖低代码表单字段解析,本仓无该能力)。
//! ③ 数据权限字段 `conditionSymbol` / `conditionText` ⇒ list 解码为中文名
//! (`conditionSymbolName` / `conditionName`)。
//! ④ 删除数据权限字段前遍历方案 `conditionJson` 比对 `field`(带前缀、equalsIgnoreCase)⇒
//! 命中返回「该字段在方案{name}中已被使用」(SYS020);数据不存在返回「删除失败,数据不存在」。
//! ⑤ 方案**新建双判重**:撞名「名称不能重复」、撞码「编码不能重复」。
//! ⑥ 方案**列表只登录无点权限守卫**(官方 `@SaCheckPermission` 缺失);返回 `PageListVO`。
//! ⑦ 方案**更新** `allData==1` ⇒ 「修改失败,该方案不允许编辑」(SYS021);数据不存在 ⇒
//! 「更新失败,数据不存在」。
//! ⑧ 方案软删:成功 `code=200`;数据不存在 ⇒ 「删除失败,数据不存在」。
//! ⑨ 连接 `saveLinkData`:id 空新建(返 `{id}`)、id 非空更新(返 `null`)。
//! ⑩ 连接 `getVisualTables`:低代码 type 3/9/11 ⇒ `{linkId:"", linkTables:[]}`;其余按
//! `menuId+type` 查 `base_module_link` ⇒ 逗号串拆成数组。
//! ⑪ 连接 `getInfo`:命中返行、未命中返 `null`。
//! ⑫ 连接表字段 `Tables/.../Fields` ⇒ 占位空 `PageListVO`(依赖 dbTableService 内省)。
//!
//! 🔴 pglite-rs 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。
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 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
ensure_base(&db).await.expect("ensure_base 失败");
first_seed(&db, "123456").await.expect("first_seed 失败");
db
})
.await
}
async fn serve(state: AppState) -> u16 {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("绑定失败");
let port = listener.local_addr().expect("取本地地址失败").port();
let server = tokio::spawn(async move {
let _ = axum::serve(listener, build_app(state)).await;
});
tokio::task::yield_now().await;
std::mem::forget(server);
port
}
async fn call(port: u16, method: &str, path: &str, token: &str, body: Option<&str>) -> (String, Value) {
let mut stream = TcpStream::connect(("127.0.0.1", port)).await.expect("连接失败");
let payload = body.unwrap_or("");
let req = format!(
"{method} {path} HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Authorization: {token}\r\n\
Content-Type: application/json\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(std::time::Duration::from_secs(15), stream.read_to_end(&mut buf))
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (head, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let status = head.lines().next().unwrap_or_default().to_string();
let json: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null);
(status, json)
}
async fn login(port: u16) -> String {
let enc = ssw_platform::platform::cipher::encrypt_password("123456");
let payload = format!("account=admin&password={enc}");
let mut stream = TcpStream::connect(("127.0.0.1", port)).await.expect("连接失败");
let req = format!(
"POST /api/oauth/Login HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Content-Type: application/x-www-form-urlencoded\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(std::time::Duration::from_secs(15), stream.read_to_end(&mut buf))
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let json: Value = serde_json::from_str(body.trim()).expect("登录响应必须是 JSON");
json["data"]["token"].as_str().expect("登录必须返回 token").to_string()
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-batch11-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
}
}
/// 取一个真实存在的「功能菜单(type=2)」id(种子里只有 type=0/2,无 type=3)。
async fn any_menu_id() -> String {
let rows = Db::query_json_params(
db().await,
"SELECT f_id AS \"id\" FROM base_module \
WHERE COALESCE(f_delete_mark, 0) = 0 AND f_type = 2 ORDER BY f_sort_code ASC LIMIT 1",
&[],
)
.await
.expect("查菜单失败");
assert!(!rows.is_empty(), "库里必须有 type=2 的功能菜单");
rows[0]["id"].as_str().expect("菜单必须有 id").to_string()
}
/// 插入一个 `type=3` 的低代码菜单(触发 enCode 前缀化逻辑)。
async fn insert_type3_menu(id: &str) {
Db::exec_params(
db().await,
"INSERT INTO base_module (f_id, f_type) VALUES ($1::text, 3)",
&[&id],
)
.await
.expect("插入 type=3 菜单失败");
}
/// 插入一条数据权限方案(带 conditionJson,用于 SYS020 引用校验)。
async fn insert_scheme(module_id: &str, name: &str, en_code: &str, condition_json: &str) {
Db::exec_params(
db().await,
"INSERT INTO base_module_scheme (f_id, f_module_id, f_full_name, f_en_code, f_condition_json) \
VALUES ($1::text, $2::text, $3::text, $4::text, $5::text)",
&[&format!("sch_{}", name), &module_id.to_string(), &name.to_string(), &en_code.to_string(), &condition_json.to_string()],
)
.await
.expect("插入方案失败");
}
/// ① + ② + ③:数据权限字段的 enCode 前缀化(建/读分离)、FieldList 空数组、condition 解码。
#[tokio::test]
async fn data_authorize_en_code_prefix_and_field_list_and_decode() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 建在 type=3 菜单 + fieldRule=1 + bindTable 非空 ⇒ 库里存 `demo_item.f_name`。
insert_type3_menu("mem_b11_t3").await;
let body = json!({
"fullName": "名称字段",
"enCode": "f_name",
"moduleId": "mem_b11_t3",
"bindTable": "demo_item",
"fieldRule": 1,
"conditionSymbol": "==,like",
"conditionText": "@userId,input"
});
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorize", &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 200, "新建数据权限字段应成功:{resp}");
let id = resp["data"]["id"].as_str().expect("必须返回 id").to_string();
// ① 库里存的是带前缀的。
let rows = Db::query_json_params(
db().await,
"SELECT f_en_code AS \"enCode\" FROM base_module_authorize WHERE f_id = $1::text",
&[&id],
)
.await
.expect("查库失败");
assert_eq!(rows[0]["enCode"], json!("demo_item.f_name"), "库里应存带前缀的编码:{rows:?}");
// ① 详情 ⇒ 已剥掉前缀(info 不解码 condition,仅 list 解码,见下)。
let (_, resp) = call(port, "GET", &format!("/api/system/ModuleDataAuthorize/{id}"), &token, None).await;
assert_eq!(resp["code"], 200, "详情应成功:{resp}");
assert_eq!(resp["data"]["enCode"], json!("f_name"), "详情应剥掉前缀:{resp}");
// ① 列表 ⇒ 也剥掉前缀 + condition 解码。
let (_, resp) = call(port, "GET", "/api/system/ModuleDataAuthorize/mem_b11_t3/List", &token, None).await;
assert_eq!(resp["code"], 200, "列表应成功:{resp}");
let list = resp["data"]["list"].as_array().expect("必须是 ListVO");
let item = list.iter().find(|r| r["id"] == json!(id)).expect("列表里必须有刚建的");
assert_eq!(item["enCode"], json!("f_name"), "列表应剥掉前缀:{item}");
assert_eq!(item["conditionSymbolName"], json!("等于,包含"), "列表 conditionSymbol 应解码:{item}");
// ② FieldList ⇒ 空数组(诚实降级)。
let (_, resp) = call(port, "GET", "/api/system/ModuleDataAuthorize/mem_b11_t3/FieldList", &token, None).await;
assert_eq!(resp["code"], 200, "FieldList 应成功:{resp}");
assert!(resp["data"].is_array(), "FieldList 必须是数组:{resp}");
assert!(resp["data"].as_array().unwrap().is_empty(), "FieldList 必须为空:{resp}");
// ① create 的 fieldRule=0 ⇒ 不前缀化(即使 bindTable 非空)。
let body = json!({
"fullName": "无前缀字段",
"enCode": "f_plain",
"moduleId": "mem_b11_t3",
"bindTable": "demo_item",
"fieldRule": 0
});
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorize", &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 200, "fieldRule=0 应成功:{resp}");
let id2 = resp["data"]["id"].as_str().expect("必须返回 id").to_string();
let rows = Db::query_json_params(
db().await,
"SELECT f_en_code AS \"enCode\" FROM base_module_authorize WHERE f_id = $1::text",
&[&id2],
)
.await
.expect("查库失败");
assert_eq!(rows[0]["enCode"], json!("f_plain"), "fieldRule=0 不应前缀化:{rows:?}");
}
/// `update` 的前缀化(仅 fieldRule==1 才前缀化)与「数据不存在」文案。
#[tokio::test]
async fn data_authorize_update_prefix_and_not_found() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
insert_type3_menu("mem_b11_t3u").await;
let body = json!({
"fullName": "字段U",
"enCode": "f_u",
"moduleId": "mem_b11_t3u",
"bindTable": "demo_item",
"fieldRule": 1
});
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorize", &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 200, "新建应成功:{resp}");
let id = resp["data"]["id"].as_str().expect("必须返回 id").to_string();
// update 带 fieldRule==1 ⇒ 重新前缀化 enCode。
let body = json!({ "enCode": "f_u2", "moduleId": "mem_b11_t3u", "fieldRule": 1, "bindTable": "demo_item" });
let (_, resp) = call(port, "PUT", &format!("/api/system/ModuleDataAuthorize/{id}"), &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 200, "更新应成功:{resp}");
let rows = Db::query_json_params(
db().await,
"SELECT f_en_code AS \"enCode\" FROM base_module_authorize WHERE f_id = $1::text",
&[&id],
)
.await
.expect("查库失败");
assert_eq!(rows[0]["enCode"], json!("demo_item.f_u2"), "update fieldRule==1 应前缀化:{rows:?}");
// 不存在 ⇒ 「更新失败,数据不存在」。
let body = json!({ "enCode": "x", "moduleId": "mem_b11_t3u", "fieldRule": 1, "bindTable": "demo_item" });
let (_, resp) = call(port, "PUT", "/api/system/ModuleDataAuthorize/no_such_id", &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 400, "更新不存在必须失败:{resp}");
assert_eq!(resp["msg"], "更新失败,数据不存在", "更新不存在文案:{resp}");
}
/// ④ + 软删:SYS020 引用拦截、删除不存在、成功删除。
#[tokio::test]
async fn data_authorize_delete_sys020_and_soft_delete() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let menu_id = any_menu_id().await; // type=2 ⇒ 不前缀化,库里 enCode 与传入一致。
// 建一条普通字段(enCode=f_ref)。
let body = json!({ "fullName": "被引用字段", "enCode": "f_ref", "moduleId": menu_id });
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorize", &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 200, "新建应成功:{resp}");
let id = resp["data"]["id"].as_str().expect("必须返回 id").to_string();
// 建一个方案,conditionJson 里 field 引用 f_ref ⇒ 删除应被 SYS020 拦截。
insert_scheme(&menu_id, "方案被引用", "sch_ref", "[{\"groups\":[{\"field\":\"f_ref\"}]}]").await;
let (_, resp) = call(port, "DELETE", &format!("/api/system/ModuleDataAuthorize/{id}"), &token, None).await;
assert_eq!(resp["code"], 400, "被方案引用必须失败:{resp}");
assert_eq!(resp["msg"], "该字段在方案方案被引用中已被使用", "SYS020 文案(含方案名):{resp}");
// 删掉方案引用后 ⇒ 删除成功。
Db::exec_params(
db().await,
"DELETE FROM base_module_scheme WHERE f_module_id = $1::text",
&[&menu_id],
)
.await
.expect("清方案失败");
let (_, resp) = call(port, "DELETE", &format!("/api/system/ModuleDataAuthorize/{id}"), &token, None).await;
assert_eq!(resp["code"], 200, "无引用应删除成功:{resp}");
// 删除不存在 ⇒ 「删除失败,数据不存在」。
let (_, resp) = call(port, "DELETE", "/api/system/ModuleDataAuthorize/no_such_id", &token, None).await;
assert_eq!(resp["code"], 400, "删不存在必须失败:{resp}");
assert_eq!(resp["msg"], "删除失败,数据不存在", "删不存在文案:{resp}");
}
/// ⑤ + ⑥ + ⑦ + ⑧:方案双判重、仅登录列表(PageListVO)、allData==1 拦截、更新/删除数据不存在。
#[tokio::test]
async fn data_authorize_scheme_dedup_list_info_and_lifecycle() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let menu_id = any_menu_id().await;
// ⑤ 新建⇒返 id。
let body = json!({ "fullName": "我的方案A", "enCode": "sch_a", "moduleId": menu_id, "matchLogic": "and" });
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorizeScheme", &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 200, "新建方案应成功:{resp}");
let id = resp["data"]["id"].as_str().expect("必须返回 id").to_string();
// ⑤ 撞名 ⇒ 「名称不能重复」。
let dup = json!({ "fullName": "我的方案A", "enCode": "sch_b", "moduleId": menu_id });
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorizeScheme", &token, Some(&dup.to_string())).await;
assert_eq!(resp["code"], 400, "撞名必须失败:{resp}");
assert_eq!(resp["msg"], "名称不能重复", "撞名文案:{resp}");
// ⑤ 撞码 ⇒ 「编码不能重复」。
let dup = json!({ "fullName": "我的方案C", "enCode": "sch_a", "moduleId": menu_id });
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorizeScheme", &token, Some(&dup.to_string())).await;
assert_eq!(resp["code"], 400, "撞码必须失败:{resp}");
assert_eq!(resp["msg"], "编码不能重复", "撞码文案:{resp}");
// ⑥ 列表 ⇒ **仅登录**即可,返回 PageListVO。
let (_, resp) = call(port, "GET", &format!("/api/system/ModuleDataAuthorizeScheme/{menu_id}/List"), &token, None).await;
assert_eq!(resp["code"], 200, "方案列表应成功:{resp}");
assert!(resp["data"]["pagination"].is_object(), "必须是 PageListVO:{resp}");
let list = resp["data"]["list"].as_array().expect("必须有 list");
assert!(list.iter().any(|r| r["id"] == json!(id)), "列表应含刚建方案:{resp}");
// ⑦ allData==1 ⇒ SYS021(即便 fullName 缺失也先判这条)。
let (_, resp) = call(port, "PUT", &format!("/api/system/ModuleDataAuthorizeScheme/{id}"), &token, Some(&json!({ "allData": 1 }).to_string())).await;
assert_eq!(resp["code"], 400, "allData==1 必须失败:{resp}");
assert_eq!(resp["msg"], "修改失败,该方案不允许编辑", "SYS021 文案:{resp}");
// ⑦ 正常更新(allData=0)⇒ 成功。
let (_, resp) = call(port, "PUT", &format!("/api/system/ModuleDataAuthorizeScheme/{id}"), &token, Some(&json!({ "fullName": "我的方案A改", "enCode": "sch_a", "moduleId": menu_id, "allData": 0 }).to_string())).await;
assert_eq!(resp["code"], 200, "正常更新应成功:{resp}");
// ⑦ 更新不存在 ⇒ 「更新失败,数据不存在」。
let (_, resp) = call(port, "PUT", "/api/system/ModuleDataAuthorizeScheme/no_such_id", &token, Some(&json!({ "fullName": "x", "enCode": "x", "moduleId": menu_id, "allData": 0 }).to_string())).await;
assert_eq!(resp["code"], 400, "更新不存在必须失败:{resp}");
assert_eq!(resp["msg"], "更新失败,数据不存在", "更新不存在文案:{resp}");
// ⑧ 删除 ⇒ 成功;再删 ⇒ 「删除失败,数据不存在」。
let (_, resp) = call(port, "DELETE", &format!("/api/system/ModuleDataAuthorizeScheme/{id}"), &token, None).await;
assert_eq!(resp["code"], 200, "删除应成功:{resp}");
let (_, resp) = call(port, "DELETE", &format!("/api/system/ModuleDataAuthorizeScheme/{id}"), &token, None).await;
assert_eq!(resp["code"], 400, "删不存在必须失败:{resp}");
assert_eq!(resp["msg"], "删除失败,数据不存在", "删不存在文案:{resp}");
}
/// ⑨ + ⑩ + ⑪ + ⑫:连接 save/create-update、visualTables 低代码空/非低代码查表、getInfo 命中/未命中、表字段占位空 PageListVO。
#[tokio::test]
async fn data_authorize_link_save_visual_tables_info_fields() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let menu_id = any_menu_id().await;
// ⑨ 新建(id 空)⇒ 返 {id}。
let body = json!({ "moduleId": menu_id, "linkId": "lnk_new", "linkTables": "t_x,t_y", "dataType": 2 });
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorizeLink/saveLinkData", &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 200, "saveLinkData 新建应成功:{resp}");
let id = resp["data"]["id"].as_str().expect("新建必须返回 id").to_string();
// ⑨ 更新(带 id)⇒ 返 null;只 SET body 里出现的键(`linkTables` 不带 ⇒ 保持原值)。
let body = json!({ "id": id, "moduleId": menu_id, "linkId": "lnk_upd", "dataType": 2 });
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorizeLink/saveLinkData", &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 200, "saveLinkData 更新应成功:{resp}");
assert_eq!(resp["data"], Value::Null, "更新应返 null:{resp}");
let rows = Db::query_json_params(
db().await,
"SELECT f_link_id AS \"linkId\", f_link_tables AS \"linkTables\" FROM base_module_link WHERE f_id = $1::text",
&[&id],
).await.expect("查连接失败");
assert_eq!(rows[0]["linkId"], json!("lnk_upd"), "linkId 应被更新:{rows:?}");
assert_eq!(rows[0]["linkTables"], json!("t_x,t_y"), "body 没带的 linkTables 应保持原值:{rows:?}");
// ⑩ 低代码 type=3 ⇒ 诚实返回 {linkId:"", linkTables:[]}。
let (_, resp) = call(port, "GET", &format!("/api/system/ModuleDataAuthorizeLink/getVisualTables/{menu_id}/3"), &token, None).await;
assert_eq!(resp["code"], 200, "低代码表名应成功:{resp}");
assert_eq!(resp["data"]["linkId"], json!(""), "低代码 linkId 必须空:{resp}");
assert_eq!(resp["data"]["linkTables"], json!([]), "低代码 linkTables 必须空数组:{resp}");
// ⑩ 非低代码 type=5 ⇒ 查 base_module_link(先通过端点建一条,避免裸 SQL 整型绑定问题)。
let body = json!({ "moduleId": menu_id, "linkId": "lnk_real", "linkTables": "t_a,t_b,t_c", "dataType": 5 });
let (_, resp) = call(port, "POST", "/api/system/ModuleDataAuthorizeLink/saveLinkData", &token, Some(&body.to_string())).await;
assert_eq!(resp["code"], 200, "saveLinkData 建连接应成功:{resp}");
let (_, resp) = call(port, "GET", &format!("/api/system/ModuleDataAuthorizeLink/getVisualTables/{menu_id}/5"), &token, None).await;
assert_eq!(resp["code"], 200, "非低代码表名应成功:{resp}");
assert_eq!(resp["data"]["linkId"], json!("lnk_real"), "应回 linkId:{resp}");
assert_eq!(resp["data"]["linkTables"], json!(["t_a", "t_b", "t_c"]), "逗号串应拆成数组:{resp}");
// ⑪ getInfo type=5 命中 ⇒ 返行;type=99 未命中 ⇒ null。
let (_, resp) = call(port, "GET", &format!("/api/system/ModuleDataAuthorizeLink/getInfo/{menu_id}/5"), &token, None).await;
assert_eq!(resp["code"], 200, "getInfo 命中应成功:{resp}");
assert_eq!(resp["data"]["linkId"], json!("lnk_real"), "getInfo 应回 linkId:{resp}");
assert_eq!(resp["data"]["dataType"], json!(5), "getInfo 应回 dataType:{resp}");
let (_, resp) = call(port, "GET", &format!("/api/system/ModuleDataAuthorizeLink/getInfo/{menu_id}/99"), &token, None).await;
assert_eq!(resp["code"], 200, "getInfo 未命中应成功:{resp}");
assert_eq!(resp["data"], Value::Null, "getInfo 未命中应返 null:{resp}");
// ⑫ 表字段 ⇒ 占位空 PageListVO。
let (_, resp) = call(port, "GET", "/api/system/ModuleDataAuthorizeLink/lnk_b11/Tables/demo/Fields/1/1", &token, None).await;
assert_eq!(resp["code"], 200, "表字段应成功:{resp}");
assert!(resp["data"]["pagination"].is_object(), "必须是 PageListVO:{resp}");
assert!(resp["data"]["list"].as_array().expect("必须有 list").is_empty(), "表字段必须为空:{resp}");
}
+4 -3
View File
@@ -380,10 +380,11 @@ async fn data_model_tables_info_and_fields() {
let total = tables["data"]["pagination"]["total"]
.as_i64()
.expect("必须有 total");
// schema.sql 现在是 49 张表(批次 9 新增 6 张:数据接口 + 接口认证 + 打印模板/版本;
// 批次 10 新增 6 张:签章 + 签章授权人 + 按钮/列表/表单权限 + 高级查询方案);
// schema.sql 现在是 52 张表(批次 9 新增 6 张:数据接口 + 接口认证 + 打印模板/版本;
// 批次 10 新增 6 张:签章 + 签章授权人 + 按钮/列表/表单权限 + 高级查询方案;
// 批次 11 新增 3 张:base_module_authorize / base_module_scheme / base_module_link);
// 真有变化时这条会红,提醒同步(与 DDL 计数测试同口径)。
assert_eq!(total, 49, "表清单必须来自 information_schema: {tables}");
assert_eq!(total, 52, "表清单必须来自 information_schema: {tables}");
let list = tables["data"]["list"].as_array().expect("必须有 list");
assert!(
list.iter().any(|r| r["table"] == "base_user"),