package jnpf.bizcommon.audit.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import jnpf.audit.model.AuditEventDTO;
|
import jnpf.audit.AuditConsts;
|
import jnpf.bizcommon.audit.entity.AuditEventEntity;
|
import jnpf.bizcommon.audit.mapper.AuditEventMapper;
|
import jnpf.bizcommon.audit.service.AuditEventService;
|
import jnpf.bizcommon.audit.service.AuditFormRegistry;
|
import jnpf.bizcommon.audit.service.support.AuditDiffKey;
|
import jnpf.bizcommon.audit.service.support.AuditEventCategories;
|
import jnpf.util.JsonUtil;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.function.Function;
|
|
@Slf4j
|
@Service
|
public class AuditEventServiceImpl implements AuditEventService {
|
|
@Autowired
|
private AuditEventMapper auditEventMapper;
|
|
@Autowired
|
private AuditFormRegistry auditFormRegistry;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int saveIdempotent(AuditEventDTO dto) {
|
validate(dto);
|
AuditEventEntity entity = toEntity(dto);
|
entity.setEventCategory(AuditEventCategories.resolve(entity.getEventType(), entity.getExtra()));
|
entity.setFieldDiffs(scopeFieldDiffs(entity.getFieldDiffs(),
|
entity.getTargetTable(), entity.getTargetId()));
|
entity.setFieldDiffs(filterFieldDiffs(entity.getFieldDiffs(), entity.getTargetTable(),
|
auditFormRegistry::resolvePhysicalColumns));
|
int rows = auditEventMapper.insertIgnore(entity);
|
if (rows > 0 || isBlank(entity.getOperationId())) {
|
return rows;
|
}
|
|
AuditEventEntity existing = auditEventMapper.selectByOperationCategoryForUpdate(
|
entity.getOperationId(), entity.getEventCategory());
|
if (existing == null || entity.getClientEventId().equals(existing.getClientEventId())) {
|
log.info("[audit] duplicate client_event_id ignored, clientEventId={}", dto.getClientEventId());
|
return 0;
|
}
|
mergeInto(existing, entity);
|
auditEventMapper.updateMerged(existing);
|
log.info("[audit] merged operation event, operationId={}, category={}, sourceClientEventId={}",
|
entity.getOperationId(), entity.getEventCategory(), entity.getClientEventId());
|
return 1;
|
}
|
|
private void mergeInto(AuditEventEntity existing, AuditEventEntity incoming) {
|
// 升级前的已存事件没有逐项 targetId；参与迟到事件/重试合并时，用事件顶层主键补齐。
|
// 只修改本次锁定的内存实体，历史数据无需离线迁移。
|
existing.setFieldDiffs(scopeFieldDiffs(existing.getFieldDiffs(),
|
existing.getTargetTable(), existing.getTargetId()));
|
Map<String, Object> existingExtra = parseExtra(existing.getExtra());
|
Map<String, Object> incomingExtra = parseExtra(incoming.getExtra());
|
String existingSnapshotKey = snapshotKey(existing.getTargetTable(), existing.getTargetId());
|
String existingSnapshot = existing.getDataSnapshot();
|
String incomingSnapshotKey = snapshotKey(incoming.getTargetTable(), incoming.getTargetId());
|
String incomingSnapshot = incoming.getDataSnapshot();
|
long existingTime = time(existing.getEventTime());
|
long incomingTime = time(incoming.getEventTime());
|
long firstTime = longValue(existingExtra.get("mergeFirstEventTime"), existingTime);
|
long lastTime = longValue(existingExtra.get("mergeLastEventTime"), existingTime);
|
boolean incomingIsEarlier = incomingTime < firstTime;
|
boolean incomingIsLater = incomingTime >= lastTime;
|
boolean business = AuditEventCategories.BUSINESS.equals(existing.getEventCategory());
|
boolean existingIsFormSource = business && Integer.valueOf(0).equals(existing.getSourceLayer());
|
boolean existingHasFormSource = business && (existingIsFormSource
|
|| Boolean.TRUE.equals(existingExtra.get("mergeHasFormSource")));
|
boolean incomingIsFormSource = business && Integer.valueOf(0).equals(incoming.getSourceLayer());
|
long lastSupplementTime = longValue(existingExtra.get("mergeLastSupplementEventTime"),
|
existingIsFormSource ? Long.MIN_VALUE : existingTime);
|
boolean incomingIsLatestSupplement = !incomingIsFormSource && incomingTime >= lastSupplementTime;
|
Set<String> formProtectedFields = normalizedProtectedFields(
|
existingExtra.get("mergeFormProtectedFields"));
|
if (business && Integer.valueOf(0).equals(existing.getSourceLayer())) {
|
formProtectedFields.addAll(protectedFormFields(existing.getFieldDiffs()));
|
}
|
if (incomingIsFormSource) {
|
formProtectedFields.addAll(protectedFormFields(incoming.getFieldDiffs()));
|
}
|
|
String mergedDiffs = mergeFieldDiffs(
|
existing.getFieldDiffs(), incoming.getFieldDiffs(), incomingIsEarlier,
|
existingHasFormSource ? incomingIsLatestSupplement : incomingIsLater,
|
existingHasFormSource, incomingIsFormSource, formProtectedFields);
|
String storedFormSnapshot = strValue(existingExtra.get("mergeFormSnapshot"));
|
String storedFormSnapshotKey = strValue(existingExtra.get("mergeFormSnapshotKey"));
|
String formSnapshot = incomingIsFormSource ? incomingSnapshot
|
: (storedFormSnapshot != null ? storedFormSnapshot
|
: (existingIsFormSource ? existingSnapshot : null));
|
String mergedSnapshot = mergeSnapshots(existingSnapshot, incomingSnapshot,
|
incomingIsLater, incomingIsLatestSupplement, business,
|
existingHasFormSource, incomingIsFormSource,
|
formSnapshot);
|
int incomingPriority = sourcePriority(existing.getEventCategory(), incoming.getSourceLayer());
|
int existingPriority = sourcePriority(existing.getEventCategory(), existing.getSourceLayer());
|
boolean preferIncoming = incomingPriority > existingPriority
|
|| (incomingPriority == existingPriority && incomingIsLater);
|
if (preferIncoming) {
|
copyPresentation(existing, incoming);
|
}
|
existing.setEventTime(new Date(Math.max(lastTime, incomingTime)));
|
existing.setFieldDiffs(mergedDiffs);
|
existing.setDataSnapshot(mergedSnapshot);
|
existing.setExtra(mergeExtra(existingExtra, incomingExtra, existing.getClientEventId(),
|
incoming.getClientEventId(), Math.min(firstTime, incomingTime), Math.max(lastTime, incomingTime),
|
existingSnapshotKey, existingSnapshot, incomingSnapshotKey, incomingSnapshot,
|
existingHasFormSource || incomingIsFormSource, formProtectedFields,
|
formSnapshot, incomingIsFormSource ? incomingSnapshotKey
|
: (storedFormSnapshotKey != null
|
? storedFormSnapshotKey
|
: (existingIsFormSource ? existingSnapshotKey : null)),
|
incomingIsLatestSupplement ? incomingTime : lastSupplementTime));
|
}
|
|
static String mergeFieldDiffs(String existingJson, String incomingJson,
|
boolean incomingIsEarlier, boolean incomingIsLater) {
|
return mergeFieldDiffs(existingJson, incomingJson, incomingIsEarlier, incomingIsLater,
|
false, false, Collections.emptySet());
|
}
|
|
static String mergeFieldDiffs(String existingJson, String incomingJson,
|
boolean incomingIsEarlier, boolean incomingIsLater,
|
boolean existingHasFormSource, boolean incomingIsFormSource,
|
Set<String> formProtectedFields) {
|
if (incomingIsFormSource) {
|
// 无论 MQ 谁先到，已有接口差异都只能作为表单基线的补充。
|
return mergeFormFirstDiffs(incomingJson, existingJson, true, formProtectedFields);
|
}
|
if (existingHasFormSource) {
|
return mergeFormFirstDiffs(existingJson, incomingJson, incomingIsLater, formProtectedFields);
|
}
|
LinkedHashMap<String, Map<String, Object>> merged = new LinkedHashMap<>();
|
addDiffs(merged, existingJson, false, true);
|
addDiffs(merged, incomingJson, incomingIsEarlier, incomingIsLater);
|
return merged.isEmpty() ? null : JSON.toJSONString(new ArrayList<>(merged.values()));
|
}
|
|
/** 表单差异决定字段顺序、初始值与展示元数据；接口只补充表单缺失、空值或零值字段。 */
|
private static String mergeFormFirstDiffs(String formFirstJson, String supplementalJson,
|
boolean supplementIsLater,
|
Set<String> formProtectedFields) {
|
LinkedHashMap<String, Map<String, Object>> merged = new LinkedHashMap<>();
|
addDiffs(merged, formFirstJson, false, true);
|
addSupplementalDiffs(merged, supplementalJson, supplementIsLater, formProtectedFields);
|
return merged.isEmpty() ? null : JSON.toJSONString(new ArrayList<>(merged.values()));
|
}
|
|
@SuppressWarnings("unchecked")
|
private static void addSupplementalDiffs(LinkedHashMap<String, Map<String, Object>> merged,
|
String json, boolean replaceNew,
|
Set<String> formProtectedFields) {
|
if (isBlank(json)) {
|
return;
|
}
|
try {
|
Object parsed = JSON.parse(json);
|
if (!(parsed instanceof List)) {
|
return;
|
}
|
for (Object raw : (List<?>) parsed) {
|
if (!(raw instanceof Map)) {
|
continue;
|
}
|
Map<String, Object> diff = new LinkedHashMap<>((Map<String, Object>) raw);
|
String field = strValue(diff.get("field"));
|
if (field == null) {
|
continue;
|
}
|
Map<String, Object> current = merged.get(recordDiffKey(diff));
|
if (current == null) {
|
merged.put(recordDiffKey(diff), diff);
|
} else if (!isFormProtected(formProtectedFields, diff)
|
&& hasDataValue(diff.get("newData"))
|
&& (replaceNew || !hasDataValue(current.get("newData")))) {
|
copyIfPresent(diff, current, "newData");
|
if (diff.containsKey("newDisplay")) {
|
current.put("newDisplay", diff.get("newDisplay"));
|
} else if (diff.containsKey("newData")) {
|
current.remove("newDisplay");
|
}
|
}
|
}
|
} catch (Throwable ignored) {
|
// 损坏的补充 diff 不得破坏已经取得的表单基线。
|
}
|
}
|
|
private static String strValue(Object value) {
|
if (value == null) {
|
return null;
|
}
|
String text = String.valueOf(value).trim();
|
return text.isEmpty() ? null : text;
|
}
|
|
private static Set<String> protectedFormFields(String json) {
|
Set<String> fields = new LinkedHashSet<>();
|
if (isBlank(json)) {
|
return fields;
|
}
|
try {
|
Object parsed = JSON.parse(json);
|
if (!(parsed instanceof List)) {
|
return fields;
|
}
|
for (Object raw : (List<?>) parsed) {
|
if (!(raw instanceof Map)) {
|
continue;
|
}
|
Map<?, ?> diff = (Map<?, ?>) raw;
|
String field = strValue(diff.get("field"));
|
if (field != null && (hasDataValue(diff.get("newData")) || hasChildDiff(diff))) {
|
fields.add(fieldDiffKey(diff));
|
}
|
}
|
} catch (Throwable ignored) {
|
// 解析失败时不猜保护字段，原始表单差异仍会作为合并基线保留。
|
}
|
return fields;
|
}
|
|
private static boolean isFormProtected(Set<String> protectedFields, Map<String, Object> diff) {
|
if (protectedFields.contains(fieldDiffKey(diff))) {
|
return true;
|
}
|
boolean hasScopedKey = protectedFields.stream().anyMatch(AuditDiffKey::isScoped);
|
// 兼容修复前已写入 extra 的无表作用域字段名。
|
return !hasScopedKey && protectedFields.contains(strValue(diff.get("field")));
|
}
|
|
/** 用户定义的空值规则：null、空字符串及数值零可由接口补充，其余表单值不可覆盖。 */
|
private static boolean hasDataValue(Object value) {
|
if (value == null) {
|
return false;
|
}
|
if (value instanceof Number) {
|
return ((Number) value).doubleValue() != 0D;
|
}
|
String text = String.valueOf(value).trim();
|
if (text.isEmpty()) {
|
return false;
|
}
|
try {
|
return new java.math.BigDecimal(text).compareTo(java.math.BigDecimal.ZERO) != 0;
|
} catch (NumberFormatException ignored) {
|
return true;
|
}
|
}
|
|
private static boolean hasChildDiff(Map<?, ?> diff) {
|
Object data = diff == null ? null : diff.get("chidData");
|
return data instanceof Collection && !((Collection<?>) data).isEmpty();
|
}
|
|
static String mergeSnapshots(String existingJson, String incomingJson,
|
boolean incomingIsLater, boolean incomingIsLatestSupplement,
|
boolean business,
|
boolean existingHasFormSource, boolean incomingIsFormSource,
|
String formSnapshot) {
|
if (business && !isBlank(formSnapshot)
|
&& (existingHasFormSource || incomingIsFormSource)) {
|
if (incomingIsFormSource) {
|
return mergeFormFirstSnapshots(formSnapshot, existingJson);
|
}
|
return incomingIsLatestSupplement
|
? mergeFormFirstSnapshots(formSnapshot, existingJson, incomingJson)
|
: mergeFormFirstSnapshots(formSnapshot, incomingJson, existingJson);
|
}
|
return incomingJson != null && incomingIsLater ? incomingJson : existingJson;
|
}
|
|
/** 表单快照决定字段顺序和有效值；其他来源只补字段，或填充表单中的 null、空串和零值。 */
|
@SuppressWarnings("unchecked")
|
static String mergeFormFirstSnapshots(String formJson, String... supplementalJson) {
|
Map<String, Object> form = parseJsonObject(formJson);
|
if (form == null) {
|
return formJson;
|
}
|
Map<String, Object> merged = new LinkedHashMap<>(form);
|
Set<String> protectedFields = new LinkedHashSet<>();
|
for (Map.Entry<String, Object> entry : form.entrySet()) {
|
if (hasDataValue(entry.getValue())) {
|
protectedFields.add(entry.getKey());
|
}
|
}
|
for (String json : supplementalJson) {
|
Map<String, Object> supplemental = parseJsonObject(json);
|
if (supplemental == null) {
|
continue;
|
}
|
for (Map.Entry<String, Object> entry : supplemental.entrySet()) {
|
if (!protectedFields.contains(entry.getKey()) && hasDataValue(entry.getValue())) {
|
merged.put(entry.getKey(), entry.getValue());
|
}
|
}
|
}
|
return JSON.toJSONString(merged);
|
}
|
|
@SuppressWarnings("unchecked")
|
private static Map<String, Object> parseJsonObject(String json) {
|
if (isBlank(json)) {
|
return null;
|
}
|
try {
|
Object parsed = JSON.parse(json);
|
return parsed instanceof Map
|
? new LinkedHashMap<>((Map<String, Object>) parsed) : null;
|
} catch (Throwable ignored) {
|
return null;
|
}
|
}
|
|
@SuppressWarnings("unchecked")
|
private static void addDiffs(LinkedHashMap<String, Map<String, Object>> merged, String json,
|
boolean replaceOld, boolean replaceNew) {
|
if (isBlank(json)) {
|
return;
|
}
|
try {
|
Object parsed = JSON.parse(json);
|
if (!(parsed instanceof List)) {
|
return;
|
}
|
for (Object raw : (List<?>) parsed) {
|
if (!(raw instanceof Map)) {
|
continue;
|
}
|
Map<String, Object> diff = new LinkedHashMap<>((Map<String, Object>) raw);
|
Object rawField = diff.get("field");
|
if (rawField == null || isBlank(String.valueOf(rawField))) {
|
continue;
|
}
|
String field = String.valueOf(rawField);
|
String key = recordDiffKey(diff);
|
Map<String, Object> current = merged.get(key);
|
if (current == null) {
|
merged.put(key, diff);
|
continue;
|
}
|
if (replaceOld) {
|
copyIfPresent(diff, current, "oldData");
|
copyIfPresent(diff, current, "oldDisplay");
|
}
|
if (replaceNew) {
|
copyIfPresent(diff, current, "newData");
|
copyIfPresent(diff, current, "newDisplay");
|
copyMetadata(diff, current);
|
}
|
}
|
} catch (Throwable ignored) {
|
// 损坏的历史 diff 不参与组合，后续合法来源仍可补齐。
|
}
|
}
|
|
private static void copyMetadata(Map<String, Object> source, Map<String, Object> target) {
|
String[] keys = {"fieldName", "changeType", "componentType", "jnpfKey", "masked",
|
"nameModified", "technical", "type", "valueType", "chidData", "chidField",
|
"targetTable", "targetId"};
|
for (String key : keys) {
|
Object value = source.get(key);
|
if (value != null && !String.valueOf(value).isEmpty()) {
|
target.put(key, value);
|
}
|
}
|
}
|
|
private static String fieldDiffKey(Map<?, ?> diff) {
|
String field = strValue(diff == null ? null : diff.get("field"));
|
String table = strValue(diff == null ? null : diff.get("targetTable"));
|
return AuditDiffKey.of(table, field);
|
}
|
|
/**
|
* 批量操作必须按记录隔离同名字段；旧日志没有 targetId 时退回原有表+字段键。
|
*/
|
private static String recordDiffKey(Map<?, ?> diff) {
|
String fieldKey = fieldDiffKey(diff);
|
String targetId = strValue(diff == null ? null : diff.get("targetId"));
|
return targetId == null ? fieldKey
|
: fieldKey + "@target:" + targetId.length() + ":" + targetId;
|
}
|
|
/**
|
* 单记录生产端无需重复填写作用域；批量生产端显式携带的逐项 targetId 优先保留。
|
*/
|
@SuppressWarnings("unchecked")
|
static String scopeFieldDiffs(String json, String defaultTable, String defaultTargetId) {
|
if (isBlank(json)) {
|
return json;
|
}
|
try {
|
Object parsed = JSON.parse(json);
|
if (!(parsed instanceof List)) {
|
return json;
|
}
|
List<Map<String, Object>> scoped = new ArrayList<>();
|
for (Object raw : (List<?>) parsed) {
|
if (!(raw instanceof Map)) {
|
continue;
|
}
|
Map<String, Object> item = new LinkedHashMap<>((Map<String, Object>) raw);
|
if (strValue(item.get("targetTable")) == null && !isBlank(defaultTable)) {
|
item.put("targetTable", defaultTable);
|
}
|
if (strValue(item.get("targetId")) == null && !isBlank(defaultTargetId)) {
|
item.put("targetId", defaultTargetId);
|
}
|
scoped.add(item);
|
}
|
return JSON.toJSONString(scoped);
|
} catch (Throwable ignored) {
|
return json;
|
}
|
}
|
|
/** 每个字段只按其所属物理表校验；元数据不可用时保留原始差异，避免静默丢审计。 */
|
@SuppressWarnings("unchecked")
|
static String filterFieldDiffs(String json, String defaultTable,
|
Function<String, Set<String>> columnResolver) {
|
if (isBlank(json) || columnResolver == null) {
|
return json;
|
}
|
try {
|
Object parsed = JSON.parse(json);
|
if (!(parsed instanceof List)) {
|
return json;
|
}
|
List<Map<String, Object>> filtered = new ArrayList<>();
|
for (Object raw : (List<?>) parsed) {
|
if (!(raw instanceof Map)) {
|
continue;
|
}
|
Map<String, Object> item = new LinkedHashMap<>((Map<String, Object>) raw);
|
boolean child = "table".equalsIgnoreCase(strValue(item.get("jnpfKey")));
|
String table = strValue(item.get("targetTable"));
|
if (!child && table == null) {
|
table = strValue(defaultTable);
|
}
|
if (table == null) {
|
// 旧子表事件没有物理表归属，无法安全判断；保留证据，不拿主表列误删。
|
filtered.add(item);
|
continue;
|
}
|
table = table.toLowerCase(Locale.ROOT);
|
item.put("targetTable", table);
|
Set<String> resolved = columnResolver.apply(table);
|
Set<String> columns = lowerSet(resolved);
|
if (columns.isEmpty()) {
|
filtered.add(item);
|
continue;
|
}
|
if (child) {
|
Map<String, Object> childItem = filterChildDiff(item, columns);
|
if (childItem != null) {
|
filtered.add(childItem);
|
}
|
continue;
|
}
|
String field = strValue(item.get("field"));
|
if (field != null && columns.contains(field.toLowerCase(Locale.ROOT))) {
|
filtered.add(item);
|
}
|
}
|
return JSON.toJSONString(filtered);
|
} catch (Throwable ignored) {
|
return json;
|
}
|
}
|
|
@SuppressWarnings("unchecked")
|
private static Map<String, Object> filterChildDiff(Map<String, Object> item, Set<String> columns) {
|
List<Map<String, Object>> fields = new ArrayList<>();
|
Object rawFields = item.get("chidField");
|
if (rawFields instanceof List) {
|
for (Object raw : (List<?>) rawFields) {
|
if (!(raw instanceof Map)) {
|
continue;
|
}
|
Map<String, Object> field = new LinkedHashMap<>((Map<String, Object>) raw);
|
String prop = strValue(field.get("prop"));
|
if (prop != null && columns.contains(prop.toLowerCase(Locale.ROOT))) {
|
fields.add(field);
|
}
|
}
|
}
|
if (fields.isEmpty()) {
|
return null;
|
}
|
|
Set<String> allowed = new LinkedHashSet<>();
|
for (Map<String, Object> field : fields) {
|
allowed.add(strValue(field.get("prop")).toLowerCase(Locale.ROOT));
|
}
|
List<Map<String, Object>> rows = new ArrayList<>();
|
Object rawRows = item.get("chidData");
|
if (rawRows instanceof List) {
|
for (Object raw : (List<?>) rawRows) {
|
if (!(raw instanceof Map)) {
|
continue;
|
}
|
Map<String, Object> row = new LinkedHashMap<>();
|
boolean hasBusinessField = false;
|
for (Map.Entry<?, ?> entry : ((Map<?, ?>) raw).entrySet()) {
|
String key = entry.getKey() == null ? null : String.valueOf(entry.getKey());
|
if (key == null) {
|
continue;
|
}
|
String normalized = key.toLowerCase(Locale.ROOT);
|
String actual = normalized.startsWith("jnpf_old_")
|
? normalized.substring("jnpf_old_".length()) : normalized;
|
if (allowed.contains(actual)) {
|
row.put(key, entry.getValue());
|
hasBusinessField = true;
|
} else if ("jnpf_type".equals(normalized)) {
|
row.put(key, entry.getValue());
|
}
|
}
|
if (hasBusinessField) {
|
rows.add(row);
|
}
|
}
|
}
|
if (rows.isEmpty()) {
|
return null;
|
}
|
item.put("chidField", fields);
|
item.put("chidData", rows);
|
return item;
|
}
|
|
private static Set<String> lowerSet(Set<String> values) {
|
if (values == null || values.isEmpty()) {
|
return Collections.emptySet();
|
}
|
Set<String> result = new LinkedHashSet<>();
|
for (String value : values) {
|
if (value != null && !value.trim().isEmpty()) {
|
result.add(value.trim().toLowerCase(Locale.ROOT));
|
}
|
}
|
return result;
|
}
|
|
private static void copyIfPresent(Map<String, Object> source, Map<String, Object> target, String key) {
|
if (source.containsKey(key)) {
|
target.put(key, source.get(key));
|
}
|
}
|
|
private static String mergeExtra(Map<String, Object> existing, Map<String, Object> incoming,
|
String existingClientId, String incomingClientId,
|
long firstTime, long lastTime,
|
String existingSnapshotKey, String existingSnapshot,
|
String incomingSnapshotKey, String incomingSnapshot,
|
boolean hasFormSource, Set<String> formProtectedFields,
|
String formSnapshot, String formSnapshotKey,
|
long lastSupplementEventTime) {
|
Map<String, Object> merged = new LinkedHashMap<>(existing);
|
merged.putAll(incoming);
|
Set<String> sourceIds = new LinkedHashSet<>();
|
addStrings(sourceIds, existing.get("mergedClientEventIds"));
|
sourceIds.add(existingClientId);
|
sourceIds.add(incomingClientId);
|
merged.put("mergedClientEventIds", new ArrayList<>(sourceIds));
|
merged.put("mergeFirstEventTime", firstTime);
|
merged.put("mergeLastEventTime", lastTime);
|
if (hasFormSource) {
|
merged.put("mergeHasFormSource", true);
|
merged.put("mergeFormProtectedFields", new ArrayList<>(formProtectedFields));
|
if (formSnapshot != null) {
|
merged.put("mergeFormSnapshot", formSnapshot);
|
}
|
if (formSnapshotKey != null) {
|
merged.put("mergeFormSnapshotKey", formSnapshotKey);
|
}
|
}
|
if (lastSupplementEventTime != Long.MIN_VALUE) {
|
merged.put("mergeLastSupplementEventTime", lastSupplementEventTime);
|
}
|
Map<String, Object> snapshots = objectMap(existing.get("mergedSnapshots"));
|
if (existingSnapshotKey != null && existingSnapshot != null) {
|
snapshots.put(existingSnapshotKey, existingSnapshot);
|
}
|
if (incomingSnapshotKey != null && incomingSnapshot != null) {
|
snapshots.put(incomingSnapshotKey, incomingSnapshot);
|
}
|
if (!snapshots.isEmpty()) {
|
merged.put("mergedSnapshots", snapshots);
|
}
|
return JsonUtil.getObjectToString(merged);
|
}
|
|
@SuppressWarnings("unchecked")
|
private static Map<String, Object> objectMap(Object value) {
|
if (value instanceof Map) {
|
return new LinkedHashMap<>((Map<String, Object>) value);
|
}
|
return new LinkedHashMap<>();
|
}
|
|
private static String snapshotKey(String targetTable, String targetId) {
|
return isBlank(targetTable) || isBlank(targetId) ? null : targetTable + ":" + targetId;
|
}
|
|
private static Map<String, Object> parseExtra(String json) {
|
if (!isBlank(json)) {
|
try {
|
Map<String, Object> parsed = JsonUtil.stringToMap(json);
|
if (parsed != null) {
|
return new LinkedHashMap<>(parsed);
|
}
|
} catch (Throwable ignored) {
|
// 原文在下面保留，避免静默丢失损坏的历史 extra。
|
}
|
}
|
Map<String, Object> result = new LinkedHashMap<>();
|
if (!isBlank(json)) {
|
result.put("mergedOriginalExtra", json);
|
}
|
return result;
|
}
|
|
private static void addStrings(Set<String> target, Object value) {
|
if (value instanceof Iterable) {
|
for (Object item : (Iterable<?>) value) {
|
if (item != null) {
|
target.add(String.valueOf(item));
|
}
|
}
|
}
|
}
|
|
static Set<String> normalizedProtectedFields(Object value) {
|
Set<String> result = new LinkedHashSet<>();
|
if (value instanceof Iterable) {
|
for (Object item : (Iterable<?>) value) {
|
if (item != null) {
|
String normalized = AuditDiffKey.normalizeStored(String.valueOf(item));
|
if (normalized != null) {
|
result.add(normalized);
|
}
|
}
|
}
|
}
|
return result;
|
}
|
|
static int sourcePriority(String category, Integer sourceLayer) {
|
if (AuditEventCategories.BUSINESS.equals(category)) {
|
return Integer.valueOf(0).equals(sourceLayer) ? 3
|
: (Integer.valueOf(2).equals(sourceLayer) ? 2 : 1);
|
}
|
if (Integer.valueOf(0).equals(sourceLayer)) {
|
return 3; // 层 0 是实际签名凭证，优先于 SIGN_USED 等使用记录。
|
}
|
return Integer.valueOf(2).equals(sourceLayer) ? 2 : 1;
|
}
|
|
private static void copyPresentation(AuditEventEntity target, AuditEventEntity source) {
|
target.setTenantId(source.getTenantId());
|
target.setOperatorId(source.getOperatorId());
|
target.setOperatorName(source.getOperatorName());
|
target.setOperatorOrgId(source.getOperatorOrgId());
|
target.setAppName(source.getAppName());
|
target.setBizModule(source.getBizModule());
|
target.setIp(source.getIp());
|
target.setIpRegion(source.getIpRegion());
|
target.setBrowser(source.getBrowser());
|
target.setOs(source.getOs());
|
target.setRequestUri(source.getRequestUri());
|
target.setEventType(source.getEventType());
|
target.setActionCode(source.getActionCode());
|
target.setActionLabel(source.getActionLabel());
|
target.setSourceLayer(source.getSourceLayer());
|
target.setTargetTable(source.getTargetTable());
|
target.setTargetId(source.getTargetId());
|
target.setBizType(source.getBizType());
|
target.setBizCode(source.getBizCode());
|
target.setReason(source.getReason());
|
target.setRecordTitle(source.getRecordTitle());
|
target.setEntryType(source.getEntryType());
|
target.setEntryId(source.getEntryId());
|
target.setEntryName(source.getEntryName());
|
target.setPrevHash(source.getPrevHash());
|
}
|
|
private static long time(Date value) {
|
return value == null ? 0L : value.getTime();
|
}
|
|
private static long longValue(Object value, long fallback) {
|
if (value instanceof Number) {
|
return ((Number) value).longValue();
|
}
|
try {
|
return value == null ? fallback : Long.parseLong(String.valueOf(value));
|
} catch (NumberFormatException ignored) {
|
return fallback;
|
}
|
}
|
|
/**
|
* 校验规则（spec v2.2 裁定 + 追加裁定，逐字执行）：
|
* eventType 必须在 {@link AuditConsts#VALID_TYPES} 内；
|
* operatorId/appName/actionCode/eventTime/tenantId 任一为空则拒绝；
|
* clientEventId 为空则拒绝（DB NOT NULL + UNIQUE 幂等键，null 无幂等语义）；
|
* sourceLayer 为 null 则拒绝（DB NOT NULL 列即必填事实源，早抛可读异常优于 DB 层裸抛；
|
* 取值范围 0-3 留给 DB CHECK 约束校验，不在此重复）。
|
*
|
* <p><b>标识类字段超长一律拒绝、不截断</b>（C1 评审 I-5）：{@code clientEventId} 是幂等键，
|
* 截断会让两个不同事件塌成同一个键、被 ON CONFLICT 当成重复而丢弃；{@code operationId} 截断
|
* 会把本不相干的操作折叠到一组。这两者截断造成的错误比拒绝更隐蔽，故宁可拒绝——
|
* 而且它们都由 SDK/服务自己构造（层 0 是 "L0-"+雪花=22 字符），超长本身就说明调用方有问题。
|
* 描述类字段则相反，见 {@link #toEntity}。
|
*/
|
private void validate(AuditEventDTO dto) {
|
if (isBlank(dto.getClientEventId())) {
|
throw new IllegalArgumentException("clientEventId 不能为空");
|
}
|
if (dto.getClientEventId().length() > LEN_CLIENT_EVENT_ID) {
|
throw new IllegalArgumentException("clientEventId 超过 " + LEN_CLIENT_EVENT_ID
|
+ " 字符，截断会破坏幂等语义，拒绝入库: " + dto.getClientEventId());
|
}
|
if (dto.getOperationId() != null && dto.getOperationId().length() > LEN_OPERATION_ID) {
|
throw new IllegalArgumentException("operationId 超过 " + LEN_OPERATION_ID
|
+ " 字符，截断会破坏操作关联语义，拒绝入库: " + dto.getOperationId());
|
}
|
if (dto.getEventType() == null || !AuditConsts.VALID_TYPES.contains(dto.getEventType())) {
|
throw new IllegalArgumentException("eventType 不在受控枚举 VALID_TYPES 内: " + dto.getEventType());
|
}
|
if (isBlank(dto.getOperatorId())) {
|
throw new IllegalArgumentException("operatorId 不能为空");
|
}
|
if (isBlank(dto.getAppName())) {
|
throw new IllegalArgumentException("appName 不能为空");
|
}
|
if (isBlank(dto.getActionCode())) {
|
throw new IllegalArgumentException("actionCode 不能为空");
|
}
|
if (dto.getEventTime() == null) {
|
throw new IllegalArgumentException("eventTime 不能为空");
|
}
|
if (isBlank(dto.getTenantId())) {
|
throw new IllegalArgumentException("tenantId 不能为空");
|
}
|
if (dto.getSourceLayer() == null) {
|
throw new IllegalArgumentException("sourceLayer 不能为空");
|
}
|
}
|
|
/**
|
* DTO → 实体，**描述类 varchar 列按列宽截断**（C1 评审 I-5）。
|
*
|
* <p>不截断会怎样：{@code biz_code} 按设计直取业务原始值（层 0 取表单字段、层 2 取 SpEL 求值），
|
* {@code browser}/{@code os}/{@code request_uri} 则由客户端 header 决定——任一超长，PG 抛
|
* {@code 22001 value too long}，而 {@code ON CONFLICT} 在冲突判定之前就已经抛了。异常冒泡回
|
* 采集侧被 {@code catch(Throwable)} 兜住（层 0 的 L002 防御、层 1 的总兜底都如此），结果是
|
* **整条审计事件永久消失，只剩一行 error 日志**。
|
*
|
* <p>更该警惕的是**它不自愈**：spec §6 层 0 的容错前提是「这次失败了，下次事件会自举补上」，
|
* 但字段若是**长期**超长（某类单据的编号天生就长），该行的每一条事件都会丢，永远补不回来——
|
* 直接突破了 spec 声明的可靠性包络。
|
*
|
* <p><b>截断必须留痕</b>（与 spec §8 迁移脚本「禁静默截断」同一条纪律）：被截断的列名记进
|
* {@code extra.truncatedFields}。审计可以记得不全，但不能让人以为记全了。
|
*/
|
private AuditEventEntity toEntity(AuditEventDTO dto) {
|
AuditEventEntity entity = new AuditEventEntity();
|
List<String> truncated = new ArrayList<>();
|
// 标识类：已在 validate 里卡死长度，这里原样搬运
|
entity.setClientEventId(dto.getClientEventId());
|
entity.setOperationId(dto.getOperationId());
|
entity.setEventTime(dto.getEventTime());
|
entity.setTenantId(clip(dto.getTenantId(), LEN_TENANT_ID, "tenant_id", truncated));
|
entity.setOperatorId(clip(dto.getOperatorId(), LEN_OPERATOR_ID, "operator_id", truncated));
|
entity.setOperatorName(clip(dto.getOperatorName(), LEN_OPERATOR_NAME, "operator_name", truncated));
|
entity.setOperatorOrgId(clip(dto.getOperatorOrgId(), LEN_OPERATOR_ORG_ID, "operator_org_id", truncated));
|
entity.setAppName(clip(dto.getAppName(), LEN_APP_NAME, "app_name", truncated));
|
entity.setBizModule(clip(dto.getBizModule(), LEN_BIZ_MODULE, "biz_module", truncated));
|
entity.setIp(clip(dto.getIp(), LEN_IP, "ip", truncated));
|
entity.setIpRegion(clip(dto.getIpRegion(), LEN_IP_REGION, "ip_region", truncated));
|
entity.setBrowser(clip(dto.getBrowser(), LEN_BROWSER, "browser", truncated));
|
entity.setOs(clip(dto.getOs(), LEN_OS, "os", truncated));
|
entity.setRequestUri(clip(dto.getRequestUri(), LEN_REQUEST_URI, "request_uri", truncated));
|
entity.setEventType(dto.getEventType()); // 受控枚举，validate 已挡
|
entity.setActionCode(clip(dto.getActionCode(), LEN_ACTION_CODE, "action_code", truncated));
|
entity.setActionLabel(clip(dto.getActionLabel(), LEN_ACTION_LABEL, "action_label", truncated));
|
entity.setSourceLayer(dto.getSourceLayer());
|
entity.setTargetTable(clip(dto.getTargetTable(), LEN_TARGET_TABLE, "target_table", truncated));
|
entity.setTargetId(clip(dto.getTargetId(), LEN_TARGET_ID, "target_id", truncated));
|
entity.setBizType(clip(dto.getBizType(), LEN_BIZ_TYPE, "biz_type", truncated));
|
entity.setBizCode(clip(dto.getBizCode(), LEN_BIZ_CODE, "biz_code", truncated));
|
// 以下都是 text 列，无长度约束
|
entity.setFieldDiffs(dto.getFieldDiffs());
|
entity.setDataSnapshot(dto.getDataSnapshot());
|
entity.setReason(dto.getReason());
|
entity.setRecordTitle(clip(dto.getRecordTitle(), LEN_RECORD_TITLE, "record_title", truncated));
|
entity.setEntryType(clip(dto.getEntryType(), LEN_ENTRY_TYPE, "entry_type", truncated));
|
entity.setEntryId(clip(dto.getEntryId(), LEN_ENTRY_ID, "entry_id", truncated));
|
entity.setEntryName(clip(dto.getEntryName(), LEN_ENTRY_NAME, "entry_name", truncated));
|
entity.setPrevHash(clip(dto.getPrevHash(), LEN_PREV_HASH, "prev_hash", truncated));
|
entity.setExtra(truncated.isEmpty() ? dto.getExtra() : noteTruncation(dto.getExtra(), truncated));
|
return entity;
|
}
|
|
/**
|
* 列宽常量，与 {@code audit_events} 的 DDL 逐列对齐（PG-only，见 spec §4 表定义）。
|
* DDL 若放宽，这里只是截得早一点（保守、不致命）；DDL 若收窄，必须同步改这里。
|
*/
|
private static final int LEN_CLIENT_EVENT_ID = 70;
|
private static final int LEN_OPERATION_ID = 64;
|
private static final int LEN_TENANT_ID = 64;
|
private static final int LEN_OPERATOR_ID = 64;
|
private static final int LEN_OPERATOR_NAME = 100;
|
private static final int LEN_OPERATOR_ORG_ID = 64;
|
private static final int LEN_APP_NAME = 50;
|
private static final int LEN_BIZ_MODULE = 100;
|
private static final int LEN_IP = 50;
|
private static final int LEN_IP_REGION = 100;
|
private static final int LEN_BROWSER = 100;
|
private static final int LEN_OS = 100;
|
private static final int LEN_REQUEST_URI = 500;
|
private static final int LEN_ACTION_CODE = 50;
|
private static final int LEN_ACTION_LABEL = 200;
|
private static final int LEN_TARGET_TABLE = 100;
|
private static final int LEN_TARGET_ID = 64;
|
private static final int LEN_BIZ_TYPE = 50;
|
private static final int LEN_BIZ_CODE = 100;
|
private static final int LEN_RECORD_TITLE = 500;
|
private static final int LEN_ENTRY_TYPE = 20;
|
private static final int LEN_ENTRY_ID = 50;
|
private static final int LEN_ENTRY_NAME = 200;
|
private static final int LEN_PREV_HASH = 64;
|
|
/** 超长则截断并把列名记进 {@code truncated}；否则原样返回。 */
|
private static String clip(String value, int max, String column, List<String> truncated) {
|
if (value == null || value.length() <= max) {
|
return value;
|
}
|
truncated.add(column);
|
log.warn("[audit] {} 超长（{} > {}），已截断入库并记入 extra.truncatedFields", column, value.length(), max);
|
return value.substring(0, max);
|
}
|
|
/**
|
* 把截断记录并进 {@code extra}。
|
*
|
* <p>原 {@code extra} 不是合法 JSON 时**不能就这么丢掉留痕**（那又变回静默截断），
|
* 改为包一层并把原文完整保留在 {@code originalExtra} 里——{@code extra} 是 text 列，装得下。
|
*/
|
private String noteTruncation(String extra, List<String> truncated) {
|
Map<String, Object> merged = null;
|
if (extra != null && !extra.trim().isEmpty()) {
|
try {
|
merged = JsonUtil.stringToMap(extra);
|
} catch (Throwable ignore) {
|
merged = null;
|
}
|
}
|
if (merged == null) {
|
merged = new LinkedHashMap<>();
|
if (extra != null && !extra.trim().isEmpty()) {
|
merged.put("originalExtra", extra); // 原文不是 JSON，原样兜住，不丢信息
|
}
|
}
|
merged.put("truncatedFields", truncated);
|
return JsonUtil.getObjectToString(merged);
|
}
|
|
private static boolean isBlank(String s) {
|
return s == null || s.trim().isEmpty();
|
}
|
}
|
