package com.estate.expert.admin.stat.report.data;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.estate.expert.admin.domain.business.device.Device;
|
import com.estate.expert.admin.domain.business.device.DeviceType;
|
import com.estate.expert.admin.domain.exam.eval.fuzzy.FuzzyResult;
|
import com.estate.expert.admin.domain.exam.record.error.ErrorLevel;
|
import com.estate.expert.admin.domain.exam.record.error.ErrorRecord;
|
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
|
import com.estate.expert.admin.utils.tree.TreeNode;
|
import com.estate.expert.admin.utils.tree.TreeRoot;
|
import lombok.experimental.SuperBuilder;
|
import org.springframework.util.StringUtils;
|
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.TreeMap;
|
|
/**
|
* 代管设备风险评估报告数据。
|
*/
|
@SuperBuilder
|
public abstract class DaiguanDeviceReportData extends ReportDataBase {
|
|
List<ErrorRecord> records;
|
|
protected Map<Integer, FuzzyResult> deviceResMap;
|
|
TreeRoot<HierarchyData> deviceHierarchy;
|
|
Map<String, Long> deviceProblemHazardCounts;
|
|
Map<Integer, Long> deviceCheckCounts;
|
|
/**
|
* 生成报告数据
|
* @return 报告数据
|
*/
|
public JSONObject generate() {
|
var result = buildReportInfo();
|
result.put("工程概况", buildProjectInfo());
|
result.put("设备信息", buildDeviceInfo());
|
result.put("设备分组信息", buildDeviceGroupInfo());
|
result.put("评估结果", buildEvalInfo());
|
return result;
|
}
|
|
/**
|
* 构建评估信息
|
* @return 评估信息
|
*/
|
@Override
|
protected JSONObject buildEvalInfo() {
|
JSONObject evalInfo = new JSONObject();
|
var deviceScoreInfo = buildDeviceScoreInfo();
|
|
evalInfo.put("分类评估", buildDeviceTypeCheckItem(deviceScoreInfo.size() + 1));
|
evalInfo.put("设备得分情况", deviceScoreInfo);
|
evalInfo.put("隐患等级分布汇总", buildDeviceErrorLevels());
|
return evalInfo;
|
}
|
|
/**
|
* 按设备类型汇总设备信息，供新版设备报告使用。
|
*/
|
protected List<Object> buildDeviceGroupInfo() {
|
Map<String, List<Device>> groupedDevices = devices.stream()
|
.sorted(Comparator.comparing(device -> device.getType() != null ? device.getType().ordinal() : Integer.MAX_VALUE))
|
.collect(java.util.stream.Collectors.groupingBy(
|
device -> device.getType() != null ? device.getType().getDesc() : "",
|
java.util.LinkedHashMap::new,
|
java.util.stream.Collectors.toList()
|
));
|
|
List<Object> groupInfos = new ArrayList<>();
|
groupedDevices.forEach((deviceType, groupDevices) -> {
|
var deviceNumbers = groupDevices.stream()
|
.map(Device::getManufacturerNumber)
|
.filter(StringUtils::hasText)
|
.toList();
|
var numbers = deviceNumbers.isEmpty() ? List.of("") : deviceNumbers;
|
|
for (int i = 0; i < numbers.size(); i++) {
|
JSONObject groupInfo = new JSONObject();
|
groupInfo.put("设备类型", i == 0 ? deviceType : "");
|
groupInfo.put("设备数量", i == 0 ? groupDevices.size() : "");
|
groupInfo.put("设备编号", numbers.get(i));
|
groupInfos.add(groupInfo);
|
}
|
});
|
return groupInfos;
|
}
|
|
private JSONObject buildDeviceTypeCheckItem(int startIndex) {
|
JSONObject result = new JSONObject();
|
var details = new ArrayList<>();
|
float totalScore = 0;
|
int totalTypes = 0;
|
int totalDevices = 0;
|
for (var deviceType : DeviceType.values()) {
|
var detail = buildDeviceTypeCheckDetail(deviceType);
|
if (detail != null) {
|
details.add(detail);
|
totalTypes++;
|
totalScore += Float.parseFloat((String) detail.get("分数"));
|
totalDevices += (int) detail.get("数量");
|
}
|
}
|
result.put("详情", details);
|
result.put("总数", totalTypes);
|
result.put("设备总数", totalDevices);
|
result.put("总分", totalTypes == 0 ? formatFloat(0) : formatFloat(totalScore / totalTypes));
|
fillIndexes(details, startIndex);
|
fillDetailIndexes(details);
|
return result;
|
}
|
|
private List<Object> buildDeviceScoreInfo() {
|
List<Object> result = new ArrayList<>();
|
for (var deviceType : DeviceType.values()) {
|
List<Object> details = new ArrayList<>();
|
float totalScore = 0;
|
int totalDevices = 0;
|
|
for (var deviceId : deviceResMap.keySet()) {
|
var device = devices.stream().filter(d -> d.getId().equals(deviceId)).findFirst().orElse(null);
|
if (device == null || device.getType() != deviceType) {
|
continue;
|
}
|
|
var score = getDeviceScore(deviceId);
|
JSONObject detail = new JSONObject();
|
detail.put("分项名称", device.getManufacturerNumber());
|
detail.put("分项得分", formatFloat(score));
|
details.add(detail);
|
totalScore += score;
|
totalDevices++;
|
}
|
|
if (totalDevices == 0) {
|
continue;
|
}
|
|
JSONObject summary = new JSONObject();
|
summary.put("分项名称", "综合得分");
|
summary.put("分项得分", formatFloat(totalScore / totalDevices));
|
details.add(summary);
|
|
JSONObject info = new JSONObject();
|
info.put("设备类型", deviceType.getDesc());
|
info.put("详情", details);
|
result.add(info);
|
}
|
fillIndexes(result, 1);
|
return result;
|
}
|
|
private void fillIndexes(List<Object> items, int startIndex) {
|
int index = startIndex;
|
for (Object item : items) {
|
if (item instanceof JSONObject jsonObject) {
|
jsonObject.put("序号", index++);
|
}
|
}
|
}
|
|
private void fillDetailIndexes(List<Object> items) {
|
int index = 1;
|
for (Object item : items) {
|
if (item instanceof JSONObject jsonObject) {
|
jsonObject.put("隐患详单序号", toChineseIndex(index++));
|
}
|
}
|
}
|
|
private String toChineseIndex(int index) {
|
return switch (index) {
|
case 1 -> "一";
|
case 2 -> "二";
|
case 3 -> "三";
|
case 4 -> "四";
|
case 5 -> "五";
|
case 6 -> "六";
|
case 7 -> "七";
|
case 8 -> "八";
|
case 9 -> "九";
|
case 10 -> "十";
|
default -> String.valueOf(index);
|
};
|
}
|
|
/**
|
* 获取设备分数
|
* @param deviceId 设备ID
|
* @return 设备分数
|
*/
|
protected abstract float getDeviceScore(Integer deviceId);
|
|
private JSONObject buildDeviceTypeCheckDetail(DeviceType deviceType) {
|
int totalDevice = 0;
|
float totalScore = 0;
|
List<Object> deviceCheckItems = new ArrayList<>();
|
JSONArray records = new JSONArray();
|
int[] totalErrors = new int[4];
|
|
for (var deviceId : deviceResMap.keySet()) {
|
var device = devices.stream().filter(d -> d.getId().equals(deviceId)).findFirst().orElse(null);
|
if (device == null || device.getType() != deviceType) {
|
continue;
|
}
|
|
var deviceData = deviceResMap.get(deviceId).root().getData();
|
totalScore += getDeviceScore(deviceId);
|
totalDevice++;
|
for (int i = 0; i < 4; i++) {
|
totalErrors[i] += deviceData.getTotalErrorCounts()[i];
|
}
|
|
var errorLevels = buildDeviceErrorLevels(device);
|
if (errorLevels != null) {
|
deviceCheckItems.addAll(errorLevels);
|
}
|
|
var errorRecords = buildDeviceErrorRecords(device);
|
if (errorRecords != null) {
|
records.addAll(errorRecords);
|
}
|
}
|
fillProblemDetailIndexes(records);
|
|
if (totalDevice > 0) {
|
JSONObject info = new JSONObject();
|
info.put("设备类型", deviceType.getDesc());
|
info.put("数量", totalDevice);
|
info.put("分数", formatFloat(totalScore / totalDevice));
|
info.put("分项隐患", deviceCheckItems);
|
info.put("分项问题", records);
|
info.put("一级隐患", totalErrors[0]);
|
info.put("二级隐患", totalErrors[1]);
|
info.put("三级隐患", totalErrors[2]);
|
info.put("四级隐患", totalErrors[3]);
|
return info;
|
}
|
return null;
|
}
|
|
private void fillProblemDetailIndexes(JSONArray deviceRecords) {
|
int index = 1;
|
for (Object deviceRecord : deviceRecords) {
|
if (!(deviceRecord instanceof JSONObject deviceInfo)) {
|
continue;
|
}
|
var problems = deviceInfo.getJSONArray("问题");
|
if (problems == null) {
|
continue;
|
}
|
for (Object problem : problems) {
|
if (!(problem instanceof JSONObject problemInfo)) {
|
continue;
|
}
|
var problemDetail = problemInfo.getJSONObject("问题详情");
|
if (problemDetail != null) {
|
problemDetail.put("隐患详单问题序号", index++);
|
}
|
}
|
}
|
}
|
|
private JSONObject buildDeviceErrorLevels() {
|
int totalErrors = 0;
|
var totalErrorCounts = new int[4];
|
|
for (var device : devices) {
|
var deviceRes = deviceResMap.get(device.getId());
|
if (deviceRes == null) {
|
continue;
|
}
|
var deviceErrorCounts = deviceRes.root().getData().getTotalErrorCounts();
|
for (int i = 0; i < 4; i++) {
|
totalErrorCounts[i] += deviceErrorCounts[i];
|
totalErrors += deviceErrorCounts[i];
|
}
|
}
|
|
List<Object> errorInfos = new ArrayList<>();
|
for (int i = 0; i < 4; i++) {
|
var errorLevel = ErrorLevel.values()[i];
|
var count = totalErrorCounts[i];
|
var info = new TreeMap<>();
|
info.put("隐患等级", errorLevel.getDesc());
|
info.put("隐患程度", errorLevel.getDesc2());
|
info.put("数量", count);
|
info.put("比例", totalErrors == 0 ? formatPercent(0) : formatPercent(count * 1.0 / totalErrors));
|
errorInfos.add(info);
|
}
|
|
JSONObject result = new JSONObject();
|
result.put("隐患数量", totalErrors);
|
result.put("一级隐患数量", totalErrorCounts[0]);
|
result.put("二级隐患数量", totalErrorCounts[1]);
|
result.put("三级隐患数量", totalErrorCounts[2]);
|
result.put("四级隐患数量", totalErrorCounts[3]);
|
result.put("分项", errorInfos);
|
return result;
|
}
|
|
private List<Object> buildDeviceErrorLevels(Device device) {
|
var deviceRes = deviceResMap.get(device.getId());
|
if (deviceRes == null) {
|
return null;
|
}
|
List<Object> result = new ArrayList<>();
|
|
JSONObject info = new JSONObject();
|
info.put("设备编号", device.getManufacturerNumber());
|
|
var errorCounts = deviceRes.root().getData().getTotalErrorCounts();
|
info.put("一级隐患", errorCounts[0]);
|
info.put("二级隐患", errorCounts[1]);
|
info.put("三级隐患", errorCounts[2]);
|
info.put("四级隐患", errorCounts[3]);
|
result.add(info);
|
return result;
|
}
|
|
private List<Object> buildDeviceErrorRecords(Device device) {
|
var deviceRes = deviceResMap.get(device.getId());
|
if (deviceRes == null) {
|
return null;
|
}
|
List<Object> result = new ArrayList<>();
|
|
JSONObject info = new JSONObject();
|
info.put("设备编号", device.getManufacturerNumber());
|
info.put("问题", buildDeviceErrorInfo(device));
|
result.add(info);
|
return result;
|
}
|
|
private List<Object> buildDeviceErrorInfo(Device device) {
|
var deviceRecords = buildDeviceRecords(device);
|
List<Object> result = new ArrayList<>();
|
for (var record : deviceRecords) {
|
JSONObject info = new JSONObject();
|
info.put("检查问题", StringUtils.hasText(record.getRemark()) ? record.getRemark() : record.getProblem().getDescription());
|
info.put("隐患等级", record.getLevel().getDesc());
|
info.put("同类隐患出现频次", getDeviceProblemHazardCount(record));
|
info.put("检查频次", getDeviceProblemCheckCount(record));
|
var subItem = buildRecordDetail(record);
|
subItem.put("项目级别", errorNode(record).getName());
|
info.put("问题详情", subItem);
|
result.add(info);
|
}
|
return result;
|
}
|
|
private long getDeviceProblemHazardCount(ErrorRecord record) {
|
if (deviceProblemHazardCounts == null) {
|
return 0L;
|
}
|
return deviceProblemHazardCounts.getOrDefault(buildDeviceProblemKey(record), 0L);
|
}
|
|
private long getDeviceProblemCheckCount(ErrorRecord record) {
|
Integer deviceId = record != null && record.getDevice() != null ? record.getDevice().getId() : null;
|
if (deviceId == null || deviceCheckCounts == null) {
|
return 0L;
|
}
|
return Math.max(deviceCheckCounts.getOrDefault(deviceId, 0L), 0L);
|
}
|
|
private String buildDeviceProblemKey(ErrorRecord record) {
|
Integer deviceId = record != null && record.getDevice() != null ? record.getDevice().getId() : null;
|
Integer problemId = record != null && record.getProblem() != null ? record.getProblem().getId() : null;
|
return buildDeviceProblemKey(deviceId, problemId);
|
}
|
|
public static String buildDeviceProblemKey(Integer deviceId, Integer problemId) {
|
return Objects.toString(deviceId, "") + "::" + Objects.toString(problemId, "");
|
}
|
|
private List<ErrorRecord> buildDeviceRecords(Device device) {
|
return records.stream()
|
.filter(r -> r.getDevice().getId().equals(device.getId()))
|
.sorted(Comparator.comparing(r -> r.getLevel() != null ? r.getLevel().ordinal() : ErrorLevel.P4.ordinal()))
|
.toList();
|
}
|
|
protected TreeNode<HierarchyData> errorNode(ErrorRecord record) {
|
var hierarchyPath = record.getProblem().getHierarchyPath();
|
return deviceHierarchy.get(hierarchyPath);
|
}
|
}
|
