From eecf1b03b0fdee1fd25d9ee4c1d0f6d4232d52d0 Mon Sep 17 00:00:00 2001 From: admin Date: Sat, 31 Oct 2026 03:50:49 +0800 Subject: [PATCH] =?UTF-8?q?=E9=9D=A2=20B=EF=BC=9A=E6=95=B0=E6=8D=AE?= =?UTF-8?q?=E5=AD=97=E5=85=B8=E5=88=86=E7=B1=BB+=E6=95=B0=E6=8D=AE=20CRUD?= =?UTF-8?q?=EF=BC=88+14=20=E7=AB=AF=E7=82=B9=EF=BC=8C=E6=96=B0=E8=A1=A8=20?= =?UTF-8?q?2=20=E5=BC=A0=EF=BC=8Ctables=2014=E2=86=9216=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/contract.md | 32 +- src/backend/db/schema.sql | 43 +++ src/backend/src/main.rs | 4 +- src/backend/src/platform/db.rs | 12 +- src/backend/src/platform/jnpf.rs | 514 +++++++++++++++++++++++++++++++ src/backend/src/routes.rs | 27 +- 6 files changed, 621 insertions(+), 11 deletions(-) diff --git a/docs/contract.md b/docs/contract.md index 65763a0..a6348c6 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -437,7 +437,7 @@ SELECT row_to_json(q)::text AS _row FROM () 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}` diff --git a/src/backend/db/schema.sql b/src/backend/db/schema.sql index 4b21710..a4f2585 100644 --- a/src/backend/db/schema.sql +++ b/src/backend/db/schema.sql @@ -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), diff --git a/src/backend/src/main.rs b/src/backend/src/main.rs index 30691ac..da25f9b 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -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", ]; /// 命令行解析的结果(**纯数据**,便于单测)。 diff --git a/src/backend/src/platform/db.rs b/src/backend/src/platform/db.rs index dee6434..3d89f6e 100644 --- a/src/backend/src/platform/db.rs +++ b/src/backend/src/platform/db.rs @@ -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::>().len(), - 14, + 16, "表名不许重复" ); // 8 张 base_* 必须都在(业务表由业务层 spec 派生,不在本文件写死)。 diff --git a/src/backend/src/platform/jnpf.rs b/src/backend/src/platform/jnpf.rs index 7132786..e43d4d0 100644 --- a/src/backend/src/platform/jnpf.rs +++ b/src/backend/src/platform/jnpf.rs @@ -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, + headers: HeaderMap, +) -> Json { + 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, + headers: HeaderMap, + Path(id): Path, +) -> Json { + 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, + headers: HeaderMap, + Path(id): Path, +) -> Json { + 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, + headers: HeaderMap, + body: Bytes, +) -> Json { + 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> = + 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 = (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, ¶ms_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, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + 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 = Vec::new(); + let mut values: Vec> = 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, ¶ms_of(&values)).await { + return db_error(e, "修改字典分类"); + } + ok(Value::Null) +} + +/// `DELETE /api/system/DictionaryType/{id}` —— 删字典分类(软删,**不级联**字典数据)。 +pub async fn dict_type_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + 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, ¶ms_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, + headers: HeaderMap, + Path(type_id): Path, +) -> Json { + 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, + headers: HeaderMap, + Path(type_id): Path, +) -> Json { + 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, + headers: HeaderMap, + Path((type_id, id)): Path<(String, String)>, +) -> Json { + 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, + headers: HeaderMap, + Path(id): Path, +) -> Json { + 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, + headers: HeaderMap, + body: Bytes, +) -> Json { + 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> = + 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 = (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, ¶ms_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, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + 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 = Vec::new(); + let mut values: Vec> = 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, ¶ms_of(&values)).await { + return db_error(e, "修改字典数据"); + } + ok(Value::Null) +} + +/// `DELETE /api/system/DictionaryData/{id}` —— 删字典数据(软删)。 +pub async fn dict_data_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + 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, ¶ms_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, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DICTIONARY).await { + return resp; + } + let _ = id.trim(); + ok(Value::Null) +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index 508aea7..25abba0 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -190,6 +190,20 @@ pub fn build_router(state: AppState) -> axum::Router { "/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",