面 B:数据字典分类+数据 CRUD(+14 端点,新表 2 张,tables 14→16)

This commit is contained in:
admin committed 2026-10-31 03:50:49 +08:00
1 parent 5f6ca8d963
commit eecf1b03b0
6 files changed
+621 -11

No files matched your search

+30 -2
View File
@@ -437,7 +437,7 @@ SELECT row_to_json(q)::text AS _row FROM (<sql>) AS q
## 6. 端点全表
> 🔴 **本节是「人读」版;机器可读版在附录 A 的 `[ENDPOINT]` 区段**
> (列:`face` / `method` / `path` / `guard` / `owner`,一行一条端点,**102** 条;
> (列:`face` / `method` / `path` / `guard` / `owner`,一行一条端点,**116** 条;
> 外加 `[FACE]` 区段登记各契约面的条数)。
> 由 **`scripts/check-contract.sh`** 把它与**代码里真实注册的路由**逐条对账
> (总数 / 存在性 / 方法 / 归属层 / 守卫,**双向**)⇒
@@ -1221,6 +1221,20 @@ B GET /api/system/Menu/getSystemMenu permission.menu platform
B GET /api/system/Menu/{id}/Actions/Export permission.menu platform
B GET /api/system/Menu/getPermissionGroup/{id} permission.menu platform
B GET /api/system/Menu/getPermission/{id}/{permissionId} permission.menu platform
B GET /api/system/DictionaryType permission.dictionary platform
B POST /api/system/DictionaryType permission.dictionary platform
B GET /api/system/DictionaryType/{id} permission.dictionary platform
B PUT /api/system/DictionaryType/{id} permission.dictionary platform
B DELETE /api/system/DictionaryType/{id} permission.dictionary platform
B GET /api/system/DictionaryType/Selector/{id} permission.dictionary platform
B POST /api/system/DictionaryData permission.dictionary platform
B GET /api/system/DictionaryData/{id} permission.dictionary platform
B GET /api/system/DictionaryData/{id}/Info permission.dictionary platform
B PUT /api/system/DictionaryData/{id} permission.dictionary platform
B DELETE /api/system/DictionaryData/{id} permission.dictionary platform
B GET /api/system/DictionaryData/{id}/Data/Selector permission.dictionary platform
B GET /api/system/DictionaryData/{id}/Selector/{pid} permission.dictionary platform
B GET /api/system/DictionaryData/{id}/Actions/Export permission.dictionary platform
B GET /api/permission/Role permission.role platform
B POST /api/oauth/Logout 登录 platform
B GET /api/system/BaseLang/LangJson 登录 platform
@@ -1243,7 +1257,7 @@ A DELETE /api/ssw/asset/DataResource/Delete asset/DataResource asset
[FACE]
# face 条数 说明
A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条)
B 72 面 B 专属(官方 JNPF 形状)
B 86 面 B 专属(官方 JNPF 形状)
AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流)
[OFFICIAL]
@@ -1334,6 +1348,20 @@ GET /api/system/Menu/getSystemMenu implemented menu.ts:60 面 B 已落地:同
GET /api/system/Menu/{id}/Actions/Export implemented menu.ts:38 面 B 已落地:**恒 `data:null`**(无导出文件服务);前端 `if (!res.data.url) return;` 静默跳过
GET /api/system/Menu/getPermissionGroup/{id} implemented menu.ts:42 面 B 已落地:恒 `{list:[]}`(按钮/列/表单级权限不做,见已知限制 (ag))
GET /api/system/Menu/getPermission/{id}/{permissionId} implemented menu.ts:46 面 B 已落地:恒 `{list:[]}`,同上
GET /api/system/DictionaryType implemented dictionary.ts:8 面 B 已落地:ListVO;新表 `base_dictionary_type`(官方 DDL 逐字)
POST /api/system/DictionaryType implemented dictionary.ts:16 面 B 已落地:`DICT_TYPE_WRITE_FIELDS` 白名单 + 名称非空
GET /api/system/DictionaryType/{id} implemented dictionary.ts:28 面 B 已落地:字典分类详情
PUT /api/system/DictionaryType/{id} implemented dictionary.ts:20 面 B 已落地:**只 SET body 里出现的键**
DELETE /api/system/DictionaryType/{id} implemented dictionary.ts:32 面 B 已落地:软删本行;**不级联**字典数据
GET /api/system/DictionaryType/Selector/{id} implemented dictionary.ts:12 面 B 已落地:ListVO 全量分类(本仓分类只有一层 ⇒ 忽略 id)
POST /api/system/DictionaryData implemented dictionary.ts:50 面 B 已落地:`DICT_DATA_WRITE_FIELDS` 白名单 + 名称非空
GET /api/system/DictionaryData/{id} implemented dictionary.ts:36 面 B 已落地:ListVO 按 `f_dictionary_type_id` 过滤
GET /api/system/DictionaryData/{id}/Info implemented dictionary.ts:58 面 B 已落地:字典数据详情
PUT /api/system/DictionaryData/{id} implemented dictionary.ts:54 面 B 已落地:**只 SET body 里出现的键**
DELETE /api/system/DictionaryData/{id} implemented dictionary.ts:62 面 B 已落地:软删本行
GET /api/system/DictionaryData/{id}/Data/Selector implemented dictionary.ts:44 面 B 已落地:按分类过滤的下拉
GET /api/system/DictionaryData/{id}/Selector/{pid} implemented dictionary.ts:40 面 B 已落地:同分类下拉树(本仓字典数据无层级 ⇒ 平铺)
GET /api/system/DictionaryData/{id}/Actions/Export implemented dictionary.ts:66 面 B 已落地:**恒 `data:null`**(无导出服务);前端 `if (!res.data.url) return;` 静默跳过
GET /api/permission/Role implemented RoleController.java:99-100 面 B 已落地:PageListVO 形状
GET /api/permission/Role/{id} implemented role.ts:25 面 B 已落地:表单直接 `setFieldsValue(res.data)`
POST /api/permission/Role implemented role.ts:17 面 B 已落地:`ROLE_WRITE_FIELDS` 白名单写库 + 名称非空校验,返 `{id}`
+43
View File
@@ -164,6 +164,49 @@ CREATE TABLE base_position (
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE base_dictionary_type (
f_id VARCHAR(50) NOT NULL,
f_parent_id VARCHAR(50),
f_full_name VARCHAR(200),
f_en_code VARCHAR(200),
f_is_tree INTEGER,
f_type INTEGER,
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_dictionary_data (
f_id VARCHAR(50) NOT NULL,
f_parent_id VARCHAR(50),
f_full_name VARCHAR(200),
f_en_code VARCHAR(200),
f_simple_spelling VARCHAR(500),
f_is_default INTEGER,
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_dictionary_type_id VARCHAR(50),
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
CREATE TABLE base_user (
f_id VARCHAR(50) NOT NULL,
f_account VARCHAR(50),
+3 -1
View File
@@ -42,7 +42,7 @@ use ssw_platform::routes;
/// 多应用 MVP 新增了平台表 `base_system`(`SystemEntity` 注册表,
/// 承载 `App-Code` → `systemId` 的映射),故清单现在是 **8 张**
/// (原 7 张 + `base_system`)。
const BASE_TABLES: [&str; 10] = [
const BASE_TABLES: [&str; 12] = [
"base_group",
"base_user",
"base_role",
@@ -53,6 +53,8 @@ const BASE_TABLES: [&str; 10] = [
"base_user_relation",
"base_system",
"base_position",
"base_dictionary_type",
"base_dictionary_data",
];
/// 命令行解析的结果(**纯数据**,便于单测)。
+6 -6
View File
@@ -1055,22 +1055,22 @@ mod tests {
}
#[test]
fn schema_sql_has_fourteen_tables() {
// schema.sql 必须包含 14 张表的 CREATE TABLE
// (10 张 base_*:8 张官方 + 多应用注册表 base_system + 用户分组 base_group + 岗位 base_position,+ 4 张业务表)。
fn schema_sql_has_sixteen_tables() {
// schema.sql 必须包含 16 张表的 CREATE TABLE
// (12 张 base_*:8 张官方 + base_system + base_group + base_position + 字典分类/字典数据,+ 4 张业务表)。
let count = SCHEMA_SQL.matches("CREATE TABLE ").count();
assert_eq!(count, 14, "schema.sql 的 CREATE TABLE 数量应为 14");
assert_eq!(count, 16, "schema.sql 的 CREATE TABLE 数量应为 16");
}
/// 🔴 [`ddl_tables`] 的解析必须与上面那条计数一致(不能只数到 12 却解析出别的)。
#[test]
fn ddl_tables_parses_every_create_table() {
let tables = ddl_tables();
assert_eq!(tables.len(), 14, "ddl_tables 应解析出 14 张表");
assert_eq!(tables.len(), 16, "ddl_tables 应解析出 16 张表");
assert!(tables.iter().all(|t| !t.is_empty()));
assert_eq!(
tables.iter().collect::<std::collections::HashSet<_>>().len(),
14,
16,
"表名不许重复"
);
// 8 张 base_* 必须都在(业务表由业务层 spec 派生,不在本文件写死)。
+514
View File
@@ -3584,6 +3584,520 @@ pub async fn menu_permission_info(
ok(json!({ "list": [] }))
}
// ---------------------------------------------------------------- 数据字典(base_dictionary_*)
/// 🔴 字典**没有**官方 `permission.*` 点权限码(官方靠菜单路径鉴权)
/// ⇒ 本仓自定 `permission.dictionary`,与面 B 的 `has_en_code_permission` 同一套判据。
const EN_DICTIONARY: &str = "permission.dictionary";
const DICT_TYPE_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \
f_en_code AS \"enCode\", COALESCE(f_parent_id, '0') AS \"parentId\", \
COALESCE(f_is_tree, 0) AS \"isTree\", f_type AS \"type\", \
f_description AS \"description\", \
COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \
COALESCE(f_sort_code, 0) AS \"sortCode\", \
(EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\"";
const DICT_TYPE_WRITE_FIELDS: [(&str, &str, &str); 7] = [
("parentId", "f_parent_id", ""),
("fullName", "f_full_name", ""),
("enCode", "f_en_code", ""),
("isTree", "f_is_tree", "::integer"),
("type", "f_type", "::integer"),
("description", "f_description", ""),
("enabledMark", "f_enabled_mark", "::integer"),
];
const DICT_DATA_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \
f_en_code AS \"enCode\", COALESCE(f_parent_id, '0') AS \"parentId\", \
f_dictionary_type_id AS \"dictionaryTypeId\", \
COALESCE(f_is_default, 0) AS \"isDefault\", f_description AS \"description\", \
COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \
COALESCE(f_sort_code, 0) AS \"sortCode\", \
(EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\"";
const DICT_DATA_WRITE_FIELDS: [(&str, &str, &str); 7] = [
("parentId", "f_parent_id", ""),
("fullName", "f_full_name", ""),
("enCode", "f_en_code", ""),
("dictionaryTypeId", "f_dictionary_type_id", ""),
("isDefault", "f_is_default", "::integer"),
("description", "f_description", ""),
("enabledMark", "f_enabled_mark", "::integer"),
];
/// `GET /api/system/DictionaryType` —— 字典分类列表(`ListVO`)。
pub async fn dict_type_list(
State(state): State<AppState>,
headers: HeaderMap,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DICTIONARY).await {
return resp;
}
let sql = format!(
"SELECT {DICT_TYPE_PROJECTION} FROM base_dictionary_type \
WHERE COALESCE(f_delete_mark,0) = 0 ORDER BY f_sort_code ASC, f_full_name ASC"
);
match state.db.query_json_params(&sql, &[]).await {
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "字典分类查询"),
}
}
/// `GET /api/system/DictionaryType/Selector/{id}` —— 字典分类下拉。
pub async fn dict_type_selector(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DICTIONARY).await {
return resp;
}
let _ = id.trim();
let sql = format!(
"SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \
COALESCE(f_parent_id, '0') AS \"parentId\", \
COALESCE(f_sort_code, 0) AS \"sortCode\" \
FROM base_dictionary_type WHERE COALESCE(f_delete_mark,0) = 0 \
ORDER BY f_sort_code ASC, f_full_name ASC"
);
match state.db.query_json_params(&sql, &[]).await {
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "字典分类下拉查询"),
}
}
/// `GET /api/system/DictionaryType/{id}` —— 字典分类详情。
pub async fn dict_type_info(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DICTIONARY).await {
return resp;
}
let id = id.trim().to_string();
let sql = format!(
"SELECT {DICT_TYPE_PROJECTION} FROM base_dictionary_type \
WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1"
);
match state.db.query_json_params(&sql, &[&id]).await {
Ok(rows) => match rows.into_iter().next() {
Some(row) => ok(row),
None => fail(code::FAIL, "字典分类不存在"),
},
Err(e) => db_error(e, "字典分类详情查询"),
}
}
/// `POST /api/system/DictionaryType` —— 建字典分类。
pub async fn dict_type_create(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_DICTIONARY).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 new_id = new_uuid();
let mut columns: Vec<&str> = vec!["f_id", "f_tenant_id", "f_full_name"];
let mut casts: Vec<&str> = vec!["", "", ""];
let mut values: Vec<Option<String>> =
vec![Some(new_id.clone()), Some("0".to_string()), Some(full_name)];
for (json_key, column, cast) in DICT_TYPE_WRITE_FIELDS {
if column == "f_full_name" {
continue;
}
if obj.contains_key(json_key) {
columns.push(column);
casts.push(cast);
values.push(value_to_text(obj.get(json_key)));
}
}
if !obj.contains_key("enabledMark") {
columns.push("f_enabled_mark");
casts.push("::integer");
values.push(Some("1".to_string()));
}
if !obj.contains_key("sortCode") {
columns.push("f_sort_code");
casts.push("::bigint");
values.push(Some("0".to_string()));
}
columns.push("f_creator_user_id");
casts.push("");
values.push(Some(user.account));
columns.push("f_delete_mark");
casts.push("::integer");
values.push(Some("0".to_string()));
columns.push("f_creator_time");
let mut marks: Vec<String> = (0..values.len())
.map(|i| placeholder(i + 1, casts[i]))
.collect();
marks.push("now()".to_string());
let sql = format!(
"INSERT INTO base_dictionary_type ({}) VALUES ({})",
columns.join(", "),
marks.join(", ")
);
if let Err(e) = state.db.exec_params(&sql, &params_of(&values)).await {
return db_error(e, "新建字典分类");
}
ok(json!({ "id": new_id }))
}
/// `PUT /api/system/DictionaryType/{id}` —— 改字典分类(**只 SET body 里出现的键**)。
pub async fn dict_type_update(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_DICTIONARY).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,
};
let rows = match state
.db
.query_json_params(
"SELECT f_id AS \"id\" FROM base_dictionary_type \
WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1",
&[&id],
)
.await
{
Ok(rows) => rows,
Err(e) => return db_error(e, "字典分类查询"),
};
if rows.is_empty() {
return fail(code::FAIL, "字典分类不存在");
}
let mut sets: Vec<String> = Vec::new();
let mut values: Vec<Option<String>> = Vec::new();
for (json_key, column, cast) in DICT_TYPE_WRITE_FIELDS {
if !obj.contains_key(json_key) {
continue;
}
values.push(value_to_text(obj.get(json_key)));
sets.push(format!("{} = ${}::text{}", column, values.len(), cast));
}
if sets.is_empty() {
return ok(Value::Null);
}
values.push(Some(user.account));
sets.push(format!("f_last_modify_user_id = ${}::text", values.len()));
sets.push("f_last_modify_time = now()".to_string());
values.push(Some(id));
let sql = format!(
"UPDATE base_dictionary_type SET {} WHERE f_id = ${}::text",
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/DictionaryType/{id}` —— 删字典分类(软删,**不级联**字典数据)。
pub async fn dict_type_delete(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_DICTIONARY).await {
Ok(u) => u,
Err(resp) => return resp,
};
let id = id.trim().to_string();
let values = [Some(user.account), Some(id)];
let sql = "UPDATE base_dictionary_type SET f_delete_mark = 1, f_delete_time = now(), \
f_delete_user_id = $1::text WHERE f_id = $2::text \
AND COALESCE(f_delete_mark,0) = 0";
if let Err(e) = state.db.exec_params(sql, &params_of(&values)).await {
return db_error(e, "删除字典分类");
}
ok(Value::Null)
}
/// `GET /api/system/DictionaryData/{typeId}` —— 某分类下的字典数据(`ListVO`)。
pub async fn dict_data_list(
State(state): State<AppState>,
headers: HeaderMap,
Path(type_id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DICTIONARY).await {
return resp;
}
let type_id = type_id.trim().to_string();
let sql = format!(
"SELECT {DICT_DATA_PROJECTION} FROM base_dictionary_data \
WHERE COALESCE(f_delete_mark,0) = 0 AND f_dictionary_type_id = $1::text \
ORDER BY f_sort_code ASC, f_full_name ASC"
);
match state.db.query_json_params(&sql, &[&type_id]).await {
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "字典数据查询"),
}
}
/// `GET /api/system/DictionaryData/{typeId}/Data/Selector` —— 字典数据下拉。
pub async fn dict_data_selector(
State(state): State<AppState>,
headers: HeaderMap,
Path(type_id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DICTIONARY).await {
return resp;
}
let type_id = type_id.trim().to_string();
let sql = format!(
"SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \
COALESCE(f_parent_id, '0') AS \"parentId\", \
COALESCE(f_sort_code, 0) AS \"sortCode\" \
FROM base_dictionary_data \
WHERE COALESCE(f_delete_mark,0) = 0 AND f_dictionary_type_id = $1::text \
ORDER BY f_sort_code ASC, f_full_name ASC"
);
match state.db.query_json_params(&sql, &[&type_id]).await {
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "字典数据下拉查询"),
}
}
/// `GET /api/system/DictionaryData/{typeId}/Selector/{id}` —— 字典数据**树**下拉。
pub async fn dict_data_selector_tree(
State(state): State<AppState>,
headers: HeaderMap,
Path((type_id, id)): Path<(String, String)>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DICTIONARY).await {
return resp;
}
let type_id = type_id.trim().to_string();
let _ = id.trim();
let sql = format!(
"SELECT {DICT_DATA_PROJECTION} FROM base_dictionary_data \
WHERE COALESCE(f_delete_mark,0) = 0 AND f_dictionary_type_id = $1::text \
ORDER BY f_sort_code ASC, f_full_name ASC"
);
match state.db.query_json_params(&sql, &[&type_id]).await {
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "字典数据树查询"),
}
}
/// `GET /api/system/DictionaryData/{id}/Info` —— 字典数据详情。
pub async fn dict_data_info(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DICTIONARY).await {
return resp;
}
let id = id.trim().to_string();
let sql = format!(
"SELECT {DICT_DATA_PROJECTION} FROM base_dictionary_data \
WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1"
);
match state.db.query_json_params(&sql, &[&id]).await {
Ok(rows) => match rows.into_iter().next() {
Some(row) => ok(row),
None => fail(code::FAIL, "字典数据不存在"),
},
Err(e) => db_error(e, "字典数据详情查询"),
}
}
/// `POST /api/system/DictionaryData` —— 建字典数据。
pub async fn dict_data_create(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_DICTIONARY).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 new_id = new_uuid();
let mut columns: Vec<&str> = vec!["f_id", "f_tenant_id", "f_full_name"];
let mut casts: Vec<&str> = vec!["", "", ""];
let mut values: Vec<Option<String>> =
vec![Some(new_id.clone()), Some("0".to_string()), Some(full_name)];
for (json_key, column, cast) in DICT_DATA_WRITE_FIELDS {
if column == "f_full_name" {
continue;
}
if obj.contains_key(json_key) {
columns.push(column);
casts.push(cast);
values.push(value_to_text(obj.get(json_key)));
}
}
if !obj.contains_key("enabledMark") {
columns.push("f_enabled_mark");
casts.push("::integer");
values.push(Some("1".to_string()));
}
if !obj.contains_key("sortCode") {
columns.push("f_sort_code");
casts.push("::bigint");
values.push(Some("0".to_string()));
}
columns.push("f_creator_user_id");
casts.push("");
values.push(Some(user.account));
columns.push("f_delete_mark");
casts.push("::integer");
values.push(Some("0".to_string()));
columns.push("f_creator_time");
let mut marks: Vec<String> = (0..values.len())
.map(|i| placeholder(i + 1, casts[i]))
.collect();
marks.push("now()".to_string());
let sql = format!(
"INSERT INTO base_dictionary_data ({}) VALUES ({})",
columns.join(", "),
marks.join(", ")
);
if let Err(e) = state.db.exec_params(&sql, &params_of(&values)).await {
return db_error(e, "新建字典数据");
}
ok(json!({ "id": new_id }))
}
/// `PUT /api/system/DictionaryData/{id}` —— 改字典数据(**只 SET body 里出现的键**)。
pub async fn dict_data_update(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_DICTIONARY).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,
};
let rows = match state
.db
.query_json_params(
"SELECT f_id AS \"id\" FROM base_dictionary_data \
WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1",
&[&id],
)
.await
{
Ok(rows) => rows,
Err(e) => return db_error(e, "字典数据查询"),
};
if rows.is_empty() {
return fail(code::FAIL, "字典数据不存在");
}
let mut sets: Vec<String> = Vec::new();
let mut values: Vec<Option<String>> = Vec::new();
for (json_key, column, cast) in DICT_DATA_WRITE_FIELDS {
if !obj.contains_key(json_key) {
continue;
}
values.push(value_to_text(obj.get(json_key)));
sets.push(format!("{} = ${}::text{}", column, values.len(), cast));
}
if sets.is_empty() {
return ok(Value::Null);
}
values.push(Some(user.account));
sets.push(format!("f_last_modify_user_id = ${}::text", values.len()));
sets.push("f_last_modify_time = now()".to_string());
values.push(Some(id));
let sql = format!(
"UPDATE base_dictionary_data SET {} WHERE f_id = ${}::text",
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/DictionaryData/{id}` —— 删字典数据(软删)。
pub async fn dict_data_delete(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_DICTIONARY).await {
Ok(u) => u,
Err(resp) => return resp,
};
let id = id.trim().to_string();
let values = [Some(user.account), Some(id)];
let sql = "UPDATE base_dictionary_data SET f_delete_mark = 1, f_delete_time = now(), \
f_delete_user_id = $1::text WHERE f_id = $2::text \
AND COALESCE(f_delete_mark,0) = 0";
if let Err(e) = state.db.exec_params(sql, &params_of(&values)).await {
return db_error(e, "删除字典数据");
}
ok(Value::Null)
}
/// `GET /api/system/DictionaryData/{id}/Actions/Export` —— 导出字典(**无导出服务**)。
///
/// 🔴 前端 `exportData(id)` 读 `res.data.url`;本仓没有文件导出 ⇒ 恒 `data:null`,
/// 前端 `if (!res.data.url) return;` 会静默跳过(不弹红条)。
pub async fn dict_data_export(
State(state): State<AppState>,
headers: HeaderMap,
Path(id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DICTIONARY).await {
return resp;
}
let _ = id.trim();
ok(Value::Null)
}
#[cfg(test)]
mod tests {
use super::*;
+25 -2
View File
@@ -190,6 +190,20 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
"/api/system/DictionaryData/All",
get(jnpf::dictionary_data_all),
)
.route("/api/system/DictionaryType", get(jnpf::dict_type_list))
.route("/api/system/DictionaryType", post(jnpf::dict_type_create))
.route("/api/system/DictionaryType/Selector/{id}", get(jnpf::dict_type_selector))
.route("/api/system/DictionaryType/{id}", get(jnpf::dict_type_info))
.route("/api/system/DictionaryType/{id}", put(jnpf::dict_type_update))
.route("/api/system/DictionaryType/{id}", delete(jnpf::dict_type_delete))
.route("/api/system/DictionaryData", post(jnpf::dict_data_create))
.route("/api/system/DictionaryData/{id}", get(jnpf::dict_data_list))
.route("/api/system/DictionaryData/{id}/Data/Selector", get(jnpf::dict_data_selector))
.route("/api/system/DictionaryData/{id}/Selector/{pid}", get(jnpf::dict_data_selector_tree))
.route("/api/system/DictionaryData/{id}/Info", get(jnpf::dict_data_info))
.route("/api/system/DictionaryData/{id}", put(jnpf::dict_data_update))
.route("/api/system/DictionaryData/{id}", delete(jnpf::dict_data_delete))
.route("/api/system/DictionaryData/{id}/Actions/Export", get(jnpf::dict_data_export))
.route("/api/system/HomeData", get(jnpf::home_data))
.route(
"/api/system/MenuData/useModuleNum/{id}",
@@ -769,7 +783,7 @@ mod tests {
let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON");
assert_eq!(body["ok"], true);
assert_eq!(body["tables"], 14);
assert_eq!(body["tables"], 16);
assert_eq!(body["version"], env!("CARGO_PKG_VERSION"));
}
@@ -784,7 +798,7 @@ mod tests {
let port = serve(new_state(db().await)).await;
// 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。
const JNPF_REGISTERED: [&str; 55] = [
const JNPF_REGISTERED: [&str; 64] = [
"/api/permission/Users",
"/api/permission/Users/any-id",
"/api/permission/Users/BatchDelete",
@@ -835,6 +849,15 @@ mod tests {
"/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/system/DictionaryData/All",
"/api/system/HomeData",
"/api/system/MenuData/useModuleNum/any-id",