新需求

zxl

2025-09-19 0d243e7f5dc593cdc6e0608bb52cd635f8fc6982

新需求

 ycl-common/src/main/java/enumeration/ConstructionTypeEnum.java

New file
@@ -0,0 +1,25 @@
package enumeration;


import lombok.Getter;

/**
 * zgyw
 *
 * @author : zxl
 * @date : 2025-09-16 09:42
 **/
@Getter
public enum ConstructionTypeEnum {
    PHASE_ONE_TWO("一二期"),
    PHASE_THREE("三期"),
    PHASE_FOURTH("四期"),
    CHECK_ENTER_SICHUAN("入川即检");

    private String desc;


    ConstructionTypeEnum(String desc) {
        this.desc = desc;
    }
}

 ycl-common/src/main/java/enumeration/DataCenterMethodNameEnum.java

New file
@@ -0,0 +1,22 @@
package enumeration;

import lombok.Getter;

@Getter
public enum DataCenterMethodNameEnum {

    VIDEO_POINT_ONLINE_RATE("视频：点位在线率优化线程"),
    DEPT_VIDEO_POINT_ONLINE_RATE("视频：部级点位在线率优化线程"),
    VIDEO_IMPORTANT_POINT_ONLINE_RATE("视频：重点点位在线率优化线程"),
    DEPT_VIDEO_AVAILABILITY_RATE("视频：部级录像可用率"),
    VIDEO_AVAILABILITY_RATE("视频：录像可用率"),

    VIDEO_IMPORTANT_POINT_AVAILABILITY_RATE("视频：重点点位录像可用率")
    ;

    private String desc;

    DataCenterMethodNameEnum(String desc) {
        this.desc = desc;
    }
}

 ycl-pojo/src/main/java/com/ycl/platform/domain/entity/DemeritRecord.java

New file
@@ -0,0 +1,30 @@
package com.ycl.platform.domain.entity;


import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ycl.platform.base.AbsEntity;
import lombok.Data;

import java.math.BigDecimal;

/**
 * zgyw
 * 录像扣分记录
 * @author : zxl
 * @date : 2025-09-15 16:15
 **/
@Data
@TableName("t_demerit_record")
public class DemeritRecord extends AbsEntity {

    @TableField("dept_id")
    private Integer deptId;

    @TableField("demerit")
    private BigDecimal demerit;

    @TableField("construction_type")
    private String constructionType;
}

 ycl-pojo/src/main/java/com/ycl/platform/domain/query/DemeritRecordQuery.java

New file
@@ -0,0 +1,41 @@
package com.ycl.platform.domain.query;


import com.fasterxml.jackson.annotation.JsonFormat;
import com.ycl.platform.base.AbsQuery;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;

import java.util.Date;

/**
 * zgyw
 * 扣分情况集合
 * @author : zxl
 * @date : 2025-09-15 16:28
 **/
@Data
public class DemeritRecordQuery extends AbsQuery {

    /**
     * 区域id
     */
    private String deptId;

    /**
     * 建设类型(一、二、三期、入川即检、老人脸)
     */
    private String constructionType;

    /**
     * 日/月展示
     */
    private String searchType;

    @JsonFormat(pattern = "yyyy-MM-dd",timezone = "GMT+8")
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date dayDate;
    @JsonFormat(pattern = "yyyy-MM",timezone = "GMT+8")
    @DateTimeFormat(pattern = "yyyy-MM")
    private Date monthDate;
}

 ycl-pojo/src/main/java/com/ycl/platform/domain/vo/TMonitorVO.java

@@ -21,6 +21,9 @@
public class TMonitorVO extends BaseEntity {
    private static final long serialVersionUID = 1L;


    private String constructionType;

    /**
     * $column.columnComment
     */

 ycl-pojo/src/main/java/com/ycl/platform/domain/vo/screen/DemeritRecordVO.java

New file
@@ -0,0 +1,36 @@
package com.ycl.platform.domain.vo.screen;


import com.ycl.platform.base.AbsVo;
import lombok.Data;
import java.math.BigDecimal;

/**
 * zgyw
 *
 * @author : zxl
 * @date : 2025-09-15 16:20
 **/
@Data
public class DemeritRecordVO extends AbsVo {

    /**
     * id
     */
    private Integer deptId;
    /**
     * 区名
     */
    private String deptName;

    /**
     * 分建设类型
     */
    private String constructionType;

    /**
     * 扣分
     */
    private BigDecimal demerit;

}

 ycl-server/src/main/java/com/ycl/platform/controller/DemeritRecordController.java

New file
@@ -0,0 +1,30 @@
package com.ycl.platform.controller;


import com.ycl.platform.domain.query.DemeritRecordQuery;
import com.ycl.platform.service.IDemeritRecordService;
import com.ycl.system.Result;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * zgyw
 *
 * @author : zxl
 * @date : 2025-09-17 13:49
 **/

@RequiredArgsConstructor
@RestController
@RequestMapping("/demeritRecord")
public class DemeritRecordController {
    public final IDemeritRecordService demeritRecordService;

    @GetMapping("/getPage")
    public Result getPage(DemeritRecordQuery query){
        return demeritRecordService.getDemeritRecordPage(query);
    }

}

 ycl-server/src/main/java/com/ycl/platform/controller/WorkOrderController.java

@@ -43,6 +43,12 @@

    private final WorkOrderService workOrderService;

    @DeleteMapping("/delByIds")
    public Result delByIds(@RequestBody List<String> ids){

        return workOrderService.batchDeleteWorkOrder(ids);
    }

    @GetMapping("/process/{workOrderNo}")
    @ApiOperation(value = "过程图", notes = "过程图")
    @PreAuthorize("@ss.hasPermi('work:order:process')")

 ycl-server/src/main/java/com/ycl/platform/mapper/DemeritRecordMapper.java

New file
@@ -0,0 +1,15 @@
package com.ycl.platform.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.ycl.platform.domain.entity.DemeritRecord;
import com.ycl.platform.domain.query.DemeritRecordQuery;
import com.ycl.platform.domain.vo.screen.DemeritRecordVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface DemeritRecordMapper extends BaseMapper<DemeritRecord> {

    IPage<DemeritRecordVO> getPage(@Param("query") DemeritRecordQuery query, IPage<DemeritRecordVO> page);
}

 ycl-server/src/main/java/com/ycl/platform/service/DataCenterService.java

@@ -40,6 +40,7 @@
     */
    Result videoPointOnlineRate(DataCenterQuery query);


    /**
     * 视频：点位在线率
     *

 ycl-server/src/main/java/com/ycl/platform/service/IDemeritRecordService.java

New file
@@ -0,0 +1,26 @@
package com.ycl.platform.service;


import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.ycl.platform.domain.entity.DemeritRecord;
import com.ycl.platform.domain.query.DemeritRecordQuery;
import com.ycl.platform.domain.vo.screen.DemeritRecordVO;
import com.ycl.system.Result;

import java.util.List;

/**
 * zgyw
 *
 * @author : zxl
 * @date : 2025-09-15 16:26
 **/
public interface IDemeritRecordService extends IService<DemeritRecord> {

    public Result getDemeritRecordPage(DemeritRecordQuery query);

    void add(List<DemeritRecord> records);

    Result delete(Integer id);
}

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

@@ -35,17 +35,21 @@
import com.ycl.utils.bean.BeanUtils;
import com.ycl.utils.poi.ExcelUtil;
import constant.*;
import enumeration.DataCenterMethodNameEnum;
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.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;

import java.io.IOException;
@@ -54,6 +58,9 @@
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ExecutionException;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@@ -75,7 +82,9 @@
    private final ICheckIndexFaceService checkIndexFaceService;
    private final DynamicColumnMapper dynamicColumnMapper;


    @Qualifier("threadPoolTaskExecutor")
    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;

    private final static String TIME_FIELD = "mongoCreateTime";

@@ -690,155 +699,439 @@

    }



    /**
     * 视频：点位在线率
     *
     * @param params
     * @return
     * 内部类：存储统计结果（避免零散变量传递）
     */
    @Override
    public Result videoPointOnlineRate(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("name", "no", "ip");
        //此处新增了根据用户权限查询的情况
        Query query = null;
        SysDept sysDept = getSysDeptByLoginUser();
        AreaDeptEnum areaDeptEnum = null;
        if (sysDept !=null){
            areaDeptEnum = AreaDeptEnum.fromDept(Math.toIntExact(sysDept.getDeptId()));
            if (areaDeptEnum != null){
                query = MongoUtil.getQueryDataCenter(areaDeptEnum.getCode(),params,TIME_FIELD,likeFileds,null,"no");
    private static class StatisticsResult {
        int totalCount;
        int onlineCount;
        int offlineCount;
        int unknownCount;
        BigDecimal onlineRate;

            }else{
                query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
            }
        }else {
            query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        public StatisticsResult(int totalCount, int onlineCount, int offlineCount, int unknownCount, BigDecimal onlineRate) {
            this.totalCount = totalCount;
            this.onlineCount = onlineCount;
            this.offlineCount = offlineCount;
            this.unknownCount = unknownCount;
            this.onlineRate = onlineRate;
        }
        //查视频设备
        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 (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());
    }
    /**
     * 列表数据格式化
     */
    private void formatResultList(List<TMonitorResult> resultList,String tag) {
        if(DataCenterMethodNameEnum.VIDEO_POINT_ONLINE_RATE.name().equals(tag)){
            resultList.forEach(item -> {
                // pingOnline 状态转换
                if (item.getPingOnline() == null) {
                    item.setPingOnlineStr("未知");
                } else if (item.getPingOnline()) {
                    item.setPingOnlineStr("在线");
                } else {
                    item.setPingOnlineStr("离线");
                }
                item.setOffLineTimeStr(offLineTime);
            }
            //添加动态数据
            List<DynamicColumnVO> list = dynamicColumnMapper.getDynamicColumnByTable(TableNameConstants.COLUMN_NAME_VIDEO_POINT,item.getNo());
            item.setDynamicColumnList(list);
        });

                // online 状态转换
                if (1 == item.getOnline()) {
                    item.setOnlineStr("在线");
                } else if (-1 == item.getOnline()) {
                    item.setOnlineStr("离线");
                } else {
                    item.setOnlineStr("未知");
                }

        params.setDeptTag(-1);
        params.setDeviceType(1);
                // 离线时间截断（保留最后2条）
                List<String> offLineTime = item.getOffLineTimeStr();
                if (!CollectionUtils.isEmpty(offLineTime) && offLineTime.size() > 1) {
                    item.setOffLineTimeStr(offLineTime.subList(offLineTime.size() - 2, offLineTime.size()));
                }

        //卡片统计
        int totalCount = 0;
        int onlineCount = 0;
        int offlineCount = 0;
        int unknownCount = 0;
        //构建条件
        List<Criteria> criteriaList = new ArrayList<>();
        // 添加固定条件
        criteriaList.add(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
        criteriaList.add(Criteria.where("mongoCreateTime").gte(params.getStartTime()).lte(params.getEndTime()));
        //此处新增了根据用户权限查询的情况
        if (areaDeptEnum != null){
            criteriaList.add(Criteria.where("no").regex("^" +areaDeptEnum.getCode()));
                // 添加动态列数据
                List<DynamicColumnVO> dynamicColumns = dynamicColumnMapper.getDynamicColumnByTable(
                        TableNameConstants.COLUMN_NAME_VIDEO_POINT,
                        item.getNo()
                );
                item.setDynamicColumnList(dynamicColumns);
            });
        }
        // 根据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));
        else if (DataCenterMethodNameEnum.DEPT_VIDEO_POINT_ONLINE_RATE.name().equals(tag)
        || DataCenterMethodNameEnum.VIDEO_IMPORTANT_POINT_ONLINE_RATE.name().equals(tag)){
            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("未知");
                }
            });
        }
        // 构建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(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);

    }

    /**
     * 视频：部级点位在线率
     * 卡片统计计算
     */
    private StatisticsResult calculateStatistics(DataCenterQuery params, AreaDeptEnum areaDeptEnum,String tag) {
        int totalCount = 0, onlineCount = 0, offlineCount = 0, unknownCount = 0;

        // 计算在线率
        BigDecimal onlineRate = BigDecimal.ZERO;
        if (DataCenterMethodNameEnum.VIDEO_POINT_ONLINE_RATE.name().equals(tag)){
            // 构建统计条件
            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()));

            // 权限过滤
            if (areaDeptEnum != null) {
                criteriaList.add(Criteria.where("no").regex("^" + areaDeptEnum.getCode()));
            }
            // 数据类型过滤（省/部门标签）
            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));
            }

            // MongoDB 聚合查询
            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()) {
                onlineCount = (Integer) result.getOrDefault("onlineCount", 0);
                offlineCount = (Integer) result.getOrDefault("offlineCount", 0);
                unknownCount = (Integer) result.getOrDefault("unknownCount", 0);
                totalCount = onlineCount + offlineCount + unknownCount;
            }

            if (totalCount != 0) {
                onlineRate = new BigDecimal(onlineCount)
                        .divide(new BigDecimal(totalCount), 3, RoundingMode.DOWN)
                        .multiply(new BigDecimal("100"));
            }
        }
        else if (DataCenterMethodNameEnum.DEPT_VIDEO_POINT_ONLINE_RATE.name().equals(tag)) {
            // 构建统计条件
            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));
            // 权限过滤
            if (areaDeptEnum != null) {
                criteriaList.add(Criteria.where("no").regex("^" + areaDeptEnum.getCode()));
            }
            // 数据类型过滤（省/部门标签）
            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));
            }

            // MongoDB 聚合查询
            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()) {
                onlineCount = (Integer) result.getOrDefault("onlineCount", 0);
                offlineCount = (Integer) result.getOrDefault("offlineCount", 0);
                unknownCount = (Integer) result.getOrDefault("unknownCount", 0);
                totalCount = onlineCount + offlineCount + unknownCount;
            }


            if (totalCount != 0) {
                onlineRate = new BigDecimal(onlineCount)
                        .divide(new BigDecimal(totalCount), 3, RoundingMode.DOWN)
                        .multiply(new BigDecimal("100"));
            }

        }
        else if (DataCenterMethodNameEnum.VIDEO_IMPORTANT_POINT_ONLINE_RATE.name().equals(tag)){
            // 构建统计条件
            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));

            // 权限过滤
            if (areaDeptEnum != null) {
                criteriaList.add(Criteria.where("no").regex("^" + areaDeptEnum.getCode()));
            }
            // 数据类型过滤（省/部门标签）
            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));
            }

            // MongoDB 聚合查询
            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()) {
                onlineCount = (Integer) result.getOrDefault("onlineCount", 0);
                offlineCount = (Integer) result.getOrDefault("offlineCount", 0);
                unknownCount = (Integer) result.getOrDefault("unknownCount", 0);
                totalCount = onlineCount + offlineCount + unknownCount;
            }

            if (totalCount != 0) {
                onlineRate = new BigDecimal(onlineCount)
                        .divide(new BigDecimal(totalCount), 3, RoundingMode.DOWN)
                        .multiply(new BigDecimal("100"));
            }
        }

        return new StatisticsResult(totalCount, onlineCount, offlineCount, unknownCount, onlineRate);
    }

    /**
     * 视频：点位在线率优化线程
     *
     * @param params
     * @return
     */
    @Override
    public Result deptVideoPointOnlineRate(DataCenterQuery params) {
   public Result videoPointOnlineRate(DataCenterQuery params) {
        List<String> likeFileds = Arrays.asList("name", "no", "ip");
        //此处新增了根据用户权限查询的情况
        Query query = null;
        final Query query;
        SysDept sysDept = getSysDeptByLoginUser();
        AreaDeptEnum areaDeptEnum = null;
        final AreaDeptEnum areaDeptEnum; // 声明为final

        if (sysDept != null) {

            areaDeptEnum = AreaDeptEnum.fromDept(Math.toIntExact(sysDept.getDeptId()));
            if (areaDeptEnum != null) {
                query = MongoUtil.getQueryDataCenter(areaDeptEnum.getCode(), params, TIME_FIELD, likeFileds, null, "no");
            } else {
                query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
            }
        } else {
            //需要初始化 不然下方引入 多线程会报未初始化
            areaDeptEnum = null;
            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"),
                Sort.Order.desc("offLineCount")
        );
        query.with(sort);

        long total = mongoTemplate.count(query, TMonitorResult.class);
        //运行分页查询线程
        CompletableFuture<List<TMonitorResult>> listFuture = CompletableFuture.supplyAsync(() -> {
            try {
                MongoUtil.setPage(query, params, TIME_FIELD);
                List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
                //构建列表数据
                formatResultList(resultList,DataCenterMethodNameEnum.VIDEO_POINT_ONLINE_RATE.name());
                return resultList;
            } catch (Exception e) {
                throw new CompletionException("视频设备列表查询失败：" + e.getMessage(), e);
            }
        }, taskExecutor);
        //运行统计线程
        CompletableFuture<StatisticsResult> statsFuture = CompletableFuture.supplyAsync(() -> {
            try {
                return calculateStatistics(params, areaDeptEnum,DataCenterMethodNameEnum.VIDEO_POINT_ONLINE_RATE.name()); // 现在可安全引用
            } catch (Exception e) {
                throw new CompletionException("视频设备状态统计失败：" + e.getMessage(), e);
            }
        }, taskExecutor);

        try {
            CompletableFuture.allOf(listFuture, statsFuture).join();
            List<TMonitorResult> resultList = listFuture.get();
            StatisticsResult statsResult = statsFuture.get();

            HashMap<String, Object> map = new HashMap<>();
            map.put("count", Arrays.asList(
                    String.valueOf(statsResult.totalCount),
                    String.valueOf(statsResult.onlineCount),
                    String.valueOf(statsResult.offlineCount),
                    String.valueOf(statsResult.unknownCount),
                    this.remove0(statsResult.onlineRate)
            ));
            map.put("list", resultList);

            return Result.ok().data(map).total(total);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return Result.error("查询被中断，请稍后重试");
        } catch (ExecutionException e) {
            Throwable rootCause = e.getCause();
            String errorMsg = rootCause != null ? rootCause.getMessage() : "视频设备数据查询失败";
            return Result.error(errorMsg);
        }
    }

//    @Override
//    public Result videoPointOnlineRate(DataCenterQuery params) {
//        List<String> likeFileds = Arrays.asList("name", "no", "ip");
//        //此处新增了根据用户权限查询的情况
//        Query query = null;
//        SysDept sysDept = getSysDeptByLoginUser();
//        AreaDeptEnum areaDeptEnum = null;
//        if (sysDept !=null){
//            areaDeptEnum = AreaDeptEnum.fromDept(Math.toIntExact(sysDept.getDeptId()));
//            if (areaDeptEnum != null){
//                query = MongoUtil.getQueryDataCenter(areaDeptEnum.getCode(),params,TIME_FIELD,likeFileds,null,"no");
//
//            }else{
//                query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
//            }
//        }else {
//            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 (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> list = dynamicColumnMapper.getDynamicColumnByTable(TableNameConstants.COLUMN_NAME_VIDEO_POINT,item.getNo());
//            item.setDynamicColumnList(list);
//        });
//
//
//        params.setDeptTag(-1);
//        params.setDeviceType(1);
//
//        //卡片统计
//        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()));
//        //此处新增了根据用户权限查询的情况
//        if (areaDeptEnum != null){
//            criteriaList.add(Criteria.where("no").regex("^" +areaDeptEnum.getCode()));
//        }
//        // 根据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"));
//        }
//        HashMap<String, Object> map = new HashMap<>();
//        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
//        map.put("list", resultList);
//        return Result.ok().data(map).total(total);
//    }
    /**
     * 视频：部级点位在线率优化线程
     *
     * @param params
     * @return
     */
    @Override
    public Result deptVideoPointOnlineRate(DataCenterQuery params){
        List<String> likeFileds  =Arrays.asList("name","no","ip");
        final Query query;
        SysDept sysDept = getSysDeptByLoginUser();
        final AreaDeptEnum areaDeptEnum;
        if (sysDept !=null){
            areaDeptEnum = AreaDeptEnum.fromDept(Math.toIntExact(sysDept.getDeptId()));
            if (areaDeptEnum != null){
@@ -848,9 +1141,9 @@
                query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
            }
        }else {
            areaDeptEnum = null;
            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));
        //下拉框在线情况查询条件
@@ -861,88 +1154,258 @@
        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 (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");

        CompletableFuture<List<TMonitorResult>> listFuture = CompletableFuture.supplyAsync(() ->{
            MongoUtil.setPage(query,params,TIME_FIELD);
            List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
            formatResultList(resultList,DataCenterMethodNameEnum.DEPT_VIDEO_POINT_ONLINE_RATE.name());
            return resultList;
        },taskExecutor);

        CompletableFuture<StatisticsResult> statsFuture = CompletableFuture.supplyAsync(()->{
            try {
                return calculateStatistics(params, areaDeptEnum,DataCenterMethodNameEnum.DEPT_VIDEO_POINT_ONLINE_RATE.name()); // 现在可安全引用
            } catch (Exception e) {
                throw new CompletionException("视频设备状态统计失败：" + e.getMessage(), e);
            }
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
            } else if (-1 == item.getOnline()) {
                item.setOnlineStr("离线");
            } else {
                item.setOnlineStr("未知");
            }
        });
        // 统计设备数量
        //卡片统计
        int totalCount = 0;
        int onlineCount = 0;
        int offlineCount = 0;
        int unknownCount = 0;
        //构建条件
        List<Criteria> criteriaList = new ArrayList<>();
        //此处新增了根据用户权限查询的情况
        if (areaDeptEnum != null){
            criteriaList.add(Criteria.where("no").regex("^" +areaDeptEnum.getCode()));
        },taskExecutor);

        try {
            CompletableFuture.allOf(listFuture, statsFuture).join();
            List<TMonitorResult> resultList = listFuture.get();
            StatisticsResult statsResult = statsFuture.get();

            HashMap<String, Object> map = new HashMap<>();
            map.put("count", Arrays.asList(
                    String.valueOf(statsResult.totalCount),
                    String.valueOf(statsResult.onlineCount),
                    String.valueOf(statsResult.offlineCount),
                    String.valueOf(statsResult.unknownCount),
                    this.remove0(statsResult.onlineRate)
            ));
            map.put("list", resultList);

            return Result.ok().data(map).total(total);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return Result.error("查询被中断，请稍后重试");
        } catch (ExecutionException e) {
            Throwable rootCause = e.getCause();
            String errorMsg = rootCause != null ? rootCause.getMessage() : "视频设备数据查询失败";
            return Result.error(errorMsg);
        }
        // 添加固定条件
        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(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }

//    @Override
//    public Result deptVideoPointOnlineRate(DataCenterQuery params) {
//        List<String> likeFileds = Arrays.asList("name", "no", "ip");
//        //此处新增了根据用户权限查询的情况
//        Query query = null;
//        SysDept sysDept = getSysDeptByLoginUser();
//        AreaDeptEnum areaDeptEnum = null;
//        if (sysDept !=null){
//            areaDeptEnum = AreaDeptEnum.fromDept(Math.toIntExact(sysDept.getDeptId()));
//            if (areaDeptEnum != null){
//                query = MongoUtil.getQueryDataCenter(areaDeptEnum.getCode(),params,TIME_FIELD,likeFileds,null,"no");
//
//            }else{
//                query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
//            }
//        }else {
//            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 (item.getPingOnline() == null) {
//                item.setPingOnlineStr("未知");
//            } else if (item.getPingOnline()) {
//                item.setPingOnlineStr("在线");
//            } else if (!item.getPingOnline()) {
//                item.setPingOnlineStr("离线");
//            }
//            if (1 == item.getOnline()) {
//                item.setOnlineStr("在线");
//            } else if (-1 == item.getOnline()) {
//                item.setOnlineStr("离线");
//            } else {
//                item.setOnlineStr("未知");
//            }
//        });
//        // 统计设备数量
//        //卡片统计
//        int totalCount = 0;
//        int onlineCount = 0;
//        int offlineCount = 0;
//        int unknownCount = 0;
//        //构建条件
//        List<Criteria> criteriaList = new ArrayList<>();
//        //此处新增了根据用户权限查询的情况
//        if (areaDeptEnum != null){
//            criteriaList.add(Criteria.where("no").regex("^" +areaDeptEnum.getCode()));
//        }
//        // 添加固定条件
//        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(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
//        map.put("list", resultList);
//        return Result.ok().data(map).total(total);
//    }

//    @Override
//    public Result videoImportantPointOnlineRate(DataCenterQuery params) {
//        List<String> likeFileds = Arrays.asList("name", "no", "ip");
//        //此处新增了根据用户权限查询的情况
//        Query query = null;
//        SysDept sysDept = getSysDeptByLoginUser();
//        AreaDeptEnum areaDeptEnum = null;
//        if (sysDept !=null){
//            areaDeptEnum = AreaDeptEnum.fromDept(Math.toIntExact(sysDept.getDeptId()));
//            if (areaDeptEnum != null){
//                query = MongoUtil.getQueryDataCenter(areaDeptEnum.getCode(),params,TIME_FIELD,likeFileds,null,"no");
//
//            }else{
//                query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
//            }
//        }else {
//            query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
//        }
//        //查视频设备
//        query.addCriteria(Criteria.where("monitorType").regex(".*" + CheckConstants.Rule_Category_Video + ".*"));
//        query.addCriteria(Criteria.where("importantTag").is(Boolean.TRUE));
//        //下拉框在线情况查询条件
//        if (params.getOption() != null) {
//            query.addCriteria(Criteria.where("online").is(params.getOption()));
//        }
//        // 通过pingOnline字段排序，为false的排在前面
//        query.with(Sort.by(Sort.Order.asc("pingOnline")));
//        //分页数量
//        long total = mongoTemplate.count(query, TMonitorResult.class);
//        MongoUtil.setPage(query, params, TIME_FIELD);
//        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
//        params.setDeptTag(3);
//        params.setDeviceType(1);
//        resultList.forEach(item -> {
//            if (item.getPingOnline() == null) {
//                item.setPingOnlineStr("未知");
//            } else if (item.getPingOnline()) {
//                item.setPingOnlineStr("在线");
//            } else if (!item.getPingOnline()) {
//                item.setPingOnlineStr("离线");
//            }
//            if (1 == item.getOnline()) {
//                item.setOnlineStr("在线");
//            } else if (-1 == item.getOnline()) {
//                item.setOnlineStr("离线");
//            } else {
//                item.setOnlineStr("未知");
//            }
//        });
//
//        // 统计设备数量
//        //卡片统计
//        int totalCount = 0;
//        int onlineCount = 0;
//        int offlineCount = 0;
//        int unknownCount = 0;
//        //构建条件
//        List<Criteria> criteriaList = new ArrayList<>();
//        //此处新增了根据用户权限查询的情况
//        if (areaDeptEnum != null){
//            criteriaList.add(Criteria.where("no").regex("^" +areaDeptEnum.getCode()));
//        }
//        // 添加固定条件
//        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"));
//        }
//        HashMap<String, Object> map = new HashMap<>();
//        map.put("count", Arrays.asList(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
//        map.put("list", resultList);
//        return Result.ok().data(map).total(total);
//    }
    /**
     * 视频：重点点位在线率
     *
@@ -950,12 +1413,12 @@
     * @return
     */
    @Override
    public Result videoImportantPointOnlineRate(DataCenterQuery params) {
    public Result videoImportantPointOnlineRate(DataCenterQuery params){
        List<String> likeFileds = Arrays.asList("name", "no", "ip");
        //此处新增了根据用户权限查询的情况
        Query query = null;
        final Query query;
        SysDept sysDept = getSysDeptByLoginUser();
        AreaDeptEnum areaDeptEnum = null;
        final AreaDeptEnum areaDeptEnum;
        if (sysDept !=null){
            areaDeptEnum = AreaDeptEnum.fromDept(Math.toIntExact(sysDept.getDeptId()));
            if (areaDeptEnum != null){
@@ -965,6 +1428,7 @@
                query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
            }
        }else {
            areaDeptEnum = null;
            query = MongoUtil.getQuery(params, TIME_FIELD, likeFileds, null);
        }
        //查视频设备
@@ -976,89 +1440,53 @@
        }
        // 通过pingOnline字段排序，为false的排在前面
        query.with(Sort.by(Sort.Order.asc("pingOnline")));
        //分页数量
        long total = mongoTemplate.count(query, TMonitorResult.class);
        MongoUtil.setPage(query, params, TIME_FIELD);
        List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
        params.setDeptTag(3);
        params.setDeviceType(1);
        resultList.forEach(item -> {
            if (item.getPingOnline() == null) {
                item.setPingOnlineStr("未知");
            } else if (item.getPingOnline()) {
                item.setPingOnlineStr("在线");
            } else if (!item.getPingOnline()) {
                item.setPingOnlineStr("离线");
            }
            if (1 == item.getOnline()) {
                item.setOnlineStr("在线");
            } else if (-1 == item.getOnline()) {
                item.setOnlineStr("离线");
            } else {
                item.setOnlineStr("未知");
            }
        });

        // 统计设备数量
        //卡片统计
        int totalCount = 0;
        int onlineCount = 0;
        int offlineCount = 0;
        int unknownCount = 0;
        //构建条件
        List<Criteria> criteriaList = new ArrayList<>();
        //此处新增了根据用户权限查询的情况
        if (areaDeptEnum != null){
            criteriaList.add(Criteria.where("no").regex("^" +areaDeptEnum.getCode()));
        CompletableFuture<List<TMonitorResult>> listFuture = CompletableFuture.supplyAsync(()->{
            try {
                MongoUtil.setPage(query, params, TIME_FIELD);
                List<TMonitorResult> resultList = mongoTemplate.find(query, TMonitorResult.class);
                //构建列表数据
                formatResultList(resultList,DataCenterMethodNameEnum.VIDEO_IMPORTANT_POINT_ONLINE_RATE.name());

                return resultList;
            } catch (Exception e) {
                throw new CompletionException("视频设备列表查询失败：" + e.getMessage(), e);
            }
        },taskExecutor);

        CompletableFuture<StatisticsResult> statsFuture = CompletableFuture.supplyAsync(()->{
            try {
                return calculateStatistics(params, areaDeptEnum, DataCenterMethodNameEnum.VIDEO_IMPORTANT_POINT_ONLINE_RATE.name());
            }catch (Exception e){
                throw new CompletionException("视频设备状态统计失败：" + e.getMessage(), e);
            }
        },taskExecutor);
        try {
            CompletableFuture.allOf(listFuture, statsFuture).join();
            List<TMonitorResult> resultList = listFuture.get();
            StatisticsResult statsResult = statsFuture.get();

            HashMap<String, Object> map = new HashMap<>();
            map.put("count", Arrays.asList(
                    String.valueOf(statsResult.totalCount),
                    String.valueOf(statsResult.onlineCount),
                    String.valueOf(statsResult.offlineCount),
                    String.valueOf(statsResult.unknownCount),
                    this.remove0(statsResult.onlineRate)
            ));
            map.put("list", resultList);

            return Result.ok().data(map).total(total);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return Result.error("查询被中断，请稍后重试");
        } catch (ExecutionException e) {
            Throwable rootCause = e.getCause();
            String errorMsg = rootCause != null ? rootCause.getMessage() : "视频设备数据查询失败";
            return Result.error(errorMsg);
        }
        // 添加固定条件
        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(totalCount + "", onlineCount + "", offlineCount + "", unknownCount + "", this.remove0(onlineRate)));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);

    }

    /**
@@ -1439,18 +1867,6 @@
        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);
@@ -1601,104 +2017,222 @@

            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);
//        // 统计数量
//        MongoDatabase database = mongoTemplate.getDb();
//        MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
//
//        List<Integer> status = Arrays.asList(1, 0, -1);
//        AreaDeptEnum finalAreaDeptEnum = areaDeptEnum;
//        List<String> resultCount = status.stream().map(item -> {
//            List<Document> dList = new ArrayList<>(2);
//
//            dList.add(new Document("recordStatus", new Document("$eq", item)));
//            if(finalAreaDeptEnum != null){
//                dList.add(new Document("$and", Arrays.asList(
//                        new Document("no", new Document("$in", noString)),
//                        new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
//                )));
//            }else {
//                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);
//        if(finalAreaDeptEnum != null){
//            documentList.add(new Document("$and", Arrays.asList(
//                    new Document("no", new Document("$in", noString)),
//                    new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
//            )));
//        }else {
//            documentList.add(new Document("no", new Document("$in", noString)));
//        }
//        //        documentList.add(new Document("$and", Arrays.asList(
//        //                new Document("no", new Document("$in", noString)),
//        //                new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
//        //        )));
//        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", this.buildCount(areaDeptEnum,noString,params,DataCenterMethodNameEnum.VIDEO_AVAILABILITY_RATE.name()));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }
    public List<String> buildCount(AreaDeptEnum areaDeptEnum,List<String> noString,DataCenterQuery params,String tag){
        MongoDatabase databaes= mongoTemplate.getDb();
        MongoCollection<Document> collection = databaes.getCollection("uy_record_meta_d_sum");
        AreaDeptEnum finalAreaDeptEnum = areaDeptEnum;
        List<String> resultCount = status.stream().map(item -> {
            List<Document> dList = new ArrayList<>(2);

            dList.add(new Document("recordStatus", new Document("$eq", item)));
            if(finalAreaDeptEnum != null){
                dList.add(new Document("$and", Arrays.asList(
                        new Document("no", new Document("$in", noString)),
                        new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
                )));
            }else {
                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();
        // 2. 构建聚合管道（核心：一次管道统计所有指标）
        List<Document> pipeline = new ArrayList<>();

        List<Document> documentList = new ArrayList<>(2);
        if(finalAreaDeptEnum != null){
            documentList.add(new Document("$and", Arrays.asList(
        // 阶段1：$match - 基础过滤（复用两次查询的共同条件）
        List<Document> baseFilterList = new ArrayList<>();
        if (DataCenterMethodNameEnum.DEPT_VIDEO_POINT_ONLINE_RATE.name().equals(tag)){
            baseFilterList.add(new Document("deptTag", new Document("$eq", Boolean.TRUE)));
        }
        if (DataCenterMethodNameEnum.VIDEO_IMPORTANT_POINT_AVAILABILITY_RATE.name().equals(tag)){
            baseFilterList.add(new Document("importantTag", new Document("$eq", Boolean.TRUE)));
        }

        // 条件1：no的过滤（in + 可选前缀匹配，和你原代码逻辑一致）
        if (finalAreaDeptEnum != null) {
            baseFilterList.add(new Document("$and", Arrays.asList(
                    new Document("no", new Document("$in", noString)),
                    new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
            )));
        }else {
            documentList.add(new Document("no", new Document("$in", noString)));
        } else {
            baseFilterList.add(new Document("no", new Document("$in", noString)));
        }
//        documentList.add(new Document("$and", Arrays.asList(
//                new Document("no", new Document("$in", noString)),
//                new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
//        )));
        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")
        setTag(params, baseFilterList);
        Document matchStage = new Document("$match", new Document("$and", baseFilterList));
        pipeline.add(matchStage);
        // 阶段2：$group - 按deviceId去重，标记各条件是否满足
        // --------------------------
        // 逻辑：每个设备只统计一次，用$cond标记“是否符合某条件”（符合=1，不符合=0）
        Document groupByDeviceStage = new Document("$group",
                new Document("_id", "$deviceId") // 按设备ID分组（去重核心）
                        // 标记：该设备是否满足 recordStatus=1
                        .append("status1Flag", new Document("$sum",
                                new Document("$cond", Arrays.asList(
                                        new Document("$eq", Arrays.asList("$recordStatus", 1)), // 判断条件
                                        1, // 符合：记1
                                        0  // 不符合：记0
                                ))
                        ))
                        // 标记：该设备是否满足 recordStatus=0
                        .append("status0Flag", new Document("$sum",
                                new Document("$cond", Arrays.asList(
                                        new Document("$eq", Arrays.asList("$recordStatus", 0)),
                                        1,
                                        0
                                ))
                        ))
                        // 标记：该设备是否满足 recordStatus=-1
                        .append("statusMinus1Flag", new Document("$sum",
                                new Document("$cond", Arrays.asList(
                                        new Document("$eq", Arrays.asList("$recordStatus", -1)),
                                        1,
                                        0
                                ))
                        ))
                        // 标记：该设备是否满足 missDuration ≤ finalRecordingMinTime（原第二段查询条件）
                        .append("missOkFlag", new Document("$sum",
                                new Document("$cond", Arrays.asList(
                                        new Document("$lte", Arrays.asList("$missDuration", finalRecordingMinTime)),
                                        1,
                                        0
                                ))
                        ))
        );
        AggregateIterable<Document> result = collection2.aggregate(pipeline);
        pipeline.add(groupByDeviceStage);
        // --------------------------
        // 阶段3：$group - 全局统计（累加所有设备的标记，得到最终数量）
        // --------------------------
        // 逻辑：无分组键（_id: null），将所有设备的标记累加，得到总计数
        Document groupGlobalStage = new Document("$group",
                new Document("_id", null) // 全局分组（统计所有设备）
                        // 原第一段查询结果1：status=1的设备数
                        .append("status1Count", new Document("$sum", "$status1Flag"))
                        // 原第一段查询结果2：status=0的设备数
                        .append("status0Count", new Document("$sum", "$status0Flag"))
                        // 原第一段查询结果3：status=-1的设备数
                        .append("statusMinus1Count", new Document("$sum", "$statusMinus1Flag"))
                        // 原第二段查询结果：missDuration符合条件的设备数
                        .append("missOkCount", new Document("$sum", "$missOkFlag"))
        );
        pipeline.add(groupGlobalStage);


        Integer uniqueDeviceIdCount = 0;
        for (Document doc : result) {
            uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
            break; // 不需要继续遍历，因为 $count 只会产生一个结果
        // --------------------------
        // 执行聚合查询，提取所有统计结果
        // --------------------------
        AggregateIterable<Document> aggregateResult = collection.aggregate(pipeline);
        Document statDoc = null;
        for (Document doc : aggregateResult) { // 全局分组只会返回1条结果
            statDoc = doc;
            break;
        }
        log.error("录像可用率打印：{}",uniqueDeviceIdCount);
        int totalCount = 0;
        for (String s : resultCount) {
            totalCount += Integer.parseInt(s);
        }
        resultCount.add(0, totalCount + "");

        // 初始化默认值（避免空指针）
        int status1Count = 0, status0Count = 0, statusMinus1Count = 0, missOkCount = 0;
        if (statDoc != null) {
            status1Count = statDoc.getInteger("status1Count", 0);
            status0Count = statDoc.getInteger("status0Count", 0);
            statusMinus1Count = statDoc.getInteger("statusMinus1Count", 0);
            missOkCount = statDoc.getInteger("missOkCount", 0);
        }
        int total = status1Count + status0Count + statusMinus1Count;
        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"));
        if (total != 0) { // 只有当total不为0时，才计算比率
            onlineRate = new BigDecimal(missOkCount)
                    .divide(new BigDecimal(total), 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);
        return Result.ok().data(map).total(total);
        List<String> list = new ArrayList<>();
        list.add(total +"");
        list.add(status1Count +"");
        list.add(status0Count +"");
        list.add(statusMinus1Count +"");
        list.add(this.remove0(onlineRate));
        return list;
    }

    /**
@@ -1709,6 +2243,7 @@
     */
    @Override
    public Result deptVideoAvailabilityRate(DataCenterQuery params) {
        List<String> noString = tMonitorMapper.getIdListVideo();
        List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
        SysDept sysDept = getSysDeptByLoginUser();
        AreaDeptEnum areaDeptEnum = null;
@@ -1723,10 +2258,15 @@
        }else {
            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()));
        }
        //新增部级判断
        query.addCriteria(Criteria.where("deptTag").is(Boolean.TRUE));
        long total = mongoTemplate.count(query, RecordMetaDSumResult.class);
        MongoUtil.setPage(query, params, "createTime");
        List<RecordMetaDSumResult> resultList = mongoTemplate.find(query, RecordMetaDSumResult.class);
@@ -1736,104 +2276,12 @@
            AreaDeptEnum areaDeptEnumInfo = AreaDeptEnum.fromCode(areaCode);
            if (areaDeptEnumInfo != null) item.setArealayername(areaDeptEnumInfo.getName());
        });
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
        List<Integer> status = Arrays.asList(1, 0, -1);
        AreaDeptEnum finalAreaDeptEnum = areaDeptEnum;
        List<String> resultCount = status.stream().map(item -> {
            List<Document> dList = new ArrayList<>(4);
            dList.add(new Document("deptTag", new Document("$eq", Boolean.TRUE)));
            dList.add(new Document("recordStatus", new Document("$eq", item)));
            setTag(params, dList);
            if (finalAreaDeptEnum != null){
                dList.add(new Document("$and", Arrays.asList(
//                    new Document("no", new Document("$in", noString)),
                        new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
                )));
            }
            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 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);
        if (finalAreaDeptEnum != null){
            documentList.add(new Document("$and", Arrays.asList(
//                    new Document("no", new Document("$in", noString)),
                    new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
            )));
        }
        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 (!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<>();
        map.put("count", resultCount);
        map.put("count", this.buildCount(areaDeptEnum,noString,params,DataCenterMethodNameEnum.DEPT_VIDEO_POINT_ONLINE_RATE.name()));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }

    /**
     * 视频：重点点位录像可用率
     *
@@ -1842,6 +2290,7 @@
     */
    @Override
    public Result videoImportantPointAvailabilityRate(DataCenterQuery params) {
        List<String> noString = tMonitorMapper.getIdListVideo();
        List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
        SysDept sysDept = getSysDeptByLoginUser();
        AreaDeptEnum areaDeptEnum = null;
@@ -1857,10 +2306,14 @@
            query = MongoUtil.getQuery(params, "createTime", likeFileds, null);
        }
        query.addCriteria(Criteria.where("importantTag").is(Boolean.TRUE));
        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);
@@ -1871,96 +2324,84 @@
            if (areaDeptEnumInfo != null) item.setArealayername(areaDeptEnumInfo.getName());
        });
        // 统计数量
        MongoDatabase database = mongoTemplate.getDb();
        MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
        List<Integer> status = Arrays.asList(1, 0, -1);
        AreaDeptEnum finalAreaDeptEnum = areaDeptEnum;
        List<String> resultCount = status.stream().map(item -> {
            List<Document> dList = new ArrayList<>(4);
            dList.add(new Document("importantTag", new Document("$eq", Boolean.TRUE)));
            dList.add(new Document("recordStatus", new Document("$eq", item)));
            setTag(params, dList);
            if (finalAreaDeptEnum != null){
                dList.add(new Document("$and", Arrays.asList(
//                    new Document("no", new Document("$in", noString)),
                        new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
                )));
            }
            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 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);
        if (finalAreaDeptEnum != null){
            documentList.add(new Document("$and", Arrays.asList(
//                    new Document("no", new Document("$in", noString)),
                    new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
            )));
        }
        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));
//        MongoDatabase database = mongoTemplate.getDb();
//        MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
//        List<Integer> status = Arrays.asList(1, 0, -1);
//        AreaDeptEnum finalAreaDeptEnum = areaDeptEnum;
//        List<String> resultCount = status.stream().map(item -> {
//            List<Document> dList = new ArrayList<>(4);
//            dList.add(new Document("importantTag", new Document("$eq", Boolean.TRUE)));
//            dList.add(new Document("recordStatus", new Document("$eq", item)));
//            setTag(params, dList);
//            if (finalAreaDeptEnum != null){
//                dList.add(new Document("$and", Arrays.asList(
////                    new Document("no", new Document("$in", noString)),
//                        new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
//                )));
//            }
//            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 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);
//        if (finalAreaDeptEnum != null){
//            documentList.add(new Document("$and", Arrays.asList(
////                    new Document("no", new Document("$in", noString)),
//                    new Document("no", new Document("$regex", "^" + finalAreaDeptEnum.getCode()))
//            )));
//        }
        //加一个总数
        int totalCount = 0;
        for (String s : resultCount) {
            totalCount += Integer.parseInt(s);
        }
        resultCount.add(0, totalCount + "");
        BigDecimal onlineRate = BigDecimal.ZERO;
        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));
//        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;
//        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<>();
        map.put("count", resultCount);
        map.put("count", this.buildCount(areaDeptEnum,noString,params,DataCenterMethodNameEnum.VIDEO_IMPORTANT_POINT_AVAILABILITY_RATE.name()));
        map.put("list", resultList);
        return Result.ok().data(map).total(total);
    }

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

New file
@@ -0,0 +1,72 @@
package com.ycl.platform.service.impl;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ycl.platform.domain.entity.DemeritRecord;
import com.ycl.platform.domain.query.DataCenterQuery;
import com.ycl.platform.domain.query.DemeritRecordQuery;
import com.ycl.platform.domain.vo.WorkOrderVO;
import com.ycl.platform.domain.vo.screen.DemeritRecordVO;
import com.ycl.platform.mapper.DemeritRecordMapper;
import com.ycl.platform.service.IDemeritRecordService;
import com.ycl.system.Result;
import com.ycl.system.page.PageUtil;
import com.ycl.utils.DateUtils;
import enumeration.general.AreaDeptEnum;
import lombok.RequiredArgsConstructor;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * zgyw
 *
 * @author : zxl
 * @date : 2025-09-15 16:36
 **/
@Service
@RequiredArgsConstructor
public class DemeritRecordImpl extends ServiceImpl<DemeritRecordMapper, DemeritRecord> implements IDemeritRecordService {
    private final DemeritRecordMapper demeritRecordMapper;

    @Override
    public Result getDemeritRecordPage(DemeritRecordQuery query) {

        IPage<DemeritRecordVO> page = PageUtil.getPage(query, DemeritRecordVO.class);
        baseMapper.getPage(query, page);

        for (DemeritRecordVO demeritRecordVO : page.getRecords()) {
            AreaDeptEnum areaDeptEnum = AreaDeptEnum.fromDept(Math.toIntExact(demeritRecordVO.getDeptId()));
            if (areaDeptEnum != null){
                demeritRecordVO.setDeptName(areaDeptEnum.getName());
            }

        }

        return Result.ok().data(page.getRecords()).total(page.getTotal());
    }

    @Override
    public void add(List<DemeritRecord> record) {

    }


    @Override
    public Result delete(Integer id) {


        return null;
    }


}

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

@@ -1161,6 +1161,8 @@
            exportForm.setDeptIds(deptIds);
        }
        Query query = getQuery(exportForm);


        //月份每日在线数据
        List<TMonitorResult> onlineResult = mongoTemplate.find(query, TMonitorResult.class);
        // 使用 Collectors.toMap 去重，保留每个 No 的第一个遇到的元素

 ycl-server/src/main/java/com/ycl/task/DemeritRecordTask.java

New file
@@ -0,0 +1,295 @@
package com.ycl.task;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.google.common.util.concurrent.AtomicDouble;
import com.ycl.platform.domain.entity.DemeritRecord;
import com.ycl.platform.domain.entity.Report;
import com.ycl.platform.domain.result.UY.RecordMetaDSumResult;
import com.ycl.platform.mapper.DemeritRecordMapper;
import com.ycl.platform.mapper.ReportMapper;
import com.ycl.platform.service.IDemeritRecordService;
import com.ycl.utils.DateUtils;
import enumeration.ConstructionTypeEnum;
import enumeration.general.AreaDeptEnum;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;
import utils.StringUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * zgyw
 *
 * @author : zxl
 * @date : 2025-09-15 17:32
 **/

@Slf4j
@RequiredArgsConstructor
@Component("demeritRecordTask")
public class DemeritRecordTask {

    private final MongoTemplate mongoTemplate;

    private final ReportMapper reportMapper;

    private static final ExecutorService executorService = new ThreadPoolExecutor(16,
            128,
            5000,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(1000),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );
    private final IDemeritRecordService demeritRecordService;

    // 提取公共过滤方法
    private Predicate<RecordMetaDSumResult> deviceNameStartsWith(String prefix) {
        return result -> result.getDeviceName() != null && result.getDeviceName().startsWith(prefix);
    }

    private Predicate<RecordMetaDSumResult> deviceNameStartsWithAny(String... prefixes) {
        return result -> result.getDeviceName() != null &&
                Arrays.stream(prefixes).anyMatch(prefix -> result.getDeviceName().startsWith(prefix));
    }

    private DemeritRecord buildDemeritRecord(String constructionType,BigDecimal demerit,Integer deptId) {
        DemeritRecord record = new DemeritRecord();
        record.setConstructionType(constructionType);
        record.setDemerit(demerit);
        record.setDeptId(deptId);
        return record;
    }
    private BigDecimal calculateTotalDeduction(List<RecordMetaDSumResult> records) {
        BigDecimal total = BigDecimal.ZERO; // 单线程循环，无需AtomicReference

        for (RecordMetaDSumResult record : records) {
            // 安全处理空值：若missDuration为null，默认按0分钟处理
            Double missDurationHours = record.getMissDuration();
            double missDurationMinutes = Optional.ofNullable(missDurationHours)
                    .map(hours -> hours * 60.0) // 小时转分钟
                    .orElse(0.0); // 空值默认0分钟

            // 计算单条记录的扣分
            BigDecimal deduction;
            if (missDurationMinutes > 720) {
                deduction = new BigDecimal("2.0");
            } else if (missDurationMinutes > 240) {
                deduction = new BigDecimal("1.5");
            } else if (missDurationMinutes > 60) {
                deduction = new BigDecimal("1.0");
            } else if (missDurationMinutes > 30) {
                deduction = new BigDecimal("0.5");
            } else {
                deduction = BigDecimal.ZERO;
            }

            // 累加总扣分（最后统一处理精度，避免中间四舍五入误差）
            total = total.add(deduction);
        }

        // 最终统一保留1位小数，四舍五入
        return total.setScale(1, RoundingMode.HALF_UP);
    }

    public void run(){
        log.info("开始执行计算每日扣分记录情况");
        //获得mongodb中所有全景的设备
        //mongodb查询条件
        Date today =new Date();
//        Calendar calendar = Calendar.getInstance();
//        calendar.setTime(today);
//        calendar.add(Calendar.DAY_OF_YEAR, -2); // 减去2天 测试用
//        Date twoDaysAgo = calendar.getTime();

        //计算录像可用率和重点录像可用率
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(today)).lt(DateUtils.getDayEnd(today)));
        List<RecordMetaDSumResult> results = mongoTemplate.find(query, RecordMetaDSumResult.class);

        log.info("日期:{},查询出的设备录像记录数{}",today,results.size());
        //过滤掉非全景的设备 且 1则为细节，如果是0则为全景
        results.stream().filter(obj ->
        {
            String deviceId = obj.getDeviceId();
            if (deviceId == null || deviceId.length() < 7) {
                return false; // 去除元素
            }
            // 获取倒数第七位的字符
            char seventhFromEnd = deviceId.charAt(deviceId.length() - 7);
            return seventhFromEnd != '1'; //为1 则会 false 去除掉
        });

        log.info("过滤后剩余全景设备数{}",results.size());
        //只考核LT_、(三期)
        // DX_ 、（一二期）
        // DX_R、（四区人脸）
        // DX_RS、（四区人脸）
        // （需要排除DX_R2、DX_RD、J_、T1、T3以及没有前缀的设备）
        List<String> prefixes = Arrays.asList("LT_", "DX_", "DX_R", "DX_RS");

        results.stream()
                .filter(result -> {
                    String deviceName = result.getDeviceName();
                    if (deviceName == null) {
                        return false;
                    }
                    return prefixes.stream().anyMatch(deviceName::startsWith);
                })
                .collect(Collectors.toList());

        log.info("剩余考核设备过滤后设备数{}",results.size());

        //过滤掉报备的设备
        //查询在当前时间有报备的所有设备，
        //因为录像数据的时间
        List<String> deviceIds = new LambdaQueryChainWrapper<>(reportMapper)
                .eq(Report::getStatus, 1)
                .ge(Report::getBeginCreateTime, today)
                .le(Report::getEndCreateTime, today)
                .list().stream()
                .collect(Collectors.toMap(
                        Report::getSerialNumber,  // key: serialNumber
                        Function.identity(),      // value: Report对象本身
                        (existing, replacement) ->
                                // 当key冲突时，保留createTime更大的（更新的）记录
                                existing.getCreateTime().after(replacement.getCreateTime()) ? existing : replacement
                ))
                .values().stream()
                .map(Report::getSerialNumber).collect(Collectors.toList());

        Set<String> deviceIdSet = new HashSet<>(deviceIds);
        log.info("报备设备数{}",deviceIdSet.size());
        results.stream()
                .filter(result -> {
                    // 获取当前对象的deviceId
                    String resultDeviceId = result.getDeviceId();
                    // 过滤条件：deviceId不在集合中（注意处理null值，避免NPE）
                    return resultDeviceId != null && !deviceIdSet.contains(resultDeviceId);
                })
                .collect(Collectors.toList());

        log.info("剩余过滤报备后设备数{}",results.size());

        // 按区域划分 组装成map
        results.forEach(item -> {
            String areaCode = item.getArealayername().substring(0, 6);
            AreaDeptEnum areaDeptEnum = AreaDeptEnum.fromCode(areaCode);
            if (areaDeptEnum != null) {
                item.setArealayerno(areaDeptEnum.getCode());
            }
        });
        //需要添加数据库的数据集合
        List<DemeritRecord> demeritRecords = new ArrayList<>();

        Map<String,List<RecordMetaDSumResult>> groupByArealayerno = results.stream()
                .collect(Collectors.groupingBy(RecordMetaDSumResult::getArealayerno));

        //循环分组后的map
        for (Map.Entry<String, List<RecordMetaDSumResult>> entry : groupByArealayerno.entrySet()) {
            String arealayerno = entry.getKey();
            log.info("循环区域{}",arealayerno);
            //获得区
            AreaDeptEnum areaDeptEnum = AreaDeptEnum.fromCode(arealayerno);
            if (areaDeptEnum == null) {
                log.info("区域数据异常，异常区域键值：{}",arealayerno);
                return;
            }

            List<RecordMetaDSumResult> resultList = entry.getValue();
            log.info("resultList:{}",resultList.size());
            if (CollectionUtils.isNotEmpty(resultList)) {
                // 对每个List进行处理 分建类型处理集合
                List<RecordMetaDSumResult> phase_one_two = resultList.stream()
                        .filter(deviceNameStartsWith("DX_"))
                        .collect(Collectors.toList());
                log.info("一二期考核记录数{}",phase_one_two.size());
                List<RecordMetaDSumResult> phase_three = resultList.stream()
                        .filter(deviceNameStartsWith("LT_"))
                        .collect(Collectors.toList());
                log.info("三期考核记录数{}",phase_three.size());
                List<RecordMetaDSumResult> phase_fourth = resultList.stream()
                        .filter(deviceNameStartsWithAny("DX_R", "DX_RS"))
                        .collect(Collectors.toList());
                log.info("四期考核记录数{}",phase_fourth.size());
                if (CollectionUtils.isNotEmpty(phase_one_two)){
                    BigDecimal phaseOneTwoDeduction = calculateTotalDeduction(phase_one_two);
                    DemeritRecord demeritRecordPhaseOneTwo = buildDemeritRecord(
                            ConstructionTypeEnum.PHASE_ONE_TWO.name(),
                            phaseOneTwoDeduction,
                            areaDeptEnum.getDeptId());
                    demeritRecords.add(demeritRecordPhaseOneTwo);
                }else{
                    DemeritRecord phaseOneTwoDeduction = buildDemeritRecord(
                            ConstructionTypeEnum.PHASE_ONE_TWO.name(),
                            BigDecimal.ZERO,
                            areaDeptEnum.getDeptId());
                    demeritRecords.add(phaseOneTwoDeduction);
                }


                if (CollectionUtils.isNotEmpty(phase_three)){
                    BigDecimal phaseThreeDeduction = calculateTotalDeduction(phase_three);
                    DemeritRecord demeritRecordPhaseThree = buildDemeritRecord(
                            ConstructionTypeEnum.PHASE_THREE.name(),
                            phaseThreeDeduction,
                            areaDeptEnum.getDeptId());
                    demeritRecords.add(demeritRecordPhaseThree);
                }else {
                    DemeritRecord phaseThreeDeduction = buildDemeritRecord(
                            ConstructionTypeEnum.PHASE_THREE.name(),
                            BigDecimal.ZERO,
                            areaDeptEnum.getDeptId());
                    demeritRecords.add(phaseThreeDeduction);
                }
                if (CollectionUtils.isNotEmpty(phase_fourth)){
                    BigDecimal phaseFourthDeduction = calculateTotalDeduction(phase_fourth);
                    DemeritRecord demeritRecordPhaseFourth = buildDemeritRecord(
                            ConstructionTypeEnum.PHASE_FOURTH.name(),
                            phaseFourthDeduction,
                            areaDeptEnum.getDeptId());
                    demeritRecords.add(demeritRecordPhaseFourth);
                }else{
                    DemeritRecord phaseFourthDeduction = buildDemeritRecord(
                            ConstructionTypeEnum.PHASE_FOURTH.name(),
                            BigDecimal.ZERO,
                            areaDeptEnum.getDeptId());
                    demeritRecords.add(phaseFourthDeduction);
                }

            }



        }

        //处理完数据插入数据库中
        //先删除需要插入时间是否存在数据

        LambdaQueryWrapper<DemeritRecord> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.ge(DemeritRecord::getCreateTime,DateUtils.getDayStart(today))
                        .le(DemeritRecord::getCreateTime,DateUtils.getDayEnd(today));
        demeritRecordService.remove(queryWrapper);
        demeritRecordService.saveBatch(demeritRecords);

        log.info("结束计算每日扣分记录情况：插入数据量{},数据信息:{}",demeritRecords.size(),demeritRecords);

    }
}

 ycl-server/src/main/resources/mapper/zgyw/DemeritREcordMapper.xml

New file
@@ -0,0 +1,40 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ycl.platform.mapper.DemeritRecordMapper">
    <resultMap type="com.ycl.platform.domain.vo.screen.DemeritRecordVO" id="baseResult">
        <result property="id" column="id"/>
        <result property="deptId" column="dept_id"/>
        <result property="demerit" column="demerit"/>
        <result property="createTime" column="create_time"/>
        <result property="constructionType" column="construction_type"/>
    </resultMap>


    <select id="getPage" resultMap="baseResult">
        select
            ter.id,
            ter.dept_id,
            ter.create_time,
            ter.construction_type,
            ter.demerit
        from t_demerit_record ter where ter.deleted = 0
        <if test="query.deptId != null and query.deptId != ''">
            AND ter.dept_id = #{query.deptId}
        </if>
        <if test="query.constructionType != null and query.constructionType != ''">
            AND ter.construction_type = #{query.constructionType}
        </if>
        <!-- 时间范围筛选：按日查询 -->
        <if test="query.searchType == 'day' and query.dayDate != null">
            AND ter.create_time >= #{query.dayDate}  <!-- 当天00:00:00 -->
            AND ter.create_time &lt;DATE_ADD(#{query.dayDate}, INTERVAL 1 DAY)  <!-- 次日00:00:00（不包含） -->
        </if>
        <!-- 时间范围筛选：按月查询 -->
        <if test="query.searchType == 'month' and query.monthDate != null">
            AND ter.create_time >= #{query.monthDate}  <!-- 当月1日00:00:00 -->
            AND ter.create_time &lt;DATE_ADD(LAST_DAY(#{query.monthDate}), INTERVAL 1 DAY)  <!-- 下月1日00:00:00（不包含） -->
        </if>
    </select>
</mapper>

 ycl-server/src/main/resources/mapper/zgyw/TMonitorMapper.xml

@@ -166,7 +166,25 @@
            <if test="cameraDept != null  and cameraDept != ''">and camera_dept = #{cameraDept}</if>
            <if test="hybm != null  and hybm != ''">and hybm = #{hybm}</if>
            <if test="lxbm != null ">and lxbm = #{lxbm}</if>
<!--            <if test="recovery != null ">and p.recovery = #{recovery}</if>-->
            <if test="constructionType != null and constructionType != ''">
                <choose>
                    <when test="constructionType == 'PHASE_ONE_TWO'">
                        and m.name LIKE 'DX_%'
                    </when>
                    <when test="constructionType == 'PHASE_THREE'">
                        and m.name LIKE 'LT_%'
                    </when>

                    <when test="constructionType == 'PHASE_FOURTH'">
                        and (
                        m.name LIKE 'DX_R%'
                        OR
                        m.name LIKE 'DX_RS%'
                        )
                    </when>
                </choose>
            </if>

            ${params.dataScope}
        </where>
    </select>
@@ -417,6 +435,23 @@
            <if test="address != null">
                and p.dept_id = #{address}
            </if>
            <if test="constructionType != null and constructionType != ''">
                <choose>
                    <when test="constructionType == 'PHASE_ONE_TWO'">
                        and m.name LIKE 'DX_%'
                    </when>
                    <when test="constructionType == 'PHASE_THREE'">
                        and m.name LIKE 'LT_%'
                    </when>
                    <when test="constructionType == 'PHASE_FOURTH'">
                        and (
                        m.name LIKE 'DX_R%'
                        OR
                        m.name LIKE 'DX_RS%'
                        )
                    </when>
                </choose>
            </if>
            ${params.dataScope}
        </where>
    </select>