package jnpf.bizcommon.audit.service.value;
|
|
import com.alibaba.fastjson.JSON;
|
import jnpf.bizcommon.audit.entity.model.AuditFieldDiffViewVO;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.core.annotation.Order;
|
import org.springframework.jdbc.core.JdbcTemplate;
|
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
|
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
|
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.Locale;
|
import java.util.Map;
|
import java.util.Set;
|
|
/**
|
* 请验单字段的显式业务解析器；引用表和展示列均为固定白名单。
|
*
|
* <p><b>{@code @Order} 不是装饰</b>（2026-08-02 加）：解析器按注入顺序串行执行，先写上
|
* display 的那个说了算（后续解析器一律 {@code if (display == null)} 才动手）。表专用解析器
|
* 必须排在通用解析器之前，否则 {@code qingyan_ren} 会被
|
* {@link JnpfUserFieldValueResolver} 按通用格式（realName/account）抢先解析掉，
|
* 本类为它定的格式（只显示姓名）就永远不生效。Spring 对没标注的 bean 一律按
|
* {@code LOWEST_PRECEDENCE} 处理、保留扫描序——那是类名字母序的副产品，不该拿它当契约。
|
*/
|
@Slf4j
|
@Component
|
@Order(LimsQingyandanFieldValueResolver.ORDER)
|
public class LimsQingyandanFieldValueResolver implements AuditFieldValueResolver {
|
|
/** 表专用解析器，最先跑。 */
|
public static final int ORDER = 100;
|
|
private static final String TABLE = "lims_qingyandan";
|
private static final String UNAVAILABLE = "名称暂不可用";
|
private static final Map<String, String> BIZ_STATUS = labels(
|
"created", "已创建", "confirmed", "已提交", "pending_fetch", "待取样",
|
"deleted", "已废弃", "cancelled", "已撤回", "fetched", "已取样",
|
"pending_receive", "待接样", "received", "已接样", "rejected", "已退回");
|
private static final Map<String, String> BIZ_TYPE = labels("CP", "成品");
|
private static final Map<String, String> JIANCE_FANGSHI = labels(
|
"quanjian", "全检", "bufenjian", "部分检", "mianjian", "免检");
|
|
private final ReferenceLookup lookup;
|
|
@Autowired
|
public LimsQingyandanFieldValueResolver(JdbcTemplate jdbcTemplate) {
|
this(new JdbcReferenceLookup(jdbcTemplate));
|
}
|
|
LimsQingyandanFieldValueResolver(ReferenceLookup lookup) {
|
this.lookup = lookup;
|
}
|
|
@Override
|
public boolean supports(String targetTable) {
|
return targetTable != null && TABLE.equals(targetTable.trim().toLowerCase(Locale.ROOT));
|
}
|
|
@Override
|
public void resolve(AuditFieldValueContext context, List<AuditFieldDiffViewVO> fields) {
|
if (fields == null || fields.isEmpty()) {
|
return;
|
}
|
applyBusinessEnums(fields);
|
Set<String> projectIds = new LinkedHashSet<>();
|
Set<String> standardIds = new LinkedHashSet<>();
|
Set<String> userIds = new LinkedHashSet<>();
|
Set<String> productIds = new LinkedHashSet<>();
|
|
for (AuditFieldDiffViewVO field : fields) {
|
String name = normalized(field.getField());
|
if ("jiance_xiangmu".equals(name)) {
|
setMissingSemantics(field, "multiReference", "checkbox");
|
collect(projectIds, field.getOldData());
|
collect(projectIds, field.getNewData());
|
} else if ("jianyan_biaozhun".equals(name)) {
|
setMissingSemantics(field, "reference", "select");
|
collect(standardIds, field.getOldData());
|
collect(standardIds, field.getNewData());
|
} else if ("qingyan_ren".equals(name)) {
|
setMissingSemantics(field, "reference", "userSelect");
|
collect(userIds, field.getOldData());
|
collect(userIds, field.getNewData());
|
} else if ("chanpin_id".equals(name)) {
|
setMissingSemantics(field, "reference", "popupSelect");
|
field.setTechnical(Boolean.TRUE);
|
collect(productIds, field.getOldData());
|
collect(productIds, field.getNewData());
|
}
|
}
|
|
if (context == null || blank(context.getTenantId())) {
|
return;
|
}
|
String tenantId = context.getTenantId().trim();
|
Map<String, String> projects = projectIds.isEmpty()
|
? Collections.emptyMap() : lookup.projects(tenantId, projectIds);
|
Map<String, String> standards = standardIds.isEmpty()
|
? Collections.emptyMap() : lookup.standards(tenantId, standardIds);
|
Map<String, String> users = userIds.isEmpty()
|
? Collections.emptyMap() : lookup.users(tenantId, userIds);
|
Map<String, String> products = productIds.isEmpty()
|
? Collections.emptyMap() : lookup.products(tenantId, productIds);
|
|
for (AuditFieldDiffViewVO field : fields) {
|
String name = normalized(field.getField());
|
if ("jiance_xiangmu".equals(name)) {
|
apply(field, projects, true);
|
} else if ("jianyan_biaozhun".equals(name)) {
|
apply(field, standards, false);
|
} else if ("qingyan_ren".equals(name)) {
|
apply(field, users, false);
|
} else if ("chanpin_id".equals(name)) {
|
apply(field, products, false);
|
}
|
}
|
}
|
|
private static void applyBusinessEnums(List<AuditFieldDiffViewVO> fields) {
|
for (AuditFieldDiffViewVO field : fields) {
|
String name = normalized(field.getField());
|
if ("biz_status".equals(name)) {
|
applyEnum(field, BIZ_STATUS, "select");
|
} else if ("biz_type".equals(name)) {
|
applyEnum(field, BIZ_TYPE, "select");
|
} else if ("jiance_fangshi".equals(name)) {
|
applyEnum(field, JIANCE_FANGSHI, "radio");
|
}
|
}
|
}
|
|
private static void applyEnum(AuditFieldDiffViewVO field, Map<String, String> labels,
|
String componentType) {
|
setMissingSemantics(field, "enum", componentType);
|
if (field.getOldDisplay() == null) {
|
field.setOldDisplay(enumDisplay(field.getOldData(), labels));
|
}
|
if (field.getNewDisplay() == null) {
|
field.setNewDisplay(enumDisplay(field.getNewData(), labels));
|
}
|
}
|
|
private static String enumDisplay(String raw, Map<String, String> labels) {
|
if (blank(raw)) {
|
return "";
|
}
|
return labels.get(raw.trim());
|
}
|
|
private static Map<String, String> labels(String... values) {
|
Map<String, String> labels = new LinkedHashMap<>();
|
for (int i = 0; i + 1 < values.length; i += 2) {
|
labels.put(values[i], values[i + 1]);
|
}
|
return Collections.unmodifiableMap(labels);
|
}
|
|
private static void setMissingSemantics(AuditFieldDiffViewVO field,
|
String valueType, String componentType) {
|
if (blank(field.getValueType())) {
|
field.setValueType(valueType);
|
}
|
if (blank(field.getComponentType())) {
|
field.setComponentType(componentType);
|
}
|
}
|
|
private static void apply(AuditFieldDiffViewVO field, Map<String, String> names, boolean multiple) {
|
if (field.getOldDisplay() == null) {
|
field.setOldDisplay(display(field.getOldData(), names, multiple));
|
}
|
if (field.getNewDisplay() == null) {
|
field.setNewDisplay(display(field.getNewData(), names, multiple));
|
}
|
}
|
|
private static String display(String raw, Map<String, String> names, boolean multiple) {
|
if (blank(raw)) {
|
return "";
|
}
|
List<String> ids = multiple ? parseIds(raw) : Collections.singletonList(raw.trim());
|
if (ids.isEmpty()) {
|
return UNAVAILABLE;
|
}
|
List<String> display = new ArrayList<>(ids.size());
|
for (String id : ids) {
|
String name = names.get(id);
|
display.add(blank(name) ? UNAVAILABLE : name);
|
}
|
return String.join("、", display);
|
}
|
|
private static void collect(Set<String> target, String raw) {
|
target.addAll(parseIds(raw));
|
}
|
|
@SuppressWarnings("unchecked")
|
private static List<String> parseIds(String raw) {
|
if (blank(raw)) {
|
return Collections.emptyList();
|
}
|
String trimmed = raw.trim();
|
if (!trimmed.startsWith("[")) {
|
return Collections.singletonList(trimmed);
|
}
|
try {
|
Object parsed = JSON.parse(trimmed);
|
if (!(parsed instanceof Collection)) {
|
return Collections.emptyList();
|
}
|
List<String> ids = new ArrayList<>();
|
for (Object value : (Collection<Object>) parsed) {
|
if (value != null && !String.valueOf(value).trim().isEmpty()) {
|
ids.add(String.valueOf(value).trim());
|
}
|
}
|
return ids;
|
} catch (Throwable ignored) {
|
return Collections.emptyList();
|
}
|
}
|
|
private static String normalized(String field) {
|
return field == null ? null : field.trim().toLowerCase(Locale.ROOT);
|
}
|
|
private static boolean blank(String value) {
|
return value == null || value.trim().isEmpty();
|
}
|
|
interface ReferenceLookup {
|
Map<String, String> projects(String tenantId, Set<String> ids);
|
|
Map<String, String> standards(String tenantId, Set<String> ids);
|
|
Map<String, String> users(String tenantId, Set<String> ids);
|
|
Map<String, String> products(String tenantId, Set<String> ids);
|
}
|
|
/** 每种引用固定一条 IN 查询；SQL 表名和列名不接受外部输入。 */
|
private static final class JdbcReferenceLookup implements ReferenceLookup {
|
private final NamedParameterJdbcTemplate jdbc;
|
|
private JdbcReferenceLookup(JdbcTemplate jdbcTemplate) {
|
this.jdbc = new NamedParameterJdbcTemplate(jdbcTemplate);
|
}
|
|
@Override
|
public Map<String, String> projects(String tenantId, Set<String> ids) {
|
return query("projects", ids, tenantId,
|
"SELECT f_id, jianyan_xiangmu_mingcheng AS display_name "
|
+ "FROM zhiliang_biaozhun_guanli_zixiang "
|
+ "WHERE f_id IN (:ids) "
|
+ "AND COALESCE(NULLIF(f_tenant_id, ''), '0') = :tenantId",
|
row -> text(row.get("display_name")));
|
}
|
|
@Override
|
public Map<String, String> standards(String tenantId, Set<String> ids) {
|
return query("standards", ids, tenantId,
|
"SELECT f_id, biaozhun_bianhao, mingcheng FROM zhiliang_biaozhun_guanli "
|
+ "WHERE f_id IN (:ids) "
|
+ "AND COALESCE(NULLIF(f_tenant_id, ''), '0') = :tenantId",
|
row -> join(text(row.get("biaozhun_bianhao")), text(row.get("mingcheng"))));
|
}
|
|
@Override
|
public Map<String, String> users(String tenantId, Set<String> ids) {
|
return query("users", ids, tenantId,
|
"SELECT f_id, f_real_name, f_account FROM base_user "
|
+ "WHERE f_id IN (:ids) "
|
+ "AND COALESCE(NULLIF(f_tenant_id, ''), '0') = :tenantId",
|
row -> first(text(row.get("f_real_name")), text(row.get("f_account"))));
|
}
|
|
@Override
|
public Map<String, String> products(String tenantId, Set<String> ids) {
|
return query("products", ids, tenantId,
|
"SELECT f_id, mingcheng, bianma FROM yangpin_guanli "
|
+ "WHERE f_id IN (:ids) "
|
+ "AND COALESCE(NULLIF(f_tenant_id, ''), '0') = :tenantId",
|
row -> product(text(row.get("mingcheng")), text(row.get("bianma"))));
|
}
|
|
private Map<String, String> query(String resolverName, Set<String> ids, String tenantId,
|
String sql, DisplayFactory factory) {
|
if (ids.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
try {
|
MapSqlParameterSource params = new MapSqlParameterSource()
|
.addValue("ids", ids)
|
.addValue("tenantId", tenantId);
|
List<Map<String, Object>> rows = jdbc.queryForList(sql, params);
|
Map<String, String> result = new LinkedHashMap<>();
|
for (Map<String, Object> row : rows) {
|
String id = text(row.get("f_id"));
|
String display = factory.display(row);
|
if (id != null && display != null) {
|
result.put(id, display);
|
}
|
}
|
return result;
|
} catch (RuntimeException ex) {
|
log.warn("[AUDIT-QUERY] 字段引用批量解析失败 resolver={} count={} err={}",
|
resolverName, ids.size(), ex.getClass().getSimpleName());
|
return Collections.emptyMap();
|
}
|
}
|
|
private interface DisplayFactory {
|
String display(Map<String, Object> row);
|
}
|
|
private static String join(String code, String name) {
|
if (code == null) {
|
return name;
|
}
|
return name == null ? code : code + " · " + name;
|
}
|
|
private static String product(String name, String code) {
|
if (name == null) {
|
return code;
|
}
|
return code == null ? name : name + "（" + code + "）";
|
}
|
|
private static String first(String first, String second) {
|
return first == null ? second : first;
|
}
|
|
private static String text(Object value) {
|
if (value == null) {
|
return null;
|
}
|
String text = String.valueOf(value).trim();
|
return text.isEmpty() ? null : text;
|
}
|
}
|
}
|
