面 B:用户选人/授权/角色关系/用户关系(+16 端点);官方覆盖 101/112 → 121/128

This commit is contained in:
admin committed 2026-10-31 03:59:16 +08:00
1 parent eecf1b03b0
commit e237d641b5
3 files changed
+625 -7

No files matched your search

+38 -6
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`,一行一条端点,**116** 条;
> (列:`face` / `method` / `path` / `guard` / `owner`,一行一条端点,**132** 条;
> 外加 `[FACE]` 区段登记各契约面的条数)。
> 由 **`scripts/check-contract.sh`** 把它与**代码里真实注册的路由**逐条对账
> (总数 / 存在性 / 方法 / 归属层 / 守卫,**双向**)⇒
@@ -1235,6 +1235,22 @@ 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/Users/Selector permission.user platform
B POST /api/permission/Users/getUserList permission.user platform
B POST /api/permission/Users/getSelectedList permission.user platform
B POST /api/permission/Users/getSelectedUserList permission.user platform
B GET /api/permission/Users/ReceiveUserList permission.user platform
B GET /api/permission/Users/getAllPermission permission.user platform
B GET /api/permission/Users/Authorize permission.user platform
B GET /api/permission/Authority/{kind}/{objectId} permission.role platform
B POST /api/permission/Authority/{kind}/{objectId} permission.role platform
B GET /api/permission/RoleRelation/roleList permission.role platform
B POST /api/permission/RoleRelation/addRoles permission.role platform
B POST /api/permission/RoleRelation/deleteRoles permission.role platform
B POST /api/permission/RoleRelation/delete permission.role platform
B POST /api/permission/UserRelation permission.user platform
B POST /api/permission/UserRelation/delete permission.user platform
B GET /api/permission/UserRelation/userList permission.user platform
B GET /api/permission/Role permission.role platform
B POST /api/oauth/Logout 登录 platform
B GET /api/system/BaseLang/LangJson 登录 platform
@@ -1257,7 +1273,7 @@ A DELETE /api/ssw/asset/DataResource/Delete asset/DataResource asset
[FACE]
# face 条数 说明
A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条)
B 86 面 B 专属(官方 JNPF 形状)
B 102 面 B 专属(官方 JNPF 形状)
AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流)
[OFFICIAL]
@@ -1285,7 +1301,7 @@ DELETE /api/permission/Users/{id} implemented UserController.java:496 面 B 已
POST /api/permission/Users/BatchDelete implemented UserController.java:592 面 B 已落地:一条 UPDATE … IN ⇒ 原子;空集合返成功
POST /api/permission/Users/BatchUpdateState implemented UserController.java:694 面 B 已落地:批量改 f_enabled_mark
GET /api/permission/Users/All absent UserController.java:729 全量用户未做
GET /api/permission/Users/Selector absent UserController.java:769 用户下拉未做
GET /api/permission/Users/Selector implemented UserController.java:769 用户下拉未做
POST /api/permission/Users/UserCondition absent UserController.java:806 用户条件查询未做
GET /api/permission/Users/{id}/GetPosition implemented UserController.java:273 面 B 已落地:无 base_position 表 ⇒ 由 f_position_id 反推,包成 `[{id}]`
POST /api/permission/Users/{id}/Actions/ResetPassword implemented user.ts:37 面 B 已落地:body.password ⇒ md5;兼容 newPassword
@@ -1295,9 +1311,9 @@ GET /api/permission/Users/TemplateDownload oos user.ts:57-69 导入导出族 —
POST /api/permission/Users/ImportData oos user.ts:57-69 导入导出族 —— v1 明确不做
POST /api/permission/Users/ImportPreview oos user.ts:57-69 导入导出族 —— v1 明确不做
GET /api/permission/Users/ExportExceptionData oos user.ts:57-69 导入导出族 —— v1 明确不做
POST /api/permission/Users/getUserList absent user.ts:49 批量选择族(可后置,未列入 v1 范围也未明确排除)
POST /api/permission/Users/getSelectedList absent user.ts:73 批量选择族(可后置)
POST /api/permission/Users/getSelectedUserList absent user.ts:77 批量选择族(可后置)
POST /api/permission/Users/getUserList implemented user.ts:49 批量选择族(可后置,未列入 v1 范围也未明确排除)
POST /api/permission/Users/getSelectedList implemented user.ts:73 批量选择族(可后置)
POST /api/permission/Users/getSelectedUserList implemented user.ts:77 批量选择族(可后置)
GET /api/permission/Group implemented group.ts:9 面 B 已落地:ListVO `{list}`(前端 `user/index.vue:340` 取 `res.data.list`);新表 `base_group`(官方 `JNPF-PostgreSQL.sql:1758`,14 列逐字)
POST /api/permission/Group implemented group.ts:17 面 B 已落地:白名单写库 + 名称非空校验,返 `{id}`;成员关系**不在**本表
GET /api/permission/Group/{id} implemented group.ts:25 面 B 已落地:`GroupForm.vue:64` 直接 `setFieldsValue(res.data)`
@@ -1362,6 +1378,22 @@ 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/Users/Selector implemented user.ts:13 面 B 已落地:用户选择器 ListVO;`keyword` 命中 `f_account`/`f_real_name`
POST /api/permission/Users/getUserList implemented user.ts:49 面 B 已落地:body `{ids}` ⇒ `ANY(string_to_array(...))`
POST /api/permission/Users/getSelectedList implemented user.ts:73 面 B 已落地:**刻意不复用** getUserList(委托会让契约扫描器推不出守卫)
POST /api/permission/Users/getSelectedUserList implemented user.ts:77 面 B 已落地:组织维度已选用户,同 getSelectedList
GET /api/permission/Users/ReceiveUserList implemented user.ts:89 面 B 已落地:交接接收人候选,同 Selector(**先自己判守卫再委托**)
GET /api/permission/Users/getAllPermission implemented user.ts:109 面 B 已落地:点权限集合 = 可见菜单的 `f_en_code`(本仓只做菜单级,见限制 (ag))
GET /api/permission/Users/Authorize implemented user.ts:113 面 B 已落地:同 getAllPermission(授权只到菜单级)
GET /api/permission/Authority/{kind}/{objectId} implemented auth.ts:17 面 B 已落地:**恒 `{ids:[], all:false, list:[]}`**(本仓无 Portal/流程/打印模板三类对象)
POST /api/permission/Authority/{kind}/{objectId} implemented auth.ts:21 面 B 已落地:恒成功(同上,无对象可授权)
GET /api/permission/RoleRelation/roleList implemented roleRelation.ts:29 面 B 已落地:`base_role_relation` 只记用户↔角色 ⇒ `objectId` 当**用户 id** 用
POST /api/permission/RoleRelation/addRoles implemented roleRelation.ts:21 面 B 已落地:body `{objectId, roleIds}`;幂等插(`ON CONFLICT DO NOTHING`)
POST /api/permission/RoleRelation/deleteRoles implemented roleRelation.ts:25 面 B 已落地:body `{objectId, roleIds}` ⇒ 软删关系行
POST /api/permission/RoleRelation/delete implemented roleRelation.ts:17 面 B 已落地:body `{objectId, ids}`,等价 deleteRoles
POST /api/permission/UserRelation implemented userRelation.ts:13 面 B 已落地:body `{objectType, objectId, userIds}`,写 `base_user_relation`
POST /api/permission/UserRelation/delete implemented userRelation.ts:17 面 B 已落地:软删关系行
GET /api/permission/UserRelation/userList implemented userRelation.ts:9 面 B 已落地:`objectId` 下的用户 ListVO
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}`
+555
View File
@@ -1023,6 +1023,24 @@ fn flag_of(v: Option<&Value>) -> &'static str {
/// 取 body 里的 id 数组(`{ids:[…]}` / `{ids:"a,b"}` 都认)。
///
/// 🔴 非数组 ⇒ **空集合**(官方批量接口对空集合返回成功,不报错)。
/// 取 `obj[key]` 的字符串 id 数组(数组或逗号串都收;空 ⇒ 空数组)。
fn id_list_of(obj: &Map<String, Value>, key: &str) -> Vec<String> {
match obj.get(key) {
Some(Value::Array(items)) => items
.iter()
.filter_map(|v| match v {
Value::String(s) if !s.is_empty() => Some(s.clone()),
Value::Number(n) => Some(n.to_string()),
_ => None,
})
.collect(),
Some(Value::String(s)) if !s.is_empty() => {
s.split(',').map(|x| x.trim().to_string()).collect()
}
_ => Vec::new(),
}
}
fn id_list(obj: &Map<String, Value>) -> Vec<String> {
match obj.get("ids") {
Some(Value::Array(items)) => items
@@ -4098,6 +4116,543 @@ pub async fn dict_data_export(
ok(Value::Null)
}
// ---------------------------------------------------------------- 用户选人 / 授权 / 关系
/// `GET /api/permission/Users/Selector` —— 用户下拉(**用户选择器**,`ListVO`)。
///
/// 🔴 几乎所有「选人」控件都走它(工作流、授权、交接)。本仓只有 `base_user` 一张表
/// ⇒ 恒返未软删用户;`organizeId`/`positionId`/`roleId` 暂不做过滤(本仓无对应关系表)。
pub async fn users_selector(
State(state): State<AppState>,
headers: HeaderMap,
raw: RawQuery,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_USER).await {
return resp;
}
let keyword = crate::platform::sys::query_param(&raw, "keyword");
let keyword = keyword.trim().to_string();
let sql = if keyword.is_empty() {
format!(
"SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \
f_real_name AS \"fullName\", f_gender AS \"gender\", \
f_mobile_phone AS \"mobilePhone\", f_email AS \"email\", \
f_head_icon AS \"headIcon\", \
COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \
COALESCE(f_sort_code, 0) AS \"sortCode\" \
FROM base_user WHERE f_delete_mark = 0 \
ORDER BY f_sort_code ASC, f_account ASC"
)
} else {
format!(
"SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \
f_real_name AS \"fullName\", f_gender AS \"gender\", \
f_mobile_phone AS \"mobilePhone\", f_email AS \"email\", \
f_head_icon AS \"headIcon\", \
COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \
COALESCE(f_sort_code, 0) AS \"sortCode\" \
FROM base_user WHERE f_delete_mark = 0 \
AND (f_account ILIKE $1::text OR f_real_name ILIKE $1::text) \
ORDER BY f_sort_code ASC, f_account ASC"
)
};
let like_values = [Some(format!("%{keyword}%"))];
let params: Vec<&(dyn ToSql + Sync)> = if keyword.is_empty() {
Vec::new()
} else {
params_of(&like_values)
};
match state.db.query_json_params(&sql, &params).await {
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "用户下拉查询"),
}
}
/// `POST /api/permission/Users/getUserList` —— 按 id 集取用户基本信息(body `{ids:[…]}`)。
pub async fn users_get_user_list(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_USER).await {
return resp;
}
let obj = match parse_body(&body) {
Ok(Value::Object(o)) => o,
Ok(_) => return ok(list_vo(Vec::new())),
Err(resp) => return resp,
};
let ids = id_list(&obj);
if ids.is_empty() {
return ok(list_vo(Vec::new()));
}
let joined = ids.join(",");
let sql = "SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \
f_real_name AS \"fullName\", f_gender AS \"gender\", \
f_mobile_phone AS \"mobilePhone\", f_email AS \"email\", \
f_head_icon AS \"headIcon\", f_organize_id AS \"organizeId\", \
f_position_id AS \"positionId\", \
COALESCE(f_enabled_mark, 0) AS \"enabledMark\" \
FROM base_user WHERE f_delete_mark = 0 \
AND f_id = ANY(string_to_array($1::text, ',')) \
ORDER BY f_account ASC";
match state
.db
.query_json_params(sql, &params_of(&[Some(joined)]))
.await
{
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "用户基本信息查询"),
}
}
/// `POST /api/permission/Users/getSelectedList` —— 已选用户(**刻意不复用 `getUserList`**)。
pub async fn users_get_selected_list(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_USER).await {
return resp;
}
let obj = match parse_body(&body) {
Ok(Value::Object(o)) => o,
Ok(_) => return ok(list_vo(Vec::new())),
Err(resp) => return resp,
};
let ids = id_list(&obj);
if ids.is_empty() {
return ok(list_vo(Vec::new()));
}
let joined = ids.join(",");
let sql = "SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \
f_real_name AS \"fullName\", f_head_icon AS \"headIcon\", \
f_organize_id AS \"organizeId\", f_position_id AS \"positionId\" \
FROM base_user WHERE f_delete_mark = 0 \
AND f_id = ANY(string_to_array($1::text, ','))";
match state
.db
.query_json_params(sql, &params_of(&[Some(joined)]))
.await
{
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "已选用户查询"),
}
}
/// `POST /api/permission/Users/getSelectedUserList` —— 已选用户(**组织维度**,恒同 `getSelectedList`)。
pub async fn users_get_selected_user_list(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_USER).await {
return resp;
}
let obj = match parse_body(&body) {
Ok(Value::Object(o)) => o,
Ok(_) => return ok(list_vo(Vec::new())),
Err(resp) => return resp,
};
let ids = id_list(&obj);
if ids.is_empty() {
return ok(list_vo(Vec::new()));
}
let joined = ids.join(",");
let sql = "SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \
f_real_name AS \"fullName\", f_head_icon AS \"headIcon\", \
f_organize_id AS \"organizeId\", f_position_id AS \"positionId\" \
FROM base_user WHERE f_delete_mark = 0 \
AND f_id = ANY(string_to_array($1::text, ','))";
match state
.db
.query_json_params(sql, &params_of(&[Some(joined)]))
.await
{
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "已选用户(组织维度)查询"),
}
}
/// `GET /api/permission/Users/ReceiveUserList` —— 工作交接的**接收人**候选(`ListVO`)。
pub async fn users_receive_user_list(
State(state): State<AppState>,
headers: HeaderMap,
) -> Json<ActionResult> {
// 🔴 守卫**先自己判一遍**:契约扫描器静态推守卫,纯委托会「推不出」。
if let Err(resp) = guard(&state, &headers, EN_USER).await {
return resp;
}
users_selector(State(state), headers, RawQuery(None)).await
}
/// `GET /api/permission/Users/getAllPermission` —— 当前用户的**全部点权限**(`ListVO`)。
///
/// 🔴 本仓**只做菜单级**权限(已知限制 (ag))⇒ 点权限集合 = 可见菜单的 `f_en_code` 列表。
pub async fn users_get_all_permission(
State(state): State<AppState>,
headers: HeaderMap,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_USER).await {
Ok(u) => u,
Err(resp) => return resp,
};
let sys = system::resolve_system(&state.db, system::app_code_of(&headers).as_deref()).await;
let rows = load_menus(&state.db, &user.user_id, user.is_admin, &sys.id).await;
let list: Vec<Value> = rows
.into_iter()
.filter_map(|m| {
let code = m.en_code.clone().unwrap_or_default().trim().to_string();
if code.is_empty() {
None
} else {
Some(json!({ "enCode": code, "id": m.id, "fullName": m.full_name }))
}
})
.collect();
ok(list_vo(list))
}
/// `GET /api/permission/Users/Authorize` —— 用户授权页的**已授权集合**(`ListVO`)。
///
/// 🔴 本仓授权只到菜单级 ⇒ 返该用户可见菜单 id 列表,形状与 `getAllPermission` 同源。
pub async fn users_authorize(
State(state): State<AppState>,
headers: HeaderMap,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_USER).await {
return resp;
}
users_get_all_permission(State(state), headers).await
}
/// `GET /api/permission/Authority/{type}/{objectId}` —— 通用权限树(门户/流程/打印模板)。
///
/// 🔴 本仓**没有** Portal / 流程 / 打印模板三类对象 ⇒ 恒返空权限模型
/// (`ids:[]` + `all:false`),与面 B 的 `AuthorityDataReturnVO` 同形。
pub async fn authority_common_values(
State(state): State<AppState>,
headers: HeaderMap,
Path((kind, object_id)): Path<(String, String)>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_ROLE).await {
return resp;
}
let _ = (kind.trim(), object_id.trim());
ok(json!({ "ids": [], "all": false, "list": [] }))
}
/// `POST /api/permission/Authority/{type}/{objectId}` —— 更新通用权限(**恒成功**)。
pub async fn authority_common_update(
State(state): State<AppState>,
headers: HeaderMap,
Path((kind, object_id)): Path<(String, String)>,
body: Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_ROLE).await {
return resp;
}
let _ = (kind.trim(), object_id.trim(), body);
ok(Value::Null)
}
/// `GET /api/permission/RoleRelation/roleList` —— 某对象已绑定的角色(`ListVO`)。
///
/// 🔴 官方是「按 objectId 查角色关系」;本仓 `base_role_relation` 只记**用户↔角色**
/// ⇒ `objectId` 当**用户 id** 用;查不到就返空(不是错误)。
pub async fn role_relation_role_list(
State(state): State<AppState>,
headers: HeaderMap,
raw: RawQuery,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_ROLE).await {
return resp;
}
let object_id = crate::platform::sys::query_param(&raw, "objectId");
let object_id = object_id.trim().to_string();
if object_id.is_empty() {
return ok(list_vo(Vec::new()));
}
// 🔴 `base_role_relation` 是**通用对象关系**(`f_object_type` + `f_object_id`),
// 没有 `f_user_id` 这一列 —— 官方同构(`RoleRelation` 可挂用户/机构/岗位/分组)。
let sql = "SELECT r.f_id AS \"id\", r.f_full_name AS \"fullName\", \
r.f_en_code AS \"enCode\", r.f_type AS \"type\", \
COALESCE(r.f_sort_code, 0) AS \"sortCode\" \
FROM base_role_relation rr \
JOIN base_role r ON r.f_id = rr.f_role_id \
WHERE COALESCE(rr.f_delete_mark,0) = 0 AND COALESCE(r.f_delete_mark,0) = 0 \
AND rr.f_object_id = $1::text \
ORDER BY r.f_sort_code ASC, r.f_full_name ASC";
match state
.db
.query_json_params(sql, &params_of(&[Some(object_id)]))
.await
{
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "角色关系查询"),
}
}
/// `POST /api/permission/RoleRelation/addRoles` —— 给对象批量**加**角色(body `{objectId, roleIds}`)。
pub async fn role_relation_add_roles(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_ROLE).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 object_id = obj
.get("objectId")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string();
let ids = id_list_of(&obj, "roleIds");
if object_id.is_empty() || ids.is_empty() {
return ok(Value::Null);
}
let object_type = obj
.get("objectType")
.and_then(Value::as_str)
.unwrap_or_default()
.trim();
let object_type = if object_type.is_empty() {
"User".to_string()
} else {
object_type.to_string()
};
for role_id in ids {
let values = [
Some(new_uuid()),
Some(user.account.clone()),
Some(object_id.clone()),
Some(object_type.clone()),
Some(role_id),
];
let sql = "INSERT INTO base_role_relation \
(f_id, f_creator_user_id, f_object_id, f_object_type, f_role_id, \
f_creator_time, f_delete_mark) \
VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, now(), 0) \
ON CONFLICT DO NOTHING";
if let Err(e) = state.db.exec_params(sql, &params_of(&values)).await {
return db_error(e, "添加角色关系");
}
}
ok(Value::Null)
}
/// `POST /api/permission/RoleRelation/deleteRoles` —— 批量**解绑**角色(body `{objectId, roleIds}`)。
pub async fn role_relation_delete_roles(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_ROLE).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 object_id = obj
.get("objectId")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string();
let ids = id_list_of(&obj, "roleIds");
if object_id.is_empty() || ids.is_empty() {
return ok(Value::Null);
}
for role_id in ids {
let values = [
Some(user.account.clone()),
Some(object_id.clone()),
Some(role_id),
];
let sql = "UPDATE base_role_relation SET f_delete_mark = 1, f_delete_time = now(), \
f_delete_user_id = $1::text \
WHERE f_object_id = $2::text AND f_role_id = $3::text";
if let Err(e) = state.db.exec_params(sql, &params_of(&values)).await {
return db_error(e, "删除角色关系");
}
}
ok(Value::Null)
}
/// `POST /api/permission/RoleRelation/delete` —— 解绑(body `{objectId, ids}`,恒等价 `deleteRoles`)。
pub async fn role_relation_delete(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_ROLE).await {
return resp;
}
let obj = match parse_body(&body) {
Ok(Value::Object(o)) => o,
Ok(_) => return ok(Value::Null),
Err(resp) => return resp,
};
let object_id = obj
.get("objectId")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string();
let ids = id_list_of(&obj, "ids");
if object_id.is_empty() || ids.is_empty() {
return ok(Value::Null);
}
for role_id in ids {
let values = [Some(object_id.clone()), Some(role_id)];
let sql = "UPDATE base_role_relation SET f_delete_mark = 1, f_delete_time = now() \
WHERE f_object_id = $1::text AND f_role_id = $2::text";
if let Err(e) = state.db.exec_params(sql, &params_of(&values)).await {
return db_error(e, "删除角色关系");
}
}
ok(Value::Null)
}
/// `POST /api/permission/UserRelation` —— 建用户↔对象关系(body `{objectType, objectId, userIds}`)。
pub async fn user_relation_create(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_USER).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 object_type = obj
.get("objectType")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string();
let object_id = obj
.get("objectId")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string();
let ids = id_list_of(&obj, "userIds");
if object_id.is_empty() || ids.is_empty() {
return ok(Value::Null);
}
let object_type = if object_type.is_empty() {
"Group".to_string()
} else {
object_type
};
for uid in ids {
let values = [
Some(new_uuid()),
Some(user.account.clone()),
Some(uid),
Some(object_type.clone()),
Some(object_id.clone()),
];
let sql = "INSERT INTO base_user_relation \
(f_id, f_creator_user_id, f_user_id, f_object_type, f_object_id, \
f_creator_time, f_delete_mark) \
VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, now(), 0) \
ON CONFLICT DO NOTHING";
if let Err(e) = state.db.exec_params(sql, &params_of(&values)).await {
return db_error(e, "新建用户关系");
}
}
ok(Value::Null)
}
/// `POST /api/permission/UserRelation/delete` —— 删用户↔对象关系(body `{objectType, objectId, userIds}`)。
pub async fn user_relation_delete(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
let user = match guard(&state, &headers, EN_USER).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 object_id = obj
.get("objectId")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string();
let ids = id_list_of(&obj, "userIds");
if object_id.is_empty() || ids.is_empty() {
return ok(Value::Null);
}
for uid in ids {
let values = [
Some(user.account.clone()),
Some(uid),
Some(object_id.clone()),
];
let sql = "UPDATE base_user_relation SET f_delete_mark = 1, f_delete_time = now(), \
f_delete_user_id = $1::text \
WHERE f_user_id = $2::text AND f_object_id = $3::text";
if let Err(e) = state.db.exec_params(sql, &params_of(&values)).await {
return db_error(e, "删除用户关系");
}
}
ok(Value::Null)
}
/// `GET /api/permission/UserRelation/userList` —— 某对象下的用户(`ListVO`)。
pub async fn user_relation_user_list(
State(state): State<AppState>,
headers: HeaderMap,
raw: RawQuery,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_USER).await {
return resp;
}
let object_id = crate::platform::sys::query_param(&raw, "objectId");
let object_id = object_id.trim().to_string();
if object_id.is_empty() {
return ok(list_vo(Vec::new()));
}
let sql = "SELECT u.f_id AS \"id\", u.f_account AS \"account\", \
u.f_real_name AS \"realName\", u.f_real_name AS \"fullName\", \
u.f_head_icon AS \"headIcon\", \
COALESCE(u.f_enabled_mark, 0) AS \"enabledMark\" \
FROM base_user_relation ur \
JOIN base_user u ON u.f_id = ur.f_user_id \
WHERE COALESCE(ur.f_delete_mark,0) = 0 AND COALESCE(u.f_delete_mark,0) = 0 \
AND ur.f_object_id = $1::text";
match state
.db
.query_json_params(sql, &params_of(&[Some(object_id)]))
.await
{
Ok(rows) => ok(list_vo(rows)),
Err(e) => db_error(e, "用户关系列表查询"),
}
}
#[cfg(test)]
mod tests {
use super::*;
+32 -1
View File
@@ -180,6 +180,22 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
"/api/permission/Users/{id}/SelectorByUserPosId",
get(jnpf::user_selector_by_pos_id),
)
.route("/api/permission/Users/Selector", get(jnpf::users_selector))
.route("/api/permission/Users/getUserList", post(jnpf::users_get_user_list))
.route("/api/permission/Users/getSelectedList", post(jnpf::users_get_selected_list))
.route("/api/permission/Users/getSelectedUserList", post(jnpf::users_get_selected_user_list))
.route("/api/permission/Users/ReceiveUserList", get(jnpf::users_receive_user_list))
.route("/api/permission/Users/getAllPermission", get(jnpf::users_get_all_permission))
.route("/api/permission/Users/Authorize", get(jnpf::users_authorize))
.route("/api/permission/Authority/{kind}/{objectId}", get(jnpf::authority_common_values))
.route("/api/permission/Authority/{kind}/{objectId}", post(jnpf::authority_common_update))
.route("/api/permission/RoleRelation/roleList", get(jnpf::role_relation_role_list))
.route("/api/permission/RoleRelation/addRoles", post(jnpf::role_relation_add_roles))
.route("/api/permission/RoleRelation/deleteRoles", post(jnpf::role_relation_delete_roles))
.route("/api/permission/RoleRelation/delete", post(jnpf::role_relation_delete))
.route("/api/permission/UserRelation", post(jnpf::user_relation_create))
.route("/api/permission/UserRelation/delete", post(jnpf::user_relation_delete))
.route("/api/permission/UserRelation/userList", get(jnpf::user_relation_user_list))
.route(
"/api/system/System/getDevUser",
get(jnpf::system_get_dev_user),
@@ -798,7 +814,7 @@ mod tests {
let port = serve(new_state(db().await)).await;
// 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。
const JNPF_REGISTERED: [&str; 64] = [
const JNPF_REGISTERED: [&str; 79] = [
"/api/permission/Users",
"/api/permission/Users/any-id",
"/api/permission/Users/BatchDelete",
@@ -858,6 +874,21 @@ mod tests {
"/api/system/DictionaryData/any-id/Data/Selector",
"/api/system/DictionaryData/any-id/Selector/any-id",
"/api/system/DictionaryData/any-id/Actions/Export",
"/api/permission/Users/Selector",
"/api/permission/Users/getUserList",
"/api/permission/Users/getSelectedList",
"/api/permission/Users/getSelectedUserList",
"/api/permission/Users/ReceiveUserList",
"/api/permission/Users/getAllPermission",
"/api/permission/Users/Authorize",
"/api/permission/Authority/any-id/any-id",
"/api/permission/RoleRelation/roleList",
"/api/permission/RoleRelation/addRoles",
"/api/permission/RoleRelation/deleteRoles",
"/api/permission/RoleRelation/delete",
"/api/permission/UserRelation",
"/api/permission/UserRelation/delete",
"/api/permission/UserRelation/userList",
"/api/system/DictionaryData/All",
"/api/system/HomeData",
"/api/system/MenuData/useModuleNum/any-id",