package jnpf.dmsIntegration.audit;
|
|
import jnpf.dmsEntity.permission.entity.DmsAccessExclusionEntity;
|
import jnpf.dmsEntity.permission.entity.DmsDocumentEntity;
|
import jnpf.dmsEntity.permission.entity.DmsFilePermissionEntity;
|
import jnpf.dmsEntity.permission.entity.DmsFileVersionEntity;
|
import jnpf.dmsEntity.permission.entity.DmsFolderEntity;
|
import jnpf.dmsMapper.DmsDocumentMapper;
|
import jnpf.dmsMapper.DmsFileVersionMapper;
|
import jnpf.dmsMapper.DmsFolderMapper;
|
import jnpf.dmsMapper.DmsPermissionGroupMapper;
|
import jnpf.permission.OrganizeApi;
|
import jnpf.permission.PositionApi;
|
import jnpf.permission.RoleApi;
|
import jnpf.permission.UserApi;
|
import jnpf.permission.entity.OrganizeEntity;
|
import jnpf.permission.entity.PermissionGroupEntity;
|
import jnpf.permission.entity.PositionEntity;
|
import jnpf.permission.entity.RoleEntity;
|
import jnpf.permission.entity.UserEntity;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Component;
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.UUID;
|
import java.util.function.Function;
|
|
/** Resolves occurrence-time display labels for permission audit evidence. */
|
@Slf4j
|
@Component
|
@RequiredArgsConstructor
|
public class DmsPermissionAuditDisplayResolver {
|
private final DmsFolderMapper folderMapper;
|
private final DmsDocumentMapper documentMapper;
|
private final DmsFileVersionMapper fileVersionMapper;
|
private final UserApi userApi;
|
private final OrganizeApi organizeApi;
|
private final PositionApi positionApi;
|
private final RoleApi roleApi;
|
private final DmsPermissionGroupMapper permissionGroupMapper;
|
|
public DisplayValues resolvePermissions(String tenantId, Collection<DmsFilePermissionEntity> values) {
|
DisplayValues result = new DisplayValues();
|
resolveResources(tenantId, permissionResources(values), result);
|
Map<String, Set<String>> principals = new LinkedHashMap<>();
|
Set<String> users = new LinkedHashSet<>();
|
if (values != null) {
|
for (DmsFilePermissionEntity value : values) {
|
if (value == null) continue;
|
add(principals, value.getPrincipalType(), value.getPrincipalId());
|
add(users, value.getGrantedById());
|
add(users, value.getRevokedById());
|
}
|
}
|
resolvePrincipals(principals, result);
|
resolveUsers(users, result);
|
return result;
|
}
|
|
public DisplayValues resolveExclusions(String tenantId, Collection<DmsAccessExclusionEntity> values) {
|
DisplayValues result = new DisplayValues();
|
resolveResources(tenantId, exclusionResources(values), result);
|
Set<String> users = new LinkedHashSet<>();
|
if (values != null) {
|
for (DmsAccessExclusionEntity value : values) {
|
if (value == null) continue;
|
add(users, value.getUserId());
|
add(users, value.getExcludedById());
|
add(users, value.getRevokedById());
|
}
|
}
|
resolveUsers(users, result);
|
return result;
|
}
|
|
private void resolveResources(String tenantId, Map<String, Set<UUID>> ids, DisplayValues result) {
|
try {
|
List<UUID> folderIds = list(ids.get("FOLDER"));
|
if (!folderIds.isEmpty()) {
|
for (DmsFolderEntity item : orEmpty(folderMapper.selectByTenantAndIds(tenantId, folderIds))) {
|
result.resources.put(key("FOLDER", item.getId()), fallback(item.getName(), item.getId()));
|
}
|
}
|
} catch (RuntimeException ex) {
|
log.warn("DMS permission audit folder display lookup failed", ex);
|
}
|
try {
|
List<UUID> documentIds = list(ids.get("DOCUMENT"));
|
if (!documentIds.isEmpty()) {
|
for (DmsDocumentEntity item : orEmpty(documentMapper.selectByTenantAndIds(tenantId, documentIds))) {
|
String label = joinCode(item.getDocumentNo(), item.getName());
|
result.resources.put(key("DOCUMENT", item.getId()), fallback(label, item.getId()));
|
}
|
}
|
} catch (RuntimeException ex) {
|
log.warn("DMS permission audit document display lookup failed", ex);
|
}
|
try {
|
List<UUID> versionIds = list(ids.get("FILE_VERSION"));
|
if (!versionIds.isEmpty()) {
|
for (DmsFileVersionEntity item : orEmpty(fileVersionMapper.selectByTenantAndIds(
|
tenantId, versionIds))) {
|
String version = trim(item.getVersionLabel());
|
String label = trim(item.getFileName());
|
if (label != null && version != null) label = label + " - " + version;
|
result.resources.put(key("FILE_VERSION", item.getId()), fallback(label, item.getId()));
|
}
|
}
|
} catch (RuntimeException ex) {
|
log.warn("DMS permission audit file version display lookup failed", ex);
|
}
|
}
|
|
private void resolvePrincipals(Map<String, Set<String>> ids, DisplayValues result) {
|
resolveUsers(ids.get("USER"), result);
|
List<String> orgIds = list(ids.get("ORG"));
|
if (!orgIds.isEmpty()) try {
|
putNames(result.principals, "ORG", organizeApi.getListByIds(orgIds),
|
OrganizeEntity::getId, OrganizeEntity::getFullName);
|
} catch (RuntimeException ex) { log.warn("DMS permission audit organization display lookup failed", ex); }
|
List<String> positionIds = list(ids.get("POSITION"));
|
if (!positionIds.isEmpty()) try {
|
putNames(result.principals, "POSITION", positionApi.getListByIds(positionIds),
|
PositionEntity::getId, PositionEntity::getFullName);
|
} catch (RuntimeException ex) { log.warn("DMS permission audit position display lookup failed", ex); }
|
List<String> roleIds = list(ids.get("ROLE"));
|
if (!roleIds.isEmpty()) try {
|
putNames(result.principals, "ROLE", roleApi.getListByIds(roleIds),
|
RoleEntity::getId, RoleEntity::getFullName);
|
} catch (RuntimeException ex) { log.warn("DMS permission audit role display lookup failed", ex); }
|
Set<String> groupIds = ids.get("GROUP");
|
if (groupIds != null && !groupIds.isEmpty()) try {
|
putNames(result.principals, "GROUP", permissionGroupMapper.selectEnabledByIds(groupIds),
|
PermissionGroupEntity::getId, PermissionGroupEntity::getFullName);
|
} catch (RuntimeException ex) { log.warn("DMS permission audit group display lookup failed", ex); }
|
}
|
|
private void resolveUsers(Collection<String> ids, DisplayValues result) {
|
List<String> requested = list(ids);
|
if (requested.isEmpty()) return;
|
try {
|
for (UserEntity user : orEmpty(userApi.getUserName(requested))) {
|
if (user == null || trim(user.getId()) == null) continue;
|
String name = trim(user.getRealName());
|
String account = trim(user.getAccount());
|
String display = name != null && account != null ? name + "（" + account + "）"
|
: (name != null ? name : account);
|
if (display != null) {
|
result.users.put(user.getId(), display);
|
result.principals.put(key("USER", user.getId()), display);
|
}
|
}
|
} catch (RuntimeException ex) {
|
log.warn("DMS permission audit user display lookup failed", ex);
|
}
|
}
|
|
private static Map<String, Set<UUID>> permissionResources(Collection<DmsFilePermissionEntity> values) {
|
Map<String, Set<UUID>> result = new LinkedHashMap<>();
|
if (values != null) {
|
for (DmsFilePermissionEntity value : values) {
|
if (value != null) add(result, value.getResourceType(), value.getResourceId());
|
}
|
}
|
return result;
|
}
|
|
private static Map<String, Set<UUID>> exclusionResources(Collection<DmsAccessExclusionEntity> values) {
|
Map<String, Set<UUID>> result = new LinkedHashMap<>();
|
if (values != null) {
|
for (DmsAccessExclusionEntity value : values) {
|
if (value != null) add(result, value.getResourceType(), value.getResourceId());
|
}
|
}
|
return result;
|
}
|
|
private static <T> void putNames(Map<String, String> target, String type, Collection<T> values,
|
Function<T, String> id, Function<T, String> name) {
|
if (values == null) return;
|
for (T value : values) {
|
if (value == null || trim(id.apply(value)) == null || trim(name.apply(value)) == null) continue;
|
target.put(key(type, id.apply(value)), name.apply(value).trim());
|
}
|
}
|
|
private static String joinCode(String code, String name) {
|
String normalizedCode = trim(code);
|
String normalizedName = trim(name);
|
if (normalizedCode != null && normalizedName != null) return "[" + normalizedCode + "] " + normalizedName;
|
return normalizedName != null ? normalizedName : normalizedCode;
|
}
|
|
private static String fallback(String value, Object id) {
|
return trim(value) == null ? String.valueOf(id) : value.trim();
|
}
|
|
private static String key(String type, Object id) {
|
return String.valueOf(type) + ":" + String.valueOf(id);
|
}
|
|
private static <T> void add(Map<String, Set<T>> target, String type, T id) {
|
if (trim(type) != null && id != null) {
|
target.computeIfAbsent(type.trim(), ignored -> new LinkedHashSet<>()).add(id);
|
}
|
}
|
|
private static void add(Set<String> target, String value) {
|
if (trim(value) != null) target.add(value.trim());
|
}
|
|
private static <T> List<T> list(Collection<T> values) {
|
return values == null || values.isEmpty() ? Collections.emptyList() : new ArrayList<>(values);
|
}
|
|
private static <T> List<T> orEmpty(List<T> values) {
|
return values == null ? Collections.emptyList() : values;
|
}
|
|
private static String trim(String value) {
|
return value == null || value.trim().isEmpty() ? null : value.trim();
|
}
|
|
public static final class DisplayValues {
|
private final Map<String, String> resources = new LinkedHashMap<>();
|
private final Map<String, String> principals = new LinkedHashMap<>();
|
private final Map<String, String> users = new LinkedHashMap<>();
|
|
public String resource(String type, UUID id) {
|
return display(resources.get(key(type, id)), id);
|
}
|
|
public String principal(String type, String id) {
|
return display(principals.get(key(type, id)), id);
|
}
|
|
public String user(String id) {
|
return display(users.get(id), id);
|
}
|
|
DisplayValues addResource(String type, UUID id, String display) {
|
resources.put(key(type, id), display);
|
return this;
|
}
|
|
DisplayValues addPrincipal(String type, String id, String display) {
|
principals.put(key(type, id), display);
|
return this;
|
}
|
|
DisplayValues addUser(String id, String display) {
|
users.put(id, display);
|
principals.put(key("USER", id), display);
|
return this;
|
}
|
|
private static String display(String resolved, Object raw) {
|
return resolved != null ? resolved : (raw == null ? "" : raw + "（名称暂不可用）");
|
}
|
}
|
}
|
