package jnpf.flowable.util;
|
|
import com.alibaba.fastjson.JSON;
|
import jnpf.base.ActionResult;
|
import jnpf.base.entity.DictionaryDataEntity;
|
import jnpf.base.model.datainterface.DataInterfacePage;
|
import jnpf.base.model.datainterface.DataInterfaceModel;
|
import jnpf.permission.entity.OrganizeEntity;
|
import jnpf.permission.entity.PositionEntity;
|
import jnpf.permission.entity.RoleEntity;
|
import jnpf.permission.entity.GroupEntity;
|
import jnpf.permission.entity.UserEntity;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Component;
|
|
import java.time.Instant;
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
/** Resolves form component keys before they are written into flow titles. */
|
@Component
|
@RequiredArgsConstructor
|
public class FlowAuditTitleValueResolver implements FlowAuditTitleUtil.ValueResolver {
|
private final ServiceUtil serviceUtil;
|
|
@Override
|
public String resolve(Map<String, Object> field, Map<String, Object> config, Object value,
|
Map<String, Object> row) {
|
String raw = FlowAuditTitleUtil.display(value);
|
if (raw == null) {
|
return null;
|
}
|
String key = string(config.get("jnpfKey"));
|
List<String> ids = values(value);
|
switch (key) {
|
case "userSelect":
|
case "createUser":
|
case "modifyUser":
|
return names(ids, serviceUtil.getUserName(ids).stream()
|
.collect(Collectors.toMap(UserEntity::getId, UserEntity::getRealName, (a, b) -> a)));
|
case "customUserSelect":
|
return customUserNames(ids);
|
case "comSelect":
|
case "depSelect":
|
case "currDept":
|
case "currOrganize":
|
return names(ids, serviceUtil.getOrganizeList(ids).stream()
|
.collect(Collectors.toMap(OrganizeEntity::getId, OrganizeEntity::getFullName, (a, b) -> a)));
|
case "posSelect":
|
case "currPosition":
|
return names(ids, serviceUtil.getPosList(ids).stream()
|
.collect(Collectors.toMap(PositionEntity::getId, PositionEntity::getFullName, (a, b) -> a)));
|
case "roleSelect":
|
return names(ids, serviceUtil.getRoleList(ids).stream()
|
.collect(Collectors.toMap(RoleEntity::getId, RoleEntity::getFullName, (a, b) -> a)));
|
case "groupSelect":
|
return names(ids, serviceUtil.getGroupList(ids).stream()
|
.collect(Collectors.toMap(GroupEntity::getId, GroupEntity::getFullName, (a, b) -> a)));
|
case "select":
|
case "treeSelect":
|
case "radio":
|
case "checkbox":
|
case "cascader":
|
return optionNames(field, config, ids, row);
|
case "popupSelect":
|
case "popupTableSelect":
|
return popupNames(field, config, ids, row);
|
case "date":
|
case "dateCalculate":
|
case "createTime":
|
case "modifyTime":
|
return date(field, value, raw);
|
default:
|
return raw;
|
}
|
}
|
|
private String customUserNames(List<String> ids) {
|
List<String> names = new ArrayList<>();
|
for (String value : ids) {
|
int separator = value.lastIndexOf("--");
|
String id = separator < 0 ? value : value.substring(0, separator);
|
String type = separator < 0 ? "user" : value.substring(separator + 2);
|
String name;
|
switch (type) {
|
case "company":
|
case "department":
|
name = names(Collections.singletonList(id), serviceUtil.getOrganizeList(Collections.singletonList(id))
|
.stream().collect(Collectors.toMap(OrganizeEntity::getId, OrganizeEntity::getFullName)));
|
break;
|
case "position":
|
name = names(Collections.singletonList(id), serviceUtil.getPosList(Collections.singletonList(id))
|
.stream().collect(Collectors.toMap(PositionEntity::getId, PositionEntity::getFullName)));
|
break;
|
case "role":
|
name = names(Collections.singletonList(id), serviceUtil.getRoleList(Collections.singletonList(id))
|
.stream().collect(Collectors.toMap(RoleEntity::getId, RoleEntity::getFullName)));
|
break;
|
case "group":
|
name = names(Collections.singletonList(id), serviceUtil.getGroupList(Collections.singletonList(id))
|
.stream().collect(Collectors.toMap(GroupEntity::getId, GroupEntity::getFullName)));
|
break;
|
default:
|
name = names(Collections.singletonList(id), serviceUtil.getUserName(Collections.singletonList(id))
|
.stream().collect(Collectors.toMap(UserEntity::getId, UserEntity::getRealName)));
|
}
|
if (name != null) {
|
names.add(name);
|
}
|
}
|
return names.isEmpty() ? null : String.join(",", names);
|
}
|
|
private String optionNames(Map<String, Object> field, Map<String, Object> config,
|
List<String> ids, Map<String, Object> row) {
|
String type = string(config.get("dataType"));
|
List<Map<String, Object>> options;
|
if ("dictionary".equals(type)) {
|
List<DictionaryDataEntity> dictionary = serviceUtil.getDictionaryData(string(config.get("dictionaryType")));
|
Map<String, String> labels = new LinkedHashMap<>();
|
for (DictionaryDataEntity item : dictionary) {
|
labels.put(item.getId(), item.getFullName());
|
labels.put(item.getEnCode(), item.getFullName());
|
}
|
return names(ids, labels);
|
}
|
if ("dynamic".equals(type)) {
|
ActionResult<Object> result = serviceUtil.infoToId(string(config.get("propsUrl")), parameters(config, row));
|
options = result != null && result.getData() instanceof List
|
? maps((List<?>) result.getData()) : Collections.emptyList();
|
} else {
|
options = maps(list(field.get("options")));
|
}
|
Map<String, Object> props = map(field.get("props"));
|
String valueKey = string(props.getOrDefault("value", "id"));
|
String labelKey = string(props.getOrDefault("label", "fullName"));
|
Map<String, String> labels = new LinkedHashMap<>();
|
collectOptions(options, valueKey, labelKey, string(props.get("children")), labels);
|
return names(ids, labels);
|
}
|
|
private String popupNames(Map<String, Object> field, Map<String, Object> config,
|
List<String> ids, Map<String, Object> row) {
|
String interfaceId = string(field.get("interfaceId"));
|
if (interfaceId.isEmpty()) {
|
return null;
|
}
|
DataInterfacePage page = new DataInterfacePage();
|
page.setIds(ids);
|
page.setPropsValue(string(field.get("propsValue")));
|
page.setRelationField(string(field.get("relationField")));
|
List<DataInterfaceModel> params = new ArrayList<>();
|
for (Object item : list(config.get("templateJson"))) {
|
Map<String, Object> parameter = map(item);
|
DataInterfaceModel model = JSON.parseObject(JSON.toJSONString(parameter), DataInterfaceModel.class);
|
model.setDefaultValue(parameterValue(parameter, row));
|
params.add(model);
|
}
|
page.setParamList(params);
|
List<Map<String, Object>> records = serviceUtil.getInterfaceRows(interfaceId, page);
|
Map<String, String> labels = new LinkedHashMap<>();
|
for (Map<String, Object> record : records) {
|
Object id = record.get(page.getPropsValue());
|
Object label = record.get(page.getRelationField());
|
if (id != null && label != null) {
|
labels.put(String.valueOf(id), String.valueOf(label));
|
}
|
}
|
return names(ids, labels);
|
}
|
|
private static Map<String, String> parameters(Map<String, Object> config, Map<String, Object> row) {
|
Map<String, String> result = new LinkedHashMap<>();
|
for (Object item : list(config.get("templateJson"))) {
|
Map<String, Object> parameter = map(item);
|
String field = string(parameter.get("field"));
|
if (!field.isEmpty()) {
|
result.put(field, parameterValue(parameter, row));
|
}
|
}
|
return result;
|
}
|
|
private static String parameterValue(Map<String, Object> parameter, Map<String, Object> row) {
|
Object source = parameter.get("sourceType");
|
if (source != null && !"1".equals(String.valueOf(source))) {
|
return string(parameter.get("defaultValue"));
|
}
|
return string(row.get(string(parameter.get("relationField"))));
|
}
|
|
private static String date(Map<String, Object> field, Object value, String fallback) {
|
if (!(value instanceof Number) && !fallback.matches("\\d{10,13}")) {
|
return fallback;
|
}
|
try {
|
long timestamp = Long.parseLong(fallback);
|
if (fallback.length() == 10) {
|
timestamp *= 1000;
|
}
|
String format = string(field.get("format"));
|
if (format.isEmpty()) {
|
format = "yyyy-MM-dd HH:mm:ss";
|
}
|
LocalDateTime date = LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());
|
return date.format(DateTimeFormatter.ofPattern(format));
|
} catch (RuntimeException ignored) {
|
return fallback;
|
}
|
}
|
|
private static void collectOptions(List<Map<String, Object>> options, String valueKey, String labelKey,
|
String childrenKey, Map<String, String> labels) {
|
for (Map<String, Object> option : options) {
|
Object value = option.get(valueKey);
|
Object label = option.get(labelKey);
|
if (value != null && label != null) {
|
labels.put(String.valueOf(value), String.valueOf(label));
|
}
|
if (!childrenKey.isEmpty()) {
|
collectOptions(maps(list(option.get(childrenKey))), valueKey, labelKey, childrenKey, labels);
|
}
|
}
|
}
|
|
private static String names(List<String> ids, Map<String, String> labels) {
|
List<String> names = new ArrayList<>();
|
for (String id : ids) {
|
String name = labels.get(id);
|
if (name != null && !name.trim().isEmpty()) {
|
names.add(name);
|
}
|
}
|
return names.isEmpty() ? null : String.join(",", names);
|
}
|
|
private static List<String> values(Object value) {
|
List<?> list = value instanceof List ? (List<?>) value : list(value);
|
if (list.isEmpty() && value != null) {
|
list = Collections.singletonList(value);
|
}
|
List<String> result = new ArrayList<>();
|
for (Object item : list) {
|
if (item != null && !(item instanceof Map) && !String.valueOf(item).trim().isEmpty()) {
|
result.add(String.valueOf(item).trim());
|
}
|
}
|
return result;
|
}
|
|
private static List<?> list(Object value) {
|
if (value instanceof List) {
|
return (List<?>) value;
|
}
|
if (value instanceof String && ((String) value).trim().startsWith("[")) {
|
try {
|
return JSON.parseArray((String) value);
|
} catch (RuntimeException ignored) {
|
return Collections.emptyList();
|
}
|
}
|
return Collections.emptyList();
|
}
|
|
@SuppressWarnings("unchecked")
|
private static Map<String, Object> map(Object value) {
|
return value instanceof Map ? (Map<String, Object>) value : Collections.emptyMap();
|
}
|
|
private static List<Map<String, Object>> maps(List<?> values) {
|
List<Map<String, Object>> result = new ArrayList<>();
|
for (Object value : values) {
|
if (value instanceof Map) {
|
result.add(map(value));
|
}
|
}
|
return result;
|
}
|
|
private static String string(Object value) {
|
return value == null ? "" : String.valueOf(value);
|
}
|
}
|
