工单阈值bug、工单分页故障查询bug、工单未进入下发表bug

fuliqi

2024-10-30 746a85a842adc99322b364d1c564a624dce62429

 ycl-server/src/main/java/com/ycl/platform/service/impl/DataCenterServiceImpl.java

@@ -1,34 +1,48 @@
package com.ycl.platform.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.mongodb.client.AggregateIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.ycl.platform.domain.entity.ImageResourceSecurityDetail;
import com.ycl.platform.domain.entity.YwPoint;
import com.ycl.platform.domain.entity.*;
import com.ycl.platform.domain.query.DataCenterQuery;
import com.ycl.platform.domain.result.HK.*;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.result.UY.*;
import com.ycl.platform.domain.vo.DataCenter.MonitorQualifyResultVO;
import com.ycl.platform.domain.vo.PointDetailVO;
import com.ycl.platform.domain.vo.home.HomeFaceVO;
import com.ycl.platform.mapper.ImageResourceSecurityDetailMapper;
import com.ycl.platform.mapper.YwPointMapper;
import com.ycl.platform.service.DataCenterService;
import com.ycl.platform.service.YwPointService;
import com.ycl.platform.service.*;
import com.ycl.system.Result;
import com.ycl.system.page.PageUtil;
import com.ycl.utils.DateUtils;
import com.ycl.utils.MongoUtil;
import com.ycl.utils.bean.BeanUtils;
import constant.ApiConstants;
import constant.CheckConstants;
import enumeration.general.AreaDeptEnum;
import lombok.RequiredArgsConstructor;
import org.apache.commons.collections.CollectionUtils;
import org.bson.Document;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.*;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.TextCriteria;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
@@ -44,9 +58,14 @@
    private final MongoTemplate mongoTemplate;
    private final ImageResourceSecurityDetailMapper securityDetailMapper;
    private final YwPointMapper pointMapper;
    private final ICheckIndexVideoService checkIndexVideoService;
    private final ICheckIndexCarService checkIndexCarService;
    private final ICheckIndexFaceService checkIndexFaceService;


    private final static String TIME_FIELD = "mongoCreateTime";

    private static DecimalFormat DF = new DecimalFormat("#.####");

    /**
     * 视频：点位在线率
@@ -56,21 +75,89 @@
     */
    @Override
    public Result videoPointOnlineRate(DataCenterQuery params) {
        // 生成查询
        Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, null);

        // 先查总数再分页
        long total = mongoTemplate.count(query, VideoOnlineResult.class);
        List<String> likeFileds = Arrays.asList("name", "no", "ip");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        //查视频设备
        query.addCriteria(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
        //下拉框在线情况查询条件
        if (params.getOption() != null) {
            query.addCriteria(Criteria.where("online").is(params.getOption()));
        }
        // 通过pingOnline字段排序，为false的排在前面
        query.with(Sort.by(Sort.Order.asc("pingOnline")));
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<VideoOnlineResult> resultList = mongoTemplate.find(query, VideoOnlineResult.class);
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
        resultList.forEach(item -> {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
            } else if (-1 == item.getOnline()) {
                item.setOnlineStr("离线");
            } else {
                item.setOnlineStr("未知");
            }
        });
        params.setDeptTag(-1);
        params.setDeviceType(1);

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_online");
        long distinctCount = collection.distinct("deviceId", String.class).into(new ArrayList<>()).size();
        //卡片统计
        int totalCount = 0;
        int onlineCount = 0;
        int offlineCount = 0;
        int unknownCount = 0;
        //构建条件
        List<Criteria> criteriaList = new ArrayList<>();
        // 添加固定条件
        criteriaList.add(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
        criteriaList.add(Criteria.where("mongoCreateTime").gte(params.getStartTime()).lte(params.getEndTime()));
        // 根据dataType动态添加条件
        if (params.getDataType() == 1) {
            criteriaList.add(Criteria.where("provinceTag").is(Boolean.TRUE));
        } else if (params.getDataType() == 2) {
            criteriaList.add(Criteria.where("deptTag").is(Boolean.TRUE));
        }
        // 构建match操作
        MatchOperation match = Aggregation.match(
                new Criteria().andOperator(criteriaList.toArray(new Criteria[0]))
        );
        GroupOperation group = Aggregation.group()
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Online)).then(1).otherwise(0)).as("onlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Offline)).then(1).otherwise(0)).as("offlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Unknown)).then(1).otherwise(0)).as("unknownCount");
        // 将匹配阶段和分组阶段组合起来
        Aggregation aggregation = Aggregation.newAggregation(match, group);
        // 执行聚合查询
        AggregationResults<Map> results = mongoTemplate.aggregate(aggregation, "t_monitor_online", Map.class); // 替换为你的集合名称
        for (Map<String, Object> result : results.getMappedResults()) {
            offlineCount = (Integer) result.getOrDefault("offlineCount", 0L);
            unknownCount = (Integer) result.getOrDefault("unknownCount", 0L);
            onlineCount = (Integer) result.getOrDefault("onlineCount", 0L);
            totalCount = offlineCount + unknownCount + onlineCount;
        }
        /** 查询当天在线率 */
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getSiteOnline)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, params.getStartTime(), params.getEndTime())
                .list();

        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getSiteOnline).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(distinctCount));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -83,39 +170,89 @@
     */
    @Override
    public Result deptVideoPointOnlineRate(DataCenterQuery params) {
        // 先查出部级点位的国标
        List<String> deptGBList = pointMapper.getDeptPointGB(0);

        // 生成查询
        Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, deptGBList);

        // 先查总数再分页
        long total = mongoTemplate.count(query, VideoOnlineResult.class);
        List<String> likeFileds = Arrays.asList("name", "no", "ip");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        //查视频设备
        query.addCriteria(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
        query.addCriteria(Criteria.where("deptTag").is(Boolean.TRUE));
        //下拉框在线情况查询条件
        if (params.getOption() != null) {
            query.addCriteria(Criteria.where("online").is(params.getOption()));
        }
        // 通过pingOnline字段排序，为false的排在前面
        query.with(Sort.by(Sort.Order.asc("pingOnline")));
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<VideoOnlineResult> resultList = mongoTemplate.find(query, VideoOnlineResult.class);

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_online");
        Document filter = new Document("deviceId", new Document("$in", deptGBList));
        // 构建聚合管道
        List<Document> pipeline = Arrays.asList(
                // 只要部级的
                new Document("$match", filter),
                // $group 去重
                new Document("$group", new Document("_id", "$deviceId")),
                new Document("$count", "uniqueDeviceIds")
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
        resultList.forEach(item -> {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
            } else if (-1 == item.getOnline()) {
                item.setOnlineStr("离线");
            } else {
                item.setOnlineStr("未知");
            }
        });
        // 统计设备数量
        //卡片统计
        int totalCount = 0;
        int onlineCount = 0;
        int offlineCount = 0;
        int unknownCount = 0;
        //构建条件
        List<Criteria> criteriaList = new ArrayList<>();
        // 添加固定条件
        criteriaList.add(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
        criteriaList.add(Criteria.where("mongoCreateTime").gte(params.getStartTime()).lte(params.getEndTime()));
        // 根据dataType动态添加条件
        if (params.getDataType() == 1) {
            criteriaList.add(Criteria.where("provinceTag").is(Boolean.TRUE));
        } else if (params.getDataType() == 2) {
            criteriaList.add(Criteria.where("deptTag").is(Boolean.TRUE));
        }
        // 构建match操作
        MatchOperation match = Aggregation.match(
                new Criteria().andOperator(criteriaList.toArray(new Criteria[0]))
        );
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        Integer uniqueDeviceIdCount = 0;
        for (Document doc : result) {
            uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
            break; // 不需要继续遍历，因为 $count 只会产生一个结果
        GroupOperation group = Aggregation.group()
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Online)).then(1).otherwise(0)).as("onlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Offline)).then(1).otherwise(0)).as("offlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Unknown)).then(1).otherwise(0)).as("unknownCount");
        // 将匹配阶段和分组阶段组合起来
        Aggregation aggregation = Aggregation.newAggregation(match, group);
        // 执行聚合查询
        AggregationResults<Map> results = mongoTemplate.aggregate(aggregation, "t_monitor_online", Map.class); // 替换为你的集合名称
        for (Map<String, Object> result : results.getMappedResults()) {
            offlineCount = (Integer) result.getOrDefault("offlineCount", 0L);
            unknownCount = (Integer) result.getOrDefault("unknownCount", 0L);
            onlineCount = (Integer) result.getOrDefault("onlineCount", 0L);
            totalCount = offlineCount + unknownCount + onlineCount;
        }

        params.setDeptTag(1);
        params.setDeviceType(1);
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getMinistrySiteOnline)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, params.getStartTime(), params.getEndTime())
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getMinistrySiteOnline).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(uniqueDeviceIdCount));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -128,41 +265,89 @@
     */
    @Override
    public Result videoImportantPointOnlineRate(DataCenterQuery params) {
        // 先查出重点点位的国标
        List<String> deptGBList = pointMapper.getDeptPointGB(1);

        Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, deptGBList);

        long total = mongoTemplate.count(query, VideoOnlineResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<VideoOnlineResult> resultList = mongoTemplate.find(query, VideoOnlineResult.class);

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_online");
        Document filter = new Document("deviceId", new Document("$in", deptGBList));
        // 构建聚合管道
        List<Document> pipeline = Arrays.asList(
                new Document("$match", filter),
                // $group 去重
                new Document("$group", new Document("_id", "$deviceId")),
                new Document("$count", "uniqueDeviceIds")
        );
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        Integer uniqueDeviceIdCount = 0;
        for (Document doc : result) {
            uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
            break; // 不需要继续遍历，因为 $count 只会产生一个结果
        List<String> likeFileds = Arrays.asList("name", "no", "ip");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        //查视频设备
        query.addCriteria(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
        query.addCriteria(Criteria.where("importantTag").is(Boolean.TRUE));
        //下拉框在线情况查询条件
        if (params.getOption() != null) {
            query.addCriteria(Criteria.where("online").is(params.getOption()));
        }
        // 通过pingOnline字段排序，为false的排在前面
        query.with(Sort.by(Sort.Order.asc("pingOnline")));
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
        params.setDeptTag(3);
        params.setDeviceType(1);
        resultList.forEach(item -> {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
            } else if (-1 == item.getOnline()) {
                item.setOnlineStr("离线");
            } else {
                item.setOnlineStr("未知");
            }
        });

//        long nonNetwork = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("0")), VideoOnlineResult.class);
//        long network = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("1")), VideoOnlineResult.class);
//        long video = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".*1.*")), VideoOnlineResult.class);
//        long car = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".*2.*")), VideoOnlineResult.class);
//        long face = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".*3.*")), VideoOnlineResult.class);
        // 统计设备数量
        //卡片统计
        int totalCount = 0;
        int onlineCount = 0;
        int offlineCount = 0;
        int unknownCount = 0;
        //构建条件
        List<Criteria> criteriaList = new ArrayList<>();
        // 添加固定条件
        criteriaList.add(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
        criteriaList.add(Criteria.where("mongoCreateTime").gte(params.getStartTime()).lte(params.getEndTime()));
        // 根据dataType动态添加条件
        if (params.getDataType() == 1) {
            criteriaList.add(Criteria.where("provinceTag").is(Boolean.TRUE));
        } else if (params.getDataType() == 2) {
            criteriaList.add(Criteria.where("deptTag").is(Boolean.TRUE));
        }
        // 构建match操作
        MatchOperation match = Aggregation.match(
                new Criteria().andOperator(criteriaList.toArray(new Criteria[0]))
        );
        GroupOperation group = Aggregation.group()
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Online)).then(1).otherwise(0)).as("onlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Offline)).then(1).otherwise(0)).as("offlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Unknown)).then(1).otherwise(0)).as("unknownCount");
        // 将匹配阶段和分组阶段组合起来
        Aggregation aggregation = Aggregation.newAggregation(match, group);
        // 执行聚合查询
        AggregationResults<Map> results = mongoTemplate.aggregate(aggregation, "t_monitor_online", Map.class); // 替换为你的集合名称
        for (Map<String, Object> result : results.getMappedResults()) {
            offlineCount = (Integer) result.getOrDefault("offlineCount", 0L);
            unknownCount = (Integer) result.getOrDefault("unknownCount", 0L);
            onlineCount = (Integer) result.getOrDefault("onlineCount", 0L);
            totalCount = offlineCount + unknownCount + onlineCount;
        }
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeySiteOnline)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, params.getStartTime(), params.getEndTime())
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getKeySiteOnline).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(uniqueDeviceIdCount));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -175,42 +360,91 @@
     */
    @Override
    public Result videoImportantPointImageOnlineRate(DataCenterQuery params) {
        // 先查出重点指挥图像点位的国标
        List<String> deptGBList = pointMapper.getDeptPointGB(2);

        Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, deptGBList);

        long total = mongoTemplate.count(query, VideoOnlineResult.class);
        List<String> likeFileds = Arrays.asList("name", "no", "ip");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        //查视频设备
        query.addCriteria(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
        query.addCriteria(Criteria.where("importantCommandImageTag").is(Boolean.TRUE));
        //下拉框在线情况查询条件
        if (params.getOption() != null) {
            query.addCriteria(Criteria.where("online").is(params.getOption()));
        }
        // 通过pingOnline字段排序，为false的排在前面
        query.with(Sort.by(Sort.Order.asc("pingOnline")));
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<VideoOnlineResult> resultList = mongoTemplate.find(query, VideoOnlineResult.class);
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_online");
        Document filter = new Document("deviceId", new Document("$in", deptGBList));
        // 构建聚合管道
        List<Document> pipeline = Arrays.asList(
                new Document("$match", filter),
                // $group 去重
                new Document("$group", new Document("_id", "$deviceId")),
                new Document("$count", "uniqueDeviceIds")
        params.setDeptTag(4);
        params.setDeviceType(1);
        resultList.forEach(item -> {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
            } else if (-1 == item.getOnline()) {
                item.setOnlineStr("离线");
            } else {
                item.setOnlineStr("未知");
            }
        });

        // 统计设备数量
        //卡片统计
        int totalCount = 0;
        int onlineCount = 0;
        int offlineCount = 0;
        int unknownCount = 0;
        //构建条件
        List<Criteria> criteriaList = new ArrayList<>();
        // 添加固定条件
        criteriaList.add(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
        criteriaList.add(Criteria.where("mongoCreateTime").gte(params.getStartTime()).lte(params.getEndTime()));
        // 根据dataType动态添加条件
        if (params.getDataType() == 1) {
            criteriaList.add(Criteria.where("provinceTag").is(Boolean.TRUE));
        } else if (params.getDataType() == 2) {
            criteriaList.add(Criteria.where("deptTag").is(Boolean.TRUE));
        }
        // 构建match操作
        MatchOperation match = Aggregation.match(
                new Criteria().andOperator(criteriaList.toArray(new Criteria[0]))
        );
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        Integer uniqueDeviceIdCount = 0;
        for (Document doc : result) {
            uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
            break; // 不需要继续遍历，因为 $count 只会产生一个结果
        GroupOperation group = Aggregation.group()
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Online)).then(1).otherwise(0)).as("onlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Offline)).then(1).otherwise(0)).as("offlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Unknown)).then(1).otherwise(0)).as("unknownCount");
        // 将匹配阶段和分组阶段组合起来
        Aggregation aggregation = Aggregation.newAggregation(match, group);
        // 执行聚合查询
        AggregationResults<Map> results = mongoTemplate.aggregate(aggregation, "t_monitor_online", Map.class); // 替换为你的集合名称
        for (Map<String, Object> result : results.getMappedResults()) {
            offlineCount = (Integer) result.getOrDefault("offlineCount", 0L);
            unknownCount = (Integer) result.getOrDefault("unknownCount", 0L);
            onlineCount = (Integer) result.getOrDefault("onlineCount", 0L);
            totalCount = offlineCount + unknownCount + onlineCount;
        }

//        // 统计数
//        long nonNetwork = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("0")), VideoOnlineResult.class);
//        long network = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("1")), VideoOnlineResult.class);
//        long video = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".*1.*")), VideoOnlineResult.class);
//        long car = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".*2.*")), VideoOnlineResult.class);
//        long face = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".*3.*")), VideoOnlineResult.class);
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeyCommandImageOnline)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, params.getStartTime(), params.getEndTime())
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getKeyCommandImageOnline).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(uniqueDeviceIdCount));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -223,24 +457,42 @@
     */
    @Override
    public Result videoOneMachineDocumentRegister(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "serialNumber.showValue", TIME_FIELD, null);

        List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
        List<Criteria> andCriteria = MongoUtil.getAndCriteria(params, TIME_FIELD, likeFileds, null);
        Query query = new Query();
        Criteria and = new Criteria();
        if(params.getOption()!=null){
            if(params.getOption() ==1){
                andCriteria.add(Criteria.where("newDevice").is(Boolean.TRUE));
            }else if(params.getOption() ==-1){
                andCriteria.add(Criteria.where("newDevice").is(Boolean.FALSE));
            }
        }
        and.andOperator(andCriteria);
        query = Query.query(and);
        long total = mongoTemplate.count(query, MonitorQualifyResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<MonitorQualifyResult> resultList = mongoTemplate.find(query, MonitorQualifyResult.class);

        List<MonitorQualifyResultVO> resultVOS = new ArrayList<>();
        for (MonitorQualifyResult result : resultList) {
            MonitorQualifyResultVO vo = MonitorQualifyResult.getVO(result);
            resultVOS.add(vo);
        }
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_monitor_qualify");
        //总数
        List<Document> dList1 = new ArrayList<>(2);
        setTag(params, dList1);
        Document totalFilter = new Document("$and",dList1);
        //新设备数
        List<Document> dList2 = new ArrayList<>(2);
        setTag(params, dList2);
        dList2.add(new Document("newDevice",Boolean.TRUE));
        Document newFilter = new Document("$and",dList2);

        Document ipErrFilter = new Document("ip.error", true);
        Document macdzErrFilter = new Document("macdz.error", true);
        Document latitudeErrFilter = new Document("latitude.error", true);
        Document longitudeErrFilter = new Document("longitude.error", true);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<Integer> rList = lists.stream().map(filter -> {
        List<Document> lists = Arrays.asList(totalFilter, newFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -255,12 +507,25 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getMonitorRegistration)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getMonitorRegistration).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("list", resultList);
        map.put("list", resultVOS);
        return Result.ok().data(map).total(total);
    }

@@ -272,24 +537,101 @@
     */
    @Override
    public Result videoOneMachineDocumentQualified(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "serialNumber.showValue", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
        List<Criteria> andCriteria = MongoUtil.getAndCriteria(params, TIME_FIELD, likeFileds, null);
        Query query = new Query();
        Criteria and = new Criteria();
        and.andOperator(andCriteria);
        query = Query.query(and);
        if(params.getOption()!=null){
            if(params.getOption() ==1){
                andCriteria.add(Criteria.where("serialNumber.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("name.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("civilCode.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("integrated_device.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("jkdwlx.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("latitude.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("longitude.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("macdz.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("name.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("sbzt.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("sxjcjqy.error").is(Boolean.FALSE));
                andCriteria.add(Criteria.where("sxjgnlx.error").is(Boolean.FALSE));
                Criteria and2 = new Criteria();
                and2.andOperator(andCriteria);
                query = Query.query(and2);
            }else if(params.getOption() ==-1){
                Criteria c1 = Criteria.where("serialNumber.error").is(Boolean.TRUE);
                Criteria c2 = Criteria.where("name.error").is(Boolean.TRUE);
                Criteria c3 = Criteria.where("civilCode.error").is(Boolean.TRUE);
                Criteria c4 = Criteria.where("integrated_device.error").is(Boolean.TRUE);
                Criteria c5 = Criteria.where("jkdwlx.error").is(Boolean.TRUE);
                Criteria c6 = Criteria.where("latitude.error").is(Boolean.TRUE);
                Criteria c7 = Criteria.where("longitude.error").is(Boolean.TRUE);
                Criteria c8 = Criteria.where("macdz.error").is(Boolean.TRUE);
                Criteria c9 = Criteria.where("name.error").is(Boolean.TRUE);
                Criteria c10 = Criteria.where("sbzt.error").is(Boolean.TRUE);
                Criteria c11 = Criteria.where("sxjcjqy.error").is(Boolean.TRUE);
                Criteria c12 = Criteria.where("sxjgnlx.error").is(Boolean.TRUE);
                Criteria orOperator = new Criteria().orOperator(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12);
                orOperator.andOperator(andCriteria);
                query = Query.query(orOperator);
            }
        }

        long total = mongoTemplate.count(query, MonitorQualifyResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<MonitorQualifyResult> resultList = mongoTemplate.find(query, MonitorQualifyResult.class);

        List<MonitorQualifyResultVO> resultVOS = new ArrayList<>();
        for (MonitorQualifyResult result : resultList) {
            MonitorQualifyResultVO vo = MonitorQualifyResult.getVO(result);
            resultVOS.add(vo);
        }
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_monitor_qualify");
        //总数
        List<Document> dList1 = new ArrayList<>(2);
        setTag(params, dList1);
        Document totalFilter = new Document("$and",dList1);
        //合格数
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("serialNumber.error",Boolean.FALSE));
        dList2.add(new Document("name.error",Boolean.FALSE));
        dList2.add(new Document("civilCode.error",Boolean.FALSE));
        dList2.add(new Document("integrated_device.error",Boolean.FALSE));
        dList2.add(new Document("jkdwlx.error",Boolean.FALSE));
        dList2.add(new Document("latitude.error",Boolean.FALSE));
        dList2.add(new Document("longitude.error",Boolean.FALSE));
        dList2.add(new Document("macdz.error",Boolean.FALSE));
        dList2.add(new Document("name.error",Boolean.FALSE));
        dList2.add(new Document("sbzt.error",Boolean.FALSE));
        dList2.add(new Document("sxjcjqy.error",Boolean.FALSE));
        dList2.add(new Document("sxjgnlx.error",Boolean.FALSE));
        setTag(params,dList2);
        Document qualifyFilter = new Document("$and",dList2);
        //不合格数
        List<Document> dList3  = new ArrayList<>(2);
        setTag(params,dList3);
        List<Document> errorConditions = new ArrayList<>();
        errorConditions.add(new Document("serialNumber.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("name.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("civilCode.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("integrated_device.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("jkdwlx.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("latitude.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("longitude.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("macdz.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("name.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("sbzt.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("sxjcjqy.error", new Document("$eq", Boolean.TRUE)));
        errorConditions.add(new Document("sxjgnlx.error", new Document("$eq", Boolean.TRUE)));
        Document errorFilter = new Document("$or", errorConditions);
        dList3.add(errorFilter);
        Document unQualifyFilter = new Document("$and", dList3);

        Document ipErrFilter = new Document("ip.error", true);
        Document macdzErrFilter = new Document("macdz.error", true);
        Document latitudeErrFilter = new Document("latitude.error", true);
        Document longitudeErrFilter = new Document("longitude.error", true);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<Integer> rList = lists.stream().map(filter -> {
        List<Document> lists = Arrays.asList(totalFilter, qualifyFilter, unQualifyFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -304,41 +646,69 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getMonitorQualification)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getMonitorQualification).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("list", resultList);
        map.put("list", resultVOS);
        return Result.ok().data(map).total(total);
    }

    /**
     * 视频：档案考核比
     *
     * 档案留存总量：mongo存的所有去重后的档案
     * 当日档案：当日的档案
     * 档案考核比 = 当日档案/档案留存总量
     * @param params
     * @return
     * @return1
     */
    @Override
    public Result videoAssessmentFileRatio(DataCenterQuery params) {
        // TODO 新增一张表记录每次的档案考核
        Query query = MongoUtil.getQuery(params, "serialNumber.showValue", TIME_FIELD, null);

        List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
        List<Criteria> andCriteria = MongoUtil.getAndCriteria(params, TIME_FIELD, likeFileds, null);
        Query query = new Query();
        Criteria and = new Criteria();
        and.andOperator(andCriteria);
        query = Query.query(and);
        long total = mongoTemplate.count(query, MonitorQualifyResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<MonitorQualifyResult> resultList = mongoTemplate.find(query, MonitorQualifyResult.class);

        List<MonitorQualifyResultVO> resultVOS = new ArrayList<>();
        for (MonitorQualifyResult result : resultList) {
            MonitorQualifyResultVO vo = MonitorQualifyResult.getVO(result);
            resultVOS.add(vo);
        }
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_monitor_qualify");
        //总数
        List<Document> dList1 = new ArrayList<>(2);
        DataCenterQuery totalParams = new DataCenterQuery();
        BeanUtils.copyProperties(params,totalParams);
        totalParams.setStartTime(null);
        setTag(totalParams, dList1);
        Document totalFilter = new Document("$and",dList1);
        //当日档案数
        List<Document> dList2 = new ArrayList<>(2);
        setTag(params, dList2);
        Document newFilter = new Document("$and",dList2);

        Document ipErrFilter = new Document("ip.error", true);
        Document macdzErrFilter = new Document("macdz.error", true);
        Document latitudeErrFilter = new Document("latitude.error", true);
        Document longitudeErrFilter = new Document("longitude.error", true);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<Integer> rList = lists.stream().map(filter -> {
        List<Document> lists = Arrays.asList(totalFilter, newFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -353,12 +723,25 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getArchivesRate)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getArchivesRate).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("list", resultList);
        map.put("list", resultVOS);
        return Result.ok().data(map).total(total);
    }

@@ -370,19 +753,30 @@
     */
    @Override
    public Result videoAvailabilityRate(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "deviceId", "createTime", null);

        List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
        Query query = MongoUtil.getQuery(params, "createTime", likeFileds, null);
        //下拉框录像情况查询条件
        if (params.getOption() != null) {
            query.addCriteria(Criteria.where("recordStatus").is(params.getOption()));
        }
        long total = mongoTemplate.count(query, RecordMetaDSumResult.class);
        MongoUtil.setPage(query, params, "createTime");
        List<RecordMetaDSumResult> resultList = mongoTemplate.find(query, RecordMetaDSumResult.class);

        //翻译行政区域
        resultList.forEach(item->{
            String areaCode = item.getArealayername().substring(0, 6);
            AreaDeptEnum areaDeptEnum = AreaDeptEnum.fromCode(areaCode);
            if(areaDeptEnum!=null) item.setArealayername(areaDeptEnum.getName());
        });
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
        List<Integer> status = Arrays.asList(1, 0, -1);
        List<Integer> resultCount = status.stream().map(item -> {
            Document filter = new Document("recordStatus", item);
        List<String> resultCount = status.stream().map(item -> {
            List<Document> dList = new ArrayList<>(2);
            dList.add(new Document("recordStatus", new Document("$eq", item)));
            setTag(params, dList);
            Document filter = new Document("$and", dList);
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -397,9 +791,28 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getVideoAvailable)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getVideoAvailable).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        //加一个总数
        int totalCount = 0;
        for (String s : resultCount) {
            totalCount += Integer.parseInt(s);
        }
        resultCount.add(0, totalCount + "");

        resultCount.add(this.remove0(onlineRate));

        HashMap<String, Object> map = new HashMap<>();
        map.put("count", resultCount);
@@ -415,24 +828,31 @@
     */
    @Override
    public Result deptVideoAvailabilityRate(DataCenterQuery params) {

        List<String> deptGBList = pointMapper.getDeptPointGB(0);

        Query query = MongoUtil.getQuery(params, "deviceId", "createTime", deptGBList);

        List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
        Query query = MongoUtil.getQuery(params, "createTime", likeFileds, 1);
        //下拉框录像情况查询条件
        if (params.getOption() != null) {
            query.addCriteria(Criteria.where("recordStatus").is(params.getOption()));
        }
        long total = mongoTemplate.count(query, RecordMetaDSumResult.class);
        MongoUtil.setPage(query, params, "createTime");
        List<RecordMetaDSumResult> resultList = mongoTemplate.find(query, RecordMetaDSumResult.class);

        //翻译行政区域
        resultList.forEach(item->{
            String areaCode = item.getArealayername().substring(0, 6);
            AreaDeptEnum areaDeptEnum = AreaDeptEnum.fromCode(areaCode);
            if(areaDeptEnum!=null) item.setArealayername(areaDeptEnum.getName());
        });
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
        List<Integer> status = Arrays.asList(1, 0, -1);
        List<Integer> resultCount = status.stream().map(item -> {
            Document filter = new Document("$and", Arrays.asList(
                    new Document("deviceId", new Document("$in", deptGBList)), // $in 条件
                    new Document("recordStatus", item)
            ));
        List<String> resultCount = status.stream().map(item -> {
            List<Document> dList = new ArrayList<>(4);
            dList.add(new Document("deptTag", new Document("$eq", Boolean.TRUE)));
            dList.add(new Document("recordStatus", new Document("$eq", item)));
            setTag(params, dList);
            Document filter = new Document("$and", dList);
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -447,10 +867,28 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());


        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getMinistryVideoAvailable)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getMinistryVideoAvailable).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        //加一个总数
        int totalCount = 0;
        for (String s : resultCount) {
            totalCount += Integer.parseInt(s);
        }
        resultCount.add(0, totalCount + "");
        resultCount.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", resultCount);
        map.put("list", resultList);
@@ -465,24 +903,31 @@
     */
    @Override
    public Result videoImportantPointAvailabilityRate(DataCenterQuery params) {

        List<String> deptGBList = pointMapper.getDeptPointGB(1);

        Query query = MongoUtil.getQuery(params, "deviceId", "createTime", deptGBList);

        List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
        Query query = MongoUtil.getQuery(params, "createTime", likeFileds, 3);
        //下拉框录像情况查询条件
        if (params.getOption() != null) {
            query.addCriteria(Criteria.where("recordStatus").is(params.getOption()));
        }
        long total = mongoTemplate.count(query, RecordMetaDSumResult.class);
        MongoUtil.setPage(query, params, "createTime");
        List<RecordMetaDSumResult> resultList = mongoTemplate.find(query, RecordMetaDSumResult.class);

        //翻译行政区域
        resultList.forEach(item->{
            String areaCode = item.getArealayername().substring(0, 6);
            AreaDeptEnum areaDeptEnum = AreaDeptEnum.fromCode(areaCode);
            if(areaDeptEnum!=null) item.setArealayername(areaDeptEnum.getName());
        });
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
        List<Integer> status = Arrays.asList(1, 0, -1);
        List<Integer> resultCount = status.stream().map(item -> {
            Document filter = new Document("$and", Arrays.asList(
                    new Document("deviceId", new Document("$in", deptGBList)), // $in 条件
                    new Document("recordStatus", item)
            ));
        List<String> resultCount = status.stream().map(item -> {
            List<Document> dList = new ArrayList<>(4);
            dList.add(new Document("importantTag", new Document("$eq", Boolean.TRUE)));
            dList.add(new Document("recordStatus", new Document("$eq", item)));
            setTag(params, dList);
            Document filter = new Document("$and", dList);
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -497,9 +942,28 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeyVideoAvailable)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getKeyVideoAvailable).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        //加一个总数
        int totalCount = 0;
        for (String s : resultCount) {
            totalCount += Integer.parseInt(s);
        }
        resultCount.add(0, totalCount + "");
        resultCount.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", resultCount);
        map.put("list", resultList);
@@ -507,15 +971,15 @@
    }

    /**
     * 视频：标注正确率
     * 视频：标注正确率（暂停）
     *
     * @param params
     * @return
     */
    @Override
    public Result videoLabelingAccuracy(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "deviceId", "", new ArrayList<>());
        List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, RecordMetaDSumResult.class);
        List<RecordMetaDSumResult> resultList = mongoTemplate.find(query, RecordMetaDSumResult.class);
@@ -539,24 +1003,99 @@
     */
    @Override
    public Result videoImportantPointLabelingAccuracy(DataCenterQuery params) {

        List<String> deptGBList = pointMapper.getDeptPointGB(1);
        Query query = MongoUtil.getQuery(params, "deviceNo", "checkTime", deptGBList);

        List<String> likeFileds = Arrays.asList("deviceNo", "osdName");
        List<Criteria> andCriteria = MongoUtil.getAndCriteria(params, "checkTime", likeFileds, 3);
        Query query = new Query();
        Criteria and = new Criteria();
        and.andOperator(andCriteria);
        query = Query.query(and);
        //下拉框标注正确查询条件
        if (params.getOption() != null) {
            if(params.getOption()==1) {
                andCriteria.add(Criteria.where("osdNameCorrect").is(1));
                andCriteria.add(Criteria.where("osdTimeCorrect").is(1));
                andCriteria.add(Criteria.where("osdProvinceCorrect").is(1));
                andCriteria.add(Criteria.where("osdCityCorrect").is(1));
                andCriteria.add(Criteria.where("osdPartCorrect").is(1));
                Criteria and2 = new Criteria();
                and2.andOperator(andCriteria);
                query = Query.query(and2);
            }else if(params.getOption()==-1){
                // 使用$or条件连接多个字段检查，每个字段检查是否等于-1
                Criteria c1 = Criteria.where("osdNameCorrect").is(-1);
                Criteria c2 = Criteria.where("osdTimeCorrect").is(-1);
                Criteria c3 = Criteria.where("osdProvinceCorrect").is(-1);
                Criteria c4 = Criteria.where("osdCityCorrect").is(-1);
                Criteria c5 = Criteria.where("osdPartCorrect").is(-1);
                Criteria orOperator = new Criteria().orOperator(c1, c2, c3, c4, c5);
                orOperator.andOperator(andCriteria);
                query = Query.query(orOperator);
            }else {
                Criteria c1 = Criteria.where("osdNameCorrect").is(0);
                Criteria c2 = Criteria.where("osdTimeCorrect").is(0);
                Criteria c3 = Criteria.where("osdProvinceCorrect").is(0);
                Criteria c4 = Criteria.where("osdCityCorrect").is(0);
                Criteria c5 = Criteria.where("osdPartCorrect").is(0);
                Criteria orOperator = new Criteria().orOperator(c1, c2, c3, c4, c5);
                orOperator.andOperator(andCriteria);
                query = Query.query(orOperator);
            }
        }
        long total = mongoTemplate.count(query, OsdCheckResult.class);
        MongoUtil.setPage(query, params, "checkTime");
        List<OsdCheckResult> resultList = mongoTemplate.find(query, OsdCheckResult.class);

        for (OsdCheckResult osdCheckResult : resultList) {
            OsdCheckResult.getText(osdCheckResult);
        }
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("osd_check_result");
        //总数
        List<Document> dList = new ArrayList<>(2);
        dList.add(new Document("importantTag", Boolean.TRUE));
        setTag(params, dList);
        Document osdFilter = new Document("$and", dList);
        //正常数
        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("importantTag", Boolean.TRUE));
        dList1.add(new Document("osdNameCorrect", new Document("$eq", 1)));
        dList1.add(new Document("osdTimeCorrect", new Document("$eq", 1)));
        dList1.add(new Document("osdProvinceCorrect", new Document("$eq", 1)));
        dList1.add(new Document("osdCityCorrect", new Document("$eq", 1)));
        dList1.add(new Document("osdPartCorrect", new Document("$eq", 1)));
        setTag(params, dList1);
        Document osdCorrectFilter = new Document("$and", dList1);
        //异常数
        List<Document> dList2 = new ArrayList<>(2);
        setTag(params,dList2);
        Document importantTagCondition = new Document("importantTag", Boolean.TRUE);
        dList2.add(importantTagCondition);
        List<Document> errorConditions = new ArrayList<>();
        errorConditions.add(new Document("osdNameCorrect", new Document("$eq", -1)));
        errorConditions.add(new Document("osdTimeCorrect", new Document("$eq", -1)));
        errorConditions.add(new Document("osdProvinceCorrect", new Document("$eq", -1)));
        errorConditions.add(new Document("osdCityCorrect", new Document("$eq", -1)));
        errorConditions.add(new Document("osdPartCorrect", new Document("$eq", -1)));
        Document errorFilter = new Document("$or", errorConditions);
        dList2.add(errorFilter);
        Document osdErrorFilter = new Document("$and", dList2);
        //TODO：未知数  新增0的状态
        List<Document> dList3 = new ArrayList<>(2);
        setTag(params,dList3);
        dList3.add(importantTagCondition);
        List<Document> unknownConditions = new ArrayList<>();
        unknownConditions.add(new Document("osdNameCorrect", new Document("$eq", 0)));
        unknownConditions.add(new Document("osdTimeCorrect", new Document("$eq", 0)));
        unknownConditions.add(new Document("osdProvinceCorrect", new Document("$eq", 0)));
        unknownConditions.add(new Document("osdCityCorrect", new Document("$eq", 0)));
        unknownConditions.add(new Document("osdPartCorrect", new Document("$eq", 0)));
        // 使用$or逻辑组合剩余的条件
        Document unknownFilter = new Document("$or", unknownConditions);
        dList3.add(unknownFilter);
        Document osdUnknownFilter = new Document("$and", dList3);

        Document osdNameFilter = new Document("osdNameCorrect", 1);
        Document osdNameErrFilter = new Document("osdNameCorrect", -1);
        Document osdTimeFilter = new Document("osdTimeCorrect", 1);
        Document osdTimeErrFilter = new Document("osdTimeCorrect", -1);
        List<Document> lists = Arrays.asList(osdNameFilter, osdNameErrFilter, osdTimeFilter, osdTimeErrFilter);
        List<Integer> rList = lists.stream().map(filter -> {
        List<Document> lists = Arrays.asList(osdFilter, osdCorrectFilter, osdErrorFilter,osdUnknownFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -571,10 +1110,22 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());


        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeyAnnotationAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getKeyAnnotationAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("list", resultList);
@@ -590,7 +1141,8 @@
    @Override
    public Result videoCheckTimeAccuracy(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "deviceId", "", new ArrayList<>());
        List<String> likeFileds = Arrays.asList("deviceId");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, OneMachineFileResult.class);
        List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
@@ -614,23 +1166,75 @@
     */
    @Override
    public Result videoImportantPointCheckTimeAccuracy(DataCenterQuery params) {

        List<String> deptGBList = pointMapper.getDeptPointGB(1);

        Query query = MongoUtil.getQuery(params, "deviceNo", "checkTime", deptGBList);
        List<String> likeFileds = Arrays.asList("deviceNo", "osdName");
        Query query = MongoUtil.getQuery(params, "checkTime", likeFileds, 3);
        //下拉框标注正确查询条件
        if (params.getOption() != null) {
            if(params.getOption()==1) {
               query.addCriteria(Criteria.where("osdTimeCorrect").is(1));
            }else if(params.getOption()==-1){
                query.addCriteria(Criteria.where("osdTimeCorrect").is(-1));
            }else {
                query.addCriteria(Criteria.where("osdTimeCorrect").is(0));
            }
        }

        long total = mongoTemplate.count(query, OsdCheckResult.class);
        MongoUtil.setPage(query, params, "checkTime");
        List<OsdCheckResult> resultList = mongoTemplate.find(query, OsdCheckResult.class);

        for (OsdCheckResult osdCheckResult : resultList) {
            OsdCheckResult.getText(osdCheckResult);
        }
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("osd_check_result");
        //总数
        List<Document> dList = new ArrayList<>(2);
        dList.add(new Document("importantTag", Boolean.TRUE));
        setTag(params, dList);
        Document osdFilter = new Document("$and", dList);
        //正常数
        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("importantTag", Boolean.TRUE));
        dList1.add(new Document("osdNameCorrect", new Document("$eq", 1)));
        dList1.add(new Document("osdTimeCorrect", new Document("$eq", 1)));
        dList1.add(new Document("osdProvinceCorrect", new Document("$eq", 1)));
        dList1.add(new Document("osdCityCorrect", new Document("$eq", 1)));
        dList1.add(new Document("osdPartCorrect", new Document("$eq", 1)));
        setTag(params, dList1);
        Document osdCorrectFilter = new Document("$and", dList1);
        //异常数
        List<Document> dList2 = new ArrayList<>(2);
        setTag(params,dList2);
        Document importantTagCondition = new Document("importantTag", Boolean.TRUE);
        dList2.add(importantTagCondition);
        List<Document> errorConditions = new ArrayList<>();
        errorConditions.add(new Document("osdNameCorrect", new Document("$eq", -1)));
        errorConditions.add(new Document("osdTimeCorrect", new Document("$eq", -1)));
        errorConditions.add(new Document("osdProvinceCorrect", new Document("$eq", -1)));
        errorConditions.add(new Document("osdCityCorrect", new Document("$eq", -1)));
        errorConditions.add(new Document("osdPartCorrect", new Document("$eq", -1)));
        Document errorFilter = new Document("$or", errorConditions);
        dList2.add(errorFilter);
        Document osdErrorFilter = new Document("$and", dList2);
        //TODO：未知数  新增0的状态
        List<Document> dList3 = new ArrayList<>(2);
        setTag(params,dList3);
        dList3.add(importantTagCondition);
        List<Document> unknownConditions = new ArrayList<>();
        unknownConditions.add(new Document("osdNameCorrect", new Document("$eq", 0)));
        unknownConditions.add(new Document("osdTimeCorrect", new Document("$eq", 0)));
        unknownConditions.add(new Document("osdProvinceCorrect", new Document("$eq", 0)));
        unknownConditions.add(new Document("osdCityCorrect", new Document("$eq", 0)));
        unknownConditions.add(new Document("osdPartCorrect", new Document("$eq", 0)));
        // 使用$or逻辑组合剩余的条件
        Document unknownFilter = new Document("$or", unknownConditions);
        dList3.add(unknownFilter);
        Document osdUnknownFilter = new Document("$and", dList3);

        Document osdTimeFilter = new Document("osdTimeCorrect", 1);
        Document osdTimeErrFilter = new Document("osdTimeCorrect", -1);
        List<Document> lists = Arrays.asList(osdTimeFilter, osdTimeErrFilter);
        List<Integer> rList = lists.stream().map(filter -> {
        List<Document> lists = Arrays.asList(osdFilter, osdCorrectFilter, osdErrorFilter,osdUnknownFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -645,9 +1249,22 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeyTimingAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexVideo::getKeyTimingAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("list", resultList);
@@ -663,23 +1280,42 @@
     */
    @Override
    public Result vehicleViewDockStable(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);

        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        //加DataType为车辆
        query.addCriteria(Criteria.where("dataType").is(ApiConstants.HK_DataType_CAR));
        if(params.getOption()!=null){
            if(ApiConstants.HK_SnapCount_ResultType_Normal.equals(params.getOption())) {
                query.addCriteria(Criteria.where("resultType").is(ApiConstants.HK_SnapCount_ResultType_Normal));
            }else if(ApiConstants.HK_SnapCount_ResultType_Null.equals(params.getOption())){
                query.addCriteria(Criteria.where("resultType").is(ApiConstants.HK_SnapCount_ResultType_Null));
            }else if(ApiConstants.HK_SnapCount_ResultType_Descent.equals(params.getOption())){
                query.addCriteria(Criteria.where("resultType").is(ApiConstants.HK_SnapCount_ResultType_Descent));
            }else if(ApiConstants.HK_SnapCount_ResultType_Low.equals(params.getOption())){
                query.addCriteria(Criteria.where("resultType").is(ApiConstants.HK_SnapCount_ResultType_Low));
            }
        }
        long total = mongoTemplate.count(query, SnapshotDataMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<SnapshotDataMonitorResult> resultList = mongoTemplate.find(query, SnapshotDataMonitorResult.class);

        resultList.forEach(item ->item.setResultTypeText(item.getResultTypeText()));
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_snapshot_data_monitor");

        Document normalFilter = new Document("resultType", 1);
        Document noDataFilter = new Document("resultType", 2);
        Document trFilter = new Document("resultType", 3);
        Document littleFilter = new Document("resultType", 4);
        List<Document> lists = Arrays.asList(normalFilter, noDataFilter, trFilter, littleFilter);
        List<Integer> rList = lists.stream().map(filter -> {
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("resultType", new Document("$eq", 1)));
        dList2.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("resultType", new Document("$eq", 2)));
        dList3.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList3);

        Document noDataFilter = new Document("$and", dList2);
        Document trFilter = new Document("$and", dList3);
        List<Document> lists = Arrays.asList(noDataFilter, trFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -694,9 +1330,37 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        // 构建基本的$match条件
        List<Document> matchConditions = new ArrayList<>();
        setTag(params, matchConditions);
        matchConditions.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        List<Document> pipeline = Arrays.asList(
                new Document("$match", new Document("$and", matchConditions)),
                new Document("$group", new Document("_id", "$mongoCreateTime")
                        .append("dataCount", new Document("$sum", "$dataCount"))
                ));
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        int dataCount = 0;
        for (Document doc : result) {
            dataCount = doc.getInteger("dataCount");
        }
        rList.add(0,dataCount+"");
        List<CheckIndexCar> carList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getViewConnectStability)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(carList)) {
            BigDecimal sum = carList.stream().map(CheckIndexCar::getViewConnectStability).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(carList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("list", resultList);
@@ -711,20 +1375,90 @@
     */
    @Override
    public Result vehiclePointOnlineRate(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);

        long total = mongoTemplate.count(query, SnapshotDataMonitorResult.class);
        List<String> likeFileds = Arrays.asList("name", "no", "ip");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        //查车辆设备
        query.addCriteria(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Car + ".*"));
        //下拉框在线情况查询条件
        if (params.getOption() != null) {
            query.addCriteria(Criteria.where("online").is(params.getOption()));
        }
        // 通过pingOnline字段排序，为false的排在前面
        query.with(Sort.by(Sort.Order.asc("pingOnline")));
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<SnapshotDataMonitorResult> resultList = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
        //系统ping的结果
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
        params.setDeptTag(-1);
        params.setDeviceType(2);
        resultList.forEach(item -> {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
            } else if (-1 == item.getOnline()) {
                item.setOnlineStr("离线");
            } else {
                item.setOnlineStr("未知");
            }
        });

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_snapshot_data_monitor");
        long distinctCount = collection.distinct("externalIndexCode", String.class).into(new ArrayList<>()).size();
        // 统计设备数量
        //卡片统计
        int totalCount = 0;
        int onlineCount = 0;
        int offlineCount = 0;
        int unknownCount = 0;
        //构建条件
        List<Criteria> criteriaList = new ArrayList<>();
        // 添加固定条件
        criteriaList.add(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Car + ".*"));
        criteriaList.add(Criteria.where("mongoCreateTime").gte(params.getStartTime()).lte(params.getEndTime()));
        // 根据dataType动态添加条件
        if (params.getDataType() == 1) {
            criteriaList.add(Criteria.where("provinceTag").is(Boolean.TRUE));
        } else if (params.getDataType() == 2) {
            criteriaList.add(Criteria.where("deptTag").is(Boolean.TRUE));
        }
        // 构建match操作
        MatchOperation match = Aggregation.match(
                new Criteria().andOperator(criteriaList.toArray(new Criteria[0]))
        );
        GroupOperation group = Aggregation.group()
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Online)).then(1).otherwise(0)).as("onlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Offline)).then(1).otherwise(0)).as("offlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Unknown)).then(1).otherwise(0)).as("unknownCount");
        // 将匹配阶段和分组阶段组合起来
        Aggregation aggregation = Aggregation.newAggregation(match, group);
        // 执行聚合查询
        AggregationResults<Map> results = mongoTemplate.aggregate(aggregation, "t_monitor_online", Map.class); // 替换为你的集合名称
        for (Map<String, Object> result : results.getMappedResults()) {
            offlineCount = (Integer) result.getOrDefault("offlineCount", 0L);
            unknownCount = (Integer) result.getOrDefault("unknownCount", 0L);
            onlineCount = (Integer) result.getOrDefault("onlineCount", 0L);
            totalCount = offlineCount + unknownCount + onlineCount;
        }

        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getSiteOnline)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getSiteOnline).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(distinctCount));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -737,24 +1471,47 @@
     */
    @Override
    public Result vehicleNetDeviceDirectoryConsistency(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);

        List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
        List<Criteria> andCriteria = MongoUtil.getAndCriteria(params, TIME_FIELD, likeFileds, null);
        // 1/2/3 视频/车辆/人脸
        Pattern pattern = Pattern.compile(".*2.*");
        andCriteria.add(Criteria.where("sxjgnlx.value").regex(pattern));
        Query query = new Query();
        Criteria and = new Criteria();
        if(params.getOption()!=null){
            if(params.getOption() ==1){
                andCriteria.add(Criteria.where("newDevice").is(Boolean.TRUE));
            }else if(params.getOption() ==-1){
                andCriteria.add(Criteria.where("newDevice").is(Boolean.FALSE));
            }
        }
        and.andOperator(andCriteria);
        query = Query.query(and);
        long total = mongoTemplate.count(query, MonitorQualifyResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<MonitorQualifyResult> resultList = mongoTemplate.find(query, MonitorQualifyResult.class);

        // 统计数量
        List<MonitorQualifyResultVO> resultVOS = new ArrayList<>();
        for (MonitorQualifyResult result : resultList) {
            MonitorQualifyResultVO vo = MonitorQualifyResult.getVO(result);
            resultVOS.add(vo);
        }
        //统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_monitor_qualify");
        //总数
        List<Document> dList1 = new ArrayList<>(2);
        setTag(params, dList1);
        dList1.add(new Document("sxjgnlx.value", new Document("$regex", ".*2.*")));
        Document totalFilter = new Document("$and",dList1);
        //新设备数
        List<Document> dList2 = new ArrayList<>(2);
        setTag(params, dList2);
        dList2.add(new Document("sxjgnlx.value", new Document("$regex", ".*2.*")));
        dList2.add(new Document("newDevice",Boolean.TRUE));
        Document newFilter = new Document("$and",dList2);

        Document ipErrFilter = new Document("ip.error", true);
        Document macdzErrFilter = new Document("macdz.error", true);
        Document latitudeErrFilter = new Document("latitude.error", true);
        Document longitudeErrFilter = new Document("longitude.error", true);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<Integer> rList = lists.stream().map(filter -> {
        List<Document> lists = Arrays.asList(totalFilter, newFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -769,12 +1526,25 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getDeviceDirectoryConsistent)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getDeviceDirectoryConsistent).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("list", resultList);
        map.put("list", resultVOS);
        return Result.ok().data(map).total(total);
    }

@@ -786,8 +1556,20 @@
     */
    @Override
    public Result vehicleCollectionConsistency(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "crossName");
        List<Criteria> andCriteria = MongoUtil.getAndCriteria(params, TIME_FIELD, likeFileds, null);
        Query query = new Query();
        Criteria and = new Criteria();
        and.andOperator(andCriteria);
        query = Query.query(and);
        if(params.getOption()!=null){
            if(params.getOption() ==1){
                query.addCriteria(Criteria.where("lalType").is(ApiConstants.HK_Info_LayType_Normal));
                query.addCriteria(Criteria.where("gbCodeType").is(ApiConstants.HK_Info_GbCodeType_Normal));
            }else if(params.getOption() !=-1){

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
            }
        }

        long total = mongoTemplate.count(query, CrossDetailResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
@@ -797,13 +1579,25 @@
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_cross_detail");

        Document ipErrFilter = new Document("lalType", 1);
        Document macdzErrFilter = new Document("lalType", 2);
        Document latitudeErrFilter = new Document("lalType", 3);
        Document longitudeErrFilter = new Document("lalType", 4);
        List<Document> dList1 = new ArrayList<>(2);
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("lalType", new Document("$eq", 1)));
        dList2.add(new Document("gbCodeType", new Document("$eq", 1)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        setTag(params, dList3);
        List<Document> errorConditions = new ArrayList<>();
        errorConditions.add(new Document("lalType",new Document("$eq",-1)));
        errorConditions.add(new Document("gbCodeType",new Document("$eq",-1)));
        Document errorDoc = new Document("$or",errorConditions);
        dList3.add(errorDoc);
        Document totalFilter = new Document("$and", dList1);
        Document correctFilter = new Document("$and", dList2);
        Document errorFilter = new Document("$and", dList3);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<Integer> rList = lists.stream().map(filter -> {
        List<Document> lists = Arrays.asList(totalFilter, correctFilter, errorFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
@@ -818,9 +1612,22 @@
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount;
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getVehicleInformationCollectionAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getVehicleInformationCollectionAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("list", resultList);
@@ -835,15 +1642,32 @@
     */
    @Override
    public Result vehicleCollectionDataIntegrity(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, DataIntegrityMonitoringResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<DataIntegrityMonitoringResult> resultList = mongoTemplate.find(query, DataIntegrityMonitoringResult.class);
        // 统计数

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_data_integrity_monitoring");

        Date now = new Date();
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getVehicleCaptureIntegrity)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getVehicleCaptureIntegrity).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }

        HashMap<String, Object> map = new HashMap<>();
        map.put("count", CollectionUtils.EMPTY_COLLECTION);
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -856,15 +1680,27 @@
     */
    @Override
    public Result vehicleCollectionDataCaptured(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, AttrRecognitionMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<AttrRecognitionMonitorResult> resultList = mongoTemplate.find(query, AttrRecognitionMonitorResult.class);
        // 统计数

        Date now = new Date();
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getVehicleCaptureAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getVehicleCaptureAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", CollectionUtils.EMPTY_COLLECTION);
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -877,18 +1713,65 @@
     */
    @Override
    public Result vehicleClockAccuracy(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, VehicleDeviceInspectionResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<VehicleDeviceInspectionResult> resultList = mongoTemplate.find(query, VehicleDeviceInspectionResult.class);
        // 统计数
        long one = mongoTemplate.count(new Query().addCriteria(Criteria.where("snapResult").is("1")), VehicleDeviceInspectionResult.class);
        long two = mongoTemplate.count(new Query().addCriteria(Criteria.where("snapResult").is("2")), VehicleDeviceInspectionResult.class);
        long four = mongoTemplate.count(new Query().addCriteria(Criteria.where("snapResult").is("4")), VehicleDeviceInspectionResult.class);


        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_vehicle_device_inspection");

        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("snapResult", new Document("$eq", 1)));
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("snapResult", new Document("$eq", 2)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("snapResult", new Document("$eq", 4)));
        setTag(params, dList3);
        Document ipErrFilter = new Document("$and", dList1);
        Document macdzErrFilter = new Document("$and", dList2);
        Document longitudeErrFilter = new Document("$and", dList3);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, longitudeErrFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
                    // $group 去重
                    new Document("$group", new Document("_id", "$externalIndexCode")),
                    new Document("$count", "uniqueDeviceIds")
            );
            // 执行聚合查询并获取结果
            AggregateIterable<Document> result = collection.aggregate(pipeline);
            Integer uniqueDeviceIdCount = 0;
            for (Document doc : result) {
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getVehicleTimingAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getVehicleTimingAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(one, two, four));
        map.put("count", rList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -901,15 +1784,28 @@
     */
    @Override
    public Result vehicleTimelyUploadAccuracy(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, SnapshotDelayMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<SnapshotDelayMonitorResult> resultList = mongoTemplate.find(query, SnapshotDelayMonitorResult.class);

        // 统计数
        Date now = new Date();
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getVehicleUploadTimeliness)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getVehicleUploadTimeliness).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", CollectionUtils.EMPTY_COLLECTION);
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -922,15 +1818,28 @@
     */
    @Override
    public Result vehicleUrlAccuracy(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, PicAccessResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<PicAccessResult> resultList = mongoTemplate.find(query, PicAccessResult.class);

        // 统计数
        Date now = new Date();
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getVehicleUrlAvailability)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getVehicleUrlAvailability).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", CollectionUtils.EMPTY_COLLECTION);
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -943,15 +1852,28 @@
     */
    @Override
    public Result vehicleBigImgAccuracy(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, new ArrayList<>());
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, VehicleDeviceSamplingResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<VehicleDeviceSamplingResult> resultList = mongoTemplate.find(query, VehicleDeviceSamplingResult.class);

        // 统计数
        Date now = new Date();
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getVehiclePictureAvailability)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getVehiclePictureAvailability).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", CollectionUtils.EMPTY_COLLECTION);
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -964,19 +1886,89 @@
     */
    @Override
    public Result faceViewDockStable(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);

        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        //加DataType为车辆
        query.addCriteria(Criteria.where("dataType").is(ApiConstants.HK_DataType_FACE));
        if(params.getOption()!=null){
            if(ApiConstants.HK_SnapCount_ResultType_Normal.equals(params.getOption())) {
                query.addCriteria(Criteria.where("resultType").is(ApiConstants.HK_SnapCount_ResultType_Normal));
            }else if(ApiConstants.HK_SnapCount_ResultType_Null.equals(params.getOption())){
                query.addCriteria(Criteria.where("resultType").is(ApiConstants.HK_SnapCount_ResultType_Null));
            }else if(ApiConstants.HK_SnapCount_ResultType_Descent.equals(params.getOption())){
                query.addCriteria(Criteria.where("resultType").is(ApiConstants.HK_SnapCount_ResultType_Descent));
            }else if(ApiConstants.HK_SnapCount_ResultType_Low.equals(params.getOption())){
                query.addCriteria(Criteria.where("resultType").is(ApiConstants.HK_SnapCount_ResultType_Low));
            }
        }
        long total = mongoTemplate.count(query, SnapshotDataMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<SnapshotDataMonitorResult> resultList = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
        // 统计数
        long one = mongoTemplate.count(new Query().addCriteria(Criteria.where("resultType").is("1")), SnapshotDataMonitorResult.class);
        long two = mongoTemplate.count(new Query().addCriteria(Criteria.where("resultType").is("2")), SnapshotDataMonitorResult.class);
        long three = mongoTemplate.count(new Query().addCriteria(Criteria.where("resultType").is("3")), SnapshotDataMonitorResult.class);
        long four = mongoTemplate.count(new Query().addCriteria(Criteria.where("resultType").is("4")), SnapshotDataMonitorResult.class);
        resultList.forEach(item ->item.setResultTypeText(item.getResultTypeText()));
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_snapshot_data_monitor");

        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("resultType", new Document("$eq", 1)));
        dList2.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("resultType", new Document("$eq", 2)));
        dList3.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList3);

        Document noDataFilter = new Document("$and", dList2);
        Document trFilter = new Document("$and", dList3);
        List<Document> lists = Arrays.asList(noDataFilter, trFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
                    // $group 去重
                    new Document("$group", new Document("_id", "$externalIndexCode")),
                    new Document("$count", "uniqueDeviceIds")
            );
            // 执行聚合查询并获取结果
            AggregateIterable<Document> result = collection.aggregate(pipeline);
            Integer uniqueDeviceIdCount = 0;
            for (Document doc : result) {
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());
        // 构建基本的$match条件
        List<Document> matchConditions = new ArrayList<>();
        setTag(params, matchConditions);
        matchConditions.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_FACE)));
        List<Document> pipeline = Arrays.asList(
                new Document("$match", new Document("$and", matchConditions)),
                new Document("$group", new Document("_id", "$mongoCreateTime")
                        .append("dataCount", new Document("$sum", "$dataCount"))
                ));
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        int dataCount = 0;
        for (Document doc : result) {
            dataCount = doc.getInteger("dataCount");
        }
        rList.add(0,dataCount+"");
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getViewConnectStability)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexFace::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexFace::getViewConnectStability).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(one, two, three, four));
        map.put("count", rList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -989,19 +1981,89 @@
     */
    @Override
    public Result facePointOnlineRate(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);

        long total = mongoTemplate.count(query, SnapshotDataMonitorResult.class);
        List<String> likeFileds = Arrays.asList("name", "no", "ip");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        //查人脸设备
        query.addCriteria(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Face + ".*"));
        //下拉框在线情况查询条件
        if (params.getOption() != null) {
            query.addCriteria(Criteria.where("online").is(params.getOption()));
        }
        // 通过pingOnline字段排序，为false的排在前面
        query.with(Sort.by(Sort.Order.asc("pingOnline")));
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<SnapshotDataMonitorResult> resultList = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
        // 统计数
        long one = mongoTemplate.count(new Query().addCriteria(Criteria.where("resultType").is("1")), SnapshotDataMonitorResult.class);
        long two = mongoTemplate.count(new Query().addCriteria(Criteria.where("resultType").is("2")), SnapshotDataMonitorResult.class);
        long three = mongoTemplate.count(new Query().addCriteria(Criteria.where("resultType").is("3")), SnapshotDataMonitorResult.class);
        long four = mongoTemplate.count(new Query().addCriteria(Criteria.where("resultType").is("4")), SnapshotDataMonitorResult.class);
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
        resultList.forEach(item -> {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
            } else if (-1 == item.getOnline()) {
                item.setOnlineStr("离线");
            } else {
                item.setOnlineStr("未知");
            }
        });
        params.setDeptTag(-1);
        params.setDeviceType(3);

// 统计设备数量
        //卡片统计
        int totalCount = 0;
        int onlineCount = 0;
        int offlineCount = 0;
        int unknownCount = 0;
        //构建条件
        List<Criteria> criteriaList = new ArrayList<>();
        // 添加固定条件
        criteriaList.add(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Face + ".*"));
        criteriaList.add(Criteria.where("mongoCreateTime").gte(params.getStartTime()).lte(params.getEndTime()));
        // 根据dataType动态添加条件
        if (params.getDataType() == 1) {
            criteriaList.add(Criteria.where("provinceTag").is(Boolean.TRUE));
        } else if (params.getDataType() == 2) {
            criteriaList.add(Criteria.where("deptTag").is(Boolean.TRUE));
        }
        // 构建match操作
        MatchOperation match = Aggregation.match(
                new Criteria().andOperator(criteriaList.toArray(new Criteria[0]))
        );
        GroupOperation group = Aggregation.group()
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Online)).then(1).otherwise(0)).as("onlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Offline)).then(1).otherwise(0)).as("offlineCount")
                .sum(ConditionalOperators.when(Criteria.where("online").is(ApiConstants.UY_OnlineSite_Unknown)).then(1).otherwise(0)).as("unknownCount");
        // 将匹配阶段和分组阶段组合起来
        Aggregation aggregation = Aggregation.newAggregation(match, group);
        // 执行聚合查询
        AggregationResults<Map> results = mongoTemplate.aggregate(aggregation, "t_monitor_online", Map.class); // 替换为你的集合名称
        for (Map<String, Object> result : results.getMappedResults()) {
            offlineCount = (Integer) result.getOrDefault("offlineCount", 0L);
            unknownCount = (Integer) result.getOrDefault("unknownCount", 0L);
            onlineCount = (Integer) result.getOrDefault("onlineCount", 0L);
            totalCount = offlineCount + unknownCount + onlineCount;
        }
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getSiteOnline)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexFace::getCreateTime, params.getStartTime(), params.getEndTime())
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexFace::getSiteOnline).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }

        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(one, two, three, four));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1014,21 +2076,80 @@
     */
    @Override
    public Result faceDirectoryConsistency(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "serialNumber.showValue", TIME_FIELD, null);

        List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
        List<Criteria> andCriteria = MongoUtil.getAndCriteria(params, TIME_FIELD, likeFileds, null);
        // 1/2/3 视频/车辆/人脸
        Pattern pattern = Pattern.compile(".*3.*");
        andCriteria.add(Criteria.where("sxjgnlx.value").regex(pattern));
        Query query = new Query();
        Criteria and = new Criteria();
        if(params.getOption()!=null){
            if(params.getOption() ==1){
                andCriteria.add(Criteria.where("newDevice").is(Boolean.TRUE));
            }else if(params.getOption() ==-1){
                andCriteria.add(Criteria.where("newDevice").is(Boolean.FALSE));
            }
        }
        and.andOperator(andCriteria);
        query = Query.query(and);
        long total = mongoTemplate.count(query, MonitorQualifyResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<MonitorQualifyResult> resultList = mongoTemplate.find(query, MonitorQualifyResult.class);
        // 统计数
        long nonNetwork = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("0")), MonitorQualifyResult.class);
        long network = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("1")), MonitorQualifyResult.class);
        long video = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".*1.*")), MonitorQualifyResult.class);
        long car = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".*2.*")), MonitorQualifyResult.class);
        long face = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".*3.*")), MonitorQualifyResult.class);
        List<MonitorQualifyResultVO> resultVOS = new ArrayList<>();
        for (MonitorQualifyResult result : resultList) {
            MonitorQualifyResultVO vo = MonitorQualifyResult.getVO(result);
            resultVOS.add(vo);
        }
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_monitor_qualify");
        //总数
        List<Document> dList1 = new ArrayList<>(2);
        setTag(params, dList1);
        dList1.add(new Document("sxjgnlx.value", new Document("$regex", ".*3.*")));
        Document totalFilter = new Document("$and",dList1);
        //新设备数
        List<Document> dList2 = new ArrayList<>(2);
        setTag(params, dList2);
        dList2.add(new Document("sxjgnlx.value", new Document("$regex", ".*3.*")));
        dList2.add(new Document("newDevice",Boolean.TRUE));
        Document newFilter = new Document("$and",dList2);

        List<Document> lists = Arrays.asList(totalFilter, newFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
                    // $group 去重
                    new Document("$group", new Document("_id", "$serialNumber.showValue")),
                    new Document("$count", "uniqueDeviceIds")
            );
            // 执行聚合查询并获取结果
            AggregateIterable<Document> result = collection.aggregate(pipeline);
            Integer uniqueDeviceIdCount = 0;
            for (Document doc : result) {
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getDeviceDirectoryConsistent)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .eq(params.getDataType().equals(2), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Dept)
                .between(CheckIndexFace::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexFace::getDeviceDirectoryConsistent).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(nonNetwork, network, video, car, face));
        map.put("list", resultList);
        map.put("count", rList);
        map.put("list", resultVOS);
        return Result.ok().data(map).total(total);
    }

@@ -1040,19 +2161,67 @@
     */
    @Override
    public Result faceCollectionConsistency(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "crossName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, CrossDetailResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<CrossDetailResult> resultList = mongoTemplate.find(query, CrossDetailResult.class);
        // 统计数
        long one = mongoTemplate.count(new Query().addCriteria(Criteria.where("lalType").is("1")), CrossDetailResult.class);
        long two = mongoTemplate.count(new Query().addCriteria(Criteria.where("lalType").is("2")), CrossDetailResult.class);
        long three = mongoTemplate.count(new Query().addCriteria(Criteria.where("lalType").is("3")), CrossDetailResult.class);
        long four = mongoTemplate.count(new Query().addCriteria(Criteria.where("lalType").is("4")), CrossDetailResult.class);

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_cross_detail");

        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("lalType", new Document("$eq", 1)));
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("lalType", new Document("$eq", 2)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("lalType", new Document("$eq", 3)));
        setTag(params, dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("lalType", new Document("$eq", 4)));
        setTag(params, dList4);
        Document ipErrFilter = new Document("$and", dList1);
        Document macdzErrFilter = new Document("$and", dList2);
        Document latitudeErrFilter = new Document("$and", dList3);
        Document longitudeErrFilter = new Document("$and", dList4);
        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
                    // $group 去重
                    new Document("$group", new Document("_id", "$externalIndexCode")),
                    new Document("$count", "uniqueDeviceIds")
            );
            // 执行聚合查询并获取结果
            AggregateIterable<Document> result = collection.aggregate(pipeline);
            Integer uniqueDeviceIdCount = 0;
            for (Document doc : result) {
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getFaceInformationCollectionAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexFace::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexFace::getFaceInformationCollectionAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(one, two, three, four));
        map.put("count", rList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1065,19 +2234,68 @@
     */
    @Override
    public Result faceImgQualification(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "cameraName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, MonitoringDetailResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<MonitoringDetailResult> resultList = mongoTemplate.find(query, MonitoringDetailResult.class);
        // 统计数
        long one = mongoTemplate.count(new Query().addCriteria(Criteria.where("lalType").is("1")), MonitoringDetailResult.class);
        long two = mongoTemplate.count(new Query().addCriteria(Criteria.where("lalType").is("2")), MonitoringDetailResult.class);
        long three = mongoTemplate.count(new Query().addCriteria(Criteria.where("lalType").is("3")), MonitoringDetailResult.class);
        long four = mongoTemplate.count(new Query().addCriteria(Criteria.where("lalType").is("4")), MonitoringDetailResult.class);

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_monitoring_detail");

        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("lalType", new Document("$eq", 1)));
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("lalType", new Document("$eq", 2)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("lalType", new Document("$eq", 3)));
        setTag(params, dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("lalType", new Document("$eq", 4)));
        setTag(params, dList4);
        Document ipErrFilter = new Document("$and", dList1);
        Document macdzErrFilter = new Document("$and", dList2);
        Document latitudeErrFilter = new Document("$and", dList3);
        Document longitudeErrFilter = new Document("$and", dList4);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
                    // $group 去重
                    new Document("$group", new Document("_id", "$externalIndexCode")),
                    new Document("$count", "uniqueDeviceIds")
            );
            // 执行聚合查询并获取结果
            AggregateIterable<Document> result = collection.aggregate(pipeline);
            Integer uniqueDeviceIdCount = 0;
            for (Document doc : result) {
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getFacePictureQualification)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexFace::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexFace::getFacePictureQualification).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(one, two, three, four));
        map.put("count", rList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1090,18 +2308,64 @@
     */
    @Override
    public Result faceCapturesImagesAccuracy(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, FaceDeviceInspectionResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<FaceDeviceInspectionResult> resultList = mongoTemplate.find(query, FaceDeviceInspectionResult.class);
        // 统计数
        long one = mongoTemplate.count(new Query().addCriteria(Criteria.where("snapResult").is("1")), FaceDeviceInspectionResult.class);
        long two = mongoTemplate.count(new Query().addCriteria(Criteria.where("snapResult").is("2")), FaceDeviceInspectionResult.class);
        long four = mongoTemplate.count(new Query().addCriteria(Criteria.where("snapResult").is("4")), FaceDeviceInspectionResult.class);

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_vehicle_device_inspection");

        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("snapResult", new Document("$eq", 1)));
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("snapResult", new Document("$eq", 2)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("snapResult", new Document("$eq", 4)));
        setTag(params, dList3);
        Document ipErrFilter = new Document("$and", dList1);
        Document macdzErrFilter = new Document("$and", dList2);
        Document longitudeErrFilter = new Document("$and", dList3);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, longitudeErrFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
                    // $group 去重
                    new Document("$group", new Document("_id", "$externalIndexCode")),
                    new Document("$count", "uniqueDeviceIds")
            );
            // 执行聚合查询并获取结果
            AggregateIterable<Document> result = collection.aggregate(pipeline);
            Integer uniqueDeviceIdCount = 0;
            for (Document doc : result) {
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getFaceTimingAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexFace::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexFace::getFaceTimingAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(one, two, four));
        map.put("count", rList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1114,18 +2378,64 @@
     */
    @Override
    public Result faceTimelyUpload(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, FaceDeviceInspectionResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<FaceDeviceInspectionResult> resultList = mongoTemplate.find(query, FaceDeviceInspectionResult.class);
        // 统计数
        long one = mongoTemplate.count(new Query().addCriteria(Criteria.where("snapResult").is("1")), FaceDeviceInspectionResult.class);
        long two = mongoTemplate.count(new Query().addCriteria(Criteria.where("snapResult").is("2")), FaceDeviceInspectionResult.class);
        long four = mongoTemplate.count(new Query().addCriteria(Criteria.where("snapResult").is("4")), FaceDeviceInspectionResult.class);

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_vehicle_device_inspection");

        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("snapResult", new Document("$eq", 1)));
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("snapResult", new Document("$eq", 2)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("snapResult", new Document("$eq", 4)));
        setTag(params, dList3);
        Document ipErrFilter = new Document("$and", dList1);
        Document macdzErrFilter = new Document("$and", dList2);
        Document longitudeErrFilter = new Document("$and", dList3);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, longitudeErrFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
                    new Document("$match", filter),
                    // $group 去重
                    new Document("$group", new Document("_id", "$externalIndexCode")),
                    new Document("$count", "uniqueDeviceIds")
            );
            // 执行聚合查询并获取结果
            AggregateIterable<Document> result = collection.aggregate(pipeline);
            Integer uniqueDeviceIdCount = 0;
            for (Document doc : result) {
                uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
                break; // 不需要继续遍历，因为 $count 只会产生一个结果
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getFaceUploadTimeliness)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexFace::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexFace::getFaceUploadTimeliness).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(one, two, four));
        map.put("count", rList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1138,18 +2448,33 @@
     */
    @Override
    public Result faceAvailabilityOfLargeImg(DataCenterQuery params) {

        Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, null);
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, FaceDeviceSamplingResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<FaceDeviceSamplingResult> resultList = mongoTemplate.find(query, FaceDeviceSamplingResult.class);

        // 统计数
        Date now = new Date();
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getFacePictureAvailability)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexFace::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexFace::getFacePictureAvailability).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }

        HashMap<String, Object> map = new HashMap<>();
        map.put("count", CollectionUtils.EMPTY_COLLECTION);
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }

    /**
     * 视频：视频图像资源安全管理
     *
@@ -1158,9 +2483,8 @@
     */
    @Override
    public Result videoImageResourceSecurity(DataCenterQuery query) {
        ImageResourceSecurityDetail imageResourceSecurityDetail = new ImageResourceSecurityDetail();
        Page<ImageResourceSecurityDetail> page = PageHelper.startPage(query.getPageNum(), query.getPageSize());
        securityDetailMapper.selectImageResourceSecurityDetailList(imageResourceSecurityDetail);
        securityDetailMapper.selectImageResourceSecurityDetailList(query);

        // 统计数
        HashMap<String, Object> map = new HashMap<>();
@@ -1169,4 +2493,33 @@
        return Result.ok().data(map).total(page.getTotal());

    }

    /**
     * 删除尾部的0
     *
     * @param rate
     * @return
     */
    private String remove0(BigDecimal rate) {
        DF.setDecimalSeparatorAlwaysShown(false);
        return DF.format(rate) + "%";
    }

    /**
     * 设置标签搜索条件
     *
     * @param params
     * @param dList
     */
    private void setTag(DataCenterQuery params, List<Document> dList) {
        if (params.getDataType().equals(1)) {
            dList.add(new Document("provinceTag", new Document("$eq", Boolean.TRUE)));
        } else if (params.getDataType().equals(2)) {
            dList.add(new Document("deptTag", new Document("$eq", Boolean.TRUE)));
        }
        Document mongoCreateTimeRange = new Document();
        if (params.getStartTime()!=null) mongoCreateTimeRange.append("$gte", params.getStartTime());
        if (params.getEndTime()!=null) mongoCreateTimeRange .append("$lt", params.getEndTime());
        dList.add(new Document("mongoCreateTime", mongoCreateTimeRange));
    }
}