package com.trafficaudit.auditengine.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.trafficaudit.auditengine.entity.AuditResult;
|
import com.trafficaudit.auditengine.entity.AuditRun;
|
import com.trafficaudit.auditengine.mapper.AuditResultMapper;
|
import com.trafficaudit.auditengine.mapper.AuditRunMapper;
|
import com.trafficaudit.dataimport.entity.EnergyAuthVehicle;
|
import com.trafficaudit.dataimport.entity.EnergyVehicleQuarterly;
|
import com.trafficaudit.dataimport.entity.H2032EnterpriseMonthly;
|
import com.trafficaudit.dataimport.entity.InvestmentMonthly;
|
import com.trafficaudit.dataimport.entity.InvestmentProject;
|
import com.trafficaudit.dataimport.entity.InvestmentSystem;
|
import com.trafficaudit.dataimport.entity.CityBusMonthly;
|
import com.trafficaudit.dataimport.entity.CityTaxiAuth;
|
import com.trafficaudit.dataimport.entity.CityTaxiMonthly;
|
import com.trafficaudit.dataimport.entity.PassengerAuthVehicle;
|
import com.trafficaudit.dataimport.entity.PassengerEnterpriseMonthly;
|
import com.trafficaudit.dataimport.entity.TransportAuthVehicle;
|
import com.trafficaudit.dataimport.entity.VehicleTrackMileage;
|
import com.trafficaudit.dataimport.mapper.EnergyAuthVehicleMapper;
|
import com.trafficaudit.dataimport.mapper.EnergyVehicleQuarterlyMapper;
|
import com.trafficaudit.dataimport.mapper.H2032EnterpriseMonthlyMapper;
|
import com.trafficaudit.dataimport.mapper.InvestmentMonthlyMapper;
|
import com.trafficaudit.dataimport.mapper.InvestmentProjectMapper;
|
import com.trafficaudit.dataimport.mapper.InvestmentSystemMapper;
|
import com.trafficaudit.dataimport.mapper.CityBusMonthlyMapper;
|
import com.trafficaudit.dataimport.mapper.CityTaxiAuthMapper;
|
import com.trafficaudit.dataimport.mapper.CityTaxiMonthlyMapper;
|
import com.trafficaudit.dataimport.mapper.PassengerAuthVehicleMapper;
|
import com.trafficaudit.dataimport.mapper.PassengerEnterpriseMonthlyMapper;
|
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 org.apache.poi.ss.usermodel.Cell;
|
import org.apache.poi.ss.usermodel.Row;
|
import org.apache.poi.ss.usermodel.Sheet;
|
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
|
|
import javax.annotation.Resource;
|
import java.io.ByteArrayOutputStream;
|
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", "粮食");
|
}
|
|
/** H204 车辆类型码 -> 允许的运政车辆类型（已去掉重/中/轻型前缀） */
|
private static final Map<String, java.util.Set<String>> ENERGY_VEHICLE_TYPE_ALLOWED = new HashMap<>();
|
|
/** H204 燃料类型码 -> 允许的运政燃料类型 */
|
private static final Map<String, java.util.Set<String>> ENERGY_FUEL_TYPE_ALLOWED = new HashMap<>();
|
|
static {
|
ENERGY_VEHICLE_TYPE_ALLOWED.put("01", new java.util.HashSet<>(java.util.Arrays.asList("普通货车", "栏板货车", "自卸货车")));
|
ENERGY_VEHICLE_TYPE_ALLOWED.put("02", new java.util.HashSet<>(java.util.Arrays.asList("平板货车", "栏板货车")));
|
ENERGY_VEHICLE_TYPE_ALLOWED.put("03", new java.util.HashSet<>(java.util.Arrays.asList("仓栅式货车")));
|
ENERGY_VEHICLE_TYPE_ALLOWED.put("04", new java.util.HashSet<>(java.util.Arrays.asList("厢式货车")));
|
ENERGY_VEHICLE_TYPE_ALLOWED.put("06", new java.util.HashSet<>(java.util.Arrays.asList("罐式货车")));
|
ENERGY_VEHICLE_TYPE_ALLOWED.put("07", new java.util.HashSet<>(java.util.Arrays.asList("特殊结构货车", "车辆运输车")));
|
ENERGY_VEHICLE_TYPE_ALLOWED.put("08", new java.util.HashSet<>(java.util.Arrays.asList("自卸货车", "栏板货车")));
|
ENERGY_VEHICLE_TYPE_ALLOWED.put("09", new java.util.HashSet<>(java.util.Arrays.asList("车辆运输车", "中置轴车辆运输车")));
|
ENERGY_VEHICLE_TYPE_ALLOWED.put("11", new java.util.HashSet<>(java.util.Arrays.asList("半挂牵引车")));
|
|
ENERGY_FUEL_TYPE_ALLOWED.put("01", new java.util.HashSet<>(java.util.Arrays.asList("汽油")));
|
ENERGY_FUEL_TYPE_ALLOWED.put("02", new java.util.HashSet<>(java.util.Arrays.asList("柴油")));
|
ENERGY_FUEL_TYPE_ALLOWED.put("03", new java.util.HashSet<>(java.util.Arrays.asList("压缩天然气")));
|
ENERGY_FUEL_TYPE_ALLOWED.put("04", new java.util.HashSet<>(java.util.Arrays.asList("液态天然气", "液化天然气", "双燃料")));
|
ENERGY_FUEL_TYPE_ALLOWED.put("07", new java.util.HashSet<>(java.util.Arrays.asList("电动")));
|
ENERGY_FUEL_TYPE_ALLOWED.put("08", new java.util.HashSet<>(java.util.Arrays.asList("氢气")));
|
}
|
|
@Resource
|
private AuditRuleMapper ruleMapper;
|
@Resource
|
private AuditResultMapper resultMapper;
|
@Resource
|
private AuditRunMapper auditRunMapper;
|
@Resource
|
private H2032EnterpriseMonthlyMapper h2032Mapper;
|
@Resource
|
private TransportAuthVehicleMapper transportAuthMapper;
|
@Resource
|
private VehicleTrackMileageMapper trackMileageMapper;
|
@Resource
|
private PassengerEnterpriseMonthlyMapper passengerMapper;
|
@Resource
|
private PassengerAuthVehicleMapper passengerAuthMapper;
|
@Resource
|
private EnergyVehicleQuarterlyMapper energyMapper;
|
@Resource
|
private EnergyAuthVehicleMapper energyAuthMapper;
|
@Resource
|
private InvestmentProjectMapper investProjectMapper;
|
@Resource
|
private InvestmentMonthlyMapper investMonthlyMapper;
|
@Resource
|
private InvestmentSystemMapper investSystemMapper;
|
@Resource
|
private CityBusMonthlyMapper cityBusMapper;
|
@Resource
|
private CityTaxiMonthlyMapper cityTaxiMapper;
|
@Resource
|
private CityTaxiAuthMapper cityTaxiAuthMapper;
|
|
/** 记录「该期该类型已完成审核」标记（先审核再出表依据；无规则或无数据不标记，重复执行幂等） */
|
public void markAudited(String reportType, String reportPeriod, List<AuditRule> rules, boolean hasData) {
|
if (rules == null || rules.isEmpty() || !hasData) return;
|
Long cnt = auditRunMapper.selectCount(new LambdaQueryWrapper<AuditRun>()
|
.eq(AuditRun::getReportType, reportType)
|
.eq(AuditRun::getReportPeriod, reportPeriod));
|
if (cnt != null && cnt > 0) return;
|
AuditRun run = new AuditRun();
|
run.setReportType(reportType);
|
run.setReportPeriod(reportPeriod);
|
auditRunMapper.insert(run);
|
}
|
|
/** 2 参数重载：按报表类型自动取启用规则 + 校验该期有数据后再写标记（线下审核通过数据手动标记 / Controller 调用） */
|
public boolean markAudited(String reportType, String reportPeriod) {
|
List<AuditRule> rules = rulesOf(reportType);
|
if (rules.isEmpty()) {
|
log.info("markAudited skip: no enabled rules for {}", reportType);
|
return false;
|
}
|
long dataCount;
|
if ("H2031".equals(reportType)) {
|
dataCount = passengerMapper.selectCount(new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
|
.eq(PassengerEnterpriseMonthly::getReportPeriod, reportPeriod));
|
} else if ("H204".equals(reportType)) {
|
dataCount = energyMapper.selectCount(new LambdaQueryWrapper<EnergyVehicleQuarterly>()
|
.eq(EnergyVehicleQuarterly::getReportPeriod, reportPeriod));
|
} else if ("INVEST".equals(reportType)) {
|
dataCount = investMonthlyMapper.selectCount(new LambdaQueryWrapper<InvestmentMonthly>()
|
.eq(InvestmentMonthly::getReportPeriod, reportPeriod));
|
} else if ("CITY_BUS".equals(reportType)) {
|
dataCount = cityBusMapper.selectCount(new LambdaQueryWrapper<CityBusMonthly>()
|
.eq(CityBusMonthly::getReportPeriod, reportPeriod));
|
} else if ("CITY_TAXI".equals(reportType)) {
|
dataCount = cityTaxiMapper.selectCount(new LambdaQueryWrapper<CityTaxiMonthly>()
|
.eq(CityTaxiMonthly::getReportPeriod, reportPeriod));
|
} else {
|
dataCount = h2032Mapper.selectCount(new LambdaQueryWrapper<H2032EnterpriseMonthly>()
|
.eq(H2032EnterpriseMonthly::getReportPeriod, reportPeriod));
|
}
|
if (dataCount <= 0) {
|
log.info("markAudited skip: no data for {} / {}", reportType, reportPeriod);
|
return false;
|
}
|
markAudited(reportType, reportPeriod, rules, true);
|
return true;
|
}
|
|
public List<AuditResult> executeAudit(String reportPeriod) {
|
List<AuditRule> rules = rulesOf("H2032");
|
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);
|
if (!rules.isEmpty() && !reports.isEmpty()) markAudited("H2032", reportPeriod);
|
return results;
|
}
|
|
public List<AuditResult> executePassengerAudit(String reportPeriod) {
|
List<AuditRule> rules = rulesOf("H2031");
|
List<PassengerEnterpriseMonthly> reports = passengerMapper.selectList(
|
new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
|
.eq(PassengerEnterpriseMonthly::getReportPeriod, reportPeriod));
|
|
Map<String, PassengerAuthVehicle> authMap = loadPassengerAuthMap(reportPeriod);
|
Map<String, PassengerEnterpriseMonthly> lastMonthMap = loadPassengerLastMonthMap(reportPeriod);
|
|
// 幂等：只清除 H2031 规则的旧审核结果
|
List<Long> ruleIds = new ArrayList<>();
|
for (AuditRule rule : rules) ruleIds.add(rule.getId());
|
if (!ruleIds.isEmpty()) {
|
resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
|
.eq(AuditResult::getReportPeriod, reportPeriod)
|
.in(AuditResult::getRuleId, ruleIds));
|
}
|
|
Map<Long, AuditRule> ruleMap = new HashMap<>();
|
for (AuditRule rule : rules) ruleMap.put(rule.getId(), rule);
|
|
List<AuditResult> results = new ArrayList<>();
|
for (PassengerEnterpriseMonthly report : reports) {
|
for (AuditRule rule : rules) {
|
AuditResult result = checkPassengerRule(rule, report, authMap, 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("Passenger audit complete: {} reports, {} issues for {}", reports.size(), results.size(), reportPeriod);
|
if (!rules.isEmpty() && !reports.isEmpty()) markAudited("H2031", reportPeriod);
|
return results;
|
}
|
|
|
// ========== H204 能耗审核（车辆粒度，与运政车辆信息跨表对比） ==========
|
|
public List<AuditResult> executeEnergyAudit(String reportPeriod) {
|
List<AuditRule> rules = rulesOf("H204");
|
List<EnergyVehicleQuarterly> vehicles = energyMapper.selectList(
|
new LambdaQueryWrapper<EnergyVehicleQuarterly>()
|
.eq(EnergyVehicleQuarterly::getReportPeriod, reportPeriod));
|
|
Map<String, EnergyAuthVehicle> authMap = new HashMap<>();
|
List<EnergyAuthVehicle> authList = energyAuthMapper.selectList(
|
new LambdaQueryWrapper<EnergyAuthVehicle>()
|
.eq(EnergyAuthVehicle::getReportPeriod, reportPeriod));
|
for (EnergyAuthVehicle v : authList) {
|
authMap.putIfAbsent(key(v.getPlateNo()), v);
|
}
|
|
// E007 环比基准：上一季度同车牌百公里单耗
|
String lastPeriod = prevQuarter(reportPeriod);
|
Map<String, EnergyVehicleQuarterly> lastQuarterMap = new HashMap<>();
|
if (lastPeriod != null) {
|
for (EnergyVehicleQuarterly v : energyMapper.selectList(
|
new LambdaQueryWrapper<EnergyVehicleQuarterly>()
|
.eq(EnergyVehicleQuarterly::getReportPeriod, lastPeriod))) {
|
lastQuarterMap.putIfAbsent(key(v.getPlateNo()), v);
|
}
|
}
|
|
// E006 超范围基准：本期各燃料类型百公里单耗中位数
|
Map<String, Double> fuelMedianMap = fuelPer100kmMedian(vehicles);
|
|
// E008/E009 对比基准：同期 H2032 企业月报（按企业名索引）
|
Map<String, H2032EnterpriseMonthly> h2032Map = new HashMap<>();
|
for (H2032EnterpriseMonthly m : h2032Mapper.selectList(
|
new LambdaQueryWrapper<H2032EnterpriseMonthly>()
|
.eq(H2032EnterpriseMonthly::getReportPeriod, reportPeriod))) {
|
String ent = m.getEnterpriseName();
|
if (ent != null && !ent.trim().isEmpty()) h2032Map.putIfAbsent(ent.trim(), m);
|
}
|
|
// 幂等：只清除 H204 规则的旧审核结果
|
List<Long> ruleIds = new ArrayList<>();
|
for (AuditRule rule : rules) ruleIds.add(rule.getId());
|
if (!ruleIds.isEmpty()) {
|
resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
|
.eq(AuditResult::getReportPeriod, reportPeriod)
|
.in(AuditResult::getRuleId, ruleIds));
|
}
|
|
List<AuditResult> results = new ArrayList<>();
|
for (EnergyVehicleQuarterly vehicle : vehicles) {
|
for (AuditRule rule : rules) {
|
AuditResult result = checkEnergyRule(rule, vehicle, authMap, fuelMedianMap, lastQuarterMap, h2032Map);
|
if (result != null) {
|
result.setRuleName(rule.getRuleName());
|
result.setRuleCode(rule.getRuleCode());
|
result.setAlertLevel(rule.getAlertLevel());
|
result.setEnterpriseName(vehicle.getEnterpriseName());
|
result.setVerifyExplanation(null);
|
resultMapper.insert(result);
|
results.add(result);
|
}
|
}
|
}
|
log.info("Energy audit complete: {} vehicles, {} issues for {}", vehicles.size(), results.size(), reportPeriod);
|
if (!rules.isEmpty() && !vehicles.isEmpty()) markAudited("H204", reportPeriod);
|
return results;
|
}
|
|
private AuditResult checkEnergyRule(AuditRule rule, EnergyVehicleQuarterly vehicle,
|
Map<String, EnergyAuthVehicle> authMap,
|
Map<String, Double> fuelMedianMap,
|
Map<String, EnergyVehicleQuarterly> lastQuarterMap,
|
Map<String, H2032EnterpriseMonthly> h2032Map) {
|
try {
|
switch (rule.getCompareType()) {
|
case "CROSS_DIFF":
|
return checkEnergyCrossDiff(rule, vehicle, authMap);
|
case "EXISTENCE_AUTH":
|
return checkEnergyExistence(rule, vehicle, authMap);
|
case "LOADED_RATIO_DIFF":
|
return checkEnergyLoadedRatio(rule, vehicle);
|
case "FUEL_RANGE":
|
return checkEnergyFuelRange(rule, vehicle, fuelMedianMap);
|
case "FUEL_MOM":
|
return checkEnergyFuelMom(rule, vehicle, lastQuarterMap);
|
case "FREIGHT_VS_H2032":
|
return checkEnergyVsFreightReport(rule, vehicle, h2032Map);
|
case "AVG_DIST_VS_H2032":
|
return checkEnergyAvgDistVsFreight(rule, vehicle, h2032Map);
|
case "LOADED_TON_RATIO":
|
return checkEnergyLoadedTonnageRatio(rule, vehicle);
|
default:
|
return null;
|
}
|
} catch (Exception e) {
|
log.error("Energy rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
|
return null;
|
}
|
}
|
|
/** 跨表字段对比：车辆类型/燃料类型按码表比对，标记吨位（牵引车用准牵引质量）按阈值比对 */
|
private AuditResult checkEnergyCrossDiff(AuditRule rule, EnergyVehicleQuarterly vehicle,
|
Map<String, EnergyAuthVehicle> authMap) {
|
EnergyAuthVehicle auth = authMap.get(key(vehicle.getPlateNo()));
|
if (auth == null) return null; // 运政缺失由 EXISTENCE_AUTH 规则提示
|
|
String field = rule.getCheckField();
|
if ("vehicleType".equals(field)) {
|
java.util.Set<String> allowed = ENERGY_VEHICLE_TYPE_ALLOWED.get(vehicle.getVehicleTypeCode());
|
if (allowed == null || !allowed.contains(normalizeVehicleType(auth.getVehicleType()))) {
|
return buildEnergyResult(rule, vehicle,
|
"能耗=" + valueOf(vehicle.getVehicleType()) + "(码" + valueOf(vehicle.getVehicleTypeCode())
|
+ "), 运政=" + valueOf(auth.getVehicleType()),
|
"车辆类型一致", "车辆类型不一致");
|
}
|
return null;
|
}
|
if ("fuelType".equals(field)) {
|
java.util.Set<String> allowed = ENERGY_FUEL_TYPE_ALLOWED.get(vehicle.getFuelTypeCode());
|
if (allowed == null || !allowed.contains(key(auth.getFuelType()))) {
|
return buildEnergyResult(rule, vehicle,
|
"能耗=" + valueOf(vehicle.getFuelType()) + "(码" + valueOf(vehicle.getFuelTypeCode())
|
+ "), 运政=" + valueOf(auth.getFuelType()),
|
"燃料类型一致", "燃料类型不一致");
|
}
|
return null;
|
}
|
if ("markedTonnage".equals(field)) {
|
double actual = nvl(vehicle.getMarkedTonnage());
|
double reference = "11".equals(vehicle.getVehicleTypeCode())
|
? nvl(auth.getTractionQuality())
|
: nvl(auth.getMarkedTonnage());
|
double threshold = Double.parseDouble(rule.getThreshold());
|
double diff = Math.abs(actual - reference);
|
if (diff > threshold) {
|
String refName = "11".equals(vehicle.getVehicleTypeCode()) ? "准牵引质量" : "标记吨位";
|
return buildEnergyResult(rule, vehicle,
|
"能耗标记吨位=" + fmt(actual) + ", 运政" + refName + "=" + fmt(reference),
|
"差距≤" + fmt(threshold), "差距=" + fmt(diff));
|
}
|
return null;
|
}
|
return null;
|
}
|
|
/** 能耗明细车牌在运政车辆信息中不存在时提示 */
|
private AuditResult checkEnergyExistence(AuditRule rule, EnergyVehicleQuarterly vehicle,
|
Map<String, EnergyAuthVehicle> authMap) {
|
EnergyAuthVehicle auth = authMap.get(key(vehicle.getPlateNo()));
|
if (auth == null) {
|
return buildEnergyResult(rule, vehicle,
|
"车牌号=" + vehicle.getPlateNo(), "运政车辆信息存在", "运政车辆信息缺失");
|
}
|
return null;
|
}
|
|
/** E005 载货里程占比 vs 平均运距/单趟平均里程 相差±10% */
|
private AuditResult checkEnergyLoadedRatio(AuditRule rule, EnergyVehicleQuarterly vehicle) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.1);
|
double total = nvl(vehicle.getTotalMileage());
|
double loaded = nvl(vehicle.getLoadedMileage());
|
double avgDist = nvl(vehicle.getAvgDistance());
|
double avgTrip = nvl(vehicle.getAvgTripMileage());
|
if (total <= 0 || avgTrip <= 0 || avgDist <= 0) return null;
|
double r1 = loaded / total;
|
double r2 = avgDist / avgTrip;
|
if (r2 <= 0) return null;
|
double diff = Math.abs(r1 - r2) / r2;
|
if (diff <= threshold) return null;
|
return buildEnergyResult(rule, vehicle,
|
"载货里程/总行程=" + fmt4(r1) + "，平均运距/单趟平均里程=" + fmt4(r2),
|
"两者相差≤" + fmt(threshold * 100) + "%",
|
"相差=" + fmt(diff * 100) + "%");
|
}
|
|
/** E006 同燃料类型百公里单耗偏离中位数超阈值（默认 50%） */
|
private AuditResult checkEnergyFuelRange(AuditRule rule, EnergyVehicleQuarterly vehicle,
|
Map<String, Double> fuelMedianMap) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.5);
|
Double v = vehicle.getFuelPer100km();
|
if (v == null || v <= 0 || vehicle.getFuelTypeCode() == null) return null;
|
Double median = fuelMedianMap.get(vehicle.getFuelTypeCode().trim());
|
if (median == null || median <= 0) return null;
|
double diff = Math.abs(v - median) / median;
|
if (diff <= threshold) return null;
|
return buildEnergyResult(rule, vehicle,
|
"百公里单耗=" + fmt(v) + "（" + valueOf(vehicle.getFuelType()) + "），同燃料中位数=" + fmt(median),
|
"偏离中位数≤" + fmt(threshold * 100) + "%",
|
"偏离=" + fmt(diff * 100) + "%");
|
}
|
|
/** E007 同一辆车百公里单耗环比变化超阈值（默认 ±50%） */
|
private AuditResult checkEnergyFuelMom(AuditRule rule, EnergyVehicleQuarterly vehicle,
|
Map<String, EnergyVehicleQuarterly> lastQuarterMap) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.5);
|
Double cur = vehicle.getFuelPer100km();
|
if (cur == null || cur <= 0) return null;
|
EnergyVehicleQuarterly last = lastQuarterMap.get(key(vehicle.getPlateNo()));
|
if (last == null || last.getFuelPer100km() == null || last.getFuelPer100km() <= 0) return null;
|
double diff = Math.abs(cur - last.getFuelPer100km()) / last.getFuelPer100km();
|
if (diff <= threshold) return null;
|
return buildEnergyResult(rule, vehicle,
|
"本期百公里单耗=" + fmt(cur) + "，上季度=" + fmt(last.getFuelPer100km()),
|
"环比变化≤" + fmt(threshold * 100) + "%",
|
"环比变化=" + fmt(diff * 100) + "%");
|
}
|
|
/** E008 能耗货运量/周转量与 H2032 月报对比超阈值（默认 50%） */
|
private AuditResult checkEnergyVsFreightReport(AuditRule rule, EnergyVehicleQuarterly vehicle,
|
Map<String, H2032EnterpriseMonthly> h2032Map) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.5);
|
String ent = vehicle.getEnterpriseName();
|
if (ent == null || ent.trim().isEmpty()) return null;
|
H2032EnterpriseMonthly m = h2032Map.get(ent.trim());
|
if (m == null) return null;
|
List<String> msgs = new ArrayList<>();
|
if (m.getFreightTotal() != null && m.getFreightTotal() > 0 && vehicle.getFreight() != null) {
|
double r = vehicle.getFreight() / m.getFreightTotal();
|
if (r > threshold) {
|
msgs.add("能耗货运量=" + fmt(vehicle.getFreight()) + "，月报=" + fmt(m.getFreightTotal())
|
+ "，占比=" + fmt4(r));
|
}
|
}
|
if (m.getTurnoverTotal() != null && m.getTurnoverTotal() > 0 && vehicle.getTurnover() != null) {
|
double r = vehicle.getTurnover() / m.getTurnoverTotal();
|
if (r > threshold) {
|
msgs.add("能耗周转量=" + fmt(vehicle.getTurnover()) + "，月报=" + fmt(m.getTurnoverTotal())
|
+ "，占比=" + fmt4(r));
|
}
|
}
|
if (msgs.isEmpty()) return null;
|
return buildEnergyResult(rule, vehicle, String.join("；", msgs),
|
"能耗量≤月报" + fmt(threshold * 100) + "%", "超过月报" + fmt(threshold * 100) + "%");
|
}
|
|
/** E009 车辆平均运距与 H2032 月报平均运距相差超阈值（默认 ±60%） */
|
private AuditResult checkEnergyAvgDistVsFreight(AuditRule rule, EnergyVehicleQuarterly vehicle,
|
Map<String, H2032EnterpriseMonthly> h2032Map) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.6);
|
String ent = vehicle.getEnterpriseName();
|
if (ent == null || ent.trim().isEmpty()) return null;
|
H2032EnterpriseMonthly m = h2032Map.get(ent.trim());
|
if (m == null || m.getAvgDistance() == null || m.getAvgDistance() <= 0) return null;
|
double cur = nvl(vehicle.getAvgDistance());
|
if (cur <= 0) return null;
|
double diff = Math.abs(cur - m.getAvgDistance()) / m.getAvgDistance();
|
if (diff <= threshold) return null;
|
return buildEnergyResult(rule, vehicle,
|
"能耗平均运距=" + fmt(cur) + "，月报=" + fmt(m.getAvgDistance()),
|
"相差≤" + fmt(threshold * 100) + "%",
|
"相差=" + fmt(diff * 100) + "%");
|
}
|
|
/** E010 平均载货吨位/标记吨位 比值超出 [0.5, 1] */
|
private AuditResult checkEnergyLoadedTonnageRatio(AuditRule rule, EnergyVehicleQuarterly vehicle) {
|
double lo = 0.5, hi = 1.0;
|
String t = rule.getThreshold();
|
if (t != null && t.contains(",")) {
|
String[] parts = t.split(",");
|
try {
|
lo = Double.parseDouble(parts[0].trim());
|
hi = Double.parseDouble(parts[1].trim());
|
} catch (Exception ignore) {
|
}
|
}
|
double marked = nvl(vehicle.getMarkedTonnage());
|
double loaded = nvl(vehicle.getAvgLoadedTonnage());
|
if (marked <= 0 || loaded <= 0) return null;
|
double r = loaded / marked;
|
if (r >= lo && r <= hi) return null;
|
return buildEnergyResult(rule, vehicle,
|
"平均载货吨位=" + fmt(loaded) + "，标记吨位=" + fmt(marked) + "，比值=" + fmt4(r),
|
"比值在[" + fmt(lo) + "," + fmt(hi) + "]",
|
"比值=" + fmt4(r) + " 超出范围");
|
}
|
|
/** 上一季度报表期：2026-06 → 2026-03 */
|
private String prevQuarter(String period) {
|
if (period == null || period.length() < 7) return null;
|
try {
|
int year = Integer.parseInt(period.substring(0, 4));
|
int month = Integer.parseInt(period.substring(5, 7));
|
int pm = month - 3;
|
int py = year;
|
if (pm <= 0) {
|
pm += 12;
|
py -= 1;
|
}
|
return String.format("%04d-%02d", py, pm);
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
/** 本期各燃料类型百公里单耗中位数 */
|
private Map<String, Double> fuelPer100kmMedian(List<EnergyVehicleQuarterly> vehicles) {
|
Map<String, List<Double>> byFuel = new HashMap<>();
|
for (EnergyVehicleQuarterly v : vehicles) {
|
if (v.getFuelTypeCode() == null || v.getFuelPer100km() == null || v.getFuelPer100km() <= 0) continue;
|
byFuel.computeIfAbsent(v.getFuelTypeCode().trim(), k -> new ArrayList<>()).add(v.getFuelPer100km());
|
}
|
Map<String, Double> med = new HashMap<>();
|
for (Map.Entry<String, List<Double>> e : byFuel.entrySet()) {
|
List<Double> list = e.getValue();
|
list.sort(null);
|
double m = list.size() % 2 == 1 ? list.get(list.size() / 2)
|
: (list.get(list.size() / 2 - 1) + list.get(list.size() / 2)) / 2.0;
|
med.put(e.getKey(), m);
|
}
|
return med;
|
}
|
|
private Map<String, EnergyAuthVehicle> loadEnergyAuthMap(String reportPeriod) {
|
Map<String, EnergyAuthVehicle> map = new HashMap<>();
|
List<EnergyAuthVehicle> list = energyAuthMapper.selectList(
|
new LambdaQueryWrapper<EnergyAuthVehicle>()
|
.eq(EnergyAuthVehicle::getReportPeriod, reportPeriod));
|
for (EnergyAuthVehicle v : list) {
|
map.putIfAbsent(key(v.getPlateNo()), v);
|
}
|
return map;
|
}
|
|
/** 运政车辆类型去掉 重型/中型/轻型 前缀后比对 */
|
private String normalizeVehicleType(String type) {
|
if (type == null) return "";
|
String t = type.trim();
|
for (String prefix : new String[]{"重型", "中型", "轻型"}) {
|
if (t.startsWith(prefix)) {
|
t = t.substring(prefix.length());
|
break;
|
}
|
}
|
return t;
|
}
|
|
private String valueOf(String v) {
|
return v == null ? "空" : v.trim();
|
}
|
|
private AuditResult buildEnergyResult(AuditRule rule, EnergyVehicleQuarterly vehicle,
|
String actual, String threshold, String deviation) {
|
AuditResult result = new AuditResult();
|
result.setRuleId(rule.getId());
|
result.setReportId(vehicle.getId());
|
result.setEnterpriseCode(vehicle.getEnterpriseCode());
|
result.setReportPeriod(vehicle.getReportPeriod());
|
result.setActualValue(actual);
|
result.setThresholdValue(threshold);
|
result.setDeviation(deviation);
|
result.setStatus("PENDING");
|
return result;
|
}
|
|
|
// ========== INVEST 投资审核（汇总大表 与 投资系统导出 跨表对比） ==========
|
|
public List<AuditResult> executeInvestmentAudit(String reportPeriod) {
|
List<AuditRule> rules = rulesOf("INVEST");
|
List<InvestmentMonthly> monthlies = investMonthlyMapper.selectList(
|
new LambdaQueryWrapper<InvestmentMonthly>()
|
.eq(InvestmentMonthly::getReportPeriod, reportPeriod));
|
Map<Long, InvestmentProject> projectMap = new HashMap<>();
|
for (InvestmentProject p : investProjectMapper.selectList(null)) {
|
projectMap.put(p.getId(), p);
|
}
|
Map<String, List<InvestmentSystem>> sysMap = new HashMap<>();
|
for (InvestmentSystem s : investSystemMapper.selectList(
|
new LambdaQueryWrapper<InvestmentSystem>()
|
.eq(InvestmentSystem::getReportPeriod, reportPeriod))) {
|
sysMap.computeIfAbsent(normInvestName(s.getProjectName()), k -> new ArrayList<>()).add(s);
|
}
|
|
// 幂等：只清除 INVEST 规则的旧审核结果
|
List<Long> ruleIds = new ArrayList<>();
|
for (AuditRule rule : rules) ruleIds.add(rule.getId());
|
if (!ruleIds.isEmpty()) {
|
resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
|
.eq(AuditResult::getReportPeriod, reportPeriod)
|
.in(AuditResult::getRuleId, ruleIds));
|
}
|
|
List<AuditResult> results = new ArrayList<>();
|
for (InvestmentMonthly monthly : monthlies) {
|
InvestmentProject project = projectMap.get(monthly.getProjectId());
|
String projectName = project == null ? "未知项目" : project.getProjectName();
|
InvestmentSystem sys = findInvestSystem(sysMap, projectName);
|
for (AuditRule rule : rules) {
|
AuditResult result = checkInvestRule(rule, monthly, projectName, sys);
|
if (result != null) {
|
result.setRuleName(rule.getRuleName());
|
result.setRuleCode(rule.getRuleCode());
|
result.setAlertLevel(rule.getAlertLevel());
|
result.setEnterpriseName(projectName);
|
result.setVerifyExplanation(null);
|
resultMapper.insert(result);
|
results.add(result);
|
}
|
}
|
}
|
log.info("Investment audit complete: {} projects, {} issues for {}", monthlies.size(), results.size(), reportPeriod);
|
if (!rules.isEmpty() && !monthlies.isEmpty()) markAudited("INVEST", reportPeriod);
|
return results;
|
}
|
|
private AuditResult checkInvestRule(AuditRule rule, InvestmentMonthly monthly,
|
String projectName, InvestmentSystem sys) {
|
try {
|
switch (rule.getCompareType()) {
|
case "CROSS_DIFF":
|
return checkInvestCrossDiff(rule, monthly, projectName, sys);
|
case "EXISTENCE_SYS":
|
return checkInvestExistence(rule, monthly, projectName, sys);
|
default:
|
return null;
|
}
|
} catch (Exception e) {
|
log.error("Investment rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
|
return null;
|
}
|
}
|
|
/** 与投资系统导出数值对比：阈值格式 "绝对差|相对差%" */
|
private AuditResult checkInvestCrossDiff(AuditRule rule, InvestmentMonthly monthly,
|
String projectName, InvestmentSystem sys) {
|
if (sys == null) return null; // 缺失由 EXISTENCE_SYS 规则提示
|
String field = rule.getCheckField();
|
double actual;
|
double reference;
|
String fieldName;
|
if ("startCum".equals(field)) {
|
actual = nvl(monthly.getStartCum());
|
reference = nvl(sys.getStartCum());
|
fieldName = "自开始建设累计";
|
} else if ("yearCum".equals(field)) {
|
actual = nvl(monthly.getYearCum());
|
reference = nvl(sys.getYearCum());
|
fieldName = "自年初累计";
|
} else if ("monthDone".equals(field)) {
|
actual = nvl(monthly.getMonthDone());
|
reference = nvl(sys.getMonthDone());
|
fieldName = "本月完成";
|
} else {
|
return null;
|
}
|
String[] parts = rule.getThreshold().split("\\|");
|
double absThreshold = parts.length > 0 ? parseDoubleSafe(parts[0], 50) : 50;
|
double pctThreshold = parts.length > 1 ? parseDoubleSafe(parts[1], 5) : 5;
|
double diff = Math.abs(actual - reference);
|
double base = Math.max(Math.abs(reference), 1.0);
|
double pct = diff / base * 100;
|
boolean hit = diff > absThreshold && pct > pctThreshold;
|
if (!hit && reference == 0 && actual > absThreshold) {
|
hit = true;
|
}
|
if (hit) {
|
return buildInvestResult(rule, monthly,
|
"汇总大表" + fieldName + "=" + fmt(actual) + ", 投资系统=" + fmt(reference),
|
"绝对差≤" + fmt(absThreshold) + "万 且 相对差≤" + fmt(pctThreshold) + "%",
|
"绝对差=" + fmt(diff) + "万, 相对差=" + fmt(Math.round(pct * 10) / 10.0) + "%");
|
}
|
return null;
|
}
|
|
/** 汇总大表项目在投资系统导出中不存在 */
|
private AuditResult checkInvestExistence(AuditRule rule, InvestmentMonthly monthly,
|
String projectName, InvestmentSystem sys) {
|
if (sys == null) {
|
return buildInvestResult(rule, monthly,
|
"项目名称=" + projectName, "投资系统导出中存在", "投资系统导出中不存在");
|
}
|
return null;
|
}
|
|
private AuditResult buildInvestResult(AuditRule rule, InvestmentMonthly monthly,
|
String actual, String threshold, String deviation) {
|
AuditResult result = new AuditResult();
|
result.setRuleId(rule.getId());
|
result.setReportId(monthly.getId());
|
result.setReportPeriod(monthly.getReportPeriod());
|
result.setActualValue(actual);
|
result.setThresholdValue(threshold);
|
result.setDeviation(deviation);
|
result.setStatus("PENDING");
|
return result;
|
}
|
|
// ========== CITY_BUS 城市公交审核（4 组规则，企业级） ==========
|
|
public List<AuditResult> executeCityBusAudit(String reportPeriod) {
|
List<AuditRule> rules = rulesOf("CITY_BUS");
|
List<CityBusMonthly> rows = cityBusMapper.selectList(
|
new LambdaQueryWrapper<CityBusMonthly>()
|
.eq(CityBusMonthly::getReportPeriod, reportPeriod));
|
|
// 幂等：只清除 CITY_BUS 规则的旧审核结果
|
List<Long> ruleIds = new ArrayList<>();
|
for (AuditRule rule : rules) ruleIds.add(rule.getId());
|
if (!ruleIds.isEmpty()) {
|
resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
|
.eq(AuditResult::getReportPeriod, reportPeriod)
|
.in(AuditResult::getRuleId, ruleIds));
|
}
|
|
List<AuditResult> results = new ArrayList<>();
|
for (CityBusMonthly row : rows) {
|
// 无公交经营活动企业（运营车数/客运量/周转量均 0）跳过
|
if (nvl(row.getOpVehicles()) <= 0 && nvl(row.getPassengerVolume()) <= 0
|
&& nvl(row.getTurnover()) <= 0) {
|
continue;
|
}
|
for (AuditRule rule : rules) {
|
AuditResult result = checkCityBusRule(rule, row);
|
if (result != null) {
|
result.setRuleName(rule.getRuleName());
|
result.setRuleCode(rule.getRuleCode());
|
result.setAlertLevel(rule.getAlertLevel());
|
result.setEnterpriseName(row.getEnterpriseName());
|
result.setVerifyExplanation(row.getVerifyExplanation());
|
resultMapper.insert(result);
|
results.add(result);
|
}
|
}
|
}
|
log.info("CityBus audit complete: {} enterprises, {} issues for {}", rows.size(), results.size(), reportPeriod);
|
if (!rules.isEmpty() && !rows.isEmpty()) markAudited("CITY_BUS", reportPeriod);
|
return results;
|
}
|
|
private AuditResult checkCityBusRule(AuditRule rule, CityBusMonthly row) {
|
try {
|
switch (rule.getCompareType()) {
|
case "TREND_CONSISTENCY":
|
return checkCityBusTrend(rule, row);
|
case "RATIO_CHANGE":
|
return checkCityBusRatioChange(rule, row);
|
case "AVG_DIST_CHANGE":
|
return checkCityBusAvgDistChange(rule, row);
|
default:
|
return null;
|
}
|
} catch (Exception e) {
|
log.error("CityBus rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
|
return null;
|
}
|
}
|
|
/** 趋势一致：check_field 中成对字段（环比/同比）趋势不一致且增速超阈值需核实 */
|
private AuditResult checkCityBusTrend(AuditRule rule, CityBusMonthly row) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.02);
|
String field = rule.getCheckField() == null ? "" : rule.getCheckField();
|
List<String> msgs = new ArrayList<>();
|
if (field.contains("passengerCityMom")) {
|
checkTrendPair(msgs, "城市内客运量环比", row.getRatePassengerCityMom(),
|
"城际城乡客运量环比", row.getRateChengxiangMom(), threshold);
|
}
|
if (field.contains("passengerCityYoy")) {
|
checkTrendPair(msgs, "城市内客运量同比", row.getRatePassengerCityYoy(),
|
"城际城乡客运量同比", row.getRateChengxiangYoy(), threshold);
|
}
|
if (field.contains("passengerMom")) {
|
checkTrendPair(msgs, "客运量环比", row.getRatePassengerMom(),
|
"旅客周转量环比", row.getRateTurnoverMom(), threshold);
|
}
|
if (field.contains("passengerYoy")) {
|
checkTrendPair(msgs, "客运量同比", row.getRatePassengerYoy(),
|
"旅客周转量同比", row.getRateTurnoverYoy(), threshold);
|
}
|
if (msgs.isEmpty()) return null;
|
return buildCityBusResult(rule, row, String.join("；", msgs),
|
"两指标环比/同比趋势一致", "趋势不一致且增速超阈值");
|
}
|
|
private void checkTrendPair(List<String> msgs, String aName, Double aVal,
|
String bName, Double bVal, double threshold) {
|
double a = nvl(aVal);
|
double b = nvl(bVal);
|
boolean aUp = a > 0, bUp = b > 0;
|
boolean aDown = a < 0, bDown = b < 0;
|
if ((aUp && bDown) || (aDown && bUp)) {
|
double maxAbs = Math.max(Math.abs(a), Math.abs(b));
|
if (maxAbs > threshold) {
|
msgs.add(aName + "=" + fmt(a) + ", " + bName + "=" + fmt(b) + "（趋势不一致）");
|
}
|
}
|
}
|
|
/** 占比变化：本月占比 vs 由环比增速反推的上月占比，变化>1% 需核实 */
|
private AuditResult checkCityBusRatioChange(AuditRule rule, CityBusMonthly row) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.01);
|
String field = rule.getCheckField() == null ? "" : rule.getCheckField();
|
List<String> msgs = new ArrayList<>();
|
if (field.contains("passengerCityRatio")) {
|
Double change = cityBusRatioChange(row.getPassengerCityRatio(),
|
row.getPassengerCity(), row.getRatePassengerCityMom(),
|
row.getPassengerVolume(), row.getRatePassengerMom());
|
if (change != null && change > threshold) {
|
msgs.add("城市内客运量占比变化=" + fmt4(change) + "（>1%）");
|
}
|
}
|
if (field.contains("chengxiangRatio")) {
|
Double change = cityBusRatioChange(row.getChengxiangRatio(),
|
row.getPassengerChengxiang(), row.getRateChengxiangMom(),
|
row.getPassengerVolume(), row.getRatePassengerMom());
|
if (change != null && change > threshold) {
|
msgs.add("城际城乡客运量占比变化=" + fmt4(change) + "（>1%）");
|
}
|
}
|
if (msgs.isEmpty()) return null;
|
return buildCityBusResult(rule, row, String.join("；", msgs),
|
"占比变化≤1%", "占比变化>1%");
|
}
|
|
/** 占比环比变化：本月占比 vs 上月占比（由环比增速反推）；无法推算返回 null */
|
private Double cityBusRatioChange(Double curRatio, Double curValue, Double curRate,
|
Double curTotal, Double totalRate) {
|
if (curRatio == null) return null;
|
double r = nvl(curRate);
|
double tr = nvl(totalRate);
|
if (r <= -1.0 || tr <= -1.0) return null;
|
double lastRatio = (nvl(curValue) / (1 + r)) / (nvl(curTotal) / (1 + tr));
|
if (Double.isNaN(lastRatio) || Double.isInfinite(lastRatio)) return null;
|
return Math.abs(curRatio - lastRatio);
|
}
|
|
/** 平均运距变化：环比增减（公里）或城际城乡由 周转量/客运量 环比反推，超过 3 公里需核实 */
|
private AuditResult checkCityBusAvgDistChange(AuditRule rule, CityBusMonthly row) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 3.0);
|
String field = rule.getCheckField() == null ? "" : rule.getCheckField();
|
List<String> msgs = new ArrayList<>();
|
if (field.contains("avgDistanceMomChange")) {
|
double chg = Math.abs(nvl(row.getAvgDistanceMomChange()));
|
if (chg > threshold) {
|
msgs.add("平均运距环比增减=" + fmt(nvl(row.getAvgDistanceMomChange())) + "公里");
|
}
|
}
|
if (field.contains("avgDistanceCityMomChange")) {
|
double chg = Math.abs(nvl(row.getAvgDistanceCityMomChange()));
|
if (chg > threshold) {
|
msgs.add("城市内平均运距环比增减=" + fmt(nvl(row.getAvgDistanceCityMomChange())) + "公里");
|
}
|
}
|
if (field.contains("avgDistanceChengxiang")) {
|
double cur = nvl(row.getAvgDistanceChengxiang());
|
double km = nvl(row.getRateChengxiangMom());
|
double kt = nvl(row.getRateChengxiangTurnoverMom());
|
if (cur > 0 && km > -1.0 && kt > -1.0) {
|
double last = cur * (1 + km) / (1 + kt);
|
double chg = Math.abs(cur - last);
|
if (chg > threshold) {
|
msgs.add("城际城乡平均运距变化=" + fmt(chg) + "公里（本月" + fmt(cur)
|
+ " vs 上月" + fmt(last) + "）");
|
}
|
}
|
}
|
if (msgs.isEmpty()) return null;
|
return buildCityBusResult(rule, row, String.join("；", msgs),
|
"平均运距变化≤" + fmt(threshold) + "公里", "平均运距变化>" + fmt(threshold) + "公里");
|
}
|
|
private AuditResult buildCityBusResult(AuditRule rule, CityBusMonthly row,
|
String actual, String threshold, String deviation) {
|
AuditResult result = new AuditResult();
|
result.setRuleId(rule.getId());
|
result.setReportId(row.getId());
|
result.setReportPeriod(row.getReportPeriod());
|
result.setActualValue(actual);
|
result.setThresholdValue(threshold);
|
result.setDeviation(deviation);
|
result.setStatus("PENDING");
|
return result;
|
}
|
|
// ========== CITY_TAXI 巡游出租审核（7 组规则，市州级） ==========
|
|
public List<AuditResult> executeCityTaxiAudit(String reportPeriod) {
|
List<AuditRule> rules = rulesOf("CITY_TAXI");
|
List<CityTaxiMonthly> rows = cityTaxiMapper.selectList(
|
new LambdaQueryWrapper<CityTaxiMonthly>()
|
.eq(CityTaxiMonthly::getReportPeriod, reportPeriod));
|
|
// 幂等：只清除 CITY_TAXI 规则的旧审核结果
|
List<Long> ruleIds = new ArrayList<>();
|
for (AuditRule rule : rules) ruleIds.add(rule.getId());
|
if (!ruleIds.isEmpty()) {
|
resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
|
.eq(AuditResult::getReportPeriod, reportPeriod)
|
.in(AuditResult::getRuleId, ruleIds));
|
}
|
|
// 运政车辆按市州计数（T001 对比基准）
|
Map<String, Long> authCount = loadTaxiAuthCount(reportPeriod);
|
|
List<AuditResult> results = new ArrayList<>();
|
for (CityTaxiMonthly row : rows) {
|
if (row.getCity() == null || row.getCity().trim().isEmpty()) continue;
|
// 无经营活动市州（运营车数/客运量/周转量均 0）跳过
|
if (nvl(row.getOpVehicles()) <= 0 && nvl(row.getPassengerVolume()) <= 0
|
&& nvl(row.getTurnover()) <= 0) {
|
continue;
|
}
|
for (AuditRule rule : rules) {
|
AuditResult result = checkCityTaxiRule(rule, row, authCount);
|
if (result != null) {
|
result.setRuleName(rule.getRuleName());
|
result.setRuleCode(rule.getRuleCode());
|
result.setAlertLevel(rule.getAlertLevel());
|
result.setEnterpriseName(row.getCity());
|
result.setVerifyExplanation(row.getVerifyExplanation());
|
resultMapper.insert(result);
|
results.add(result);
|
}
|
}
|
}
|
log.info("CityTaxi audit complete: {} cities, {} issues for {}", rows.size(), results.size(), reportPeriod);
|
if (!rules.isEmpty() && !rows.isEmpty()) markAudited("CITY_TAXI", reportPeriod);
|
return results;
|
}
|
|
private Map<String, Long> loadTaxiAuthCount(String reportPeriod) {
|
Map<String, Long> map = new HashMap<>();
|
List<CityTaxiAuth> auths = cityTaxiAuthMapper.selectList(
|
new LambdaQueryWrapper<CityTaxiAuth>()
|
.eq(CityTaxiAuth::getReportPeriod, reportPeriod));
|
for (CityTaxiAuth a : auths) {
|
if (a.getCity() == null || a.getCity().trim().isEmpty()) continue;
|
map.merge(a.getCity(), 1L, Long::sum);
|
}
|
return map;
|
}
|
|
private AuditResult checkCityTaxiRule(AuditRule rule, CityTaxiMonthly row, Map<String, Long> authCount) {
|
try {
|
switch (rule.getCompareType()) {
|
case "CROSS_DIFF_PCT":
|
return checkTaxiAuthDiff(rule, row, authCount);
|
case "TREND_CONSISTENCY":
|
return checkCityTaxiTrend(rule, row);
|
case "RATIO_CHANGE":
|
return checkCityTaxiRatioChange(rule, row);
|
case "AVG_DIST_CHANGE":
|
return checkCityTaxiAvgDistChange(rule, row);
|
case "PAX_PER_TRIP_CHANGE":
|
return checkTaxiPaxPerTripChange(rule, row);
|
default:
|
return null;
|
}
|
} catch (Exception e) {
|
log.error("CityTaxi rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
|
return null;
|
}
|
}
|
|
/** T001 运营车数 vs 运政在营车辆数：差异率>3% 需核实（RED） */
|
private AuditResult checkTaxiAuthDiff(AuditRule rule, CityTaxiMonthly row, Map<String, Long> authCount) {
|
// 整期未导入运政数据时跳过对比（避免把“运政=0”误当基准报差异）
|
if (authCount == null || authCount.isEmpty()) return null;
|
double threshold = parseDoubleSafe(rule.getThreshold(), 3.0);
|
double monthly = nvl(row.getOpVehicles());
|
Long auth = authCount.get(row.getCity());
|
long authV = auth == null ? 0 : auth;
|
if (monthly <= 0 && authV <= 0) return null;
|
double diffPct = authV <= 0 ? 100.0 : Math.abs(monthly - authV) / authV * 100.0;
|
if (diffPct <= threshold) return null;
|
return buildTaxiResult(rule, row,
|
"月报运营车辆数=" + fmt(monthly) + "，运政在营车辆数=" + authV + "，差异率=" + fmt(diffPct) + "%",
|
"差异率≤" + fmt(threshold) + "%",
|
"差异率=" + fmt(diffPct) + "%>" + fmt(threshold) + "%");
|
}
|
|
/** T002/T003/T007 趋势一致：check_field 中成对字段（环比/同比）趋势不一致且增速超阈值需核实 */
|
private AuditResult checkCityTaxiTrend(AuditRule rule, CityTaxiMonthly row) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.02);
|
String field = rule.getCheckField() == null ? "" : rule.getCheckField();
|
List<String> msgs = new ArrayList<>();
|
if (field.contains("passengerCityMom")) {
|
checkTrendPair(msgs, "城市内客运量环比", row.getRatePassengerCityMom(),
|
"城际城乡客运量环比", row.getRatePassengerChengxiangMom(), threshold);
|
}
|
if (field.contains("turnoverMomDerived")) {
|
// 月报无直接周转量环比列：周转量=客运量×平均运距，由两者环比推导
|
Double rateTurnover = taxiTurnoverMomDerived(row);
|
if (rateTurnover != null) {
|
checkTrendPair(msgs, "客运量环比", row.getRatePassengerMom(),
|
"旅客周转量环比(推导)", rateTurnover, threshold);
|
}
|
}
|
if (field.contains("tripMom")) {
|
checkTrendPair(msgs, "载客车次总数环比", row.getRateTripMom(),
|
"客运量环比", row.getRatePassengerMom(), threshold);
|
}
|
if (field.contains("tripYoy")) {
|
checkTrendPair(msgs, "载客车次同比", row.getRateTripYoy(),
|
"客运量同比", row.getRatePassengerYoy(), threshold);
|
}
|
if (msgs.isEmpty()) return null;
|
return buildTaxiResult(rule, row, String.join("；", msgs),
|
"两指标环比/同比趋势一致", "趋势不一致且增速超阈值");
|
}
|
|
/** 推导周转量环比：rate≈(1+客运量环比)×(1+平均运距环比)-1，平均运距环比由上期运距=本期−增减推算 */
|
private Double taxiTurnoverMomDerived(CityTaxiMonthly row) {
|
double dist = nvl(row.getAvgDistance());
|
double chg = nvl(row.getAvgDistanceMomChange());
|
double rp = nvl(row.getRatePassengerMom());
|
if (dist <= 0 || dist - chg <= 0 || rp <= -1.0) return null;
|
double rd = chg / (dist - chg);
|
return (1 + rp) * (1 + rd) - 1;
|
}
|
|
/** T004 占比变化：城市内客运量占比变化>1% 需核实 */
|
private AuditResult checkCityTaxiRatioChange(AuditRule rule, CityTaxiMonthly row) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.01);
|
String field = rule.getCheckField() == null ? "" : rule.getCheckField();
|
List<String> msgs = new ArrayList<>();
|
if (field.contains("passengerCityRatio")) {
|
Double change = cityBusRatioChange(row.getPassengerCityRatio(),
|
row.getPassengerCity(), row.getRatePassengerCityMom(),
|
row.getPassengerVolume(), row.getRatePassengerMom());
|
if (change != null && change > threshold) {
|
msgs.add("城市内客运量占比变化=" + fmt4(change) + "（>1%）");
|
}
|
}
|
if (msgs.isEmpty()) return null;
|
return buildTaxiResult(rule, row, String.join("；", msgs),
|
"占比变化≤1%", "占比变化>1%");
|
}
|
|
/** T005 平均运距变化：环比增减（公里）或城际城乡由平均运距增速反推，超过 3 公里需核实 */
|
private AuditResult checkCityTaxiAvgDistChange(AuditRule rule, CityTaxiMonthly row) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 3.0);
|
String field = rule.getCheckField() == null ? "" : rule.getCheckField();
|
List<String> msgs = new ArrayList<>();
|
if (field.contains("avgDistanceMomChange")) {
|
double chg = Math.abs(nvl(row.getAvgDistanceMomChange()));
|
if (chg > threshold) {
|
msgs.add("平均运距环比增减=" + fmt(nvl(row.getAvgDistanceMomChange())) + "公里");
|
}
|
}
|
if (field.contains("avgDistanceCityMomChange")) {
|
double chg = Math.abs(nvl(row.getAvgDistanceCityMomChange()));
|
if (chg > threshold) {
|
msgs.add("城市内平均运距环比增减=" + fmt(nvl(row.getAvgDistanceCityMomChange())) + "公里");
|
}
|
}
|
if (field.contains("avgDistanceChengxiang")) {
|
double cur = nvl(row.getAvgDistanceChengxiang());
|
double dist = nvl(row.getAvgDistance());
|
double chg = nvl(row.getAvgDistanceMomChange());
|
if (cur > 0 && dist > 0 && dist > chg) {
|
double rd = chg / (dist - chg);
|
double last = cur / (1 + rd);
|
double diff = Math.abs(cur - last);
|
if (diff > threshold) {
|
msgs.add("城际城乡平均运距变化=" + fmt(diff) + "公里（本月" + fmt(cur)
|
+ " vs 上月" + fmt(last) + "）");
|
}
|
}
|
}
|
if (msgs.isEmpty()) return null;
|
return buildTaxiResult(rule, row, String.join("；", msgs),
|
"平均运距变化≤" + fmt(threshold) + "公里", "平均运距变化>" + fmt(threshold) + "公里");
|
}
|
|
/** T006 单车次载客人数变化：由上期(载客车次/客运量环比)反推，变化>0.2人 需核实 */
|
private AuditResult checkTaxiPaxPerTripChange(AuditRule rule, CityTaxiMonthly row) {
|
double threshold = parseDoubleSafe(rule.getThreshold(), 0.2);
|
String field = rule.getCheckField() == null ? "" : rule.getCheckField();
|
List<String> msgs = new ArrayList<>();
|
if (field.contains("passengersPerTrip")) {
|
double cur = nvl(row.getPassengersPerTrip());
|
double rp = nvl(row.getRatePassengerMom());
|
double rt = nvl(row.getRateTripMom());
|
if (cur > 0 && rp > -1.0 && rt > -1.0) {
|
double last = cur * (1 + rt) / (1 + rp);
|
double diff = Math.abs(cur - last);
|
if (diff > threshold) {
|
msgs.add("单车次载客人数变化=" + fmt(diff) + "人（本月" + fmt(cur)
|
+ " vs 上月" + fmt(last) + "）");
|
}
|
}
|
}
|
if (msgs.isEmpty()) return null;
|
return buildTaxiResult(rule, row, String.join("；", msgs),
|
"单车次载客人数变化≤" + fmt(threshold) + "人", "单车次载客人数变化>" + fmt(threshold) + "人");
|
}
|
|
private AuditResult buildTaxiResult(AuditRule rule, CityTaxiMonthly row,
|
String actual, String threshold, String deviation) {
|
AuditResult result = new AuditResult();
|
result.setRuleId(rule.getId());
|
result.setReportId(row.getId());
|
result.setReportPeriod(row.getReportPeriod());
|
result.setActualValue(actual);
|
result.setThresholdValue(threshold);
|
result.setDeviation(deviation);
|
result.setStatus("PENDING");
|
return result;
|
}
|
|
/** 项目名归一化：去括号字符、连接符，罗马数字统一，去省/市/县/区前缀与空白 */
|
private String normInvestName(String name) {
|
if (name == null) return "";
|
String s = name.trim();
|
s = s.replaceAll("[（(]", "").replaceAll("[）)]", "");
|
s = s.replaceAll("[·•—－_\\-]", "");
|
s = s.replaceAll("[ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹ]", "I");
|
s = s.replaceAll("^(湖北省|武汉市|黄石市|十堰市|宜昌市|襄阳市|鄂州市|荆门市|孝感市|荆州市|黄冈市|咸宁市|随州市|恩施州|仙桃市|潜江市|天门市|神农架林区)", "");
|
s = s.replaceAll("^(?:[\\u4e00-\\u9fa5]{2,4}(?:县|市|区))", "");
|
s = s.replaceAll("\\s+", "");
|
return s;
|
}
|
|
/** 名称归一化后精确匹配（同名多候选按县区消歧），失败再按评分做前缀/包含/子序列模糊匹配 */
|
private InvestmentSystem findInvestSystem(Map<String, List<InvestmentSystem>> sysMap, String projectName) {
|
String norm = normInvestName(projectName);
|
if (norm.isEmpty()) return null;
|
List<InvestmentSystem> exact = sysMap.get(norm);
|
if (exact != null && !exact.isEmpty()) {
|
return disambiguateInvest(exact, projectName);
|
}
|
InvestmentSystem best = null;
|
int bestScore = Integer.MIN_VALUE;
|
for (Map.Entry<String, List<InvestmentSystem>> e : sysMap.entrySet()) {
|
String key = e.getKey();
|
if (key.length() < 5 || norm.length() < 5) continue;
|
String shortSide = key.length() <= norm.length() ? key : norm;
|
String longSide = key.length() > norm.length() ? key : norm;
|
int idx = longSide.indexOf(shortSide);
|
int lenDiff = Math.abs(key.length() - norm.length());
|
int score;
|
if (idx == 0) {
|
// 前缀式包含（短名=长名开头）最可信
|
score = 1000 - lenDiff * 2;
|
} else if (idx > 0 && shortSide.length() >= 6) {
|
// 中后部包含：短名足够长才可信
|
score = 500 - idx * 5 - lenDiff * 2 + shortSide.length();
|
} else if (idx > 0 && shortSide.length() == 5 && lenDiff <= 5) {
|
// 5字短名中后部：差异部分不含 县/市/州 才匹配（排除 罗田县综合物流园 这类）
|
String diff = longSide.substring(0, idx) + longSide.substring(idx + shortSide.length());
|
if (diff.matches(".*(县|市|州).*")) continue;
|
score = 400 - idx * 5 - lenDiff;
|
} else if (isInvestSubsequence(shortSide, longSide) && lenDiff <= 8) {
|
// 子序列兜底：短名为长名去掉插入词后的子序列（如 综合枢纽 vs 综合客运枢纽、物流中心 vs 物流园中心）
|
score = 300 - lenDiff * 3;
|
} else {
|
continue;
|
}
|
if (score > bestScore) {
|
bestScore = score;
|
best = disambiguateInvest(e.getValue(), projectName);
|
}
|
}
|
return best;
|
}
|
|
/** 多个系统项目归一化后同名（如 咸丰县综合物流园/罗田县综合物流园 → 综合物流园），按县区前缀区分 */
|
private InvestmentSystem disambiguateInvest(List<InvestmentSystem> candidates, String projectName) {
|
if (candidates == null || candidates.isEmpty()) return null;
|
if (candidates.size() == 1) return candidates.get(0);
|
String county = extractCounty(projectName);
|
if (!county.isEmpty()) {
|
for (InvestmentSystem c : candidates) {
|
String raw = c.getProjectName() == null ? "" : c.getProjectName();
|
if (raw.contains(county)) return c;
|
}
|
}
|
return candidates.get(0);
|
}
|
|
/** 提取名称中的 县/市/区 前缀（如 咸丰县） */
|
private String extractCounty(String name) {
|
if (name == null) return "";
|
java.util.regex.Matcher m = java.util.regex.Pattern.compile("([\\u4e00-\\u9fa5]{2,4}(?:县|市|区))").matcher(name);
|
if (m.find()) return m.group(1);
|
return "";
|
}
|
|
/** 判断短名是否为长名的字符子序列（按顺序出现即可，允许中间插入词） */
|
private boolean isInvestSubsequence(String shortSide, String longSide) {
|
int i = 0;
|
for (int j = 0; i < shortSide.length() && j < longSide.length(); j++) {
|
if (shortSide.charAt(i) == longSide.charAt(j)) i++;
|
}
|
return i == shortSide.length();
|
}
|
|
private double parseDoubleSafe(String v, double def) {
|
try {
|
return Double.parseDouble(v.trim());
|
} catch (Exception e) {
|
return def;
|
}
|
}
|
|
public List<AuditResult> queryResults(String reportPeriod, String reportType) {
|
String type = reportType == null || reportType.trim().isEmpty() ? "H2032" : reportType.trim();
|
List<AuditResult> results = resultMapper.selectList(new LambdaQueryWrapper<AuditResult>()
|
.eq(AuditResult::getReportPeriod, reportPeriod)
|
.orderByAsc(AuditResult::getId));
|
List<Long> ruleIds = new ArrayList<>();
|
for (AuditRule rule : ruleMapper.selectList(null)) {
|
if (type.equals(rule.getReportType())) ruleIds.add(rule.getId());
|
}
|
List<AuditResult> filtered = new ArrayList<>();
|
for (AuditResult result : results) {
|
if (ruleIds.contains(result.getRuleId())) filtered.add(result);
|
}
|
attachInfo(filtered);
|
return filtered;
|
}
|
|
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> h2032Name = new HashMap<>();
|
Map<Long, String> h2032Explain = new HashMap<>();
|
Map<Long, String> passengerName = new HashMap<>();
|
Map<Long, String> passengerExplain = new HashMap<>();
|
Map<Long, String> energyName = new HashMap<>();
|
Map<Long, String> investName = new HashMap<>();
|
Map<Long, String> busName = new HashMap<>();
|
Map<Long, String> busExplain = new HashMap<>();
|
Map<Long, String> taxiName = new HashMap<>();
|
Map<Long, String> taxiExplain = new HashMap<>();
|
for (H2032EnterpriseMonthly r : h2032Mapper.selectList(null)) {
|
h2032Name.putIfAbsent(r.getId(), r.getEnterpriseName());
|
h2032Explain.putIfAbsent(r.getId(), r.getVerifyExplanation());
|
}
|
for (PassengerEnterpriseMonthly r : passengerMapper.selectList(null)) {
|
passengerName.putIfAbsent(r.getId(), r.getEnterpriseName());
|
passengerExplain.putIfAbsent(r.getId(), r.getVerifyExplanation());
|
}
|
for (EnergyVehicleQuarterly r : energyMapper.selectList(null)) {
|
energyName.putIfAbsent(r.getId(), r.getEnterpriseName());
|
}
|
for (CityBusMonthly r : cityBusMapper.selectList(null)) {
|
busName.putIfAbsent(r.getId(), r.getEnterpriseName());
|
busExplain.putIfAbsent(r.getId(), r.getVerifyExplanation());
|
}
|
for (CityTaxiMonthly r : cityTaxiMapper.selectList(null)) {
|
taxiName.putIfAbsent(r.getId(), r.getCity());
|
taxiExplain.putIfAbsent(r.getId(), r.getVerifyExplanation());
|
}
|
Map<Long, Long> investProjectId = new HashMap<>();
|
for (InvestmentMonthly r : investMonthlyMapper.selectList(null)) {
|
investProjectId.putIfAbsent(r.getId(), r.getProjectId());
|
}
|
for (InvestmentProject p : investProjectMapper.selectList(null)) {
|
for (Map.Entry<Long, Long> e : investProjectId.entrySet()) {
|
if (e.getValue().equals(p.getId())) investName.putIfAbsent(e.getKey(), p.getProjectName());
|
}
|
}
|
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());
|
}
|
// 各报表表 id 各自独立自增，需按规则所属报表类型分表回填企业名称
|
String type = rule == null ? null : rule.getReportType();
|
Map<Long, String> nameMap = "INVEST".equals(type) ? investName
|
: "H204".equals(type) ? energyName
|
: "H2031".equals(type) ? passengerName
|
: "CITY_BUS".equals(type) ? busName
|
: "CITY_TAXI".equals(type) ? taxiName : h2032Name;
|
Map<Long, String> explainMap = "H2031".equals(type) ? passengerExplain
|
: "CITY_BUS".equals(type) ? busExplain
|
: "CITY_TAXI".equals(type) ? taxiExplain : h2032Explain;
|
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()));
|
}
|
}
|
|
/** 最近有数据的报表期（用于前端默认选中） */
|
public String latestPeriod(String reportType) {
|
String type = reportType == null || reportType.trim().isEmpty() ? "H2032" : reportType.trim();
|
String max = null;
|
switch (type) {
|
case "H2031":
|
for (PassengerEnterpriseMonthly m : passengerMapper.selectList(
|
new LambdaQueryWrapper<PassengerEnterpriseMonthly>().select(PassengerEnterpriseMonthly::getReportPeriod))) {
|
max = maxPeriod(max, m.getReportPeriod());
|
}
|
break;
|
case "H204":
|
for (EnergyVehicleQuarterly m : energyMapper.selectList(
|
new LambdaQueryWrapper<EnergyVehicleQuarterly>().select(EnergyVehicleQuarterly::getReportPeriod))) {
|
max = maxPeriod(max, m.getReportPeriod());
|
}
|
break;
|
case "INVEST":
|
for (InvestmentMonthly m : investMonthlyMapper.selectList(
|
new LambdaQueryWrapper<InvestmentMonthly>().select(InvestmentMonthly::getReportPeriod))) {
|
max = maxPeriod(max, m.getReportPeriod());
|
}
|
break;
|
case "CITY_BUS":
|
for (CityBusMonthly m : cityBusMapper.selectList(
|
new LambdaQueryWrapper<CityBusMonthly>().select(CityBusMonthly::getReportPeriod))) {
|
max = maxPeriod(max, m.getReportPeriod());
|
}
|
break;
|
case "CITY_TAXI":
|
for (CityTaxiMonthly m : cityTaxiMapper.selectList(
|
new LambdaQueryWrapper<CityTaxiMonthly>().select(CityTaxiMonthly::getReportPeriod))) {
|
max = maxPeriod(max, m.getReportPeriod());
|
}
|
break;
|
default:
|
for (H2032EnterpriseMonthly m : h2032Mapper.selectList(
|
new LambdaQueryWrapper<H2032EnterpriseMonthly>().select(H2032EnterpriseMonthly::getReportPeriod))) {
|
max = maxPeriod(max, m.getReportPeriod());
|
}
|
break;
|
}
|
return max;
|
}
|
|
private String maxPeriod(String a, String b) {
|
if (b == null || b.trim().isEmpty()) return a;
|
if (a == null || a.compareTo(b) < 0) return b;
|
return a;
|
}
|
|
/** 审核结果导出 Excel（含企业名/规则名/状态/审核意见） */
|
public byte[] exportResults(String reportPeriod, String reportType) throws Exception {
|
List<AuditResult> results = queryResults(reportPeriod, reportType);
|
try (XSSFWorkbook wb = new XSSFWorkbook()) {
|
Sheet sheet = wb.createSheet("审核结果");
|
String[] headers = {"报表期", "企业/市州", "规则编码", "审核规则", "等级", "实际值", "阈值/基准", "偏差说明", "状态", "审核意见"};
|
Row head = sheet.createRow(0);
|
for (int i = 0; i < headers.length; i++) {
|
Cell cell = head.createCell(i);
|
cell.setCellValue(headers[i]);
|
org.apache.poi.ss.usermodel.CellStyle style = wb.createCellStyle();
|
org.apache.poi.ss.usermodel.Font font = wb.createFont();
|
font.setBold(true);
|
style.setFont(font);
|
cell.setCellStyle(style);
|
}
|
int r = 1;
|
for (AuditResult res : results) {
|
Row row = sheet.createRow(r++);
|
row.createCell(0).setCellValue(valueOf(res.getReportPeriod()));
|
row.createCell(1).setCellValue(valueOf(res.getEnterpriseName()));
|
row.createCell(2).setCellValue(valueOf(res.getRuleCode()));
|
row.createCell(3).setCellValue(valueOf(res.getRuleName()));
|
row.createCell(4).setCellValue(valueOf(res.getAlertLevel()));
|
row.createCell(5).setCellValue(valueOf(res.getActualValue()));
|
row.createCell(6).setCellValue(valueOf(res.getThresholdValue()));
|
row.createCell(7).setCellValue(valueOf(res.getDeviation()));
|
row.createCell(8).setCellValue(auditStatusCn(res.getStatus()));
|
row.createCell(9).setCellValue(valueOf(res.getReviewComment()));
|
}
|
int[] widths = {12, 28, 12, 28, 8, 36, 22, 36, 10, 28};
|
for (int i = 0; i < widths.length; i++) {
|
sheet.setColumnWidth(i, widths[i] * 256);
|
}
|
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
wb.write(out);
|
return out.toByteArray();
|
}
|
}
|
|
private String auditStatusCn(String status) {
|
if ("CONFIRMED".equals(status)) return "已确认";
|
if ("IGNORED".equals(status)) return "已忽略";
|
return "待处理";
|
}
|
|
/** 规则执行统计：每条启用规则的检查对象数与命中数 */
|
public List<Map<String, Object>> ruleStats(String reportPeriod, String reportType) {
|
String type = reportType == null || reportType.trim().isEmpty() ? "H2032" : reportType.trim();
|
List<AuditRule> rules = rulesOf(type);
|
long checked;
|
switch (type) {
|
case "H2031":
|
checked = passengerMapper.selectCount(new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
|
.eq(PassengerEnterpriseMonthly::getReportPeriod, reportPeriod));
|
break;
|
case "H204":
|
checked = energyMapper.selectCount(new LambdaQueryWrapper<EnergyVehicleQuarterly>()
|
.eq(EnergyVehicleQuarterly::getReportPeriod, reportPeriod));
|
break;
|
case "INVEST":
|
checked = investMonthlyMapper.selectCount(new LambdaQueryWrapper<InvestmentMonthly>()
|
.eq(InvestmentMonthly::getReportPeriod, reportPeriod));
|
break;
|
case "CITY_BUS":
|
checked = cityBusMapper.selectCount(new LambdaQueryWrapper<CityBusMonthly>()
|
.eq(CityBusMonthly::getReportPeriod, reportPeriod));
|
break;
|
case "CITY_TAXI":
|
checked = cityTaxiMapper.selectCount(new LambdaQueryWrapper<CityTaxiMonthly>()
|
.eq(CityTaxiMonthly::getReportPeriod, reportPeriod));
|
break;
|
default:
|
checked = h2032Mapper.selectCount(new LambdaQueryWrapper<H2032EnterpriseMonthly>()
|
.eq(H2032EnterpriseMonthly::getReportPeriod, reportPeriod));
|
break;
|
}
|
List<AuditResult> results = resultMapper.selectList(new LambdaQueryWrapper<AuditResult>()
|
.eq(AuditResult::getReportPeriod, reportPeriod));
|
Map<Long, Long> hitMap = new HashMap<>();
|
for (AuditResult r : results) {
|
hitMap.merge(r.getRuleId(), 1L, Long::sum);
|
}
|
List<Map<String, Object>> out = new ArrayList<>();
|
for (AuditRule rule : rules) {
|
Map<String, Object> m = new HashMap<>();
|
m.put("ruleId", rule.getId());
|
m.put("ruleCode", rule.getRuleCode());
|
m.put("ruleName", rule.getRuleName());
|
m.put("alertLevel", rule.getAlertLevel());
|
m.put("checked", checked);
|
m.put("hit", hitMap.getOrDefault(rule.getId(), 0L));
|
m.put("skipped", ruleSkipped(rule, reportPeriod));
|
out.add(m);
|
}
|
return out;
|
}
|
|
/** 跨表/环比基准数据整期缺失时，规则标记为跳过（避免误报） */
|
private boolean ruleSkipped(AuditRule rule, String period) {
|
String code = rule.getRuleCode();
|
if (code == null) return false;
|
switch (code) {
|
case "RULE_001":
|
case "RULE_002":
|
return transportAuthMapper.selectCount(new LambdaQueryWrapper<TransportAuthVehicle>()
|
.eq(TransportAuthVehicle::getReportPeriod, period)) == 0;
|
case "RULE_003":
|
return trackMileageMapper.selectCount(new LambdaQueryWrapper<VehicleTrackMileage>()
|
.eq(VehicleTrackMileage::getReportPeriod, period)) == 0;
|
case "RULE_004":
|
return h2032Mapper.selectCount(new LambdaQueryWrapper<H2032EnterpriseMonthly>()
|
.eq(H2032EnterpriseMonthly::getReportPeriod, getLastPeriod(period))) == 0;
|
case "RULE_P001":
|
case "RULE_P002":
|
return passengerAuthMapper.selectCount(new LambdaQueryWrapper<PassengerAuthVehicle>()
|
.eq(PassengerAuthVehicle::getReportPeriod, period)) == 0;
|
case "RULE_P003":
|
case "RULE_P004":
|
case "RULE_P005":
|
case "RULE_P006":
|
return passengerMapper.selectCount(new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
|
.eq(PassengerEnterpriseMonthly::getReportPeriod, getLastPeriod(period))) == 0;
|
case "RULE_E001":
|
case "RULE_E002":
|
case "RULE_E003":
|
return energyAuthMapper.selectCount(new LambdaQueryWrapper<EnergyAuthVehicle>()
|
.eq(EnergyAuthVehicle::getReportPeriod, period)) == 0;
|
case "RULE_E008":
|
case "RULE_E009":
|
return h2032Mapper.selectCount(new LambdaQueryWrapper<H2032EnterpriseMonthly>()
|
.eq(H2032EnterpriseMonthly::getReportPeriod, period)) == 0;
|
case "RULE_T001":
|
return cityTaxiAuthMapper.selectCount(new LambdaQueryWrapper<CityTaxiAuth>()
|
.eq(CityTaxiAuth::getReportPeriod, period)) == 0;
|
case "RULE_I001":
|
case "RULE_I002":
|
case "RULE_I003":
|
return investSystemMapper.selectCount(new LambdaQueryWrapper<InvestmentSystem>()
|
.eq(InvestmentSystem::getReportPeriod, period)) == 0;
|
default:
|
return false;
|
}
|
}
|
|
private List<AuditRule> rulesOf(String reportType) {
|
List<AuditRule> all = ruleMapper.selectEnabledRules();
|
List<AuditRule> matched = new ArrayList<>();
|
for (AuditRule rule : all) {
|
String type = rule.getReportType();
|
if (reportType.equals(type) || (type == null && "H2032".equals(reportType))) {
|
matched.add(rule);
|
}
|
}
|
return matched;
|
}
|
|
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);
|
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;
|
}
|
|
/** 上报周转量与轨迹测算周转量对比，高出阈值比例核实 */
|
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) + ", 轨迹测算=" + fmt(estimatedTurnover),
|
"≤轨迹测算×" + fmt(threshold), "=轨迹测算×" + fmt(ratio));
|
}
|
return null;
|
}
|
|
/** 货运类型环比：本月新增（上月为0、本月>0）需核实，少的不管 */
|
private AuditResult checkMom(AuditRule rule, H2032EnterpriseMonthly report,
|
Map<String, H2032EnterpriseMonthly> lastMonthMap) {
|
H2032EnterpriseMonthly lastMonth = lastMonthMap.get(key(report.getEnterpriseCode()));
|
if (lastMonth == null) return null;
|
List<String> hits = new ArrayList<>();
|
for (String field : rule.getCheckField().split(",")) {
|
double current = getH2032FieldValue(report, field);
|
double last = getH2032FieldValue(lastMonth, field);
|
if (current > 0 && last == 0) {
|
hits.add(h2032FieldLabel(field) + "=" + fmt(current));
|
}
|
}
|
if (!hits.isEmpty()) {
|
return buildResult(rule, report, "本月新增: " + String.join("、", hits),
|
"上月该类型为0", "本月新增货运类型（上月无）");
|
}
|
return null;
|
}
|
|
/** 有货运量但对应车辆为0 需核实（如 有集装箱货运量无集装箱车辆） */
|
private AuditResult checkNull(AuditRule rule, H2032EnterpriseMonthly report) {
|
String[] fields = rule.getCheckField().split(",");
|
if (fields.length < 2) return null;
|
double volume = getH2032FieldValue(report, fields[0]);
|
double vehicle = getH2032FieldValue(report, fields[1]);
|
if (volume > 0 && vehicle == 0) {
|
return buildResult(rule, report,
|
h2032FieldLabel(fields[0]) + "=" + fmt(volume) + ", " + h2032FieldLabel(fields[1]) + "=0",
|
"有" + h2032FieldLabel(fields[0]) + "应有对应车辆", "有" + h2032FieldLabel(fields[0]) + "但无" + h2032FieldLabel(fields[1]));
|
}
|
return null;
|
}
|
|
/** 数值范围检查（如 整车吨位 4≤且≤40） */
|
private AuditResult checkOutRange(AuditRule rule, H2032EnterpriseMonthly report) {
|
String[] bounds = rule.getThreshold().split(",");
|
if (bounds.length < 2) return null;
|
double value = getH2032FieldValue(report, rule.getCheckField());
|
double low = Double.parseDouble(bounds[0].trim());
|
double high = Double.parseDouble(bounds[1].trim());
|
if (value > 0 && (value < low || value > high)) {
|
return buildResult(rule, report, h2032FieldLabel(rule.getCheckField()) + "=" + fmt(value),
|
"范围 " + fmt(low) + "~" + fmt(high), "超出范围");
|
}
|
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 TransportAuthVehicle findAuth(Map<String, TransportAuthVehicle> authMap, String name) {
|
return authMap.get(key(name));
|
}
|
|
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 reportPeriod) {
|
Map<String, VehicleTrackMileage> map = new HashMap<>();
|
List<VehicleTrackMileage> list = trackMileageMapper.selectList(
|
new LambdaQueryWrapper<VehicleTrackMileage>()
|
.eq(VehicleTrackMileage::getReportPeriod, reportPeriod));
|
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 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 year + "-" + (month < 10 ? "0" + month : String.valueOf(month));
|
}
|
|
private double getH2032FieldValue(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 h2032FieldLabel(String field) {
|
String label = FREIGHT_TYPE_NAMES.get(field);
|
if (label != null) return label;
|
java.util.Map<String, String> labels = new HashMap<>();
|
labels.put("vehicleTotal", "车辆数");
|
labels.put("tonsTotal", "总吨位");
|
labels.put("vehicleContainer", "集装箱车辆数");
|
labels.put("tonsWhole", "整车吨位");
|
labels.put("turnoverTotal", "周转量");
|
labels.put("vehicleWhole", "整车车辆数");
|
String v = labels.get(field);
|
return v == null ? field : v;
|
}
|
|
private boolean nearlyEqual(double a, double b) {
|
if (a == b) return true;
|
return Math.abs(a - b) <= 1e-6 * Math.max(1.0, Math.max(Math.abs(a), Math.abs(b)));
|
}
|
|
private String key(String s) {
|
if (s == null) return "";
|
return s.trim().replaceAll("\\s+", "");
|
}
|
|
private double nvl(Double v) {
|
return v == null ? 0.0 : v;
|
}
|
|
private double num(Integer v) {
|
return v == null ? 0.0 : v.doubleValue();
|
}
|
|
private String fmt(double v) {
|
if (v == Math.floor(v) && !Double.isInfinite(v)) {
|
return String.valueOf((long) v);
|
}
|
return String.valueOf(Math.round(v * 100.0) / 100.0);
|
}
|
|
/** 占比/小数值：保留 4 位小数 */
|
private String fmt4(double v) {
|
if (v == Math.floor(v) && !Double.isInfinite(v)) {
|
return String.valueOf((long) v);
|
}
|
return String.valueOf(Math.round(v * 10000.0) / 10000.0);
|
}
|
|
// ========== H2031 旅客审核 ==========
|
|
private AuditResult checkPassengerRule(AuditRule rule, PassengerEnterpriseMonthly report,
|
Map<String, PassengerAuthVehicle> authMap,
|
Map<String, PassengerEnterpriseMonthly> lastMonthMap) {
|
try {
|
switch (rule.getCompareType()) {
|
case "DIFF":
|
return checkPassengerDiff(rule, report, authMap);
|
case "MOM_EQ_ZERO":
|
return checkPassengerMomEqZero(rule, report, lastMonthMap);
|
case "MOM_PCT":
|
return checkPassengerMomPct(rule, report, lastMonthMap);
|
case "MOM_EQ":
|
return checkPassengerMomEq(rule, report, lastMonthMap);
|
case "EXISTENCE":
|
return checkPassengerExistence(rule, report);
|
default:
|
return null;
|
}
|
} catch (Exception e) {
|
log.error("Passenger rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
|
return null;
|
}
|
}
|
|
/** 车辆数/载客位数 与运政对比，差距超阈值核实 */
|
private AuditResult checkPassengerDiff(AuditRule rule, PassengerEnterpriseMonthly report,
|
Map<String, PassengerAuthVehicle> authMap) {
|
PassengerAuthVehicle auth = authMap.get(key(report.getEnterpriseName()));
|
if (auth == null) return null;
|
double actual;
|
double reference;
|
if (rule.getCheckField().contains("seat")) {
|
actual = num(report.getSeatTotal());
|
reference = num(auth.getSeatCount());
|
} else {
|
actual = num(report.getVehicleTotal());
|
reference = num(auth.getVehicleCount());
|
}
|
double threshold = Double.parseDouble(rule.getThreshold());
|
double diff = Math.abs(actual - reference);
|
if (diff > threshold) {
|
return buildPassengerResult(rule, report, "上报=" + fmt(actual) + ", 运政=" + fmt(reference),
|
"差距≤" + fmt(threshold), "差距=" + fmt(diff));
|
}
|
return null;
|
}
|
|
/** 环比上个月等于0：值与上月相同需核实（上月为0不核实） */
|
private AuditResult checkPassengerMomEqZero(AuditRule rule, PassengerEnterpriseMonthly report,
|
Map<String, PassengerEnterpriseMonthly> lastMonthMap) {
|
PassengerEnterpriseMonthly lastMonth = lastMonthMap.get(key(report.getEnterpriseCode()));
|
if (lastMonth == null) return null;
|
List<String> hits = new ArrayList<>();
|
for (String field : rule.getCheckField().split(",")) {
|
double current = getPassengerFieldValue(report, field);
|
double last = getPassengerFieldValue(lastMonth, field);
|
if (last > 0 && nearlyEqual(current, last)) {
|
hits.add(fieldLabel(field) + "=" + fmt(current));
|
}
|
}
|
if (!hits.isEmpty()) {
|
return buildPassengerResult(rule, report, "本月与上月相同: " + String.join("、", hits),
|
"环比≠0", "环比=0");
|
}
|
return null;
|
}
|
|
/** 平均运距环比超 ±threshold% 核实 */
|
private AuditResult checkPassengerMomPct(AuditRule rule, PassengerEnterpriseMonthly report,
|
Map<String, PassengerEnterpriseMonthly> lastMonthMap) {
|
PassengerEnterpriseMonthly lastMonth = lastMonthMap.get(key(report.getEnterpriseCode()));
|
if (lastMonth == null) return null;
|
double threshold = Double.parseDouble(rule.getThreshold());
|
List<String> hits = new ArrayList<>();
|
for (String field : rule.getCheckField().split(",")) {
|
double current = getPassengerFieldValue(report, field);
|
double last = getPassengerFieldValue(lastMonth, field);
|
if (last > 0) {
|
double pct = Math.abs((current - last) / last) * 100.0;
|
if (pct > threshold) {
|
hits.add(fieldLabel(field) + "=" + fmt(current) + "，上月=" + fmt(last) + "，环比" + fmt(pct) + "%");
|
}
|
}
|
}
|
if (!hits.isEmpty()) {
|
return buildPassengerResult(rule, report, String.join("；", hits),
|
"环比≤±" + fmt(threshold) + "%", "环比超限");
|
}
|
return null;
|
}
|
|
/** 包车平均运距等于上月核实 */
|
private AuditResult checkPassengerMomEq(AuditRule rule, PassengerEnterpriseMonthly report,
|
Map<String, PassengerEnterpriseMonthly> lastMonthMap) {
|
PassengerEnterpriseMonthly lastMonth = lastMonthMap.get(key(report.getEnterpriseCode()));
|
if (lastMonth == null) return null;
|
List<String> hits = new ArrayList<>();
|
for (String field : rule.getCheckField().split(",")) {
|
double current = getPassengerFieldValue(report, field);
|
double last = getPassengerFieldValue(lastMonth, field);
|
if (last > 0 && nearlyEqual(current, last)) {
|
hits.add(fieldLabel(field) + "=" + fmt(current));
|
}
|
}
|
if (!hits.isEmpty()) {
|
return buildPassengerResult(rule, report, "等于上月: " + String.join("、", hits),
|
"与上月不同", "与上月相同");
|
}
|
return null;
|
}
|
|
/** 无班线/无包车却有对应客运量：check_field 首个为车辆字段，其余为客运量字段 */
|
private AuditResult checkPassengerExistence(AuditRule rule, PassengerEnterpriseMonthly report) {
|
String[] fields = rule.getCheckField().split(",");
|
if (fields.length < 2) return null;
|
String vehicleField = fields[0];
|
double vehicleCount = getPassengerFieldValue(report, vehicleField);
|
if (vehicleCount > 0) return null;
|
List<String> hits = new ArrayList<>();
|
for (int i = 1; i < fields.length; i++) {
|
double value = getPassengerFieldValue(report, fields[i]);
|
if (value > 0) {
|
hits.add(fieldLabel(fields[i]) + "=" + fmt(value));
|
}
|
}
|
if (!hits.isEmpty()) {
|
String label = "schedule".equals(vehicleField) || "vehicleSchedule".equals(vehicleField) ? "班线" : "包车";
|
return buildPassengerResult(rule, report, String.join("、", hits),
|
"有" + label + "车辆", "无" + label + "车辆但有客运量");
|
}
|
return null;
|
}
|
|
private Map<String, PassengerAuthVehicle> loadPassengerAuthMap(String reportPeriod) {
|
Map<String, PassengerAuthVehicle> map = new HashMap<>();
|
List<PassengerAuthVehicle> list = passengerAuthMapper.selectList(
|
new LambdaQueryWrapper<PassengerAuthVehicle>()
|
.eq(PassengerAuthVehicle::getReportPeriod, reportPeriod));
|
for (PassengerAuthVehicle v : list) {
|
map.putIfAbsent(key(v.getEnterpriseName()), v);
|
}
|
return map;
|
}
|
|
private Map<String, PassengerEnterpriseMonthly> loadPassengerLastMonthMap(String period) {
|
Map<String, PassengerEnterpriseMonthly> map = new HashMap<>();
|
String lastPeriod = getLastPeriod(period);
|
List<PassengerEnterpriseMonthly> list = passengerMapper.selectList(
|
new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
|
.eq(PassengerEnterpriseMonthly::getReportPeriod, lastPeriod));
|
for (PassengerEnterpriseMonthly v : list) {
|
map.putIfAbsent(key(v.getEnterpriseCode()), v);
|
}
|
return map;
|
}
|
|
private double getPassengerFieldValue(PassengerEnterpriseMonthly report, String fieldName) {
|
try {
|
java.lang.reflect.Field field = PassengerEnterpriseMonthly.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 fieldLabel(String field) {
|
java.util.Map<String, String> labels = new HashMap<>();
|
labels.put("passengerClass1", "一类班线客运量");
|
labels.put("passengerClass2", "二类班线客运量");
|
labels.put("passengerClass3", "三类班线客运量");
|
labels.put("passengerClass4", "四类班线客运量");
|
labels.put("passengerCharter", "包车客运量");
|
labels.put("turnoverClass1", "一类班线周转量");
|
labels.put("turnoverClass2", "二类班线周转量");
|
labels.put("turnoverClass3", "三类班线周转量");
|
labels.put("turnoverClass4", "四类班线周转量");
|
labels.put("turnoverCharter", "包车周转量");
|
labels.put("avgDistanceClass1", "一类班线平均运距");
|
labels.put("avgDistanceClass2", "二类班线平均运距");
|
labels.put("avgDistanceClass3", "三类班线平均运距");
|
labels.put("avgDistanceClass4", "四类班线平均运距");
|
labels.put("avgDistanceCharter", "包车平均运距");
|
String label = labels.get(field);
|
return label == null ? field : label;
|
}
|
|
private AuditResult buildPassengerResult(AuditRule rule, PassengerEnterpriseMonthly 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;
|
}
|
}
|
