P2-1: 现代层 OrgController 只读 REST(组织/用户/角色 + OpenAPI)

platform-metadata 新增 OrgController,7 个只读端点,底座为移植的保真层 bean
(organizationService / roleService)+ 引擎 pojoCRUDService:
- GET /api/org/user/{id}            按 ID 查用户(密码脱敏)
- GET /api/org/user/by-account/{a}  按账号查用户
- GET /api/org/user/by-depart/{d}   按部门查在岗用户
- GET /api/org/orgs                 组织列表
- GET /api/org/depart-tree/{org}    组织部门树(层级)
- GET /api/org/roles                角色列表
- GET /api/org/user/{id}/roles      用户-角色关系(含 SYS_ROLE_ROLE 数据角色派生)

@Tag + @Operation 全进 OpenAPI /v3/api-docs;响应 amis {status,msg,data} 约定;
密码列一律脱敏 ***;只读(写路径 P2-4 一起验)。

8085 客户库真实数据实测 7/7 与 DB 直查一致(见 platform-auth/P2组织权限实测报告.md §六)。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
2026-06-11 13:38:49 +08:00
parent 0ebe6d692b
commit 8d1d2ab0f7

View File

@@ -0,0 +1,243 @@
package com.eip4.platform.metadata.web;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.dsasp.server.common.dataDic.bean.GeneralPOJO;
import com.dsasp.server.common.dataDic.service.POJOCRUDService;
import com.dsasp.server.common.organization.service.OrganizationService;
import com.dsasp.server.common.user.service.RoleService;
import com.dsasp.server.common.util.UserSession;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
/**
* P2 组织/用户/角色只读 REST 门面。
*
* <p>底座是移植自 framework 的保真层 bean(原样、包名/签名不动):
* {@code organizationService}(组织/部门/岗位查询)、{@code roleService}(用户角色)、
* 以及引擎 {@code pojoCRUDService}(用户/角色实体读)。本控制器只做<b>只读</b>聚合,
* 写路径(分配角色、维护规则)由 P2-4 一起验。
*
* <p>口径:用户查询(按 id / 账号 / 部门)、组织树(按公司层级)、角色列表、用户-角色关系。
* 所有读经 ADMIN 上下文(不触发行级过滤——本接口是管理视角元数据查询,行级过滤对拍由
* platform-parity 的真实实体权限对拍覆盖)。
*/
@Tag(name = "组织/用户/角色(只读)", description = "P2 移植保真层组织权限模块的现代层只读门面")
@RestController
public class OrgController {
private final OrganizationService organizationService;
private final RoleService roleService;
private final POJOCRUDService pojoCRUDService;
private final JdbcTemplate jdbcTemplate;
public OrgController(OrganizationService organizationService,
RoleService roleService,
POJOCRUDService pojoCRUDService,
JdbcTemplate jdbcTemplate) {
this.organizationService = organizationService;
this.roleService = roleService;
this.pojoCRUDService = pojoCRUDService;
this.jdbcTemplate = jdbcTemplate;
}
// ---------------------------------------------------------------- 用户查询
@Operation(summary = "按用户 ID 查询单个用户(经引擎 loadPOJO 读 SYS_USER,密码列脱敏)")
@GetMapping("/api/org/user/{id}")
public Map<String, Object> userById(
@Parameter(description = "SYS_USER.SYS_USER_ID(36 位)") @PathVariable String id) {
GeneralPOJO po = pojoCRUDService.loadPOJO(id, "SYS_USER", UserSession.getAdmin(), false);
return ok(po == null ? null : maskUser(toRow(po)));
}
@Operation(summary = "按账号查询用户(经引擎 listSelect 按 ACCOUNT 过滤 SYS_USER)")
@GetMapping("/api/org/user/by-account/{account}")
public Map<String, Object> userByAccount(
@Parameter(description = "SYS_USER.ACCOUNT 登录账号") @PathVariable String account) {
Map<String, Object> cond = new LinkedHashMap<>();
cond.put("ACCOUNT", account);
List<Map<String, Object>> rows = maskUsers(listUsers(cond));
return okList(rows);
}
@Operation(summary = "按部门查询在岗用户(SYS_POSITION→SYS_POSITIONUSER→SYS_USER,经引擎 UserFindService 同源)")
@GetMapping("/api/org/user/by-depart/{departId}")
public Map<String, Object> usersByDepart(
@Parameter(description = "SYS_DEPART.SYS_DEPART_ID 部门 ID") @PathVariable String departId) {
// 部门 → 岗位 → 在岗用户 id(与引擎 UserFindServiceImpl.findUsersByDepart 同语义:经岗位中转)
List<String> userIds = jdbcTemplate.queryForList(
"SELECT DISTINCT trim(pu.userid) FROM sys_position p "
+ "JOIN sys_positionuser pu ON pu.positionid = p.sys_position_id "
+ "WHERE p.parentdepartid = ?", String.class, departId);
List<Map<String, Object>> rows = new ArrayList<>();
for (String uid : userIds) {
GeneralPOJO po = pojoCRUDService.loadPOJO(uid, "SYS_USER", UserSession.getAdmin(), false);
if (po != null) {
rows.add(maskUser(toRow(po)));
}
}
return okList(rows);
}
// ---------------------------------------------------------------- 组织树
@Operation(summary = "组织(公司)列表(SYS_ORG,活跃)")
@GetMapping("/api/org/orgs")
public Map<String, Object> orgs() {
List<Map<String, Object>> rows = jdbcTemplate.query(
"SELECT trim(sys_org_id) AS id, trim(name) AS name, trim(parentid) AS parentid, seq, trim(code) AS code "
+ "FROM sys_org WHERE isactive=1 ORDER BY seq, name",
(rs, i) -> {
Map<String, Object> m = new LinkedHashMap<>();
m.put("id", rs.getString("id"));
m.put("name", rs.getString("name"));
m.put("parentId", rs.getString("parentid"));
m.put("seq", rs.getObject("seq"));
m.put("code", rs.getString("code"));
return m;
});
return okList(rows);
}
@Operation(summary = "某公司的部门树(VIEW_DEPART_TREE 层级,经引擎 organizationService.getDepartTreeByOrgId)")
@GetMapping("/api/org/depart-tree/{orgId}")
public Map<String, Object> departTree(
@Parameter(description = "SYS_ORG.SYS_ORG_ID 公司 ID") @PathVariable String orgId) {
// 保真层口径:organizationService.getDepartTreeByOrgId 返回 [{SYS_DEPART_ID, NAME(=path)}]
List<Map<String, Object>> flat = organizationService.getDepartTreeByOrgId(orgId);
// 补层级/父子(VIEW_DEPART_TREE 的 level/parentid/path),供前端构树
List<Map<String, Object>> tree = jdbcTemplate.query(
"SELECT trim(view_depart_id) AS id, trim(parentid) AS parentid, level, path, seq "
+ "FROM view_depart_tree WHERE orgid = ? ORDER BY level, seq",
(rs, i) -> {
Map<String, Object> m = new LinkedHashMap<>();
m.put("id", rs.getString("id"));
m.put("parentId", rs.getString("parentid"));
m.put("level", rs.getObject("level"));
m.put("path", rs.getString("path"));
m.put("seq", rs.getObject("seq"));
return m;
}, orgId);
Map<String, Object> data = new LinkedHashMap<>();
data.put("orgId", orgId);
data.put("departCount", tree.size());
data.put("flat", flat); // 保真层原样返回(SYS_DEPART_ID + path)
data.put("tree", tree); // 带 level/parentId 便于前端构树
return okData(data);
}
// ---------------------------------------------------------------- 角色
@Operation(summary = "角色列表(SYS_ROLE,活跃)")
@GetMapping("/api/org/roles")
public Map<String, Object> roles() {
List<Map<String, Object>> rows = jdbcTemplate.query(
"SELECT trim(sys_role_id) AS id, trim(name) AS name, trim(description) AS description, roletype "
+ "FROM sys_role WHERE isactive=1 ORDER BY name",
(rs, i) -> {
Map<String, Object> m = new LinkedHashMap<>();
m.put("id", rs.getString("id"));
m.put("name", rs.getString("name"));
m.put("description", rs.getString("description"));
m.put("roleType", rs.getObject("roletype"));
return m;
});
return okList(rows);
}
@Operation(summary = "用户-角色关系:某用户的有效角色(经保真层 roleService.findRolesByUserId,含 SYS_ROLE_ROLE 数据角色派生)")
@GetMapping("/api/org/user/{id}/roles")
public Map<String, Object> rolesOfUser(
@Parameter(description = "SYS_USER.SYS_USER_ID 用户 ID") @PathVariable String id) {
// 保真层语义:直接岗位组角色 UNION SYS_ROLE_ROLE 派生的数据角色
List<String> roleIds = roleService.findRolesByUserId(id);
List<Map<String, Object>> rows = new ArrayList<>();
if (roleIds != null && !roleIds.isEmpty()) {
// 翻译角色名(只读补显示,语义不变)
for (String rid : roleIds) {
Map<String, Object> m = new LinkedHashMap<>();
m.put("roleId", rid == null ? null : rid.trim());
List<String> names = jdbcTemplate.queryForList(
"SELECT trim(name) FROM sys_role WHERE sys_role_id = ?", String.class, rid);
m.put("roleName", names.isEmpty() ? null : names.get(0));
rows.add(m);
}
}
Map<String, Object> data = new LinkedHashMap<>();
data.put("userId", id);
data.put("roleCount", rows.size());
data.put("roles", rows);
return okData(data);
}
// ---------------------------------------------------------------- 内部工具
@SuppressWarnings("unchecked")
private List<Map<String, Object>> listUsers(Map<String, Object> cond) {
Map<String, Object> result = pojoCRUDService.listSelect(
new LinkedHashMap<>(cond), "SYS_USER", UserSession.getAdmin());
List<Map<String, Object>> rows = new ArrayList<>();
Object list = result.get(POJOCRUDService.LIST_RESULT);
if (list instanceof List<?> l) {
for (Object o : l) {
if (o instanceof GeneralPOJO p) {
rows.add(toRow(p));
}
}
}
return rows;
}
private Map<String, Object> toRow(GeneralPOJO p) {
Map<String, Object> row = new LinkedHashMap<>();
row.put("_id", p.get_ID());
for (int i = 0; i < p.get_ColumnCount(); i++) {
row.put(p.get_ColumnName(i), p.get_Value(i));
}
return row;
}
/** 用户行密码列脱敏(只读门面不外泄哈希;密码哈希算法见 P2组织权限实测报告.md)。 */
private Map<String, Object> maskUser(Map<String, Object> row) {
if (row != null && row.containsKey("PASSWORD")) {
row.put("PASSWORD", "***");
}
return row;
}
private List<Map<String, Object>> maskUsers(List<Map<String, Object>> rows) {
rows.forEach(this::maskUser);
return rows;
}
private Map<String, Object> ok(Object data) {
return okData(data);
}
private Map<String, Object> okData(Object data) {
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("status", 0);
resp.put("msg", "");
resp.put("data", data);
return resp;
}
private Map<String, Object> okList(List<Map<String, Object>> items) {
Map<String, Object> data = new LinkedHashMap<>();
data.put("items", items);
data.put("total", items.size());
return okData(data);
}
}