feat(metadata): wire legacy user select picker
Some checks failed
ci / build-test-parity (push) Has been cancelled

This commit is contained in:
2026-06-17 21:31:11 +08:00
parent 380d1f17ca
commit 1581a99d75
8 changed files with 2694 additions and 2157 deletions

View File

@@ -0,0 +1,428 @@
package com.eip4.platform.metadata.web;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
* 旧 UserSelectWindow / UserOrgSelectWindow 的现代选择源。
*
* <p>前端使用 amis 内建 {@code tabs-transfer-picker},本端点返回其 options/searchApi
* 所需的树形/扁平选项。值保持旧系统口径:人员、组织、部门、岗位类别均提交原始 id,
* 「全体人员」提交旧窗口使用的 CHAR(36) 填充值。
*/
@RestController
@RequestMapping("/api/user-select")
public class UserSelectController {
/** 旧 UserOrgSelectWindow 中的 ALL 常量,保留尾部空格以兼容历史值。 */
static final String ALL_VALUE = "ALL ";
private static final int DEFAULT_LIMIT = 2000;
private final JdbcTemplate jdbcTemplate;
public UserSelectController(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@GetMapping("/options")
public Map<String, Object> options(@RequestParam(defaultValue = "controlled") String mode,
@RequestParam(required = false) String q,
@RequestParam(defaultValue = "" + DEFAULT_LIMIT) int limit) {
String normalizedMode = normalizeMode(mode);
int safeLimit = safeLimit(limit);
List<Map<String, Object>> users = listUsers(normalizedMode, q, safeLimit);
List<Map<String, Object>> tabs = new ArrayList<>();
tabs.add(tab("全部人员", "users", users));
tabs.add(tab("按公司、部门选择人员", "depart-users", departmentUserTree(users)));
tabs.add(tab("按岗位类别选择人员", "position-type-users", positionTypeUserTree(users)));
tabs.add(tab("按用户类别选择人员", "category-users", categoryUserTree(users)));
if ("org".equals(normalizedMode)) {
tabs.add(tab("全体人员", "all-users", List.of(option("全体人员", ALL_VALUE, "all"))));
tabs.add(tab("选择公司", "orgs", orgOptions(null, 500)));
tabs.add(tab("选择部门", "departs", departOptions(null, 1000)));
tabs.add(tab("选择岗位类别", "position-types", positionTypeOptions(null, 500)));
}
return okOptions(tabs);
}
@GetMapping("/search")
public Map<String, Object> search(@RequestParam(defaultValue = "controlled") String mode,
@RequestParam(name = "term", required = false) String term,
@RequestParam(name = "q", required = false) String q,
@RequestParam(defaultValue = "200") int limit) {
String normalizedMode = normalizeMode(mode);
String keyword = firstNonBlank(term, q);
int safeLimit = safeLimit(limit);
List<Map<String, Object>> result = new ArrayList<>(listUsers(normalizedMode, keyword, safeLimit));
if ("org".equals(normalizedMode)) {
if (matches(keyword, "全体人员") || matches(keyword, "ALL")) {
result.add(option("全体人员", ALL_VALUE, "all"));
}
result.addAll(orgOptions(keyword, 50));
result.addAll(departOptions(keyword, 100));
result.addAll(positionTypeOptions(keyword, 50));
}
return okOptions(result);
}
private List<Map<String, Object>> listUsers(String mode, String q, int limit) {
UserSource source = "attendance".equals(mode)
? new UserSource("view_user_kq", "view_user_kq_id", false, true)
: new UserSource("view_sys_user", "view_sys_user_id", true, false);
String labelExpr = source.hasDisplayName
? "COALESCE(NULLIF(trim(u.displayname), ''), trim(u.name) || '[' || trim(u.account) || ']')"
: "trim(u.name) || '[' || trim(u.account) || ']'";
StringBuilder sql = new StringBuilder()
.append("SELECT trim(u.").append(source.idColumn).append(") AS value, ")
.append(labelExpr).append(" AS label, ")
.append("trim(u.account) AS account, trim(u.name) AS name, ")
.append("trim(u.userorgid) AS userorgid, ")
.append("trim(u.masterdepart) AS masterdepart, trim(u.masterposition) AS masterposition ")
.append("FROM ").append(source.table).append(" u ")
.append("WHERE u.isactive = 1 AND u.state IN (1, 2) ");
List<Object> args = new ArrayList<>();
if (source.attendance && hasCollectedAttendanceRows()) {
sql.append("AND u.iscollected = 1 ");
}
appendKeywordFilter(sql, args, q, source.hasDisplayName);
sql.append("ORDER BY u.account ASC LIMIT ?");
args.add(limit);
return jdbcTemplate.query(sql.toString(), (rs, rowNum) -> userOption(rs), args.toArray());
}
private List<Map<String, Object>> departmentUserTree(List<Map<String, Object>> users) {
List<Map<String, Object>> orgs = orgOptions(null, 1000);
Map<String, Map<String, Object>> orgNodes = new LinkedHashMap<>();
for (Map<String, Object> org : orgs) {
Map<String, Object> node = groupNode(String.valueOf(org.get("label")), "ORG-GROUP:" + org.get("value"));
node.put("children", new ArrayList<Map<String, Object>>());
orgNodes.put(String.valueOf(org.get("value")), node);
}
List<Map<String, Object>> departs = jdbcTemplate.query(
"SELECT trim(view_depart_id) AS value, COALESCE(trim(parentid), '') AS parentid, "
+ "trim(orgid) AS orgid, path, seq "
+ "FROM view_depart_tree ORDER BY orgid, level, seq",
(rs, rowNum) -> {
Map<String, Object> node = groupNode(lastPathName(rs.getString("path")),
"DEPART-GROUP:" + rs.getString("value"));
node.put("departId", rs.getString("value"));
node.put("parentId", rs.getString("parentid"));
node.put("orgId", rs.getString("orgid"));
node.put("children", new ArrayList<Map<String, Object>>());
return node;
});
Map<String, Map<String, Object>> departNodes = new LinkedHashMap<>();
for (Map<String, Object> node : departs) {
departNodes.put(String.valueOf(node.get("departId")), node);
}
for (Map<String, Object> node : departs) {
String parentId = String.valueOf(node.get("parentId") == null ? "" : node.get("parentId"));
Map<String, Object> parent = departNodes.get(parentId);
if (parent != null) {
children(parent).add(node);
} else {
Map<String, Object> org = orgNodes.get(String.valueOf(node.get("orgId")));
if (org != null) {
children(org).add(node);
}
}
}
for (Map<String, Object> user : users) {
String departId = stringValue(user.get("masterDepart"));
Map<String, Object> depart = departNodes.get(departId);
if (depart != null) {
children(depart).add(user);
continue;
}
Map<String, Object> org = orgNodes.get(stringValue(user.get("userOrgId")));
if (org != null) {
children(org).add(user);
}
}
List<Map<String, Object>> roots = new ArrayList<>();
for (Map<String, Object> node : orgNodes.values()) {
if (pruneEmptyGroups(node)) {
roots.add(node);
}
}
return roots;
}
private List<Map<String, Object>> positionTypeUserTree(List<Map<String, Object>> users) {
List<Map<String, Object>> types = positionTypeOptions(null, 500);
if (types.isEmpty()) {
return List.of();
}
Map<String, Map<String, Object>> nodes = new LinkedHashMap<>();
for (Map<String, Object> type : types) {
Map<String, Object> node = groupNode(String.valueOf(type.get("label")),
"POSITIONTYPE-GROUP:" + type.get("value"));
node.put("children", new ArrayList<Map<String, Object>>());
nodes.put(String.valueOf(type.get("value")), node);
}
Map<String, String> positionToType = jdbcTemplate.query(
"SELECT trim(sys_position_id) AS positionid, trim(positiontype) AS positiontype FROM sys_position "
+ "WHERE isactive = 1 AND positiontype IS NOT NULL",
rs -> {
Map<String, String> map = new LinkedHashMap<>();
while (rs.next()) {
map.put(rs.getString("positionid"), rs.getString("positiontype"));
}
return map;
});
for (Map<String, Object> user : users) {
Map<String, Object> node = nodes.get(positionToType.get(stringValue(user.get("masterPosition"))));
if (node != null) {
children(node).add(user);
}
}
return nodes.values().stream().filter(n -> !children(n).isEmpty()).toList();
}
private List<Map<String, Object>> categoryUserTree(List<Map<String, Object>> users) {
List<Map<String, Object>> categories = jdbcTemplate.query(
"SELECT trim(sys_category_id) AS value, trim(categoryname) AS label "
+ "FROM sys_category WHERE isactive = 1 ORDER BY categoryname",
optionMapper("category"));
if (categories.isEmpty()) {
return List.of();
}
Map<String, Map<String, Object>> nodes = new LinkedHashMap<>();
for (Map<String, Object> category : categories) {
Map<String, Object> node = groupNode(String.valueOf(category.get("label")),
"CATEGORY-GROUP:" + category.get("value"));
node.put("children", new ArrayList<Map<String, Object>>());
nodes.put(String.valueOf(category.get("value")), node);
}
Map<String, List<String>> categoryUsers = jdbcTemplate.query(
"SELECT trim(categoryid) AS categoryid, trim(userid) AS userid FROM sys_categoryuser",
rs -> {
Map<String, List<String>> map = new LinkedHashMap<>();
while (rs.next()) {
map.computeIfAbsent(rs.getString("categoryid"), k -> new ArrayList<>())
.add(rs.getString("userid"));
}
return map;
});
Map<String, Map<String, Object>> userById = new LinkedHashMap<>();
for (Map<String, Object> user : users) {
userById.put(stringValue(user.get("value")), user);
}
for (Map.Entry<String, List<String>> entry : categoryUsers.entrySet()) {
Map<String, Object> node = nodes.get(entry.getKey());
if (node == null) {
continue;
}
for (String userId : entry.getValue()) {
Map<String, Object> user = userById.get(userId);
if (user != null) {
children(node).add(user);
}
}
}
return nodes.values().stream().filter(n -> !children(n).isEmpty()).toList();
}
private List<Map<String, Object>> orgOptions(String q, int limit) {
StringBuilder sql = new StringBuilder("SELECT trim(sys_org_id) AS value, trim(name) AS label "
+ "FROM sys_org WHERE isactive = 1 ");
List<Object> args = new ArrayList<>();
appendSimpleNameFilter(sql, args, q, "name");
sql.append("ORDER BY seq, name LIMIT ?");
args.add(limit);
return jdbcTemplate.query(sql.toString(), optionMapper("org"), args.toArray());
}
private List<Map<String, Object>> departOptions(String q, int limit) {
StringBuilder sql = new StringBuilder("SELECT trim(view_depart_id) AS value, path AS label "
+ "FROM view_depart_tree WHERE 1 = 1 ");
List<Object> args = new ArrayList<>();
appendSimpleNameFilter(sql, args, q, "path");
sql.append("ORDER BY orgid, seq LIMIT ?");
args.add(limit);
return jdbcTemplate.query(sql.toString(), (rs, rowNum) ->
option(lastPathName(rs.getString("label")), rs.getString("value"), "depart"), args.toArray());
}
private List<Map<String, Object>> positionTypeOptions(String q, int limit) {
StringBuilder sql = new StringBuilder("SELECT trim(sys_positiontype_id) AS value, trim(name) AS label "
+ "FROM sys_positiontype WHERE isactive = 1 ");
List<Object> args = new ArrayList<>();
appendSimpleNameFilter(sql, args, q, "name");
sql.append("ORDER BY name LIMIT ?");
args.add(limit);
return jdbcTemplate.query(sql.toString(), optionMapper("positionType"), args.toArray());
}
private boolean hasCollectedAttendanceRows() {
Number count = jdbcTemplate.queryForObject(
"SELECT count(*) FROM view_user_kq WHERE iscollected = 1", Number.class);
return count != null && count.longValue() > 0;
}
private void appendKeywordFilter(StringBuilder sql, List<Object> args, String q, boolean hasDisplayName) {
String keyword = normalizeKeyword(q);
if (keyword == null) {
return;
}
sql.append("AND (lower(u.account) LIKE ? OR lower(u.name) LIKE ? OR lower(u.mobile) LIKE ? ");
args.add(keyword);
args.add(keyword);
args.add(keyword);
if (hasDisplayName) {
sql.append("OR lower(u.displayname) LIKE ? ");
args.add(keyword);
}
sql.append(") ");
}
private void appendSimpleNameFilter(StringBuilder sql, List<Object> args, String q, String column) {
String keyword = normalizeKeyword(q);
if (keyword == null) {
return;
}
sql.append("AND lower(").append(column).append(") LIKE ? ");
args.add(keyword);
}
private static Map<String, Object> userOption(ResultSet rs) throws SQLException {
Map<String, Object> item = option(rs.getString("label"), rs.getString("value"), "user");
item.put("account", rs.getString("account"));
item.put("name", rs.getString("name"));
item.put("userOrgId", rs.getString("userorgid"));
item.put("masterDepart", rs.getString("masterdepart"));
item.put("masterPosition", rs.getString("masterposition"));
return item;
}
private static RowMapper<Map<String, Object>> optionMapper(String type) {
return (rs, rowNum) -> option(rs.getString("label"), rs.getString("value"), type);
}
private static Map<String, Object> tab(String label, String value, List<Map<String, Object>> children) {
Map<String, Object> tab = new LinkedHashMap<>();
tab.put("label", label);
tab.put("value", value);
tab.put("children", children == null ? List.of() : children);
return tab;
}
private static Map<String, Object> groupNode(String label, String value) {
Map<String, Object> item = option(label, value, "group");
item.put("disabled", true);
return item;
}
private static Map<String, Object> option(String label, String value, String type) {
Map<String, Object> item = new LinkedHashMap<>();
item.put("label", label == null || label.isBlank() ? value : label.trim());
item.put("value", value == null ? "" : value);
item.put("type", type);
return item;
}
private static boolean pruneEmptyGroups(Map<String, Object> node) {
List<Map<String, Object>> children = children(node);
children.removeIf(child -> "group".equals(child.get("type")) && !pruneEmptyGroups(child));
return !"group".equals(node.get("type")) || !children.isEmpty();
}
@SuppressWarnings("unchecked")
private static List<Map<String, Object>> children(Map<String, Object> node) {
Object children = node.get("children");
if (children instanceof List<?> list) {
return (List<Map<String, Object>>) list;
}
List<Map<String, Object>> list = new ArrayList<>();
node.put("children", list);
return list;
}
private static Map<String, Object> okOptions(List<Map<String, Object>> options) {
Map<String, Object> data = new LinkedHashMap<>();
data.put("options", options);
data.put("items", options);
data.put("total", options.size());
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("status", 0);
resp.put("msg", "");
resp.put("data", data);
return resp;
}
private static String normalizeMode(String mode) {
String m = mode == null ? "" : mode.trim().toLowerCase(Locale.ROOT);
return switch (m) {
case "all", "org", "attendance" -> m;
default -> "controlled";
};
}
private static int safeLimit(int limit) {
if (limit <= 0) {
return DEFAULT_LIMIT;
}
return Math.min(limit, 5000);
}
private static String normalizeKeyword(String q) {
if (q == null || q.isBlank()) {
return null;
}
String s = q.trim().toLowerCase(Locale.ROOT)
.replace("\\", "\\\\")
.replace("%", "\\%")
.replace("_", "\\_");
return "%" + s + "%";
}
private static boolean matches(String keyword, String value) {
if (keyword == null || keyword.isBlank()) {
return false;
}
return value.toLowerCase(Locale.ROOT).contains(keyword.trim().toLowerCase(Locale.ROOT));
}
private static String firstNonBlank(String a, String b) {
if (a != null && !a.isBlank()) {
return a;
}
return b;
}
private static String stringValue(Object value) {
return value == null ? "" : String.valueOf(value).trim();
}
private static String lastPathName(String path) {
if (path == null || path.isBlank()) {
return "";
}
int idx = path.lastIndexOf('>');
return idx >= 0 ? path.substring(idx + 1).trim() : path.trim();
}
private record UserSource(String table, String idColumn, boolean hasDisplayName, boolean attendance) {
}
}