package com.trafficaudit.auditengine.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.trafficaudit.auditengine.entity.AuditResult;
|
import com.trafficaudit.auditengine.mapper.AuditResultMapper;
|
import com.trafficaudit.dataimport.entity.H2032EnterpriseMonthly;
|
import com.trafficaudit.dataimport.entity.TransportAuthVehicle;
|
import com.trafficaudit.dataimport.entity.VehicleTrackMileage;
|
import com.trafficaudit.dataimport.mapper.H2032EnterpriseMonthlyMapper;
|
import com.trafficaudit.dataimport.mapper.TransportAuthVehicleMapper;
|
import com.trafficaudit.dataimport.mapper.VehicleTrackMileageMapper;
|
import com.trafficaudit.rulemanage.entity.AuditRule;
|
import com.trafficaudit.rulemanage.mapper.AuditRuleMapper;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* 审核规则引擎（Demo 6条规则）
|
*/
|
@Slf4j
|
@Service
|
public class AuditEngineService {
|
|
/** 牵引车标准吨位 */
|
private static final double TRACTOR_STD_TONS = 31.0;
|
|
/** 货运类型字段 → 中文名称 */
|
private static final Map<String, String> FREIGHT_TYPE_NAMES = new HashMap<>();
|
|
static {
|
FREIGHT_TYPE_NAMES.put("freightContainer", "集装箱");
|
FREIGHT_TYPE_NAMES.put("freightCoal", "煤炭及制品");
|
FREIGHT_TYPE_NAMES.put("freightOilGas", "石油天然气及制品");
|
FREIGHT_TYPE_NAMES.put("freightCrudeOil", "原油");
|
FREIGHT_TYPE_NAMES.put("freightMetalOre", "金属矿石");
|
FREIGHT_TYPE_NAMES.put("freightIronOre", "铁矿石");
|
FREIGHT_TYPE_NAMES.put("freightBuilding", "矿物性建筑材料");
|
FREIGHT_TYPE_NAMES.put("freightGrain", "粮食");
|
}
|
|
@Resource
|
private AuditRuleMapper ruleMapper;
|
@Resource
|
private AuditResultMapper resultMapper;
|
@Resource
|
private H2032EnterpriseMonthlyMapper h2032Mapper;
|
@Resource
|
private TransportAuthVehicleMapper transportAuthMapper;
|
@Resource
|
private VehicleTrackMileageMapper trackMileageMapper;
|
|
public List<AuditResult> executeAudit(String reportPeriod) {
|
List<AuditRule> rules = ruleMapper.selectEnabledRules();
|
List<H2032EnterpriseMonthly> reports = h2032Mapper.selectList(
|
new LambdaQueryWrapper<H2032EnterpriseMonthly>()
|
.eq(H2032EnterpriseMonthly::getReportPeriod, reportPeriod));
|
|
// 加载运政/轨迹数据，按企业名索引
|
Map<String, TransportAuthVehicle> authMap = loadAuthMap(reportPeriod);
|
Map<String, VehicleTrackMileage> trackMap = loadTrackMap(reportPeriod);
|
Map<String, H2032EnterpriseMonthly> lastMonthMap = loadLastMonthMap(reportPeriod);
|
|
// 幂等：同报表期先清除旧审核结果
|
resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
|
.eq(AuditResult::getReportPeriod, reportPeriod));
|
|
Map<Long, AuditRule> ruleMap = new HashMap<>();
|
for (AuditRule rule : rules) ruleMap.put(rule.getId(), rule);
|
|
List<AuditResult> results = new ArrayList<>();
|
for (H2032EnterpriseMonthly report : reports) {
|
for (AuditRule rule : rules) {
|
AuditResult result = checkRule(rule, report, authMap, trackMap, lastMonthMap);
|
if (result != null) {
|
result.setRuleName(rule.getRuleName());
|
result.setRuleCode(rule.getRuleCode());
|
result.setAlertLevel(rule.getAlertLevel());
|
result.setEnterpriseName(report.getEnterpriseName());
|
result.setVerifyExplanation(report.getVerifyExplanation());
|
resultMapper.insert(result);
|
results.add(result);
|
}
|
}
|
}
|
log.info("Audit complete: {} reports, {} issues for {}", reports.size(), results.size(), reportPeriod);
|
return results;
|
}
|
|
public List<AuditResult> queryResults(String reportPeriod) {
|
List<AuditResult> results = resultMapper.selectList(new LambdaQueryWrapper<AuditResult>()
|
.eq(AuditResult::getReportPeriod, reportPeriod)
|
.orderByAsc(AuditResult::getId));
|
attachInfo(results);
|
return results;
|
}
|
|
public void reviewResult(Long id, String status, String comment) {
|
AuditResult result = resultMapper.selectById(id);
|
if (result == null) return;
|
result.setStatus(status);
|
result.setReviewComment(comment);
|
result.setReviewedAt(LocalDateTime.now());
|
resultMapper.updateById(result);
|
}
|
|
private void attachInfo(List<AuditResult> results) {
|
if (results.isEmpty()) return;
|
Map<Long, AuditRule> ruleMap = new HashMap<>();
|
for (AuditRule rule : ruleMapper.selectList(null)) ruleMap.put(rule.getId(), rule);
|
Map<Long, String> nameMap = new HashMap<>();
|
Map<Long, String> explainMap = new HashMap<>();
|
for (H2032EnterpriseMonthly r : h2032Mapper.selectList(null)) {
|
nameMap.putIfAbsent(r.getId(), r.getEnterpriseName());
|
explainMap.putIfAbsent(r.getId(), r.getVerifyExplanation());
|
}
|
for (AuditResult result : results) {
|
AuditRule rule = ruleMap.get(result.getRuleId());
|
if (rule != null) {
|
result.setRuleName(rule.getRuleName());
|
result.setRuleCode(rule.getRuleCode());
|
result.setAlertLevel(rule.getAlertLevel());
|
}
|
String enterpriseName = nameMap.get(result.getReportId());
|
if (enterpriseName == null) {
|
// 上报数据被重新导入后旧审核结果已失效，给出提示而非空白
|
enterpriseName = "\uFF08\u539F\u6570\u636E\u5DF2\u91CD\u65B0\u5BFC\u5165\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C\u5BA1\u6838\uFF09";
|
}
|
result.setEnterpriseName(enterpriseName);
|
result.setVerifyExplanation(explainMap.get(result.getReportId()));
|
}
|
}
|
|
private AuditResult checkRule(AuditRule rule, H2032EnterpriseMonthly report,
|
Map<String, TransportAuthVehicle> authMap,
|
Map<String, VehicleTrackMileage> trackMap,
|
Map<String, H2032EnterpriseMonthly> lastMonthMap) {
|
try {
|
switch (rule.getCompareType()) {
|
case "DIFF":
|
return checkDiff(rule, report, authMap);
|
case "RATIO":
|
return checkRatio(rule, report, authMap, trackMap);
|
case "MOM":
|
return checkMom(rule, report, lastMonthMap);
|
case "NULL_CHECK":
|
return checkNull(rule, report);
|
case "OUT_RANGE":
|
return checkOutRange(rule, report, authMap);
|
default:
|
return null;
|
}
|
} catch (Exception e) {
|
log.error("Rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
|
return null;
|
}
|
}
|
|
/** 车辆数/吨位 与运政数据对比，差距超阈值核实 */
|
private AuditResult checkDiff(AuditRule rule, H2032EnterpriseMonthly report,
|
Map<String, TransportAuthVehicle> authMap) {
|
TransportAuthVehicle auth = findAuth(authMap, report.getEnterpriseName());
|
if (auth == null) return null;
|
|
double actual;
|
double reference;
|
if (rule.getCheckField().contains("tons")) {
|
actual = nvl(report.getTonsTotal());
|
reference = nvl(auth.getTrailerTons()) + nvl(auth.getOtherTons());
|
} else {
|
actual = num(report.getVehicleTotal());
|
reference = num(auth.getTractorCount()) + num(auth.getTrailerCount()) + num(auth.getOtherCount());
|
}
|
double threshold = Double.parseDouble(rule.getThreshold());
|
double diff = Math.abs(actual - reference);
|
|
if (diff > threshold) {
|
return buildResult(rule, report, "上报=" + fmt(actual) + ", 运政=" + fmt(reference),
|
"差距≤" + fmt(threshold), "差距=" + fmt(diff));
|
}
|
return null;
|
}
|
|
/** 上报周转量与轨迹测算周转量对比，高出30%核实 */
|
private AuditResult checkRatio(AuditRule rule, H2032EnterpriseMonthly report,
|
Map<String, TransportAuthVehicle> authMap,
|
Map<String, VehicleTrackMileage> trackMap) {
|
TransportAuthVehicle auth = findAuth(authMap, report.getEnterpriseName());
|
VehicleTrackMileage track = trackMap.get(key(report.getEnterpriseName()));
|
if (auth == null || track == null) return null;
|
|
double trackVehicles = num(track.getTrackedVehicles());
|
if (trackVehicles == 0.0) return null;
|
if (num(auth.getOtherCount()) == 0) return null;
|
|
// 整车吨位 = 其它车辆总吨位 / 其它车辆数
|
double wholeTonnage = nvl(auth.getOtherTons()) / num(auth.getOtherCount());
|
|
// 轨迹测算周转量 = 轨迹里程/轨迹车辆 × (牵引车数×31 + 整车吨位)
|
double avgMileagePerVehicle = nvl(track.getMonthlyMileage()) / trackVehicles;
|
double totalTonnage = num(auth.getTractorCount()) * TRACTOR_STD_TONS + wholeTonnage;
|
double estimatedTurnover = avgMileagePerVehicle * totalTonnage;
|
|
if (estimatedTurnover == 0.0) return null;
|
|
double actual = nvl(report.getTurnoverTotal());
|
double ratio = actual / estimatedTurnover;
|
double threshold = Double.parseDouble(rule.getThreshold());
|
|
if (ratio > threshold) {
|
return buildResult(rule, report,
|
"上报周转量=" + fmt(actual) + ", 轨迹测算=" + Math.round(estimatedTurnover),
|
"比值≤" + fmt(threshold), "比值=" + fmt(ratio));
|
}
|
return null;
|
}
|
|
/** 货运类型环比：本月新增货运类型核实（多的核实，少的不管） */
|
private AuditResult checkMom(AuditRule rule, H2032EnterpriseMonthly report,
|
Map<String, H2032EnterpriseMonthly> lastMonthMap) {
|
H2032EnterpriseMonthly lastMonth = lastMonthMap.get(key(report.getEnterpriseCode()));
|
if (lastMonth == null) return null;
|
|
String[] fields = {"freightContainer", "freightCoal", "freightOilGas", "freightCrudeOil",
|
"freightMetalOre", "freightIronOre", "freightBuilding", "freightGrain"};
|
List<String> newTypes = new ArrayList<>();
|
for (String field : fields) {
|
double current = getFieldValue(report, field);
|
double last = getFieldValue(lastMonth, field);
|
if (current > 0 && last == 0) {
|
newTypes.add(FREIGHT_TYPE_NAMES.get(field) + "=" + fmt(current) + "吨");
|
}
|
}
|
if (!newTypes.isEmpty()) {
|
return buildResult(rule, report, "本月新增货类: " + String.join("、", newTypes),
|
"上月为0", "环比新增");
|
}
|
return null;
|
}
|
|
/** 无集装箱车但有集装箱货运量 */
|
private AuditResult checkNull(AuditRule rule, H2032EnterpriseMonthly report) {
|
double containerFreight = nvl(report.getFreightContainer());
|
double containerVehicle = nvl(report.getVehicleContainer());
|
if (containerFreight > 0 && containerVehicle == 0) {
|
return buildResult(rule, report, "集装箱货运量=" + fmt(containerFreight),
|
"有集装箱车", "无集装箱车但有集装箱货运量");
|
}
|
return null;
|
}
|
|
/** 整车吨位不在(4,40]范围内核实 */
|
private AuditResult checkOutRange(AuditRule rule, H2032EnterpriseMonthly report,
|
Map<String, TransportAuthVehicle> authMap) {
|
TransportAuthVehicle auth = findAuth(authMap, report.getEnterpriseName());
|
if (auth == null) return null;
|
if (num(auth.getOtherCount()) == 0) return null;
|
|
double wholeTonnage = nvl(auth.getOtherTons()) / num(auth.getOtherCount());
|
|
String[] range = rule.getThreshold().split(",");
|
double min = Double.parseDouble(range[0]);
|
double max = Double.parseDouble(range[1]);
|
|
if (wholeTonnage < min || wholeTonnage > max) {
|
return buildResult(rule, report, "整车吨位=" + fmt(wholeTonnage),
|
fmt(min) + " ≤ 整车吨位 ≤ " + fmt(max), "超出范围");
|
}
|
return null;
|
}
|
|
// ========== 辅助方法 ==========
|
|
private AuditResult buildResult(AuditRule rule, H2032EnterpriseMonthly report,
|
String actual, String threshold, String deviation) {
|
AuditResult result = new AuditResult();
|
result.setRuleId(rule.getId());
|
result.setReportId(report.getId());
|
result.setEnterpriseCode(report.getEnterpriseCode());
|
result.setReportPeriod(report.getReportPeriod());
|
result.setActualValue(actual);
|
result.setThresholdValue(threshold);
|
result.setDeviation(deviation);
|
result.setStatus("PENDING");
|
return result;
|
}
|
|
private Map<String, TransportAuthVehicle> loadAuthMap(String reportPeriod) {
|
Map<String, TransportAuthVehicle> map = new HashMap<>();
|
List<TransportAuthVehicle> list = transportAuthMapper.selectList(
|
new LambdaQueryWrapper<TransportAuthVehicle>()
|
.eq(TransportAuthVehicle::getReportPeriod, reportPeriod));
|
for (TransportAuthVehicle v : list) {
|
map.putIfAbsent(key(v.getEnterpriseName()), v);
|
}
|
return map;
|
}
|
|
private Map<String, VehicleTrackMileage> loadTrackMap(String period) {
|
Map<String, VehicleTrackMileage> map = new HashMap<>();
|
List<VehicleTrackMileage> list = trackMileageMapper.selectList(
|
new LambdaQueryWrapper<VehicleTrackMileage>()
|
.eq(VehicleTrackMileage::getReportPeriod, period));
|
for (VehicleTrackMileage v : list) {
|
map.putIfAbsent(key(v.getEnterpriseName()), v);
|
}
|
return map;
|
}
|
|
private Map<String, H2032EnterpriseMonthly> loadLastMonthMap(String period) {
|
Map<String, H2032EnterpriseMonthly> map = new HashMap<>();
|
String lastPeriod = getLastPeriod(period);
|
List<H2032EnterpriseMonthly> list = h2032Mapper.selectList(
|
new LambdaQueryWrapper<H2032EnterpriseMonthly>()
|
.eq(H2032EnterpriseMonthly::getReportPeriod, lastPeriod));
|
for (H2032EnterpriseMonthly v : list) {
|
map.putIfAbsent(key(v.getEnterpriseCode()), v);
|
}
|
return map;
|
}
|
|
private TransportAuthVehicle findAuth(Map<String, TransportAuthVehicle> authMap, String name) {
|
return authMap.get(key(name));
|
}
|
|
private String key(String s) {
|
return s == null ? "" : s.trim();
|
}
|
|
/** double 显示格式化：避免科学计数法，整数值不带小数 */
|
private String fmt(double v) {
|
if (Double.isNaN(v) || Double.isInfinite(v)) return String.valueOf(v);
|
if (v == Math.rint(v) && Math.abs(v) < 1e15) {
|
return String.valueOf((long) v);
|
}
|
String s = String.format("%.6f", v);
|
if (s.indexOf('.') >= 0) {
|
s = s.replaceAll("0+$", "").replaceAll("\\.$", "");
|
}
|
return s;
|
}
|
|
private double nvl(Double v) {
|
return v == null ? 0.0 : v;
|
}
|
|
private double nvl(Integer v) {
|
return v == null ? 0.0 : v;
|
}
|
|
private int num(Integer v) {
|
return v == null ? 0 : v;
|
}
|
|
private double getFieldValue(H2032EnterpriseMonthly report, String fieldName) {
|
try {
|
java.lang.reflect.Field field = H2032EnterpriseMonthly.class.getDeclaredField(fieldName);
|
field.setAccessible(true);
|
Object value = field.get(report);
|
if (value == null) return 0.0;
|
if (value instanceof Double) return (Double) value;
|
if (value instanceof Integer) return ((Integer) value).doubleValue();
|
return Double.parseDouble(value.toString());
|
} catch (Exception e) {
|
return 0.0;
|
}
|
}
|
|
private String getLastPeriod(String period) {
|
String[] parts = period.split("-");
|
int year = Integer.parseInt(parts[0]);
|
int month = Integer.parseInt(parts[1]);
|
if (month == 1) {
|
year--;
|
month = 12;
|
} else {
|
month--;
|
}
|
return String.format("%d-%02d", year, month);
|
}
|
}
|
