修改bug

liujie

2026-03-04 bc1e19dd5e324a729b395f63408ac29d3854ccfc

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/DeviceUsageServiceImpl.java

@@ -2,6 +2,7 @@


import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@@ -147,9 +148,14 @@
        }

        Map<Integer, Integer> projectMap = projectMapper.selectList(new LambdaQueryWrapper<Project>()

                .eq(Project::getDeleted, false)).stream().collect(Collectors.toMap(Project::getId, Project::getClientId));
        Map<Integer, String> clientParamMap = clientParamMapper.selectList(new LambdaQueryWrapper<ClientParam>())
        Map<Integer, String> clientParamMap = clientParamMapper.selectList(new LambdaQueryWrapper<ClientParam>()
                        .isNotNull(ClientParam::getUnderConstructionProject))
                .stream().collect(Collectors.toMap(ClientParam::getClientId, ClientParam::getUnderConstructionProject));
        Map<Integer, String> assetParamMap = clientParamMapper.selectList(new LambdaQueryWrapper<ClientParam>()
                .isNotNull(ClientParam::getAssetProject))
                .stream().collect(Collectors.toMap(ClientParam::getClientId, ClientParam::getAssetProject));
        Map<Integer, List<Task>> taskMap = taskMapper.selectList(new LambdaQueryWrapper<Task>()
                        .ge(Task::getCreateTime, startTime)
                        .le(Task::getCreateTime, LocalDateTime.now())
@@ -161,7 +167,7 @@
                        .le(Task::getCreateTime, LocalDateTime.now())
                        .in(Task::getId, checkTaskIds)
                        .isNotNull(Task::getProjectId))
                .stream().collect(Collectors.toMap(Task::getId,e->e));
                .stream().collect(Collectors.toMap(Task::getId, e -> e));
        Map<Integer, List<EvalResult>> resultMap = evalResultMapper.selectList(new LambdaQueryWrapper<EvalResult>()
                .in(EvalResult::getCheckTaskId, checkTaskIds)
        ).stream().collect(Collectors.groupingBy(EvalResult::getProjectId));
@@ -170,55 +176,120 @@
                .eq(Record::getDeleted, false));
        List<EntrustProjectVo> deviceList = this.baseMapper.projectList(page, query);
        for (EntrustProjectVo deviceListVo : deviceList) {
            List<EvalResult> evalResults = resultMap.get(deviceListVo.getId());
            if (evalResults != null) {
                float temp = 0;
                // 计算安全检查平均分
                float avgSafetyScore = (float) evalResults.stream()
                        .filter(e -> e.getScore() != null)
                        .mapToDouble(EvalResult::getScore)
                        .average()
                        .orElse(0.0);
                // 计算设备检查平均分（需要解析 device_res_map）
                List<Float> deviceScores = evalResults.stream()
                        .filter(e -> StringUtils.hasText(e.getDeviceResMap()))
                        .map(e -> calculateDeviceScore(e.getDeviceResMap()))
                        .filter(score -> score != null && score > 0)
                        .toList();

                if (!deviceScores.isEmpty()) {
                    float avgDeviceScore = (float) deviceScores.stream()
                            .mapToDouble(Float::doubleValue)
            if (query.getCategory() == 1) {
                // 在建
                List<EvalResult> evalResults = resultMap.get(deviceListVo.getId());
                if (evalResults != null) {
                    float temp = 0;
                    // 计算安全检查平均分
                    float avgSafetyScore = (float) evalResults.stream()
                            .filter(e -> e.getScore() != null)
                            .mapToDouble(EvalResult::getScore)
                            .average()
                            .orElse(0.0);
                    temp = (avgSafetyScore + avgDeviceScore) / 2;
                }
                Integer clientId = projectMap.get(deviceListVo.getId());
                String s = clientParamMap.get(clientId);
                JSONObject jsonObject = JSON.parseObject(s);
                String a = jsonObject.getString("a");
                String b = jsonObject.getString("b");
                String c = jsonObject.getString("c");
                if (temp >= Float.parseFloat(a)) {
                    deviceListVo.setRisk("A类");
                } else if (temp >= Float.parseFloat(b)) {
                    deviceListVo.setRisk("B类");
                } else if (temp >= Float.parseFloat(c)) {
                    deviceListVo.setRisk("C类");
                    // 计算设备检查平均分（需要解析 device_res_map）
                    List<Float> deviceScores = evalResults.stream()
                            .filter(e -> StringUtils.hasText(e.getDeviceResMap()))
                            .map(e -> calculateDeviceScore(e.getDeviceResMap()))
                            .filter(score -> score != null && score > 0)
                            .toList();

                    if (!deviceScores.isEmpty()) {
                        float avgDeviceScore = (float) deviceScores.stream()
                                .mapToDouble(Float::doubleValue)
                                .average()
                                .orElse(0.0);
                        temp = (avgSafetyScore + avgDeviceScore) / 2;
                    }
                    Integer clientId = projectMap.get(deviceListVo.getId());
                    String s = clientParamMap.get(clientId);
                    JSONObject jsonObject = JSON.parseObject(s);
                    String a = jsonObject.getString("a");
                    String b = jsonObject.getString("b");
                    String c = jsonObject.getString("c");
                    if (temp >= Float.parseFloat(a)) {
                        deviceListVo.setRisk("A类");
                    } else if (temp >= Float.parseFloat(b)) {
                        deviceListVo.setRisk("B类");
                    } else if (temp >= Float.parseFloat(c)) {
                        deviceListVo.setRisk("C类");
                    }
                } else {
                    deviceListVo.setRisk(null);
                }
            } else {
                deviceListVo.setRisk(null);

                // 查询检查任务
                LambdaQueryWrapper<Task> taskWrapperPro = new LambdaQueryWrapper<>();
                taskWrapperPro.eq(Task::getProjectId, deviceListVo.getId())
                        .eq(Task::getDeleted, false);
                List<Task> tasks = taskMapper.selectList(taskWrapperPro);
                List<Integer> checkTaskIdsPro = tasks.stream().map(Task::getId).collect(Collectors.toList());

                // 查询重大隐患记录（level 表示隐患等级，0 表示重大隐患）
                LambdaQueryWrapper<Record> recordWrapperPro = new LambdaQueryWrapper<>();
                recordWrapperPro.eq(Record::getDeleted, false)
                        .in(Record::getCheckTaskId, checkTaskIdsPro)
                ; // 重大隐患等级
                List<Record> records1 = recordMapper.selectList(recordWrapperPro);
//                long c1 = records1.stream().filter(e -> e.getLevel() != null && e.getLevel() == 0).count();
//                long c2 = records1.stream().filter(e -> e.getLevel() != null && e.getLevel() == 0).count();
//                long c3 = records1.stream().filter(e -> e.getLevel() != null && e.getLevel() == 0).count();
//                long c4 = records1.stream().filter(e -> e.getLevel() != null && e.getLevel() == 0).count();
//                // 固定资产
//                String s = clientParamMap.get(query.getClientId());
//                JSONObject jsonObject = JSON.parseObject(s);
//                JSONArray a = jsonObject.getJSONArray("a");
//                for (Object o : a) {
//                    // 转化为jsonObject
//                    JSONObject jsonObject1 = (JSONObject) o;
//                }
//                JSONArray b = jsonObject.getJSONArray("b");
//                for (Object o : b) {
//                    // 转化为jsonObject
//                    JSONObject jsonObject1 = (JSONObject) o;
//                }
//                JSONArray c = jsonObject.getJSONArray("c");
//                for (Object o : c) {
//                    // 转化为jsonObject
//                    JSONObject jsonObject1 = (JSONObject) o;
//                }
                // 统计各等级隐患数量
                Map<Integer, Long> levelCountMap = records1.stream()
                        .filter(e -> e.getLevel() != null)
                        .collect(Collectors.groupingBy(Record::getLevel, Collectors.counting()));

// 获取客户参数配置
                String s = assetParamMap.get(query.getClientId());
                JSONObject jsonObject = JSON.parseObject(s);

// 初始化风险等级
                String riskLevel = null;

// 先判断 c 条件
                JSONArray cArray = jsonObject.getJSONArray("c");
                if (cArray != null && matchesCondition(cArray, levelCountMap)) {
                    riskLevel = "C类";
                }
// 再判断 b 条件
                else if (jsonObject.getJSONArray("b") != null && matchesCondition(jsonObject.getJSONArray("b"), levelCountMap)) {
                    riskLevel = "B类";
                }
// 最后判断 a 条件
                else if (jsonObject.getJSONArray("a") != null && matchesCondition(jsonObject.getJSONArray("a"), levelCountMap)) {
                    riskLevel = "A类";
                }
            }
            List<Task> tasks = taskMap.get(deviceListVo.getId());
            List<Task> tasks = taskList.stream().filter(e -> e.getProjectId().equals(deviceListVo.getId())).toList();
//            List<Task> tasks = taskMap.get(deviceListVo.getId());
            if (tasks != null && !tasks.isEmpty()) {
                List<Integer> taskIds = tasks.stream().map(Task::getId).toList();
                List<Record> recordList = records.stream().filter(e -> taskIds.contains(e.getCheckTaskId())).toList();
                Record record = recordList.stream().max(Comparator.comparing(Record::getCreateTime)).orElse(null);
                if (record != null) {
                    Task task = taskRecordMap.get(record.getCheckTaskId());
                    if (task!=null){
                        deviceListVo.setCheckTime(task.getCreateTime());
                    }

                Task task1 = tasks.stream().filter(e -> e.getDate().getYear() == LocalDateTime.now().getYear() && e.getDate().getMonth().getValue() == LocalDateTime.now().getMonth().getValue()).findFirst().orElse(null);

//                List<Record> recordList = records.stream().filter(e -> taskIds.contains(e.getCheckTaskId())).toList();
//                Record record = recordList.stream().max(Comparator.comparing(Record::getCreateTime)).orElse(null);
                if (task1 != null) {
                    deviceListVo.setCheckTime(task1.getDate().atStartOfDay());
                    deviceListVo.setCheckResult("已检查");
                } else {
                    deviceListVo.setCheckTime(null);
@@ -232,6 +303,39 @@
            }
        }
        return deviceList;
    }

    /**
     * 判断条件数组是否满足隐患统计结果
     *
     * @param conditionArray 条件数组，例如 [[{"4":"1"},{"4":"1"}], [{"4":"2"}]]
     * @param levelCountMap  隐患等级统计结果，key为隐患等级，value为数量
     * @return 是否满足条件
     */
    private boolean matchesCondition(JSONArray conditionArray, Map<Integer, Long> levelCountMap) {
        for (Object item : conditionArray) {
            if (item instanceof JSONArray) {
                JSONArray andConditions = (JSONArray) item;
                boolean allMatch = true;
                for (Object condition : andConditions) {
                    if (condition instanceof JSONObject) {
                        JSONObject conditionObj = (JSONObject) condition;
                        for (Map.Entry<String, Object> entry : conditionObj.entrySet()) {
                            int level = Integer.parseInt(entry.getKey()); // 隐患等级
                            int requiredCount = Integer.parseInt(entry.getValue().toString()); // 所需数量
                            Long actualCount = levelCountMap.getOrDefault(level, 0L);
                            if (actualCount < requiredCount) {
                                allMatch = false;
                                break;
                            }
                        }
                    }
                    if (!allMatch) break;
                }
                if (allMatch) return true; // 满足任意一个“或”条件即可返回 true
            }
        }
        return false;
    }

    private static Float calculateDeviceScore(String deviceResMapJson) {
@@ -367,7 +471,7 @@
                        .orElse(null);
                if (record != null) {
                    Task task = taskMapper.selectById(record.getCheckTaskId());
                    if (task != null){
                    if (task != null) {
                        deviceListVo.setCheckTime(task.getCreateTime());
                    }
                    deviceListVo.setCheckResult("已检查");
@@ -412,7 +516,7 @@
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目

                                        .between(StringUtils.hasLength(startTime),Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                        .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                        );
                break;
@@ -424,7 +528,7 @@
                                .eq(Project::getStatus, 1)  // 在建项目
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目
                                        .between(StringUtils.hasLength(startTime),Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                        .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                        );
                break;
@@ -478,7 +582,7 @@
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目

                                        .between(StringUtils.hasLength(startTime),Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                        .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                        );
                break;
@@ -490,7 +594,7 @@
                                .eq(Project::getStatus, 1)  // 在建项目
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目
                                        .between(StringUtils.hasLength(startTime),Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                        .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                        );
                break;
@@ -543,12 +647,12 @@
                                .eq(Project::getStatus, 1)  // 在建项目
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目
                                        .between(StringUtils.hasLength(startTime),Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                        .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                                        .or(w -> w
                                                        .isNull(Project::getStatus)  // 已完成项目
                                        .between(StringUtils.hasLength(startTime),Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                        )
                                .or(w -> w
                                        .isNull(Project::getStatus)  // 已完成项目
                                        .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                        );
                break;
            case 2:
@@ -557,11 +661,11 @@
//                        .eq(Project::getDeleted, false)
                        .eq(Project::getType, 2) // 在建工程
                        .and(wrapper -> wrapper
                                .eq(Project::getStatus, 1)  // 在建项目
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目
                                        .between(StringUtils.hasLength(startTime),Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                                        .eq(Project::getStatus, 1)  // 在建项目
                                        .or(w -> w
                                                .eq(Project::getStatus, 2)  // 已完成项目
                                                .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                        )
                                        .or(w -> w
                                                        .isNull(Project::getStatus)  // 已完成项目
//                                        .between(StringUtils.hasLength(startTime),Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
@@ -580,14 +684,14 @@
        // 查询检查任务
        LambdaQueryWrapper<Task> taskWrapper = new LambdaQueryWrapper<>();
        taskWrapper.in(Task::getProjectId, projectIds)
                ;
        ;
        List<Task> tasks = taskMapper.selectList(taskWrapper);
        List<Integer> checkTaskIds = tasks.stream().map(Task::getId).collect(Collectors.toList());

        // 查询重大隐患记录（level 表示隐患等级，0 表示重大隐患）
        LambdaQueryWrapper<Record> recordWrapper = new LambdaQueryWrapper<>();
        recordWrapper.eq(Record::getDeleted, false)
                .eq(Record::getRecordType,"error")
                .eq(Record::getRecordType, "error")
                .in(Record::getCheckTaskId, checkTaskIds);
        List<Integer> recordIds = recordMapper.selectList(recordWrapper).stream().map(Record::getId).toList();
        query.setRecordIds(recordIds);