zgyw.git - Gitblit

			@@ -1,31 +1,35 @@
			package com.ycl.platform.service.impl;

			import com.baomidou.mybatisplus.core.metadata.IPage;
			import com.github.pagehelper.Page;
			import com.github.pagehelper.PageHelper;
			import com.github.pagehelper.PageInfo;
			import com.mongodb.client.AggregateIterable;
			import com.mongodb.client.MongoCollection;
			import com.mongodb.client.MongoDatabase;
			import com.ycl.platform.domain.entity.ImageResourceSecurityDetail;
			import com.ycl.platform.domain.entity.YwPoint;
			import com.ycl.platform.domain.query.DataCenterQuery;
			import com.ycl.platform.domain.result.HK.*;
			import com.ycl.platform.domain.result.UY.MonitorQualifyResult;
			import com.ycl.platform.domain.result.UY.OneMachineFileResult;
			import com.ycl.platform.domain.result.UY.RecordMetaDSumResult;
			import com.ycl.platform.domain.result.UY.VideoOnlineResult;
			import com.ycl.platform.domain.result.UY.*;
			import com.ycl.platform.mapper.ImageResourceSecurityDetailMapper;
			import com.ycl.platform.mapper.ImageResourceSecurityMapper;
			import com.ycl.platform.mapper.YwPointMapper;
			import com.ycl.platform.service.DataCenterService;
			import com.ycl.platform.service.YwPointService;
			import com.ycl.system.Result;
			import com.ycl.system.page.TableDataInfo;
			import com.ycl.system.page.PageUtil;
			import com.ycl.utils.MongoUtil;
			import constant.HttpStatus;
			import lombok.RequiredArgsConstructor;
			import org.apache.commons.collections.CollectionUtils;
			import org.bson.Document;
			import org.springframework.data.domain.Sort;
			import org.springframework.data.mongodb.core.MongoTemplate;
			import org.springframework.data.mongodb.core.query.Criteria;
			import org.springframework.data.mongodb.core.query.Query;
			import org.springframework.data.mongodb.core.query.TextCriteria;
			import org.springframework.stereotype.Service;

			import java.util.List;
			import java.util.Objects;
			import java.util.*;
			import java.util.stream.Collectors;

			/**
			* 数据中心接口
			@@ -38,8 +42,10 @@
			public class DataCenterServiceImpl implements DataCenterService {

			private final MongoTemplate mongoTemplate;
			private final ImageResourceSecurityMapper securityMapper;
			private final ImageResourceSecurityDetailMapper securityDetailMapper;
			private final YwPointMapper pointMapper;


			private final static String TIME_FIELD = "mongoCreateTime";

			/**
			@@ -50,246 +56,69 @@
			*/
			@Override
			public Result videoPointOnlineRate(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			// 生成查询
			List<String> likeFileds = Arrays.asList("arealayerName", "ipAddr", "deviceName", "deviceId");
			Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, likeFileds, null);

			// 先查总数再分页
			long total = mongoTemplate.count(query, VideoOnlineResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<VideoOnlineResult> resultList = mongoTemplate.find(query, VideoOnlineResult.class);
			return Result.ok().data(resultList).total(total);

			// 统计数量
			MongoDatabase database = mongoTemplate.getDb();
			MongoCollection<Document> collection = database.getCollection("uy_online");
			long distinctCount = collection.distinct("deviceId", String.class).into(new ArrayList<>()).size();

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

			/**
			* 视频：一机一档注册率
			* 视频：部级点位在线率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoOneMachineDocumentRegister(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);
			}
			public Result deptVideoPointOnlineRate(DataCenterQuery params) {
			// 先查出部级点位的国标
			List<String> deptGBList = pointMapper.getDeptPointGB(0);
			List<String> likeFileds = Arrays.asList("arealayerName", "ipAddr", "deviceName", "deviceId");
			// 生成查询
			Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, likeFileds, deptGBList);

			/**
			* 视频：一机一档合格率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoOneMachineDocumentQualified(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, MonitorQualifyResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<MonitorQualifyResult> resultList = mongoTemplate.find(query, MonitorQualifyResult.class);
			return Result.ok().data(resultList).total(total);
			}
			// 先查总数再分页
			long total = mongoTemplate.count(query, VideoOnlineResult.class);
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<VideoOnlineResult> resultList = mongoTemplate.find(query, VideoOnlineResult.class);

			/**
			* 视频：档案考核比
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoAssessmentFileRatio(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			// 统计数量
			MongoDatabase database = mongoTemplate.getDb();
			MongoCollection<Document> collection = database.getCollection("uy_online");
			Document filter = new Document("deviceId", new Document("$in", deptGBList));
			// 构建聚合管道
			List<Document> pipeline = Arrays.asList(
			// 只要部级的
			new Document("$match", filter),
			// $group 去重
			new Document("$group", new Document("_id", "$deviceId")),
			new Document("$count", "uniqueDeviceIds")
			);
			// 执行聚合查询并获取结果
			AggregateIterable<Document> result = collection.aggregate(pipeline);
			Integer uniqueDeviceIdCount = 0;
			for (Document doc : result) {
			uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
			break; // 不需要继续遍历，因为 $count 只会产生一个结果
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);
			}

			/**
			* 视频：录像可用率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoAvailabilityRate(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, RecordMetaDSumResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<RecordMetaDSumResult> resultList = mongoTemplate.find(query, RecordMetaDSumResult.class);
			return Result.ok().data(resultList).total(total);
			}

			/**
			* 视频：重点点位录像可用率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoImportantPointAvailabilityRate(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, RecordMetaDSumResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<RecordMetaDSumResult> resultList = mongoTemplate.find(query, RecordMetaDSumResult.class);
			return Result.ok().data(resultList).total(total);
			}

			/**
			* 视频：标注正确率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoLabelingAccuracy(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);
			}

			/**
			* 视频：重点点位标注正确率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoImportantPointLabelingAccuracy(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);
			}

			/**
			* 视频：校时正确率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoCheckTimeAccuracy(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);
			}

			/**
			* 视频：重点点位校时正确率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoImportantPointCheckTimeAccuracy(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", Arrays.asList(uniqueDeviceIdCount));
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -300,21 +129,43 @@
			*/
			@Override
			public Result videoImportantPointOnlineRate(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			// 先查出重点点位的国标
			List<String> deptGBList = pointMapper.getDeptPointGB(1);
			List<String> likeFileds = Arrays.asList("arealayerName", "ipAddr", "deviceName", "deviceId");
			Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, likeFileds, deptGBList);

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

			// 统计数量
			MongoDatabase database = mongoTemplate.getDb();
			MongoCollection<Document> collection = database.getCollection("uy_online");
			Document filter = new Document("deviceId", new Document("$in", deptGBList));
			// 构建聚合管道
			List<Document> pipeline = Arrays.asList(
			new Document("$match", filter),
			// $group 去重
			new Document("$group", new Document("_id", "$deviceId")),
			new Document("$count", "uniqueDeviceIds")
			);
			// 执行聚合查询并获取结果
			AggregateIterable<Document> result = collection.aggregate(pipeline);
			Integer uniqueDeviceIdCount = 0;
			for (Document doc : result) {
			uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
			break; // 不需要继续遍历，因为 $count 只会产生一个结果
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);

			// long nonNetwork = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("0")), VideoOnlineResult.class);
			// long network = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("1")), VideoOnlineResult.class);
			// long video = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".1.")), VideoOnlineResult.class);
			// long car = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".2.")), VideoOnlineResult.class);
			// long face = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".3.")), VideoOnlineResult.class);
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", Arrays.asList(uniqueDeviceIdCount));
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -325,24 +176,487 @@
			*/
			@Override
			public Result videoImportantPointImageOnlineRate(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			// 先查出重点指挥图像点位的国标
			List<String> deptGBList = pointMapper.getDeptPointGB(2);
			List<String> likeFileds = Arrays.asList("arealayerName", "ipAddr", "deviceName", "deviceId");
			Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, likeFileds, deptGBList);

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

			// 统计数量
			MongoDatabase database = mongoTemplate.getDb();
			MongoCollection<Document> collection = database.getCollection("uy_online");
			Document filter = new Document("deviceId", new Document("$in", deptGBList));
			// 构建聚合管道
			List<Document> pipeline = Arrays.asList(
			new Document("$match", filter),
			// $group 去重
			new Document("$group", new Document("_id", "$deviceId")),
			new Document("$count", "uniqueDeviceIds")
			);
			// 执行聚合查询并获取结果
			AggregateIterable<Document> result = collection.aggregate(pipeline);
			Integer uniqueDeviceIdCount = 0;
			for (Document doc : result) {
			uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
			break; // 不需要继续遍历，因为 $count 只会产生一个结果
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);

			// // 统计数
			// long nonNetwork = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("0")), VideoOnlineResult.class);
			// long network = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("1")), VideoOnlineResult.class);
			// long video = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".1.")), VideoOnlineResult.class);
			// long car = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".2.")), VideoOnlineResult.class);
			// long face = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".3.")), VideoOnlineResult.class);
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", Arrays.asList(uniqueDeviceIdCount));
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：一机一档注册率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoOneMachineDocumentRegister(DataCenterQuery params) {
			List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
			Query query = MongoUtil.getQuery(params, "serialNumber.showValue", TIME_FIELD, likeFileds, null);

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

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

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

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：一机一档合格率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoOneMachineDocumentQualified(DataCenterQuery params) {
			List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
			Query query = MongoUtil.getQuery(params, "serialNumber.showValue", TIME_FIELD, likeFileds, null);

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

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

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

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：档案考核比
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoAssessmentFileRatio(DataCenterQuery params) {
			// TODO 新增一张表记录每次的档案考核
			List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
			Query query = MongoUtil.getQuery(params, "serialNumber.showValue", TIME_FIELD, likeFileds, null);

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

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

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

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：录像可用率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoAvailabilityRate(DataCenterQuery params) {
			List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
			Query query = MongoUtil.getQuery(params, "deviceId", "createTime", likeFileds, null);

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

			// 统计数量
			MongoDatabase database = mongoTemplate.getDb();
			MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
			List<Integer> status = Arrays.asList(1, 0, -1);
			List<Integer> resultCount = status.stream().map(item -> {
			Document filter = new Document("recordStatus", item);
			// 构建聚合管道
			List<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());


			HashMap<String, Object> map = new HashMap<>();
			map.put("count", resultCount);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：部级录像可用率
			*
			* @param params
			* @return
			*/
			@Override
			public Result deptVideoAvailabilityRate(DataCenterQuery params) {

			List<String> deptGBList = pointMapper.getDeptPointGB(0);
			List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
			Query query = MongoUtil.getQuery(params, "deviceId", "createTime", likeFileds, deptGBList);

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

			// 统计数量
			MongoDatabase database = mongoTemplate.getDb();
			MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
			List<Integer> status = Arrays.asList(1, 0, -1);
			List<Integer> resultCount = status.stream().map(item -> {
			Document filter = new Document("$and", Arrays.asList(
			new Document("deviceId", new Document("$in", deptGBList)), // $in 条件
			new Document("recordStatus", item)
			));
			// 构建聚合管道
			List<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());


			HashMap<String, Object> map = new HashMap<>();
			map.put("count", resultCount);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：重点点位录像可用率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoImportantPointAvailabilityRate(DataCenterQuery params) {

			List<String> deptGBList = pointMapper.getDeptPointGB(1);
			List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
			Query query = MongoUtil.getQuery(params, "deviceId", "createTime", likeFileds, deptGBList);

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

			// 统计数量
			MongoDatabase database = mongoTemplate.getDb();
			MongoCollection<Document> collection = database.getCollection("uy_record_meta_d_sum");
			List<Integer> status = Arrays.asList(1, 0, -1);
			List<Integer> resultCount = status.stream().map(item -> {
			Document filter = new Document("$and", Arrays.asList(
			new Document("deviceId", new Document("$in", deptGBList)), // $in 条件
			new Document("recordStatus", item)
			));
			// 构建聚合管道
			List<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());

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", resultCount);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：标注正确率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoLabelingAccuracy(DataCenterQuery params) {
			List<String> likeFileds = Arrays.asList("deviceId", "deviceName");
			Query query = MongoUtil.getQuery(params, "deviceId", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, RecordMetaDSumResult.class);
			List<RecordMetaDSumResult> resultList = mongoTemplate.find(query, RecordMetaDSumResult.class);
			// 统计数
			long nonNetwork = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("0")), RecordMetaDSumResult.class);
			long network = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("1")), RecordMetaDSumResult.class);
			long video = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".1.")), RecordMetaDSumResult.class);
			long car = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".2.")), RecordMetaDSumResult.class);
			long face = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".3.")), RecordMetaDSumResult.class);
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", Arrays.asList(nonNetwork, network, video, car, face));
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：重点点位标注正确率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoImportantPointLabelingAccuracy(DataCenterQuery params) {

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

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

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

			Document osdNameFilter = new Document("osdNameCorrect", 1);
			Document osdNameErrFilter = new Document("osdNameCorrect", -1);
			Document osdTimeFilter = new Document("osdTimeCorrect", 1);
			Document osdTimeErrFilter = new Document("osdTimeCorrect", -1);
			List<Document> lists = Arrays.asList(osdNameFilter, osdNameErrFilter, osdTimeFilter, osdTimeErrFilter);
			List<Integer> rList = lists.stream().map(filter -> {
			// 构建聚合管道
			List<Document> pipeline = Arrays.asList(
			new Document("$match", filter),
			// $group 去重
			new Document("$group", new Document("_id", "$deviceNo")),
			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());


			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：校时正确率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoCheckTimeAccuracy(DataCenterQuery params) {

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

			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			// 统计数
			long nonNetwork = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("0")), OneMachineFileResult.class);
			long network = mongoTemplate.count(new Query().addCriteria(Criteria.where("LWSX").is("1")), OneMachineFileResult.class);
			long video = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".1.")), OneMachineFileResult.class);
			long car = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".2.")), OneMachineFileResult.class);
			long face = mongoTemplate.count(new Query().addCriteria(Criteria.where("SXJGNLX").regex(".3.")), OneMachineFileResult.class);
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", Arrays.asList(nonNetwork, network, video, car, face));
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			* 视频：重点点位校时正确率
			*
			* @param params
			* @return
			*/
			@Override
			public Result videoImportantPointCheckTimeAccuracy(DataCenterQuery params) {

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

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

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

			Document osdTimeFilter = new Document("osdTimeCorrect", 1);
			Document osdTimeErrFilter = new Document("osdTimeCorrect", -1);
			List<Document> lists = Arrays.asList(osdTimeFilter, osdTimeErrFilter);
			List<Integer> rList = lists.stream().map(filter -> {
			// 构建聚合管道
			List<Document> pipeline = Arrays.asList(
			new Document("$match", filter),
			// $group 去重
			new Document("$group", new Document("_id", "$deviceNo")),
			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());

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}


			/**
			@@ -353,21 +667,44 @@
			*/
			@Override
			public Result vehicleViewDockStable(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, SnapshotDataMonitorResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<SnapshotDataMonitorResult> resultList = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
			return Result.ok().data(resultList).total(total);

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

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -378,21 +715,22 @@
			*/
			@Override
			public Result vehiclePointOnlineRate(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, SnapshotDataMonitorResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<SnapshotDataMonitorResult> resultList = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
			return Result.ok().data(resultList).total(total);

			// 统计数量
			MongoDatabase database = mongoTemplate.getDb();
			MongoCollection<Document> collection = database.getCollection("hk_snapshot_data_monitor");
			long distinctCount = collection.distinct("externalIndexCode", String.class).into(new ArrayList<>()).size();

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

			/**
			@@ -403,21 +741,45 @@
			*/
			@Override
			public Result vehicleNetDeviceDirectoryConsistency(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			List<String> likeFileds = Arrays.asList("ip.showValue", "name.showValue", "serialNumber.showValue");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

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

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

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

			List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
			List<Integer> rList = lists.stream().map(filter -> {
			// 构建聚合管道
			List<Document> pipeline = Arrays.asList(
			new Document("$match", filter),
			// $group 去重
			new Document("$group", new Document("_id", "$serialNumber.showValue")),
			new Document("$count", "uniqueDeviceIds")
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);
			// 执行聚合查询并获取结果
			AggregateIterable<Document> result = collection.aggregate(pipeline);
			Integer uniqueDeviceIdCount = 0;
			for (Document doc : result) {
			uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
			break; // 不需要继续遍历，因为 $count 只会产生一个结果
			}
			return uniqueDeviceIdCount;
			}).collect(Collectors.toList());

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -428,21 +790,45 @@
			*/
			@Override
			public Result vehicleCollectionConsistency(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "crossName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, CrossDetailResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<CrossDetailResult> resultList = mongoTemplate.find(query, CrossDetailResult.class);
			return Result.ok().data(resultList).total(total);

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

			Document ipErrFilter = new Document("lalType", 1);
			Document macdzErrFilter = new Document("lalType", 2);
			Document latitudeErrFilter = new Document("lalType", 3);
			Document longitudeErrFilter = new Document("lalType", 4);

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -453,21 +839,21 @@
			*/
			@Override
			public Result vehicleCollectionDataIntegrity(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, DataIntegrityMonitoringResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<DataIntegrityMonitoringResult> resultList = mongoTemplate.find(query, DataIntegrityMonitoringResult.class);
			return Result.ok().data(resultList).total(total);

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

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

			/**
			@@ -478,21 +864,17 @@
			*/
			@Override
			public Result vehicleCollectionDataCaptured(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, AttrRecognitionMonitorResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<AttrRecognitionMonitorResult> resultList = mongoTemplate.find(query, AttrRecognitionMonitorResult.class);
			return Result.ok().data(resultList).total(total);
			// 统计数
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", CollectionUtils.EMPTY_COLLECTION);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -503,21 +885,45 @@
			*/
			@Override
			public Result vehicleClockAccuracy(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, VehicleDeviceInspectionResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<VehicleDeviceInspectionResult> resultList = mongoTemplate.find(query, VehicleDeviceInspectionResult.class);
			return Result.ok().data(resultList).total(total);


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

			Document ipErrFilter = new Document("snapResult", 1);
			Document macdzErrFilter = new Document("snapResult", 2);
			Document longitudeErrFilter = new Document("snapResult", 4);

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -528,21 +934,17 @@
			*/
			@Override
			public Result vehicleTimelyUploadAccuracy(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, SnapshotDelayMonitorResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<SnapshotDelayMonitorResult> resultList = mongoTemplate.find(query, SnapshotDelayMonitorResult.class);
			return Result.ok().data(resultList).total(total);
			// 统计数
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", CollectionUtils.EMPTY_COLLECTION);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -553,21 +955,17 @@
			*/
			@Override
			public Result vehicleUrlAccuracy(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, PicAccessResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<PicAccessResult> resultList = mongoTemplate.find(query, PicAccessResult.class);
			return Result.ok().data(resultList).total(total);
			// 统计数
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", CollectionUtils.EMPTY_COLLECTION);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -578,21 +976,17 @@
			*/
			@Override
			public Result vehicleBigImgAccuracy(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, VehicleDeviceSamplingResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<VehicleDeviceSamplingResult> resultList = mongoTemplate.find(query, VehicleDeviceSamplingResult.class);
			return Result.ok().data(resultList).total(total);
			// 统计数
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", CollectionUtils.EMPTY_COLLECTION);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -603,21 +997,44 @@
			*/
			@Override
			public Result faceViewDockStable(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, SnapshotDataMonitorResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<SnapshotDataMonitorResult> resultList = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
			return Result.ok().data(resultList).total(total);

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

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -628,21 +1045,44 @@
			*/
			@Override
			public Result facePointOnlineRate(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, SnapshotDataMonitorResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<SnapshotDataMonitorResult> resultList = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
			return Result.ok().data(resultList).total(total);

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

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -653,21 +1093,45 @@
			*/
			@Override
			public Result faceDirectoryConsistency(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			List<String> likeFileds = Arrays.asList("serialNumber.showValue", "ip.showValue", "name.showValue");
			Query query = MongoUtil.getQuery(params, "serialNumber.showValue", TIME_FIELD, likeFileds, null);

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

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

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

			List<Document> lists = Arrays.asList(ipErrFilter, macdzErrFilter, latitudeErrFilter, longitudeErrFilter);
			List<Integer> rList = lists.stream().map(filter -> {
			// 构建聚合管道
			List<Document> pipeline = Arrays.asList(
			new Document("$match", filter),
			// $group 去重
			new Document("$group", new Document("_id", "$serialNumber.showValue")),
			new Document("$count", "uniqueDeviceIds")
			);
			}
			query.addCriteria(criteria);
			long total = mongoTemplate.count(query, OneMachineFileResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			List<OneMachineFileResult> resultList = mongoTemplate.find(query, OneMachineFileResult.class);
			return Result.ok().data(resultList).total(total);
			// 执行聚合查询并获取结果
			AggregateIterable<Document> result = collection.aggregate(pipeline);
			Integer uniqueDeviceIdCount = 0;
			for (Document doc : result) {
			uniqueDeviceIdCount = doc.getInteger("uniqueDeviceIds");
			break; // 不需要继续遍历，因为 $count 只会产生一个结果
			}
			return uniqueDeviceIdCount;
			}).collect(Collectors.toList());

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -678,21 +1142,45 @@
			*/
			@Override
			public Result faceCollectionConsistency(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "crossName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, CrossDetailResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<CrossDetailResult> resultList = mongoTemplate.find(query, CrossDetailResult.class);
			return Result.ok().data(resultList).total(total);

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

			Document ipErrFilter = new Document("lalType", 1);
			Document macdzErrFilter = new Document("lalType", 2);
			Document latitudeErrFilter = new Document("lalType", 3);
			Document longitudeErrFilter = new Document("lalType", 4);

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -703,21 +1191,45 @@
			*/
			@Override
			public Result faceImgQualification(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "cameraName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, MonitoringDetailResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<MonitoringDetailResult> resultList = mongoTemplate.find(query, MonitoringDetailResult.class);
			return Result.ok().data(resultList).total(total);

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

			Document ipErrFilter = new Document("lalType", 1);
			Document macdzErrFilter = new Document("lalType", 2);
			Document latitudeErrFilter = new Document("lalType", 3);
			Document longitudeErrFilter = new Document("lalType", 4);

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -728,21 +1240,44 @@
			*/
			@Override
			public Result faceCapturesImagesAccuracy(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, FaceDeviceInspectionResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<FaceDeviceInspectionResult> resultList = mongoTemplate.find(query, FaceDeviceInspectionResult.class);
			return Result.ok().data(resultList).total(total);

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

			Document ipErrFilter = new Document("snapResult", 1);
			Document macdzErrFilter = new Document("snapResult", 2);
			Document longitudeErrFilter = new Document("snapResult", 4);

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -753,21 +1288,44 @@
			*/
			@Override
			public Result faceTimelyUpload(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, FaceDeviceInspectionResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<FaceDeviceInspectionResult> resultList = mongoTemplate.find(query, FaceDeviceInspectionResult.class);
			return Result.ok().data(resultList).total(total);

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

			Document ipErrFilter = new Document("snapResult", 1);
			Document macdzErrFilter = new Document("snapResult", 2);
			Document longitudeErrFilter = new Document("snapResult", 4);

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

			HashMap<String, Object> map = new HashMap<>();
			map.put("count", rList);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}

			/**
			@@ -778,21 +1336,17 @@
			*/
			@Override
			public Result faceAvailabilityOfLargeImg(DataCenterQuery params) {
			Query query = new Query();
			// 全文索引查询
			MongoUtil.fullText(query, params.getKeyword());
			Criteria criteria = new Criteria();
			// 普通查询
			if (Objects.nonNull(params.getStartTime()) && Objects.nonNull(params.getEndTime())) {
			criteria.andOperator(
			Criteria.where(TIME_FIELD).gte(params.getStartTime()).lte(params.getEndTime())
			);
			}
			query.addCriteria(criteria);
			List<String> likeFileds = Arrays.asList("externalIndexCode", "deviceName");
			Query query = MongoUtil.getQuery(params, "externalIndexCode", TIME_FIELD, likeFileds, null);

			long total = mongoTemplate.count(query, FaceDeviceSamplingResult.class);
			query.with(Sort.by(Sort.Order.asc(TIME_FIELD))).skip(params.getSkipNum()).limit(Math.toIntExact(params.getPageSize()));
			MongoUtil.setPage(query, params, TIME_FIELD);
			List<FaceDeviceSamplingResult> resultList = mongoTemplate.find(query, FaceDeviceSamplingResult.class);
			return Result.ok().data(resultList).total(total);
			// 统计数
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", CollectionUtils.EMPTY_COLLECTION);
			map.put("list", resultList);
			return Result.ok().data(map).total(total);
			}
			/**
			* 视频：视频图像资源安全管理
			@@ -802,11 +1356,14 @@
			*/
			@Override
			public Result videoImageResourceSecurity(DataCenterQuery query) {
			ImageResourceSecurityDetail imageResourceSecurityDetail = new ImageResourceSecurityDetail();
			Page<ImageResourceSecurityDetail> page = PageHelper.startPage(query.getPageNum(), query.getPageSize());
			securityDetailMapper.selectImageResourceSecurityDetailList(imageResourceSecurityDetail);
			securityDetailMapper.selectImageResourceSecurityDetailList(query);

			return Result.ok().data(page.getResult()).total(page.getTotal());
			// 统计数
			HashMap<String, Object> map = new HashMap<>();
			map.put("count", CollectionUtils.EMPTY_COLLECTION);
			map.put("list", page);
			return Result.ok().data(map).total(page.getTotal());

			}
			}