修改大屏录像可用率指标,点位在线指标，数据中心录像可用率，

zxl

2025-05-29 71f61d13531b3e2a0099ba5afe3f268c99c5bacf

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

@@ -1,6 +1,7 @@
package com.ycl.platform.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
@@ -8,33 +9,48 @@
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.ycl.platform.domain.entity.*;
import com.ycl.platform.domain.form.UpdateDynamicValueForm;
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.PointDetailVO;
import com.ycl.platform.domain.vo.DataCenter.BigPicUsefulVO;
import com.ycl.platform.domain.vo.DataCenter.MonitorQualifyResultVO;
import com.ycl.platform.domain.vo.DataCenter.SnapClockVO;
import com.ycl.platform.domain.vo.DynamicColumnVO;
import com.ycl.platform.mapper.DynamicColumnMapper;
import com.ycl.platform.mapper.ImageResourceSecurityDetailMapper;
import com.ycl.platform.mapper.TMonitorMapper;
import com.ycl.platform.mapper.YwPointMapper;
import com.ycl.platform.service.*;
import com.ycl.system.Result;
import com.ycl.system.page.PageUtil;
import com.ycl.system.service.ISysConfigService;
import com.ycl.utils.DateUtils;
import com.ycl.utils.MongoUtil;
import constant.CheckConstants;
import com.ycl.utils.StringUtils;
import com.ycl.utils.bean.BeanUtils;
import com.ycl.utils.poi.ExcelUtil;
import constant.*;
import enumeration.general.AreaDeptEnum;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
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.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
@@ -45,19 +61,620 @@
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class DataCenterServiceImpl implements DataCenterService {

    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 DynamicColumnMapper dynamicColumnMapper;



    private final static String TIME_FIELD = "mongoCreateTime";

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



    public Map<String,List<DynamicColumnVO>> getDynamicByConditions(DataCenterQuery params,List<DynamicColumnVO> list){
        //获得到对应id，且包含传入字符串 动态列集合
        List<DynamicColumnVO> likeFieldDynamicColumnVOList = list.stream()
                .filter(dynamicColumnVO ->
                    dynamicColumnVO.getLabelId().equals(params.getDyId()) &&
                            dynamicColumnVO.getColumnValue().contains(params.getDyValue())
        ).collect(Collectors.toList());
        //获得满足条件的id集合
        List<String> ids = likeFieldDynamicColumnVOList.stream().map(DynamicColumnVO::getRefStringId).toList();
        Map<String,List<DynamicColumnVO>> groupByRefStringIdMap = list.stream().collect(Collectors.groupingBy(DynamicColumnVO::getRefStringId));
        Set<String> removeSet = new HashSet<>(ids);
        //移除掉不符合条件的key
        groupByRefStringIdMap.keySet().retainAll(removeSet);

        return groupByRefStringIdMap;
    }

    @Override
    public void recordingAvailabilityExport(HttpServletResponse response,DataCenterQuery params) throws IOException {

        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()));
        }
        MongoUtil.setNoPage(query, params, TIME_FIELD);
        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());
        });
        //获得动态列数据
        List<DynamicColumnVO> dynamicColumnVOList = dynamicColumnMapper.getDynamicColumnByTableName(TableNameConstants.COLUMN_NAME_VIDEO);

        //判断是否有查询条件
        boolean conditions = false;
        Map<String,List<DynamicColumnVO>> groupByRefStringIdMap = new HashMap<>();
        if (params.getDyId() != null && StringUtils.isNotEmpty(params.getDyValue())){
            conditions = true;
            //获得动态列集合中包含了的字符串值的集合 区分大小写
            groupByRefStringIdMap = getDynamicByConditions(params,dynamicColumnVOList);
        }else{
            groupByRefStringIdMap = dynamicColumnVOList.stream().collect(Collectors.groupingBy(DynamicColumnVO::getRefStringId));
        }
        //固定表头
        LinkedHashSet<String> headers = new LinkedHashSet<>();
        headers.add(RecordingAvailabilityHeaders.arealayername);
        headers.add(RecordingAvailabilityHeaders.arealayerno);
        headers.add(RecordingAvailabilityHeaders.createTime);
        headers.add(RecordingAvailabilityHeaders.deviceId);
        headers.add(RecordingAvailabilityHeaders.missDuration);
        headers.add(RecordingAvailabilityHeaders.platId);
        headers.add(RecordingAvailabilityHeaders.recordDuration);
        headers.add(RecordingAvailabilityHeaders.recordStatusText);
        headers.add(RecordingAvailabilityHeaders.statTime);

        List<String> headersList = new LinkedList<>();
        List<String> dynamicsHeaders = dynamicColumnMapper.getHeader(TableNameConstants.COLUMN_NAME_VIDEO);

        //添加动态表头
        if (!org.springframework.util.CollectionUtils.isEmpty(dynamicsHeaders)) {
            //使用链表保证后续补充数据时获取数据顺序一致
            headersList.addAll(dynamicsHeaders);
            headers.addAll(headersList);
        }
//        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        //查询到有动态列查询条件
        //获得对应动态列中ref的对象id 与 查询结果id过滤
        if (conditions){
            Map<String, List<DynamicColumnVO>> finalGroupByRefStringIdMap = groupByRefStringIdMap;
            resultList = resultList.stream()
                    .filter(obj -> finalGroupByRefStringIdMap.containsKey(obj.getId()))
                    .collect(Collectors.toList());
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        List<List<Object>> data = new ArrayList<>();
        for (RecordMetaDSumResult result : resultList){
            List<Object> row = new ArrayList<>();
            row.add(result.getArealayername());
            row.add(result.getArealayerno());
            row.add(dateFormat.format(result.getCreateTime()));
            row.add(result.getDeviceId());
            row.add(result.getMissDuration());
            row.add(result.getPlatId());
            row.add(result.getRecordDuration());
            row.add(result.getRecordStatusText());
            row.add(dateFormat.format(result.getCreateTime()));
            //添加动态列数据
            for (String header : headersList){
                boolean flag = false;
                List<DynamicColumnVO> columnVOS = groupByRefStringIdMap.get(result.getId());
                if (!CollectionUtils.isEmpty(columnVOS)) {
                    for (DynamicColumnVO columnVO : columnVOS) {
                        if (header.equals(columnVO.getLabelValue())) {
                            row.add(columnVO.getColumnValue());
                            flag = true;
                        }
                    }
                }
                //没找到用空串占位
                if (!flag) row.add("");
            }
            data.add(row);
        }
        List<List<String>> headList = new ArrayList<>();
        for (String header : headers) {
            headList.add(Collections.singletonList(header));
        }
        EasyExcel.write(response.getOutputStream())
                .head(headList) // 设置表头
                .sheet("录像可用率") // 设置sheet名称
                .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy())
                .doWrite(data); // 写入数据
    }

    @Override
    public void pointOnlineFaceExport(HttpServletResponse response, DataCenterQuery params) throws IOException {
        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()));
        }
        Sort sort = Sort.by(
                Sort.Order.asc("pingOnline"), // 首先按照 pingOnline 升序排序
                Sort.Order.desc("offLineCount") // 首先按照 pingOnline 升序排序
        );
        // 通过pingOnline字段排序，为false的排在前面
        query.with(sort);
        MongoUtil.setNoPage(query, params, TIME_FIELD);
        //分页数量
        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("未知");
            }
            List<String> offLineTime = item.getOffLineTimeStr();
            if (!CollectionUtils.isEmpty(offLineTime)) {
                //后续可以改成配置的离线次数(提取前n次，n为配置的离线次数)
                if (offLineTime.size() > 1) {
                    offLineTime = offLineTime.subList(0, 2);
                }
                item.setOffLineTimeStr(offLineTime);
            }
        });



        List<DynamicColumnVO> dynamicColumnVOList = dynamicColumnMapper.getDynamicColumnByTableName(TableNameConstants.COLUMN_NAME_FACE_POINT);


        //判断是否有查询条件
        boolean conditions = false;
        Map<String,List<DynamicColumnVO>> groupByRefStringIdMap = new HashMap<>();
        if (params.getDyId() != null && StringUtils.isNotEmpty(params.getDyValue())){
            conditions = true;
            //获得动态列集合中包含了的字符串值的集合 区分大小写
            groupByRefStringIdMap = getDynamicByConditions(params,dynamicColumnVOList);
        }else{
            groupByRefStringIdMap = dynamicColumnVOList.stream().collect(Collectors.groupingBy(DynamicColumnVO::getRefStringId));
        }

        //固定表头
        LinkedHashSet<String> headers = new LinkedHashSet<>();
        headers.add(PointOnlineHeaders.no);
        headers.add(PointOnlineHeaders.name);
        headers.add(PointOnlineHeaders.ip);
        headers.add(PointOnlineHeaders.onlineStr);
        headers.add(PointOnlineHeaders.pingOnlineStr);
        headers.add(PointOnlineHeaders.checkCount);
        headers.add(PointOnlineHeaders.offLineCount);
        headers.add(PointOnlineHeaders.offLineTimeStr);
        headers.add(PointOnlineHeaders.mongoCreateTime);

        List<String> headersList = new LinkedList<>();
        List<String> dynamicsHeaders = dynamicColumnMapper.getHeader(TableNameConstants.COLUMN_NAME_FACE_POINT);

        //添加动态表头
        if (!org.springframework.util.CollectionUtils.isEmpty(dynamicsHeaders)) {
            //使用链表保证后续补充数据时获取数据顺序一致
            headersList.addAll(dynamicsHeaders);
            headers.addAll(headersList);
        }

        if (conditions){
            Map<String, List<DynamicColumnVO>> finalGroupByRefStringIdMap = groupByRefStringIdMap;
            resultList = resultList.stream()
                    .filter(obj -> finalGroupByRefStringIdMap.containsKey(obj.getNo()))
                    .collect(Collectors.toList());
        }

        List<List<Object>> data = new ArrayList<>();
        for (TMonitorResult result : resultList){
            List<Object> row = new ArrayList<>();
            row.add(result.getNo());
            row.add(result.getName());
            row.add(result.getIp());
            row.add(result.getOnlineStr());
            row.add(result.getPingOnlineStr());
            row.add(result.getCheckCount());
            row.add(result.getOffLineCount());
            if (CollectionUtils.isEmpty(result.getOffLineTimeStr())){
                row.add(null);
            }else {
                row.add(result.getOffLineTimeStr().toString());
            }
            row.add(result.getMongoCreateTime());
            //添加动态列数据
            for (String header : headersList){
                boolean flag = false;
                List<DynamicColumnVO> columnVOS = groupByRefStringIdMap.get(result.getNo());
                if (!CollectionUtils.isEmpty(columnVOS)) {
                    for (DynamicColumnVO columnVO : columnVOS) {
                        if (header.equals(columnVO.getLabelValue())) {
                            row.add(columnVO.getColumnValue());
                            flag = true;
                        }
                    }
                }
                //没找到用空串占位
                if (!flag) row.add("");
            }
            data.add(row);
        }

        List<List<String>> headList = new ArrayList<>();
        for (String header : headers) {
            headList.add(Collections.singletonList(header));
        }

        EasyExcel.write(response.getOutputStream())
                .head(headList) // 设置表头
                .sheet("人脸点位在线率") // 设置sheet名称
                .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy())
                .doWrite(data); // 写入数据
    }

    @Override
    public void pointOnlineVideoExport(HttpServletResponse response, DataCenterQuery params) throws IOException {
        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()));
        }
        Sort sort = Sort.by(
                Sort.Order.asc("pingOnline"), // 首先按照 pingOnline 升序排序
                Sort.Order.desc("offLineCount") // 首先按照 pingOnline 升序排序
        );
        // 通过pingOnline字段排序，为false的排在前面
        query.with(sort);
        MongoUtil.setNoPage(query, params, TIME_FIELD);
        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("未知");
            }
            List<String> offLineTime = item.getOffLineTimeStr();
            if (!CollectionUtils.isEmpty(offLineTime)) {
                if (offLineTime.size() > 1) {
                    offLineTime = offLineTime.subList(offLineTime.size() - 2, offLineTime.size());
                }
                item.setOffLineTimeStr(offLineTime);
            }
        });
        List<DynamicColumnVO> dynamicColumnVOList = dynamicColumnMapper.getDynamicColumnByTableName(TableNameConstants.COLUMN_NAME_VIDEO_POINT);
        //判断是否有查询条件
        boolean conditions = false;
        Map<String,List<DynamicColumnVO>> groupByRefStringIdMap = new HashMap<>();
        if (params.getDyId() != null && StringUtils.isNotEmpty(params.getDyValue())){
            conditions = true;
            //获得动态列集合中包含了的字符串值的集合 区分大小写
            groupByRefStringIdMap = getDynamicByConditions(params,dynamicColumnVOList);
        }else{
            groupByRefStringIdMap = dynamicColumnVOList.stream().collect(Collectors.groupingBy(DynamicColumnVO::getRefStringId));
        }
        //固定表头
        LinkedHashSet<String> headers = new LinkedHashSet<>();
        headers.add(PointOnlineHeaders.no);
        headers.add(PointOnlineHeaders.name);
        headers.add(PointOnlineHeaders.ip);
        headers.add(PointOnlineHeaders.onlineStr);
        headers.add(PointOnlineHeaders.pingOnlineStr);
        headers.add(PointOnlineHeaders.checkCount);
        headers.add(PointOnlineHeaders.offLineCount);
        headers.add(PointOnlineHeaders.offLineTimeStr);
        headers.add(PointOnlineHeaders.mongoCreateTime);

        List<String> headersList = new LinkedList<>();
        List<String> dynamicsHeaders = dynamicColumnMapper.getHeader(TableNameConstants.COLUMN_NAME_VIDEO_POINT);

        //添加动态表头
        if (!org.springframework.util.CollectionUtils.isEmpty(dynamicsHeaders)) {
            //使用链表保证后续补充数据时获取数据顺序一致
            headersList.addAll(dynamicsHeaders);
            headers.addAll(headersList);
        }


        if (conditions){
            Map<String, List<DynamicColumnVO>> finalGroupByRefStringIdMap = groupByRefStringIdMap;
            resultList = resultList.stream()
                    .filter(obj -> finalGroupByRefStringIdMap.containsKey(obj.getNo()))
                    .collect(Collectors.toList());
        }

        List<List<Object>> data = new ArrayList<>();
        for (TMonitorResult result : resultList){
            List<Object> row = new ArrayList<>();
            row.add(result.getNo());
            row.add(result.getName());
            row.add(result.getIp());
            row.add(result.getOnlineStr());
            row.add(result.getPingOnlineStr());
            row.add(result.getCheckCount());
            row.add(result.getOffLineCount());
            if (CollectionUtils.isEmpty(result.getOffLineTimeStr())){
                row.add(null);
            }else {
                row.add(result.getOffLineTimeStr().toString());
            }
            row.add(result.getMongoCreateTime());
            //添加动态列数据
            for (String header : headersList){
                boolean flag = false;
                List<DynamicColumnVO> columnVOS = groupByRefStringIdMap.get(result.getNo());
                if (!CollectionUtils.isEmpty(columnVOS)) {
                    for (DynamicColumnVO columnVO : columnVOS) {
                        if (header.equals(columnVO.getLabelValue())) {
                            row.add(columnVO.getColumnValue());
                            flag = true;
                        }
                    }
                }
                //没找到用空串占位
                if (!flag) row.add("");
            }
            data.add(row);
        }

        List<List<String>> headList = new ArrayList<>();
        for (String header : headers) {
            headList.add(Collections.singletonList(header));
        }

        EasyExcel.write(response.getOutputStream())
                .head(headList) // 设置表头
                .sheet("视频点位在线率") // 设置sheet名称
                .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy())
                .doWrite(data); // 写入数据


    }

    @Override
    public void pointOnlineCarExport(HttpServletResponse response, DataCenterQuery params) throws IOException {
        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()));
        }
        Sort sort = Sort.by(
                Sort.Order.asc("pingOnline"), // 首先按照 pingOnline 升序排序
                Sort.Order.desc("offLineCount") // 首先按照 pingOnline 升序排序
        );
        // 通过pingOnline字段排序，为false的排在前面
        query.with(sort);
        //分页数量
        //系统ping的结果
        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("未知");
            }
            List<String> offLineTime = item.getOffLineTimeStr();
            if (!CollectionUtils.isEmpty(offLineTime)) {
                //后续可以改成配置的离线次数(提取前n次，n为配置的离线次数)
                if (offLineTime.size() > 1) {
                    offLineTime = offLineTime.subList(0, 2);
                }
                item.setOffLineTimeStr(offLineTime);
            }
        });
        List<DynamicColumnVO> dynamicColumnVOList = dynamicColumnMapper.getDynamicColumnByTableName(TableNameConstants.COLUMN_NAME_CAR_POINT);
        //判断是否有查询条件
        boolean conditions = false;
        Map<String,List<DynamicColumnVO>> groupByRefStringIdMap = new HashMap<>();
        if (params.getDyId() != null && StringUtils.isNotEmpty(params.getDyValue())){
            conditions = true;
            //获得动态列集合中包含了的字符串值的集合 区分大小写
            groupByRefStringIdMap = getDynamicByConditions(params,dynamicColumnVOList);
        }else{
            groupByRefStringIdMap = dynamicColumnVOList.stream().collect(Collectors.groupingBy(DynamicColumnVO::getRefStringId));
        }
        //固定表头
        LinkedHashSet<String> headers = new LinkedHashSet<>();
        headers.add(PointOnlineHeaders.no);
        headers.add(PointOnlineHeaders.name);
        headers.add(PointOnlineHeaders.ip);
        headers.add(PointOnlineHeaders.onlineStr);
        headers.add(PointOnlineHeaders.pingOnlineStr);
        headers.add(PointOnlineHeaders.checkCount);
        headers.add(PointOnlineHeaders.offLineCount);
        headers.add(PointOnlineHeaders.offLineTimeStr);
        headers.add(PointOnlineHeaders.mongoCreateTime);

        List<String> headersList = new LinkedList<>();
        List<String> dynamicsHeaders = dynamicColumnMapper.getHeader(TableNameConstants.COLUMN_NAME_CAR_POINT);

        //添加动态表头
        if (!org.springframework.util.CollectionUtils.isEmpty(dynamicsHeaders)) {
            //使用链表保证后续补充数据时获取数据顺序一致
            headersList.addAll(dynamicsHeaders);
            headers.addAll(headersList);
        }


        if (conditions){
            Map<String, List<DynamicColumnVO>> finalGroupByRefStringIdMap = groupByRefStringIdMap;
            resultList = resultList.stream()
                    .filter(obj -> finalGroupByRefStringIdMap.containsKey(obj.getNo()))
                    .collect(Collectors.toList());
        }

        List<List<Object>> data = new ArrayList<>();
        for (TMonitorResult result : resultList){
            List<Object> row = new ArrayList<>();
            row.add(result.getNo());
            row.add(result.getName());
            row.add(result.getIp());
            row.add(result.getOnlineStr());
            row.add(result.getPingOnlineStr());
            row.add(result.getCheckCount());
            row.add(result.getOffLineCount());
            if (CollectionUtils.isEmpty(result.getOffLineTimeStr())){
                row.add(null);
            }else {
                row.add(result.getOffLineTimeStr().toString());
            }
            row.add(result.getMongoCreateTime());
            //添加动态列数据
            for (String header : headersList){
                boolean flag = false;
                List<DynamicColumnVO> columnVOS = groupByRefStringIdMap.get(result.getNo());
                if (!CollectionUtils.isEmpty(columnVOS)) {
                    for (DynamicColumnVO columnVO : columnVOS) {
                        if (header.equals(columnVO.getLabelValue())) {
                            row.add(columnVO.getColumnValue());
                            flag = true;
                        }
                    }
                }
                //没找到用空串占位
                if (!flag) row.add("");
            }
            data.add(row);
        }

        List<List<String>> headList = new ArrayList<>();
        for (String header : headers) {
            headList.add(Collections.singletonList(header));
        }

        EasyExcel.write(response.getOutputStream())
                .head(headList) // 设置表头
                .sheet("车辆点位在线率") // 设置sheet名称
                .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy())
                .doWrite(data); // 写入数据
    }

    @Override
    public Result updateDynamicValue(UpdateDynamicValueForm form) {
        List<DynamicColumnVO> list = form.getDynamicColumnVOList();

        if (CollectionUtils.isEmpty(list) || StringUtils.isEmpty(form.getId())) {
            throw new RuntimeException("修改自定义列的传入值为null或传入id为null");
        }
        List<DynamicColumnValue> updateList = new ArrayList<>();
        List<DynamicColumnValue> addList = new ArrayList<>();

        for (DynamicColumnVO dynamicColumnVO : list){
            if(dynamicColumnVO.getColumnValue() == null){
                continue;
            }
            DynamicColumnValue dynamicColumnValue = new DynamicColumnValue();
            dynamicColumnValue.setColumnValue(dynamicColumnVO.getColumnValue());
            dynamicColumnValue.setDynamicColumnId(dynamicColumnVO.getId());
            dynamicColumnValue.setRefStringId(form.getId());
            dynamicColumnValue.setRefId(0);
            if(dynamicColumnVO.getValueId() == null){
                addList.add(dynamicColumnValue);
            }else {
                dynamicColumnValue.setId(dynamicColumnVO.getValueId());
                updateList.add(dynamicColumnValue);
            }
        }
        log.error("addList:{}",addList);
        log.error("updateList:{}",updateList);
        if (CollectionUtils.isNotEmpty(addList)){
            dynamicColumnMapper.saveBatch(addList);
        }
        if (CollectionUtils.isNotEmpty(updateList)) {
            dynamicColumnMapper.updateBatch(updateList);
        }
        return Result.ok("修改成功");



    }

    //zxl
    @Override
    public BigDecimal videoPointOnlineRateCount(DataCenterQuery params){
        //卡片统计
        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;
        }
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (totalCount!=0) {
            onlineRate = new BigDecimal(onlineCount).divide(new BigDecimal(totalCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        return onlineRate;
    }

    /**
     * 视频：点位在线率
@@ -69,42 +686,108 @@
    public Result videoPointOnlineRate(DataCenterQuery params) {
        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()));
        }
        Sort sort = Sort.by(
                Sort.Order.asc("pingOnline"), // 首先按照 pingOnline 升序排序
                Sort.Order.desc("offLineCount") // 首先按照 pingOnline 升序排序
        );
        // 通过pingOnline字段排序，为false的排在前面
        query.with(sort);
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);

        resultList.forEach(item -> {
            if (null != item.getPingOnline() && item.getPingOnline()) {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else {
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if(1== item.getOnline() ){
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
            }else if(-1==item.getOnline()){
            } else if (-1 == item.getOnline()) {
                item.setOnlineStr("离线");
            }else {
            } else {
                item.setOnlineStr("未知");
            }
            List<String> offLineTime = item.getOffLineTimeStr();
            if (!CollectionUtils.isEmpty(offLineTime)) {
                if (offLineTime.size() > 1) {
                    offLineTime = offLineTime.subList(offLineTime.size() - 2, offLineTime.size());
                }
                item.setOffLineTimeStr(offLineTime);
            }
            //添加动态数据
            List<DynamicColumnVO> list = dynamicColumnMapper.getDynamicColumnByTable(TableNameConstants.COLUMN_NAME_VIDEO_POINT,item.getNo());
            item.setDynamicColumnList(list);
        });


        params.setDeptTag(-1);
        params.setDeviceType(1);
        // 统计设备数量
        Integer distinctCount = pointMapper.distinctCount(params);

        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getSiteOnline)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .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));
        //卡片统计
        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;
        }
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (totalCount!=0) {
            onlineRate = new BigDecimal(onlineCount).divide(new BigDecimal(totalCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
//        /** 查询当天在线率 */
//        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 + "", this.remove0(onlineRate)));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -119,14 +802,25 @@
    public Result deptVideoPointOnlineRate(DataCenterQuery params) {
        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<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
        resultList.forEach(item -> {
            if (null != item.getPingOnline() && item.getPingOnline()) {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else {
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
@@ -138,24 +832,61 @@
            }
        });
        // 统计设备数量
        params.setDeptTag(1);
        params.setDeviceType(1);
        Integer distinctCount = pointMapper.distinctCount(params);

        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getMinistrySiteOnline)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .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));
        //卡片统计
        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()));
        criteriaList.add(Criteria.where("deptTag").is(Boolean.TRUE));
        // 根据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;
        }
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (totalCount!=0) {
            onlineRate = new BigDecimal(onlineCount).divide(new BigDecimal(totalCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
//        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(distinctCount + "", this.remove0(onlineRate)));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -170,18 +901,27 @@
    public Result videoImportantPointOnlineRate(DataCenterQuery params) {
        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);
        // 统计设备数量
        Integer distinctCount = pointMapper.distinctCount(params);
        resultList.forEach(item -> {
            if (null != item.getPingOnline() && item.getPingOnline()) {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else {
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
@@ -192,20 +932,61 @@
                item.setOnlineStr("未知");
            }
        });
        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeySiteOnline)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .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));

        // 统计设备数量
        //卡片统计
        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()));
        criteriaList.add(Criteria.where("importantTag").is(Boolean.TRUE));
        // 根据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;
        }
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (totalCount!=0) {
            onlineRate = new BigDecimal(onlineCount).divide(new BigDecimal(totalCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
//        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(distinctCount + "", this.remove0(onlineRate)));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -220,6 +1001,15 @@
    public Result videoImportantPointImageOnlineRate(DataCenterQuery params) {
        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);
@@ -227,12 +1017,12 @@

        params.setDeptTag(4);
        params.setDeviceType(1);
        // 统计设备数量
        Integer distinctCount = pointMapper.distinctCount(params);
        resultList.forEach(item -> {
            if (null != item.getPingOnline() && item.getPingOnline()) {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else {
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
@@ -243,20 +1033,61 @@
                item.setOnlineStr("未知");
            }
        });
        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeyCommandImageOnline)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .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));

        // 统计设备数量
        //卡片统计
        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()));
        criteriaList.add(Criteria.where("importantCommandImageTag").is(Boolean.TRUE));
        // 根据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;
        }
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (totalCount!=0) {
            onlineRate = new BigDecimal(onlineCount).divide(new BigDecimal(totalCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
//        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(distinctCount + "", this.remove0(onlineRate)));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -270,34 +1101,40 @@
    @Override
    public Result videoOneMachineDocumentRegister(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        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);
        dList1.add(new Document("ip.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList1);
        Document totalFilter = new Document("$and", dList1);
        //新设备数
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("macdz.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("latitude.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("longitude.error", new Document("$eq", Boolean.TRUE)));
        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);
        dList2.add(new Document("newDevice", Boolean.TRUE));
        Document newFilter = new Document("$and", dList2);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<Document> lists = Arrays.asList(totalFilter, newFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -316,22 +1153,26 @@
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getMonitorRegistration)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .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));
//        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));
//        }
        BigDecimal rate = BigDecimal.ZERO;
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            rate = new BigDecimal(rList.get(0)).subtract(new BigDecimal(rList.get(1))).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        rList.add(this.remove0(onlineRate));
        rList.add(this.remove0(rate));
        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);
    }

@@ -344,34 +1185,99 @@
    @Override
    public Result videoOneMachineDocumentQualified(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        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);
        dList1.add(new Document("ip.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList1);
        Document totalFilter = new Document("$and", dList1);
        //合格数
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("macdz.error", new Document("$eq", Boolean.TRUE)));
        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);
        dList3.add(new Document("latitude.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("longitude.error", new Document("$eq", Boolean.TRUE)));
        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> 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);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<Document> lists = Arrays.asList(totalFilter, qualifyFilter, unQualifyFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -389,63 +1295,70 @@
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getMonitorQualification)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .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));
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(1)).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
//        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) {
        List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        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);
        dList1.add(new Document("ip.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList1);
        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);
        dList2.add(new Document("macdz.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("latitude.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("longitude.error", new Document("$eq", Boolean.TRUE)));
        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);
        Document newFilter = new Document("$and", dList2);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
        List<Document> lists = Arrays.asList(totalFilter, newFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -463,36 +1376,61 @@
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        rList.add("0%");
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(1)).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
//        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);
    }

    /**
     * 视频：录像可用率
     *
     * @param params
     * @return
     */
    private final ISysConfigService configService;

    public double getSySMinTime(){
        //获取系统参数
        String dictLabel =  configService.selectConfigByKey("recording_min_time");
        double recordingMinTime;
        try {
            recordingMinTime = Double.parseDouble(dictLabel) / 60; // 如果 dictLabel 是以小时为单位，则无需除以 60
        } catch (Exception e) {
            log.error("配置的删除时间范围格式不正确: {}", dictLabel, e);
            return  12.0; // 默认 12 小时（以小时为单位）
        }

        return recordingMinTime;
    }
    private final TMonitorMapper tMonitorMapper;

    //zxl
    @Override
    public Result videoAvailabilityRate(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
        Query query = MongoUtil.getQuery(params, "createTime", likeFileds, null);

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

    public BigDecimal videoAvailabilityRateCount(DataCenterQuery params){
        System.out.println("------------------------------------------------------------------------------------");
        System.out.println(params);
        // 统计数量
        List<String> noString = tMonitorMapper.getIdListVideo();
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
        List<Integer> status = Arrays.asList(1, 0, -1);
        List<String> resultCount = status.stream().map(item -> {
            List<Document> dList = new ArrayList<>(2);

            dList.add(new Document("recordStatus", new Document("$eq", item)));
            dList.add(new Document("no", new Document("$in", noString)));
            setTag(params, dList);
            Document filter = new Document("$and", dList);
            // 构建聚合管道
@@ -512,19 +1450,162 @@
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getVideoAvailable)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        //计算录像可用率
        MongoDatabase databaes2 = mongoTemplate.getDb();
        MongoCollection<Document> collection2 = databaes2.getCollection("uy_record_meta_d_sum");

        double finalRecordingMinTime = getSySMinTime();

        List<Document> documentList = new ArrayList<>(2);
        documentList.add(new Document("no", new Document("$in", noString)));
        setTag(params, documentList);
        Document recording = new Document("missDuration",new Document("$lte", finalRecordingMinTime));
        documentList.add(recording);

        Document filter = new Document("$and", documentList);
        // 构建聚合管道
        List<Document> pipeline = Arrays.asList(
                new Document("$match", filter),
                // $group 去重
                new Document("$group", new Document("_id", "$deviceId")),
                new Document("$count", "uniqueDeviceIds")
        );
        AggregateIterable<Document> result = collection2.aggregate(pipeline);


        Integer uniqueDeviceIdCount = 0;
        for (Document doc : result) {
            uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
            break; // 不需要继续遍历，因为 $count 只会产生一个结果
        }
        int totalCount = 0;
        for (String s : resultCount) {
            totalCount += Integer.parseInt(s);
        }
        resultCount.add(0, totalCount + "");

        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));
//        1：完整 0：间歇 -1：异常 |
        if (!StringUtils.isEmpty(resultCount.get(0)) && !"0".equals(resultCount.get(0))) {
            //resultCount.get(0)是总数 uniqueDeviceIdCount是更具系统参数查询到mongodb中大于等于 recordDuration字段的总数
            onlineRate = new BigDecimal(uniqueDeviceIdCount).divide(new BigDecimal(resultCount.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        System.out.println(resultCount);
        System.out.println(onlineRate);
        return onlineRate;
    }




    /**
     * 视频：录像可用率
     *
     * @param params
     * @return
     */
    @Override
    public Result videoAvailabilityRate(DataCenterQuery params) {
        List<String> noString = tMonitorMapper.getIdListVideo();

        List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
        Query query = MongoUtil.getQuery(params, "createTime", likeFileds, null);
        if (CollectionUtils.isNotEmpty(noString)) { // 防止空集合异常
            query.addCriteria(Criteria.where("no").in(noString));
        }
        //下拉框录像情况查询条件
        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);
        //查询动态列数据
        //查询动态列数据更具id查询
//        List<DynamicColumnVO> dynamicColumnNames = dynamicColumnMapper.getDynamicColumnByTableName("uy_record_meta_d_sum");
        //翻译行政区域
        resultList.forEach(item -> {
            String areaCode = item.getArealayername().substring(0, 6);
            AreaDeptEnum areaDeptEnum = AreaDeptEnum.fromCode(areaCode);
            if (areaDeptEnum != null) item.setArealayername(areaDeptEnum.getName());

            List<DynamicColumnVO> list = dynamicColumnMapper.getDynamicColumnByTable(TableNameConstants.COLUMN_NAME_VIDEO,item.getId());
            item.setDynamicColumnList(list);

        });
        // 统计数量

        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
        List<Integer> status = Arrays.asList(1, 0, -1);
        List<String> resultCount = status.stream().map(item -> {
            List<Document> dList = new ArrayList<>(2);

            dList.add(new Document("recordStatus", new Document("$eq", item)));
            dList.add(new Document("no", new Document("$in", noString)));
            setTag(params, dList);
            Document filter = new Document("$and", dList);
            // 构建聚合管道
            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 只会产生一个结果
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        //计算录像可用率
        MongoDatabase databaes2 = mongoTemplate.getDb();
        MongoCollection<Document> collection2 = databaes2.getCollection("uy_record_meta_d_sum");

        double finalRecordingMinTime = getSySMinTime();

        List<Document> documentList = new ArrayList<>(2);
        documentList.add(new Document("no", new Document("$in", noString)));
        setTag(params, documentList);
        Document recording = new Document("missDuration",new Document("$lte", finalRecordingMinTime));
        documentList.add(recording);

        Document filter = new Document("$and", documentList);
        // 构建聚合管道
        List<Document> pipeline = Arrays.asList(
                new Document("$match", filter),
                // $group 去重
                new Document("$group", new Document("_id", "$deviceId")),
                new Document("$count", "uniqueDeviceIds")
        );
        AggregateIterable<Document> result = collection2.aggregate(pipeline);


        Integer uniqueDeviceIdCount = 0;
        for (Document doc : result) {
            uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
            break; // 不需要继续遍历，因为 $count 只会产生一个结果
        }
        log.error("录像可用率打印：{}",uniqueDeviceIdCount);
        int totalCount = 0;
        for (String s : resultCount) {
            totalCount += Integer.parseInt(s);
        }
        resultCount.add(0, totalCount + "");

        BigDecimal onlineRate = BigDecimal.ZERO;
//        1：完整 0：间歇 -1：异常 |
        if (!StringUtils.isEmpty(resultCount.get(0)) && !"0".equals(resultCount.get(0))) {
            //resultCount.get(0)是总数 uniqueDeviceIdCount是更具系统参数查询到mongodb中大于等于 recordDuration字段的总数
            onlineRate = new BigDecimal(uniqueDeviceIdCount).divide(new BigDecimal(resultCount.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        resultCount.add(this.remove0(onlineRate));

        HashMap<String, Object> map = new HashMap<>();
        map.put("count", resultCount);
        map.put("list", resultList);
@@ -541,11 +1622,19 @@
    public Result deptVideoAvailabilityRate(DataCenterQuery params) {
        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");
@@ -573,17 +1662,56 @@
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getMinistryVideoAvailable)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();

        //计算部级录像可用率
        MongoDatabase database2 = mongoTemplate.getDb();
        MongoCollection<Document> collection2 = database2.getCollection("uy_record_meta_d_sum");
        double finalRecordingMinTime = getSySMinTime();

        List<Document> documentList = new ArrayList<>(4);
        documentList.add(new Document("deptTag", new Document("$eq", Boolean.TRUE)));
        setTag(params, documentList);
        Document recording = new Document("missDuration",new Document("$lte", finalRecordingMinTime));
        documentList.add(recording);
        Document filter = new Document("$and", documentList);
        // 构建聚合管道
        List<Document> pipeline = Arrays.asList(
                new Document("$match", filter),
                // $group 去重
                new Document("$group", new Document("_id", "$deviceId")),
                new Document("$count", "uniqueDeviceIds")
        );
        AggregateIterable<Document> result = collection2.aggregate(pipeline);
        Integer uniqueDeviceIdCount = 0;
        for (Document doc : result) {
            uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
            break; // 不需要继续遍历，因为 $count 只会产生一个结果
        }
        log.error("部级录像可用率{}:",uniqueDeviceIdCount);



//        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 + "");
        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));
        if (!StringUtils.isEmpty(resultCount.get(0)) && !"0".equals(resultCount.get(0))) {
            onlineRate = new BigDecimal(uniqueDeviceIdCount).divide(new BigDecimal(resultCount.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        resultCount.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
@@ -602,11 +1730,19 @@
    public Result videoImportantPointAvailabilityRate(DataCenterQuery params) {
        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");
@@ -634,17 +1770,53 @@
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeyVideoAvailable)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        //计算重点点位录像可用率
        MongoDatabase database2 = mongoTemplate.getDb();
        MongoCollection<Document> collection2 = database2.getCollection("uy_record_meta_d_sum");
        double finalRecordingMinTime = getSySMinTime();

        List<Document> documentList = new ArrayList<>(4);
        documentList.add(new Document("importantTag", new Document("$eq", Boolean.TRUE)));
        setTag(params, documentList);
        Document recording = new Document("missDuration",new Document("$lte", finalRecordingMinTime));
        documentList.add(recording);
        Document filter = new Document("$and", documentList);
        // 构建聚合管道
        List<Document> pipeline = Arrays.asList(
                new Document("$match", filter),
                // $group 去重
                new Document("$group", new Document("_id", "$deviceId")),
                new Document("$count", "uniqueDeviceIds")
        );
        AggregateIterable<Document> result = collection2.aggregate(pipeline);
        Integer uniqueDeviceIdCount = 0;
        for (Document doc : result) {
            uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
            break; // 不需要继续遍历，因为 $count 只会产生一个结果
        }
        log.error("重点点位录像可用率{}:",uniqueDeviceIdCount);

//        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 + "");
        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));
        if (!StringUtils.isEmpty(resultCount.get(0)) && !"0".equals(resultCount.get(0))) {
            onlineRate = new BigDecimal(uniqueDeviceIdCount).divide(new BigDecimal(resultCount.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        resultCount.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
@@ -654,7 +1826,7 @@
    }

    /**
     * 视频：标注正确率
     * 视频：标注正确率（暂停）
     *
     * @param params
     * @return
@@ -687,37 +1859,97 @@
    @Override
    public Result videoImportantPointLabelingAccuracy(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("deviceNo", "osdName");
        Query query = MongoUtil.getQuery(params, "checkTime", likeFileds, 3);

        List<Criteria> andCriteria = MongoUtil.getAndCriteria(params, "checkTime", 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("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.getError(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);
        dList2.add(new Document("importantTag", Boolean.TRUE));
        dList2.add(new Document("osdNameCorrect", new Document("$eq", -1)));
        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);
        //未知数
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("importantTag", Boolean.TRUE));
        dList3.add(new Document("osdTimeCorrect", new Document("$eq", 1)));
        setTag(params, dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("importantTag", Boolean.TRUE));
        dList4.add(new Document("osdTimeCorrect", new Document("$eq", -1)));
        setTag(params, dList4);
        Document osdNameFilter = new Document("$and", dList1);
        Document osdNameErrFilter = new Document("$and", dList2);
        Document osdTimeFilter = new Document("$and", dList3);
        Document osdTimeErrFilter = new Document("$and", dList4);
        List<Document> lists = Arrays.asList(osdNameFilter, osdNameErrFilter, osdTimeFilter, osdTimeErrFilter);
        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);

        List<Document> lists = Arrays.asList(osdFilter, osdCorrectFilter, osdErrorFilter, osdUnknownFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -736,17 +1968,21 @@
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeyAnnotationAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
//        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));
//        }
        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));
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(1)).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
@@ -755,8 +1991,68 @@
        return Result.ok().data(map).total(total);
    }

    @Override
    public void videoImportantPointLabelingAccuracyExport(HttpServletResponse response, DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("deviceNo", "osdName");
        List<Criteria> andCriteria = MongoUtil.getAndCriteria(params, "checkTime", 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("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);
            }
        }
        List<OsdCheckResult> resultList = mongoTemplate.find(query, OsdCheckResult.class);
        for (OsdCheckResult osdCheckResult : resultList) {
            OsdCheckResult.getError(osdCheckResult);
            StringBuilder tag = new StringBuilder("" +
                    (osdCheckResult.getProvinceTag() ? "省厅、" : "") +
                    (osdCheckResult.getImportantTag() ? "重点点位、" : "") +
                    (osdCheckResult.getImportantCommandImageTag() ? "重点指挥图像、" : "") +
                    (osdCheckResult.getDeptTag() ? "部级、" : ""));
            // 删除字符串末尾的"、"
            if (tag.toString().endsWith("、")) {
                tag = new StringBuilder(tag.substring(0, tag.length() - 1));
            }
            osdCheckResult.setTagStr(tag.toString());
        }
        ExcelUtil<OsdCheckResult> util = new ExcelUtil<>(OsdCheckResult.class);
        String sheetName = "OSD标注";

        util.exportExcel(response, resultList, sheetName);
    }

    /**
     * 视频：校时正确率
     * 视频：校时正确率(停用)
     *
     * @param params
     * @return
@@ -789,29 +2085,74 @@
     */
    @Override
    public Result videoImportantPointCheckTimeAccuracy(DataCenterQuery params) {

        List<String> likeFileds = Arrays.asList("deviceNo", "osdName");
        Query query = MongoUtil.getQuery(params, "checkTime", likeFileds, 3);
        Query query = MongoUtil.getQuery(params, "checkTime", likeFileds, null);
        //下拉框标注正确查询条件
        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.getError(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);
        dList2.add(new Document("importantTag", Boolean.TRUE));
        dList2.add(new Document("osdTimeCorrect", new Document("$eq", -1)));
        setTag(params, dList2);
        Document osdTimeFilter = new Document("$and", dList1);
        Document osdTimeErrFilter = new Document("$and", dList2);
        List<Document> lists = Arrays.asList(osdTimeFilter, osdTimeErrFilter);
        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);
        //未知数
        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);

        List<Document> lists = Arrays.asList(osdFilter, osdCorrectFilter, osdErrorFilter, osdUnknownFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -830,17 +2171,21 @@
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexVideo> videoList = new LambdaQueryChainWrapper<>(checkIndexVideoService.getBaseMapper())
                .select(CheckIndexVideo::getKeyTimingAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexVideo::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexVideo::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
//        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));
//        }
        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));
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(1)).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
@@ -860,36 +2205,48 @@
    public Result vehicleViewDockStable(DataCenterQuery params) {
        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");

        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("importantTag", Boolean.TRUE));
        dList1.add(new Document("resultType", new Document("$eq", 1)));
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("importantTag", Boolean.TRUE));
        dList2.add(new Document("resultType", new Document("$eq", 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("importantTag", Boolean.TRUE));
        dList3.add(new Document("resultType", new Document("$eq", 3)));
        dList3.add(new Document("resultType", new Document("$eq", 2)));
        dList3.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("importantTag", Boolean.TRUE));
        dList4.add(new Document("resultType", new Document("$eq", 4)));
        dList4.add(new Document("resultType", new Document("$eq", 3)));
        dList4.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList4);
        Document normalFilter = new Document("$and", dList1);
        Document noDataFilter = new Document("$and", dList2);
        Document trFilter = new Document("$and", dList3);
        Document littleFilter = new Document("$and", dList4);
        List<Document> lists = Arrays.asList(normalFilter, noDataFilter, trFilter, littleFilter);
        List<Document> dList5 = new ArrayList<>(2);
        dList5.add(new Document("resultType", new Document("$eq", 4)));
        dList5.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList5);
        Document normalFilter = new Document("$and", dList2);
        Document noDataFilter = new Document("$and", dList3);
        Document downFilter = new Document("$and", dList4);
        Document lessFilter = new Document("$and", dList5);
        List<Document> lists = Arrays.asList(normalFilter, noDataFilter,downFilter,lessFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -907,18 +2264,42 @@
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getViewConnectStability)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        // 构建基本的$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));
//        }
        BigDecimal normal = new BigDecimal(rList.get(1));
        BigDecimal noData = new BigDecimal(rList.get(2));
        BigDecimal down = new BigDecimal(rList.get(3));
        BigDecimal less = new BigDecimal(rList.get(4));
        BigDecimal totalCount = normal.add(noData).add(down).add(less);
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (CollectionUtils.isNotEmpty(videoList)) {
            BigDecimal sum = videoList.stream().map(CheckIndexCar::getViewConnectStability).reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        if (totalCount.compareTo(BigDecimal.ZERO)>0) {
            onlineRate = normal.divide(totalCount, 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
@@ -937,6 +2318,18 @@
    public Result vehiclePointOnlineRate(DataCenterQuery params) {
        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()));
        }
        Sort sort = Sort.by(
                Sort.Order.asc("pingOnline"), // 首先按照 pingOnline 升序排序
                Sort.Order.desc("offLineCount") // 首先按照 pingOnline 升序排序
        );
        // 通过pingOnline字段排序，为false的排在前面
        query.with(sort);
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
@@ -944,12 +2337,12 @@
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
        params.setDeptTag(-1);
        params.setDeviceType(2);
        // 统计设备数量
        Integer distinctCount = pointMapper.distinctCount(params);
        resultList.forEach(item -> {
            if (null != item.getPingOnline() && item.getPingOnline()) {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else {
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
@@ -959,20 +2352,73 @@
            } else {
                item.setOnlineStr("未知");
            }
            List<String> offLineTime = item.getOffLineTimeStr();
            if (!CollectionUtils.isEmpty(offLineTime)) {
                //后续可以改成配置的离线次数(提取前n次，n为配置的离线次数)
                if (offLineTime.size() > 1) {
                    offLineTime = offLineTime.subList(0, 2);
                }
                item.setOffLineTimeStr(offLineTime);
            }
            //添加动态数据
            List<DynamicColumnVO> list = dynamicColumnMapper.getDynamicColumnByTable(TableNameConstants.COLUMN_NAME_CAR_POINT,item.getNo());
            item.setDynamicColumnList(list);
        });
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getSiteOnline)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(params.getStartTime()), DateUtils.getDayEnd(params.getEndTime()))
                .list();

        // 统计设备数量
        //卡片统计
        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));
//        }
        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));
        if (totalCount!=0) {
            onlineRate = new BigDecimal(onlineCount).divide(new BigDecimal(totalCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(distinctCount + "", this.remove0(onlineRate)));
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -986,33 +2432,45 @@
    @Override
    public Result vehicleNetDeviceDirectoryConsistency(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        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);
        dList1.add(new Document("ip.error", new Document("$eq", Boolean.TRUE)));
        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);
        dList2.add(new Document("macdz.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("latitude.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("longitude.error", new Document("$eq", Boolean.TRUE)));
        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);
        dList2.add(new Document("sxjgnlx.value", new Document("$regex", ".*2.*")));
        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(
@@ -1031,22 +2489,26 @@
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getDeviceDirectoryConsistent)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
//        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));
//        }
        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));
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(0)).subtract(new BigDecimal(rList.get(1))).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("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);
    }

@@ -1059,7 +2521,23 @@
    @Override
    public Result vehicleCollectionConsistency(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "crossName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        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) {
                Criteria lalType = Criteria.where("lalType").ne(ApiConstants.HK_Info_LayType_Normal);
                Criteria gbCodeType = Criteria.where("gbCodeType").ne(ApiConstants.HK_Info_GbCodeType_Normal);
                Criteria orOperator = new Criteria().orOperator(lalType, gbCodeType);
                orOperator.andOperator(andCriteria);
                query = Query.query(orOperator);
            }
        }

        long total = mongoTemplate.count(query, CrossDetailResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
@@ -1070,23 +2548,23 @@
        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)));
        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);
        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> errorConditions = new ArrayList<>();
        errorConditions.add(new Document("lalType", new Document("$ne", 1)));
        errorConditions.add(new Document("gbCodeType", new Document("$ne", 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<Document> lists = Arrays.asList(totalFilter, correctFilter, errorFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -1105,17 +2583,21 @@
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
                .select(CheckIndexCar::getVehicleInformationCollectionAccuracy)
                .eq(params.getDataType().equals(1), CheckIndexCar::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexCar::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
//        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));
//        }
        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));
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(1)).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
@@ -1134,7 +2616,15 @@
    public Result vehicleCollectionDataIntegrity(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        if (params.getOption() != null) {
            //主要属性不完整
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("noIntegrityCount").gt(0));
            } else if (params.getOption() == -1) {
                //属性不完整
                query.addCriteria(Criteria.where("mainNoIntegrityCount").gt(0));
            }
        }
        long total = mongoTemplate.count(query, DataIntegrityMonitoringResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<DataIntegrityMonitoringResult> resultList = mongoTemplate.find(query, DataIntegrityMonitoringResult.class);
@@ -1143,21 +2633,51 @@
        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));
        //抓拍量求和
        // 构建基本的$match条件
        List<Document> matchConditions = new ArrayList<>();
        setTag(params, matchConditions);
        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"))
                        .append("noIntegrityCount", new Document("$sum", "$noIntegrityCount"))
                        .append("mainNoIntegrityCount", new Document("$sum", "$mainNoIntegrityCount"))
                ));
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        int dataCount = 0;
        int noIntegrityCount = 0;
        int mainNoIntegrityCount = 0;
        for (Document doc : result) {
            dataCount = doc.getInteger("dataCount");
            noIntegrityCount = doc.getInteger("noIntegrityCount");
            mainNoIntegrityCount = doc.getInteger("mainNoIntegrityCount");
        }

//        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
//                .select(CheckIndexCar::getVehicleCaptureIntegrity)
//                .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::getVehicleCaptureIntegrity).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }
        List<String> countList = new ArrayList<>();
        countList.add(dataCount + "");
        countList.add(noIntegrityCount + "");
        countList.add(mainNoIntegrityCount + "");
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (dataCount!=0) {
            onlineRate = new BigDecimal(dataCount-noIntegrityCount).divide(new BigDecimal(dataCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        countList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("count", countList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1172,25 +2692,68 @@
    public Result vehicleCollectionDataCaptured(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        if (params.getOption() != null) {
            //主要属性不一致
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("majorDiffCount").gt(0));
            } else if (params.getOption() == -1) {
                //重要属性不一致
                query.addCriteria(Criteria.where("importantDiffCount").gt(0));
            }
        }
        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));
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_attr_recognition_monitor");

        // 构建基本的$match条件
        List<Document> matchConditions = new ArrayList<>();
        setTag(params, matchConditions);
        List<Document> pipeline = Arrays.asList(
                new Document("$match", new Document("$and", matchConditions)),
                new Document("$group", new Document("_id", "$mongoCreateTime")
                        .append("sampleCount", new Document("$sum", "$sampleCount"))
                        .append("majorDiffCount", new Document("$sum", "$majorDiffCount"))
                        .append("importantDiffCount", new Document("$sum", "$importantDiffCount"))
                ));
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        int sampleCount = 0;
        int majorDiffCount = 0;
        int importantDiffCount = 0;
        for (Document doc : result) {
            sampleCount = doc.getInteger("sampleCount");
            majorDiffCount = doc.getInteger("majorDiffCount");
            importantDiffCount = doc.getInteger("importantDiffCount");
        }

//        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
//                .select(CheckIndexCar::getVehicleCaptureAccuracy)
//                .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::getVehicleCaptureAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }

        List<String> countList = new ArrayList<>();
        countList.add(sampleCount + "");
        countList.add(majorDiffCount + "");
        countList.add(importantDiffCount + "");
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (sampleCount!=0) {
            onlineRate = new BigDecimal(sampleCount-majorDiffCount).divide(new BigDecimal(sampleCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        countList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("count", countList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1205,30 +2768,46 @@
    public Result vehicleClockAccuracy(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        if (params.getOption() != null) {
            //当日时钟异常
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("majorDiffCount").gt(0));
            } else if (params.getOption() == -1) {
                //全部时钟异常
                query.addCriteria(Criteria.where("importantDiffCount").gt(0));
            }
        }
        long total = mongoTemplate.count(query, VehicleDeviceInspectionResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<VehicleDeviceInspectionResult> resultList = mongoTemplate.find(query, VehicleDeviceInspectionResult.class);

        List<SnapClockVO> resultVos = new ArrayList<>();
        resultList.forEach(item -> {
            SnapClockVO vo = VehicleDeviceInspectionResult.getVO(item);
            resultVos.add(vo);
        });

        // 统计数量
        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)));
        dList1.add(new Document("snapClock.todayClockResult", new Document("$eq", 1)));
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("snapResult", new Document("$eq", 2)));
        dList2.add(new Document("snapClock.todayClockResult", new Document("$eq", 0)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("snapResult", new Document("$eq", 4)));
        dList3.add(new Document("snapClock.allClockResult", new Document("$eq", 1)));
        setTag(params, dList3);
        Document ipErrFilter = new Document("$and", dList1);
        Document macdzErrFilter = new Document("$and", dList2);
        Document longitudeErrFilter = new Document("$and", dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("snapClock.allClockResult", new Document("$eq", 0)));
        setTag(params, dList4);
        Document todayFilter = new Document("$and", dList1);
        Document todayErrFilter = new Document("$and", dList2);
        Document allFilter = new Document("$and", dList3);
        Document allErrFilter = new Document("$and", dList4);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, longitudeErrFilter);
        List<Document> lists = Arrays.asList(todayFilter, todayErrFilter, allFilter, allErrFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -1247,22 +2826,29 @@
            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();
//        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
//                .select(CheckIndexCar::getVehicleTimingAccuracy)
//                .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::getVehicleTimingAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }
        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));
        BigDecimal normal = new BigDecimal(rList.get(0));
        BigDecimal abnormal = new BigDecimal(rList.get(1));
        BigDecimal totalCount = normal.add(abnormal);
        if (totalCount.compareTo(BigDecimal.ZERO)>0) {
            onlineRate = normal.divide(totalCount, 3,RoundingMode.DOWN).multiply(new BigDecimal("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);
    }

@@ -1276,26 +2862,72 @@
    public Result vehicleTimelyUploadAccuracy(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        query.addCriteria(Criteria.where("dataType").is(ApiConstants.HK_DataType_CAR));
        if (params.getOption() != null) {
            //正常
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("delayCount").is(0));
            } else if (params.getOption() == -1) {
                //延迟
                query.addCriteria(Criteria.where("delayCount").gt(0));
            }
        }
        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();
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_snapshop_delay_monitor");

        List<Document> dList1 = new ArrayList<>(2);
        setTag(params, dList1);
        dList1.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        Document allFilter = new Document("$and", dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        dList2.add(new Document("delayCount", new Document("$gt", 0)));
        setTag(params, dList2);
        Document delayFilter = new Document("$and", dList2);

        List<Document> lists = Arrays.asList(allFilter, delayFilter);
        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());


//        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
//                .select(CheckIndexCar::getVehicleUploadTimeliness)
//                .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::getVehicleUploadTimeliness).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }
        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));
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(0)).subtract(new BigDecimal(rList.get(1))).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("count", rList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1310,17 +2942,44 @@
    public Result vehicleUrlAccuracy(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        if (params.getOption() != null) {
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("expCount").is(0));
            } else if (params.getOption() == -1) {
                query.addCriteria(Criteria.where("expCount").gt(0));
            }
        }
        long total = mongoTemplate.count(query, PicAccessResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        query.with(Sort.by(Sort.Order.desc("expCount")));
        List<PicAccessResult> resultList = mongoTemplate.find(query, PicAccessResult.class);

        // 统计数
        Date now = new Date();
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_pic_access");
        // 构建基本的$match条件
        List<Document> matchConditions = new ArrayList<>();
        setTag(params, matchConditions);
        List<Document> pipeline = Arrays.asList(
                new Document("$match", new Document("$and", matchConditions)),
                new Document("$group", new Document("_id", "$mongoCreateTime")
                        .append("sampleCount", new Document("$sum", "$sampleCount"))
                        .append("expCount", new Document("$sum", "$expCount"))
                ));
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        int sampleCount = 0;
        int expCount = 0;
        for (Document doc : result) {
            sampleCount = doc.getInteger("sampleCount");
            expCount = doc.getInteger("expCount");
        }

        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))
                .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)) {
@@ -1328,8 +2987,13 @@
            BigDecimal count = BigDecimal.valueOf(videoList.size());
            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
        }
        List<String> rList = new ArrayList<>();
        rList.add(sampleCount + "");
        rList.add(expCount + "");
        rList.add(this.remove0(onlineRate));

        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("count", rList);
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1344,27 +3008,65 @@
    public Result vehicleBigImgAccuracy(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        if (params.getOption() != null) {
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("bigUseful.bigPicExpCount").is(0));
            } else if (params.getOption() == -1) {
                query.addCriteria(Criteria.where("bigUseful.bigPicExpCount").gt(0));
            }
        }
        long total = mongoTemplate.count(query, VehicleDeviceSamplingResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        query.with(Sort.by(Sort.Order.desc("bigUseful.bigPicExpCount")));
        List<VehicleDeviceSamplingResult> resultList = mongoTemplate.find(query, VehicleDeviceSamplingResult.class);

        List<BigPicUsefulVO> voList = new ArrayList<>();
        resultList.forEach(item -> {
            BigPicUsefulVO picVO = VehicleDeviceSamplingResult.getPicVO(item);
            voList.add(picVO);
        });
        // 统计数
        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));
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_vehicle_device_sampling");
        // 构建基本的$match条件
        List<Document> matchConditions = new ArrayList<>();
        setTag(params, matchConditions);
        List<Document> pipeline = Arrays.asList(
                new Document("$match", new Document("$and", matchConditions)),
                new Document("$group", new Document("_id", "$mongoCreateTime")
                        .append("sampleCount", new Document("$sum", "$bigUseful.sampleCount"))
                        .append("expCount", new Document("$sum", "$bigUseful.bigPicExpCount"))
                ));
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        int sampleCount = 0;
        int expCount = 0;
        for (Document doc : result) {
            sampleCount = doc.getInteger("sampleCount");
            expCount = doc.getInteger("expCount");
        }
        List<String> countList = new ArrayList<>();
//        List<CheckIndexCar> videoList = new LambdaQueryChainWrapper<>(checkIndexCarService.getBaseMapper())
//                .select(CheckIndexCar::getVehiclePictureAvailability)
//                .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::getVehiclePictureAvailability).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }
        countList.add(sampleCount + "");
        countList.add(expCount + "");
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (sampleCount!=0) {
            onlineRate = new BigDecimal(sampleCount-expCount).divide(new BigDecimal(sampleCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        countList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", Arrays.asList(this.remove0(onlineRate)));
        map.put("list", resultList);
        map.put("count", countList);
        map.put("list", voList);
        return Result.ok().data(map).total(total);
    }

@@ -1378,32 +3080,49 @@
    public Result faceViewDockStable(DataCenterQuery params) {
        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);

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

        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("resultType", new Document("$eq", 1)));
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("resultType", new Document("$eq", 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", 3)));
        dList3.add(new Document("resultType", new Document("$eq", 2)));
        dList3.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList3);

        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("resultType", new Document("$eq", 4)));
        dList4.add(new Document("resultType", new Document("$eq", 3)));
        dList4.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList4);
        Document normalFilter = new Document("$and", dList1);
        Document noDataFilter = new Document("$and", dList2);
        Document trFilter = new Document("$and", dList3);
        Document littleFilter = new Document("$and", dList4);
        List<Document> lists = Arrays.asList(normalFilter, noDataFilter, trFilter, littleFilter);
        List<Document> dList5 = new ArrayList<>(2);
        dList5.add(new Document("resultType", new Document("$eq", 4)));
        dList5.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_CAR)));
        setTag(params, dList5);
        Document normalFilter = new Document("$and", dList2);
        Document noDataFilter = new Document("$and", dList3);
        Document downFilter = new Document("$and", dList4);
        Document lessFilter = new Document("$and", dList5);
        List<Document> lists = Arrays.asList(normalFilter, noDataFilter,downFilter,lessFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -1421,18 +3140,43 @@
            }
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getViewConnectStability)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexFace::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
        //抓拍量求和
        // 构建基本的$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));
//        }
        BigDecimal normal = new BigDecimal(rList.get(1));
        BigDecimal noData = new BigDecimal(rList.get(2));
        BigDecimal down = new BigDecimal(rList.get(3));
        BigDecimal less = new BigDecimal(rList.get(4));
        BigDecimal totalCount = normal.add(noData).add(down).add(less);
        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));
        if (totalCount.compareTo(BigDecimal.ZERO)>0) {
            onlineRate = normal.divide(totalCount, 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
@@ -1451,15 +3195,29 @@
    public Result facePointOnlineRate(DataCenterQuery params) {
        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()));
        }
        Sort sort = Sort.by(
                Sort.Order.asc("pingOnline"), // 首先按照 pingOnline 升序排序
                Sort.Order.desc("offLineCount") // 首先按照 pingOnline 升序排序
        );
        // 通过pingOnline字段排序，为false的排在前面
        query.with(sort);
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
        resultList.forEach(item -> {
            if (null != item.getPingOnline() && item.getPingOnline()) {
                item.setOnlineStr("在线");
            } else {
                item.setOnlineStr("离线");
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
@@ -1468,29 +3226,74 @@
            } else {
                item.setOnlineStr("未知");
            }
            List<String> offLineTime = item.getOffLineTimeStr();
            if (!CollectionUtils.isEmpty(offLineTime)) {
                //后续可以改成配置的离线次数(提取前n次，n为配置的离线次数)
                if (offLineTime.size() > 1) {
                    offLineTime = offLineTime.subList(0, 2);
                }
                item.setOffLineTimeStr(offLineTime);
            }
            //添加动态数据
            List<DynamicColumnVO> list = dynamicColumnMapper.getDynamicColumnByTable(TableNameConstants.COLUMN_NAME_FACE_POINT,item.getNo());
            item.setDynamicColumnList(list);
        });
        params.setDeptTag(-1);
        params.setDeviceType(3);
        // 统计设备数量
        Integer distinctCount = pointMapper.distinctCount(params);

        Date now = new Date();
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getSiteOnline)
                .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::getSiteOnline).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;
        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));
        }
        List<String> rList = new ArrayList<>(2);
        rList.add(distinctCount + "");
        rList.add(this.remove0(onlineRate));
        // 构建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));
//        }
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (totalCount!=0) {
            onlineRate = new BigDecimal(onlineCount).divide(new BigDecimal(totalCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
@@ -1503,34 +3306,46 @@
     */
    @Override
    public Result faceDirectoryConsistency(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("serialNumber.showValue", "ip.showValue", "name.showValue");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, 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);

        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);
        dList1.add(new Document("ip.error", new Document("$eq", Boolean.TRUE)));
        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);
        dList2.add(new Document("macdz.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("latitude.error", new Document("$eq", Boolean.TRUE)));
        setTag(params, dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("longitude.error", new Document("$eq", Boolean.TRUE)));
        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);
        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(
@@ -1549,22 +3364,26 @@
            return uniqueDeviceIdCount + "";
        }).collect(Collectors.toList());

        Date now = new Date();
        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
                .select(CheckIndexFace::getDeviceDirectoryConsistent)
                .eq(params.getDataType().equals(1), CheckIndexFace::getExamineTag, CheckConstants.Examine_Tag_Province)
                .between(CheckIndexFace::getCreateTime, DateUtils.getDayStart(now), DateUtils.getDayEnd(now))
                .list();
//        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));
//        }
        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));
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(0)).subtract(new BigDecimal(rList.get(1))).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("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);
    }

@@ -1577,33 +3396,50 @@
    @Override
    public Result faceCollectionConsistency(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "crossName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        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) {
                Criteria lalType = Criteria.where("lalType").ne(ApiConstants.HK_Info_LayType_Normal);
                Criteria gbCodeType = Criteria.where("gbCodeType").ne(ApiConstants.HK_Info_GbCodeType_Normal);
                Criteria orOperator = new Criteria().orOperator(lalType, gbCodeType);
                orOperator.andOperator(andCriteria);
                query = Query.query(orOperator);
            }
        }

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

        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_cross_detail");
        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)));
        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);
        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<Document> errorConditions = new ArrayList<>();
        errorConditions.add(new Document("lalType", new Document("$ne", 1)));
        errorConditions.add(new Document("gbCodeType", new Document("$ne", 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(totalFilter, correctFilter, errorFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -1622,17 +3458,21 @@
            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();
//        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
//                .select(CheckIndexFace::getFaceInformationCollectionAccuracy)
//                .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::getFaceInformationCollectionAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }
        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));
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(1)).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
@@ -1651,67 +3491,67 @@
    public Result faceImgQualification(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "cameraName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, MonitoringDetailResult.class);
        if (params.getOption() != null) {
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("faceEligibility.unfaceEligCount").is(0));
            } else if (params.getOption() == -1) {
                query.addCriteria(Criteria.where("faceEligibility.unfaceEligCount").gt(0));
            }
        }
        long total = mongoTemplate.count(query, FaceDeviceSamplingResult.class);
        query.with(Sort.by(Sort.Order.desc("faceEligibility.unfaceEligCount")));
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<MonitoringDetailResult> resultList = mongoTemplate.find(query, MonitoringDetailResult.class);
        List<FaceDeviceSamplingResult> resultList = mongoTemplate.find(query, FaceDeviceSamplingResult.class);
        List<BigPicUsefulVO> voList = new ArrayList<>();
        resultList.forEach(item -> {
            BigPicUsefulVO picVO = FaceDeviceSamplingResult.getEligeVO(item);
            voList.add(picVO);
        });

        // 统计数量
        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));
        MongoCollection<Document> collection = database.getCollection("hk_face_device_sampling");
        // 构建基本的$match条件
        List<Document> matchConditions = new ArrayList<>();
        setTag(params, matchConditions);
        List<Document> pipeline = Arrays.asList(
                new Document("$match", new Document("$and", matchConditions)),
                new Document("$group", new Document("_id", "$mongoCreateTime")
                        .append("sampleCount", new Document("$sum", "$faceEligibility.sampleCount"))
                        .append("expCount", new Document("$sum", "$faceEligibility.unfaceEligCount"))
                ));
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        int sampleCount = 0;
        int expCount = 0;
        for (Document doc : result) {
            sampleCount = doc.getInteger("sampleCount");
            expCount = doc.getInteger("expCount");
        }
        rList.add(this.remove0(onlineRate));
        List<String> countList = new ArrayList<>();

//        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
//                .select(CheckIndexFace::getFacePictureQualification)
//                .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::getFacePictureQualification).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }
        countList.add(sampleCount + "");
        countList.add(expCount + "");
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (sampleCount!=0) {
            onlineRate = new BigDecimal(sampleCount-expCount).divide(new BigDecimal(sampleCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        countList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
        map.put("count", rList);
        map.put("list", resultList);
        map.put("count", countList);
        map.put("list", voList);
        return Result.ok().data(map).total(total);
    }

@@ -1725,29 +3565,47 @@
    public Result faceCapturesImagesAccuracy(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        if (params.getOption() != null) {
            //当日时钟异常
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("majorDiffCount").gt(0));
            } else if (params.getOption() == -1) {
                //全部时钟异常
                query.addCriteria(Criteria.where("importantDiffCount").gt(0));
            }
        }
        long total = mongoTemplate.count(query, FaceDeviceInspectionResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<FaceDeviceInspectionResult> resultList = mongoTemplate.find(query, FaceDeviceInspectionResult.class);
        List<SnapClockVO> resultVos = new ArrayList<>();
        resultList.forEach(item -> {
            SnapClockVO vo = FaceDeviceInspectionResult.getVO(item);
            resultVos.add(vo);
        });

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

        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("snapResult", new Document("$eq", 1)));
        dList1.add(new Document("snapClock.todayClockResult", new Document("$eq", 1)));
        setTag(params, dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("snapResult", new Document("$eq", 2)));
        dList2.add(new Document("snapClock.todayClockResult", new Document("$eq", 0)));
        setTag(params, dList2);
        List<Document> dList3 = new ArrayList<>(2);
        dList3.add(new Document("snapResult", new Document("$eq", 4)));
        dList3.add(new Document("snapClock.allClockResult", new Document("$eq", 1)));
        setTag(params, dList3);
        Document ipErrFilter = new Document("$and", dList1);
        Document macdzErrFilter = new Document("$and", dList2);
        Document longitudeErrFilter = new Document("$and", dList3);
        List<Document> dList4 = new ArrayList<>(2);
        dList4.add(new Document("snapClock.allClockResult", new Document("$eq", 0)));
        setTag(params, dList4);
        Document todayFilter = new Document("$and", dList1);
        Document todayErrFilter = new Document("$and", dList2);
        Document allFilter = new Document("$and", dList3);
        Document allErrFilter = new Document("$and", dList4);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, longitudeErrFilter);

        List<Document> lists = Arrays.asList(todayFilter, todayErrFilter, allFilter, allErrFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -1766,22 +3624,29 @@
            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();
//        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
//                .select(CheckIndexFace::getFaceTimingAccuracy)
//                .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::getFaceTimingAccuracy).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }
        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));
        BigDecimal normal = new BigDecimal(rList.get(0));
        BigDecimal abnormal = new BigDecimal(rList.get(1));
        BigDecimal totalCount = normal.add(abnormal);
        if (totalCount.compareTo(BigDecimal.ZERO)>0) {
            onlineRate = normal.divide(totalCount, 3,RoundingMode.DOWN).multiply(new BigDecimal("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);
    }

@@ -1795,29 +3660,34 @@
    public Result faceTimelyUpload(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        long total = mongoTemplate.count(query, FaceDeviceInspectionResult.class);
        query.addCriteria(Criteria.where("dataType").is(ApiConstants.HK_DataType_FACE));
        if (params.getOption() != null) {
            //正常
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("delayCount").is(0));
            } else if (params.getOption() == -1) {
                //延迟
                query.addCriteria(Criteria.where("delayCount").gt(0));
            }
        }
        long total = mongoTemplate.count(query, SnapshotDelayMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<FaceDeviceInspectionResult> resultList = mongoTemplate.find(query, FaceDeviceInspectionResult.class);

        // 统计数量
        List<SnapshotDelayMonitorResult> resultList = mongoTemplate.find(query, SnapshotDelayMonitorResult.class);
        // 统计数
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_vehicle_device_inspection");
        MongoCollection<Document> collection = database.getCollection("hk_snapshop_delay_monitor");

        List<Document> dList1 = new ArrayList<>(2);
        dList1.add(new Document("snapResult", new Document("$eq", 1)));
        setTag(params, dList1);
        dList1.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_FACE)));
        Document allFilter = new Document("$and", dList1);
        List<Document> dList2 = new ArrayList<>(2);
        dList2.add(new Document("snapResult", new Document("$eq", 2)));
        dList2.add(new Document("dataType", new Document("$eq", ApiConstants.HK_DataType_FACE)));
        dList2.add(new Document("delayCount", new Document("$gt", 0)));
        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);
        Document delayFilter = new Document("$and", dList2);

        List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, longitudeErrFilter);
        List<Document> lists = Arrays.asList(allFilter, delayFilter);
        List<String> rList = lists.stream().map(filter -> {
            // 构建聚合管道
            List<Document> pipeline = Arrays.asList(
@@ -1836,17 +3706,22 @@
            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();

//        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
//                .select(CheckIndexFace::getFaceUploadTimeliness)
//                .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::getFaceUploadTimeliness).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }
        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));
        if (!StringUtils.isEmpty(rList.get(0)) && !"0".equals(rList.get(0))) {
            onlineRate = new BigDecimal(rList.get(0)).subtract(new BigDecimal(rList.get(1))).divide(new BigDecimal(rList.get(0)), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        rList.add(this.remove0(onlineRate));
        HashMap<String, Object> map = new HashMap<>();
@@ -1865,28 +3740,73 @@
    public Result faceAvailabilityOfLargeImg(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
        Query query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);

        if (params.getOption() != null) {
            if (params.getOption() == 1) {
                query.addCriteria(Criteria.where("bigUseful.bigPicExpCount").is(0));
            } else if (params.getOption() == -1) {
                query.addCriteria(Criteria.where("bigUseful.bigPicExpCount").gt(0));
            }
        }
        long total = mongoTemplate.count(query, FaceDeviceSamplingResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        query.with(Sort.by(Sort.Order.desc("bigUseful.bigPicExpCount")));
        List<FaceDeviceSamplingResult> resultList = mongoTemplate.find(query, FaceDeviceSamplingResult.class);

        List<BigPicUsefulVO> voList = new ArrayList<>();
        resultList.forEach(item -> {
            BigPicUsefulVO picVO = FaceDeviceSamplingResult.getPicVO(item);
            voList.add(picVO);
        });
        // 统计数
        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));
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("hk_face_device_sampling");
        // 构建基本的$match条件
        List<Document> matchConditions = new ArrayList<>();
        setTag(params, matchConditions);
        List<Document> pipeline = Arrays.asList(
                new Document("$match", new Document("$and", matchConditions)),
                new Document("$group", new Document("_id", "$mongoCreateTime")
                        .append("sampleCount", new Document("$sum", "$bigUseful.sampleCount"))
                        .append("expCount", new Document("$sum", "$bigUseful.bigPicExpCount"))
                ));
        // 执行聚合查询并获取结果
        AggregateIterable<Document> result = collection.aggregate(pipeline);
        int sampleCount = 0;
        int expCount = 0;
        for (Document doc : result) {
            sampleCount = doc.getInteger("sampleCount");
            expCount = doc.getInteger("expCount");
        }


        //新构建聚合查询离线时间

        List<String> countList = new ArrayList<>();

        // 统计数
//        List<CheckIndexFace> videoList = new LambdaQueryChainWrapper<>(checkIndexFaceService.getBaseMapper())
//                .select(CheckIndexFace::getFacePictureAvailability)
//                .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::getFacePictureAvailability).reduce(BigDecimal.ZERO, BigDecimal::add);
//            BigDecimal count = BigDecimal.valueOf(videoList.size());
//            onlineRate = sum.divide(count, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
//        }
        countList.add(sampleCount + "");
        countList.add(expCount + "");
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (sampleCount!=0) {
            onlineRate = new BigDecimal(sampleCount-expCount).divide(new BigDecimal(sampleCount), 3,RoundingMode.DOWN).multiply(new BigDecimal("100"));
        }
        countList.add(this.remove0(onlineRate));


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

@@ -1932,5 +3852,9 @@
        } 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));
    }
}