点位在线率调整

fuliqi

2024-09-10 7d5ea3631d163343b652bd6bd40b94b34c4194eb

点位在线率调整

 ycl-common/src/main/java/constant/CalculationStrategyConstants.java

@@ -5,9 +5,13 @@
 */
public class CalculationStrategyConstants {
    /**
     * 车辆点位在线率和视图库对接稳定性
     *  车辆点位在线率
     */
    public static final String Car_SiteOnline_ViewStability = "carSiteOnlineViewStability";
    public static final String Car_SiteOnline = "carSiteOnline";
    /**
     * 车辆点视图库对接稳定性
     */
    public static final String Car_ViewStability = "carViewStability";
    /**
     * 车辆抓拍数据准确性、url、大图可用性
     */
@@ -39,9 +43,13 @@
     */
    public static final String Face_SnapshotDelay = "faceSnapshotDelay";
    /**
     * 人脸点位在线率和视图库对接稳定性
     * 人脸点位在线率
     */
    public static final String Face_SiteOnline_ViewStability = "faceSiteOnlineViewStability";
    public static final String Face_SiteOnline = "faceSiteOnline";
    /**
     * 人脸视图库对接稳定性
     */
    public static final String Face_ViewStability = "faceViewStability";
    /**
     * 车辆抓拍数据准确性、url、大图可用性
     */

 ycl-pojo/src/main/java/com/ycl/platform/domain/result/SYS/TMonitorResult.java

New file
@@ -0,0 +1,16 @@
package com.ycl.platform.domain.result.SYS;


import com.ycl.platform.domain.result.BaseResult;
import lombok.Data;

/**
 * 点位在线率
 */
@Data
public class TMonitorResult extends BaseResult {
    /** 部门id */
    private Integer deptId;
    /** 在线 */
    private Boolean online;
}

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

@@ -226,6 +226,7 @@
    private String error;
    private String unitName;
    private LocalDate mongoCreateTime;

    /**
     * 当日接收到的当日抓拍量
     */

 ycl-server/src/main/java/com/ycl/calculate/CarClockAccuracyCalculation.java

@@ -1,34 +1,20 @@
package com.ycl.calculate;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ycl.platform.domain.entity.CheckIndexCar;
import com.ycl.platform.domain.entity.TMonitor;
import com.ycl.platform.domain.result.HK.DataIntegrityMonitoringResult;
import com.ycl.platform.domain.result.HK.SnapshotDataMonitorResult;
import com.ycl.platform.domain.result.HK.VehicleDeviceInspectionResult;
import com.ycl.platform.domain.vo.TMonitorVO;
import com.ycl.platform.mapper.CheckIndexCarMapper;
import com.ycl.platform.mapper.TMonitorMapper;
import com.ycl.platform.service.ICheckIndexCarService;
import com.ycl.platform.service.ITMonitorService;
import com.ycl.system.mapper.SysConfigMapper;
import constant.ApiConstants;
import constant.CheckSnapCountConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import utils.DateUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 计算车辆时钟准确性

 ycl-server/src/main/java/com/ycl/calculate/CarConsistentCalculation.java

@@ -1,33 +1,19 @@
package com.ycl.calculate;

import com.alibaba.fastjson2.JSONArray;
import com.ycl.platform.domain.entity.CheckIndexCar;
import com.ycl.platform.domain.entity.TMonitor;
import com.ycl.platform.domain.result.HK.DataIntegrityMonitoringResult;
import com.ycl.platform.domain.result.HK.VehicleDeviceInspectionResult;
import com.ycl.platform.domain.result.UY.MonitorQualifyResult;
import com.ycl.platform.domain.vo.TMonitorVO;
import com.ycl.platform.mapper.CheckIndexCarMapper;
import com.ycl.platform.mapper.TMonitorMapper;
import com.ycl.platform.service.ICheckIndexCarService;
import constant.ApiConstants;
import constant.CheckConstants;
import constant.RedisConstant;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import utils.DateUtils;
import utils.StringUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 计算车辆目录一致率
@@ -40,11 +26,7 @@
    @Autowired
    private CheckIndexCarMapper checkIndexCarMapper;
    @Autowired
    private TMonitorMapper monitorMapper;
    @Autowired
    private ICheckIndexCarService checkIndexCarService;
    @Autowired
    private RedisTemplate redisTemplate;

    //区域车辆目录一致率的内部类
    protected static class AreaStats {

 ycl-server/src/main/java/com/ycl/calculate/CarDeviceSampleCalculation.java

@@ -2,15 +2,11 @@

import com.ycl.platform.domain.entity.CheckIndexCar;
import com.ycl.platform.domain.result.HK.VehicleDeviceSamplingResult;
import com.ycl.platform.domain.vo.TMonitorVO;
import com.ycl.platform.mapper.CheckIndexCarMapper;
import com.ycl.platform.mapper.TMonitorMapper;
import com.ycl.platform.service.ICheckIndexCarService;
import constant.ApiConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import utils.DateUtils;

import java.math.BigDecimal;
@@ -19,8 +15,6 @@
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 计算车辆抓拍数据准确性、url可用性、大图可用性
@@ -33,8 +27,6 @@
public class CarDeviceSampleCalculation extends IndexCalculationServe<VehicleDeviceSamplingResult, CarDeviceSampleCalculation.AreaStats> implements CalculationStrategy<VehicleDeviceSamplingResult> {
    @Autowired
    private CheckIndexCarMapper checkIndexCarMapper;
    @Autowired
    private TMonitorMapper monitorMapper;
    @Autowired
    private ICheckIndexCarService checkIndexCarService;


 ycl-server/src/main/java/com/ycl/calculate/CarOnlineCalculation.java

New file
@@ -0,0 +1,105 @@
package com.ycl.calculate;

import com.ycl.platform.domain.entity.CheckIndexCar;
import com.ycl.platform.domain.result.HK.SnapshotDataMonitorResult;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.vo.TMonitorVO;
import com.ycl.platform.mapper.CheckIndexCarMapper;
import com.ycl.platform.service.ICheckIndexCarService;
import com.ycl.system.entity.SysDictData;
import com.ycl.system.mapper.SysDictDataMapper;
import com.ycl.utils.DateUtils;
import constant.ApiConstants;
import constant.CheckConstants;
import constant.CheckThreadConstants;
import constant.RedisConstant;
import enumeration.general.AreaDeptEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;
import java.util.*;

/**
 * 计算车辆点位在线率
 * 获取分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * 循环map计算点位在线率
 * 更新或新增
 */
@Component
@Slf4j
public class CarOnlineCalculation extends IndexCalculationServe<TMonitorResult, CarOnlineCalculation.AreaStats> implements CalculationStrategy<TMonitorResult> {
    @Autowired
    private CheckIndexCarMapper checkIndexCarMapper;
    @Autowired
    private ICheckIndexCarService checkIndexCarService;

    //区域车辆点位在线指标的内部类
    protected static class AreaStats {
        int totalSites = 0;
        int onlineSites = 0;
    }

    @Override
    public void calculate(List<TMonitorResult> list) {
        //获取分区域的指标数量
        Map<String, CarOnlineCalculation.AreaStats> areaStatsMap = getAreaStatsMap(list);
        if (areaStatsMap == null) return;

        // 查询是否index表已经存在今日数据
        List<CheckIndexCar> checkIndexCarList = checkIndexCarMapper.selectToday(DateUtils.getDate());
        List<CheckIndexCar> checkIndexCars = new ArrayList<>();
        areaStatsMap.forEach((key, stats) -> {
                if (stats.totalSites > 0) {
                CheckIndexCar checkIndexCar = createOrUpdateCheckIndexCar(key, stats, checkIndexCarList);
                if (checkIndexCar != null) {
                    checkIndexCars.add(checkIndexCar);
                }
            }
        });

        checkIndexCarService.saveOrUpdateBatch(checkIndexCars);
    }

    /**
     * 累计总点位数、离线数、总抓拍量
     */
    @Override
    public void updateAreaStats(Map<String, AreaStats> areaStatsMap, String key, TMonitorResult result) {
        //返回对象的引用，如果不存在会放入新的key,value
        AreaStats stats = areaStatsMap.computeIfAbsent(key, k -> new AreaStats());
        stats.totalSites++;

        if (result.getOnline()!=null && result.getOnline()) {
            stats.onlineSites++;
        }
    }

    /**
     * 车辆点位在线率
     */
    private CheckIndexCar createOrUpdateCheckIndexCar(String key, AreaStats stats, List<CheckIndexCar> checkIndexCarList) {
        CheckIndexCar checkIndexCar = getCheckIndex(key, checkIndexCarList, CheckIndexCar.class);
        if (checkIndexCar == null) {
            return null;
        }

        //调用点位在线计算方法
        if (stats.totalSites >= CheckThreadConstants.Check_Car_SiteOnline) {
            Map<String, Object> siteOnlineParam = new HashMap<>();
            siteOnlineParam.put("totalSites", stats.totalSites);
            siteOnlineParam.put("onlineSites", stats.onlineSites);
            BigDecimal siteOnline = siteOnline(siteOnlineParam);
            checkIndexCar.setSiteOnline(siteOnline.min(BigDecimal.ONE));
        } else {
            checkIndexCar.setSiteOnline(BigDecimal.ZERO);
        }

        return checkIndexCar;
    }
}

 ycl-server/src/main/java/com/ycl/calculate/CarSnapshopDataCalculation.java

@@ -24,7 +24,7 @@
import java.util.*;

/**
 * 计算车辆点位在线率、视图库对接稳定性
 * 计算车辆视图库对接稳定性
 * 抓拍数据量监测结果接口数据
 * 获取分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * 循环map计算点位在线率
@@ -41,10 +41,9 @@
    private RedisTemplate redisTemplate;
    @Autowired
    private SysDictDataMapper dictDataMapper;
    //区域车辆点位在线指标的内部类
    //区域车辆视图库对接稳定性的内部类
    protected static class AreaStats {
        int totalSites = 0;
        int onlineSites = 0;
        int totalDataSum = 0;
    }

@@ -90,14 +89,13 @@
        stats.totalSites++;

        if (ApiConstants.HK_SnapCount_ResultType_Null != result.getResultType()) {
            stats.onlineSites++;
            stats.totalDataSum += result.getDataCount();
        }

    }

    /**
     * 车辆点位在线率和视图库对接稳定性
     * 车辆视图库对接稳定性
     */
    private CheckIndexCar createOrUpdateCheckIndexCar(String key, AreaStats stats, List<CheckIndexCar> checkIndexCarList,List<SysDictData> carSnap) {
        CheckIndexCar checkIndexCar = getCheckIndex(key, checkIndexCarList, CheckIndexCar.class);
@@ -105,16 +103,6 @@
            return null;
        }

        //调用点位在线计算方法
        if (stats.totalSites >= CheckThreadConstants.Check_Car_SiteOnline) {
            Map<String, Object> siteOnlineParam = new HashMap<>();
            siteOnlineParam.put("totalSites", stats.totalSites);
            siteOnlineParam.put("onlineSites", stats.onlineSites);
            BigDecimal siteOnline = siteOnline(siteOnlineParam);
            checkIndexCar.setSiteOnline(siteOnline.min(BigDecimal.ONE));
        } else {
            checkIndexCar.setSiteOnline(BigDecimal.ZERO);
        }
        //视图库对接稳定性
        //Redis记录该区县当月无数据上传次数
        Integer noDateCount = (Integer) redisTemplate.opsForHash().get(RedisConstant.Check_Car_ViewConnect, key);

 ycl-server/src/main/java/com/ycl/calculate/FaceDeviceSampleCalculation.java

@@ -33,8 +33,6 @@
    @Autowired
    private CheckIndexFaceMapper checkIndexFaceMapper;
    @Autowired
    private TMonitorMapper monitorMapper;
    @Autowired
    private ICheckIndexFaceService checkIndexFaceService;

    //区域车辆抽检指标

 ycl-server/src/main/java/com/ycl/calculate/FaceOnlineCalculation.java

New file
@@ -0,0 +1,99 @@
package com.ycl.calculate;

import com.ycl.platform.domain.entity.CheckIndexCar;
import com.ycl.platform.domain.entity.CheckIndexFace;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.mapper.CheckIndexCarMapper;
import com.ycl.platform.mapper.CheckIndexFaceMapper;
import com.ycl.platform.service.ICheckIndexCarService;
import com.ycl.platform.service.ICheckIndexFaceService;
import com.ycl.utils.DateUtils;
import constant.CheckThreadConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 计算车辆点位在线率
 * 获取分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * 循环map计算点位在线率
 * 更新或新增
 */
@Component
@Slf4j
public class FaceOnlineCalculation extends IndexCalculationServe<TMonitorResult, FaceOnlineCalculation.AreaStats> implements CalculationStrategy<TMonitorResult> {
    @Autowired
    private CheckIndexFaceMapper checkIndexFaceMapper;
    @Autowired
    private ICheckIndexFaceService checkIndexFaceService;

    //区域车辆点位在线指标的内部类
    protected static class AreaStats {
        int totalSites = 0;
        int onlineSites = 0;
    }

    @Override
    public void calculate(List<TMonitorResult> list) {
        //获取分区域的指标数量
        Map<String, FaceOnlineCalculation.AreaStats> areaStatsMap = getAreaStatsMap(list);
        if (areaStatsMap == null) return;

        // 查询是否index表已经存在今日数据
        List<CheckIndexFace> checkIndexFaceList = checkIndexFaceMapper.selectToday(DateUtils.getDate());
        List<CheckIndexFace> checkIndexFaces = new ArrayList<>();
        areaStatsMap.forEach((key, stats) -> {
                if (stats.totalSites > 0) {
                CheckIndexFace checkIndexFace = createOrUpdateCheckIndexCar(key, stats, checkIndexFaceList);
                if (checkIndexFace != null) {
                    checkIndexFaces.add(checkIndexFace);
                }
            }
        });

        checkIndexFaceService.saveOrUpdateBatch(checkIndexFaces);
    }

    /**
     * 累计总点位数、离线数、总抓拍量
     */
    @Override
    public void updateAreaStats(Map<String, AreaStats> areaStatsMap, String key, TMonitorResult result) {
        //返回对象的引用，如果不存在会放入新的key,value
        AreaStats stats = areaStatsMap.computeIfAbsent(key, k -> new AreaStats());
        stats.totalSites++;

        if (result.getOnline()!=null && result.getOnline()) {
            stats.onlineSites++;
        }
    }

    /**
     * 车辆点位在线率
     */
    private CheckIndexFace createOrUpdateCheckIndexCar(String key, AreaStats stats, List<CheckIndexFace> checkIndexFaceList) {
        CheckIndexFace checkIndexFace = getCheckIndex(key, checkIndexFaceList, CheckIndexFace.class);
        if (checkIndexFace == null) {
            return null;
        }

        //调用点位在线计算方法
        if (stats.totalSites >= CheckThreadConstants.Check_Face_SiteOnline) {
            Map<String, Object> siteOnlineParam = new HashMap<>();
            siteOnlineParam.put("totalSites", stats.totalSites);
            siteOnlineParam.put("onlineSites", stats.onlineSites);
            BigDecimal siteOnline = siteOnline(siteOnlineParam);
            checkIndexFace.setSiteOnline(siteOnline.min(BigDecimal.ONE));
        } else {
            checkIndexFace.setSiteOnline(BigDecimal.ZERO);
        }

        return checkIndexFace;
    }
}

 ycl-server/src/main/java/com/ycl/calculate/FaceSnapshotDataCalculation.java

@@ -55,7 +55,6 @@
    //区域人脸点位在线指标的内部类
    protected static class AreaStats {
        int totalSites = 0;
        int onlineSites = 0;
        int totalDataSum = 0;
    }

@@ -98,27 +97,16 @@
        AreaStats stats = areaStatsMap.computeIfAbsent(key, k -> new AreaStats());
        stats.totalSites++;
        if (ApiConstants.HK_SnapCount_ResultType_Null != result.getResultType()) {
            stats.onlineSites++;
            stats.totalDataSum += result.getDataCount();
        }
    }


    //车辆点位在线率和视图库对接稳定性
    //人脸视图库对接稳定性
    private CheckIndexFace createOrUpdateCheckIndexFace(String key, AreaStats stats, List<CheckIndexFace> checkIndexFaceList,List<SysDictData> faceSnap) {
        CheckIndexFace checkIndexFace = getCheckIndex(key, checkIndexFaceList, CheckIndexFace.class);
        if (checkIndexFace == null) {
            return null;
        }
        //调用点位在线计算方法
        if (stats.totalSites >= CheckThreadConstants.Check_Face_SiteOnline) {
            Map<String, Object> siteOnlineParam = new HashMap<>();
            siteOnlineParam.put("totalSites", stats.totalSites);
            siteOnlineParam.put("onlineSites", stats.onlineSites);
            BigDecimal siteOnline = siteOnline(siteOnlineParam);
            checkIndexFace.setSiteOnline(siteOnline);
        } else {
            checkIndexFace.setSiteOnline(BigDecimal.ZERO);
        }
        //视图库对接稳定性
        //Redis记录该区县当月无数据上传次数

 ycl-server/src/main/java/com/ycl/calculate/IndexCalculationUtils.java

@@ -16,11 +16,11 @@
@Slf4j
public class IndexCalculationUtils {
    //检查是否存在当日数据
    public <I extends CheckIndex> I getCheckIndex(String key, List<I> checkIndexList, Class<I> clazz) {
        I checkIndex;
    public <T extends CheckIndex> T getCheckIndex(String key, List<T> checkIndexList, Class<T> clazz) {
        T checkIndex;

        // 检查是否已存在今日数据
        Optional<I> existingIndex = checkIndexList.stream()
        Optional<T> existingIndex = checkIndexList.stream()
                .filter(index -> key.startsWith(ApiConstants.Province) ?
                        CheckConstants.Examine_Tag_Province.equals(index.getExamineTag()) && key.split("_")[1].equals(index.getDeptId().toString())
                        : CheckConstants.Examine_Tag_County.equals(index.getExamineTag()) && key.equals(index.getDeptId().toString()))

 ycl-server/src/main/java/com/ycl/calculate/MonitorRegistrationCalculation.java

@@ -43,7 +43,6 @@
        //全年留存数
        int allFiles = 0;
    }
    //TODO:改为MonitorQualifyResult
    @Override
    public void calculate(List<MonitorQualifyResult> list) {
        //获取分区域的指标数量

 ycl-server/src/main/java/com/ycl/calculate/VideoOnlineCalculation.java

@@ -1,6 +1,7 @@
package com.ycl.calculate;

import com.ycl.platform.domain.entity.CheckIndexVideo;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.result.UY.VideoOnlineResult;
import com.ycl.platform.mapper.CheckIndexVideoMapper;
import com.ycl.platform.mapper.TMonitorMapper;
@@ -27,7 +28,7 @@
 */
@Component
@Slf4j
public class VideoOnlineCalculation extends IndexCalculationServe<VideoOnlineResult, VideoOnlineCalculation.AreaStats> implements CalculationStrategy<VideoOnlineResult> {
public class VideoOnlineCalculation extends IndexCalculationServe<TMonitorResult, VideoOnlineCalculation.AreaStats> implements CalculationStrategy<TMonitorResult> {
    @Autowired
    private CheckIndexVideoMapper checkIndexVideoMapper;
    @Autowired
@@ -48,7 +49,7 @@
    }

    @Override
    public void calculate(List<VideoOnlineResult> list) {
    public void calculate(List<TMonitorResult> list) {
        //获取分区域的指标数量
        Map<String, VideoOnlineCalculation.AreaStats> areaStatsMap = getAreaStatsMap(list);
        if (areaStatsMap == null) return;
@@ -72,7 +73,7 @@
     * 累计总点位数、在线点位数、重点点位数、重点点位在线数、指挥图像数、指挥图像在线数
     */
    @Override
    public void updateAreaStats(Map<String, AreaStats> areaStatsMap, String key, VideoOnlineResult result) {
    public void updateAreaStats(Map<String, AreaStats> areaStatsMap, String key, TMonitorResult result) {
        //返回对象的引用，如果不存在会放入新的key,value
        AreaStats stats = areaStatsMap.computeIfAbsent(key, k -> new AreaStats());
        stats.totalSites++;
@@ -87,7 +88,7 @@
        if(result.getDeptTag()!=null && result.getDeptTag()){
            stats.deptSites++;
        }
        if (ApiConstants.UY_OnlineSite_Online.equals(result.getStatus())){
        if (result.getOnline()!=null && result.getOnline()){
            stats.onlineSites++;
            if(result.getImportantTag()!=null && result.getImportantTag()){
                stats.importantOnlineSites++;

 ycl-server/src/main/java/com/ycl/factory/IndexCalculationFactory.java

@@ -16,8 +16,10 @@
    private static final Map<String, Class<? extends CalculationStrategy>> calculatorClasses = new HashMap<>();

    static {
        //车辆点位在线、视图库对接稳定性
        calculatorClasses.put(CalculationStrategyConstants.Car_SiteOnline_ViewStability, CarSnapshopDataCalculation.class);
        //车辆点位在线
        calculatorClasses.put(CalculationStrategyConstants.Car_SiteOnline, CarOnlineCalculation.class);
        //车辆视图库对接稳定性
        calculatorClasses.put(CalculationStrategyConstants.Car_ViewStability, CarSnapshopDataCalculation.class);
        //车辆信息准确率
        calculatorClasses.put(CalculationStrategyConstants.Car_InfoAccuracy, CarInFoAccuracyCalculation.class);
        //车辆抓拍数据上传延迟
@@ -31,8 +33,10 @@
        //车辆目录一致
        calculatorClasses.put(CalculationStrategyConstants.Car_DirectConsistent, CarConsistentCalculation.class);

        //人脸点位在线、视图库对接稳定
        calculatorClasses.put(CalculationStrategyConstants.Face_SiteOnline_ViewStability, FaceSnapshotDataCalculation.class);
        //人脸点位在线
        calculatorClasses.put(CalculationStrategyConstants.Face_SiteOnline, FaceOnlineCalculation.class);
        //人脸视图库对接稳定
        calculatorClasses.put(CalculationStrategyConstants.Face_ViewStability, FaceSnapshotDataCalculation.class);
        //人脸信息准确率
        calculatorClasses.put(CalculationStrategyConstants.Face_InfoAccuracy, FaceInFoAccuracyCalculation.class);
        //人脸抓拍数据延迟

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

@@ -6,6 +6,7 @@
import com.ycl.platform.domain.query.DashboardQuery;
import com.ycl.platform.domain.query.DataCenterQuery;
import com.ycl.platform.domain.query.HomeQuery;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.vo.TMonitorVO;
import com.ycl.platform.domain.vo.UpdateOnlineVO;
import com.ycl.platform.domain.vo.screen.MonitorRateVO;
@@ -162,4 +163,12 @@
     * @param online
     */
    void updateOnline(@Param("online") UpdateOnlineVO online);

    /**
     * 点位在线率
     *
     * @param tMonitor 设备资产
     * @return 设备资产集合
     */
    public List<TMonitorResult> selectMonitorResult(Short cameraFunType);
}

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

@@ -1,12 +1,16 @@
package com.ycl.task;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ycl.calculate.CalculationStrategy;
import com.ycl.factory.IndexCalculationFactory;
import com.ycl.platform.domain.entity.YwPoint;
import com.ycl.platform.domain.result.HK.*;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.result.UY.MonitorQualifyResult;
import com.ycl.platform.domain.vo.TMonitorVO;
import com.ycl.platform.mapper.TMonitorMapper;
import com.ycl.platform.mapper.YwPointMapper;
import com.ycl.utils.DateUtils;
import com.ycl.utils.StringUtils;
import constant.ApiConstants;
@@ -35,8 +39,20 @@
    private MongoTemplate mongoTemplate;
    @Autowired
    private TMonitorMapper monitorMapper;
    @Autowired
    private YwPointMapper pointMapper;
    //TODO：加任务
    public void siteOnlineTask() {
        log.info("开始计算车辆点位在线率和视图库对接稳定性");
        log.info("开始计算点位在线率");
        List<TMonitorResult> tMonitorResults = monitorMapper.selectMonitorResult(CheckConstants.Rule_Category_Car);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Car_SiteOnline);
        calculator.calculate(tMonitorResults);
        log.info("结束计算视图库对接稳定性");
    }

    //TODO：改任务名
    public void viewConnectTask() {
        log.info("开始计算视图库对接稳定性");
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //计算点位在线率和视图库对接稳定性
        Query query = new Query();
@@ -44,9 +60,9 @@
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday))
                .and("dataType").is(ApiConstants.HK_DataType_CAR));
        List<SnapshotDataMonitorResult> results = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
        CalculationStrategy<SnapshotDataMonitorResult> calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Car_SiteOnline_ViewStability);
        CalculationStrategy<SnapshotDataMonitorResult> calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Car_ViewStability);
        calculator.calculate(results);
        log.info("结束计算点位在线率和视图库对接稳定性");
        log.info("结束计算视图库对接稳定性");
    }

    public void deviceSampleTask() {
@@ -122,7 +138,7 @@
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));
        // .*表示任意数量字符 1/2/3 视频/车辆/人脸
        // 1/2/3 视频/车辆/人脸
        Pattern pattern = Pattern.compile(".*2.*");
        query.addCriteria(Criteria.where("sxjgnlx.value").regex(pattern));
        List<MonitorQualifyResult> results = mongoTemplate.find(query, MonitorQualifyResult.class);

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

@@ -4,6 +4,8 @@
import com.ycl.calculate.CalculationStrategy;
import com.ycl.factory.IndexCalculationFactory;
import com.ycl.platform.domain.result.HK.*;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.result.UY.MonitorQualifyResult;
import com.ycl.platform.domain.vo.TMonitorVO;
import com.ycl.platform.mapper.TMonitorMapper;
import com.ycl.utils.DateUtils;
@@ -20,6 +22,7 @@

import java.util.Date;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
@@ -34,16 +37,25 @@
    @Autowired
    private TMonitorMapper monitorMapper;

    //TODO：加任务
    public void siteOnlineTask() {
        log.info("开始计算人脸点位在线率和视图库对接稳定性");
        log.info("开始计算点位在线率");
        List<TMonitorResult> tMonitorResults = monitorMapper.selectMonitorResult(CheckConstants.Rule_Category_Face);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Face_SiteOnline);
        calculator.calculate(tMonitorResults);
        log.info("结束计算视图库对接稳定性");
    }
    //TODO：改名字
    public void viewConnectTask() {
        log.info("开始计算视图库对接稳定性");
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //点位在线率和视图库对接稳定性
        //视图库对接稳定性
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday))
                .and("dataType").is(ApiConstants.HK_DataType_FACE));
        List<SnapshotDataMonitorResult> results = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Face_SiteOnline_ViewStability);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Face_ViewStability);
        calculator.calculate(results);
        log.info("结束计算人脸点位在线率和视图库对接稳定性");
    }
@@ -108,10 +120,16 @@
    public void directConsistentTask() {
        log.info("开始计算人脸目录一致率");
        //人脸目录一致率
        List<TMonitorVO> tMonitorVOS = monitorMapper.selectMonitorVOList();
        List<TMonitorVO> list = tMonitorVOS.stream().filter(tMonitorVO ->!StringUtils.isEmpty(tMonitorVO.getCameraFunType()) && tMonitorVO.getCameraFunType().contains(CheckConstants.Rule_Category_Face + "")).collect(Collectors.toList());
        Date yesterday = DateUtils.addDays(new Date(), -1);
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));
        // 1/2/3 视频/车辆/人脸
        Pattern pattern = Pattern.compile(".*3.*");
        query.addCriteria(Criteria.where("sxjgnlx.value").regex(pattern));
        List<MonitorQualifyResult> results = mongoTemplate.find(query, MonitorQualifyResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Face_DirectConsistent);
        calculator.calculate(list);
        calculator.calculate(results);
        log.info("结束计算人脸目录一致率");
    }
}

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

@@ -64,6 +64,7 @@
     * 比对mongoDB一机一档信息，整理成result存入mongo
     * 同步品牌到mysql
     */
    //TODO：大华动态库linux换位置
    public void getOSD() {
        log.info("开始获取OSD");
        List<OSDResult> osdResultList = new ArrayList<>();

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

@@ -6,6 +6,7 @@
import com.ycl.platform.domain.entity.CheckIndexVideo;
import com.ycl.platform.domain.entity.ImageResourceSecurity;
import com.ycl.platform.domain.entity.ImageResourceSecurityDetail;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.result.UY.*;
import com.ycl.platform.domain.vo.PlatformOnlineVO;
import com.ycl.platform.domain.vo.TMonitorVO;
@@ -13,7 +14,9 @@
import com.ycl.platform.service.IImageResourceSecurityService;
import com.ycl.utils.DateUtils;
import com.ycl.utils.DictUtils;
import constant.ApiConstants;
import constant.CalculationStrategyConstants;
import constant.CheckConstants;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -51,18 +54,12 @@
    private final ImageResourceSecurityMapper imageResourceSecurityMapper;

    private static final BigDecimal NUM = new BigDecimal("0.15");

    //TODO：加任务
    public void siteOnlineTask() {
        log.info("开始计算点位在线率");
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //计算点位在线率和重点点位在线率和指挥图像在线率
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));

        List<VideoOnlineResult> results = mongoTemplate.find(query, VideoOnlineResult.class);
        List<TMonitorResult> tMonitorResults = monitorMapper.selectMonitorResult(CheckConstants.Rule_Category_Video);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_SiteOnline);
        calculator.calculate(results);
        calculator.calculate(tMonitorResults);
        log.info("结束计算点位在线率");
    }

@@ -83,9 +80,13 @@
    public void oneMonitorFileTask() {
        log.info("开始计算一机一档注册率、档案考核比");
        //计算一机一档注册率、档案考核比
        List<TMonitorVO> tMonitorVOS = monitorMapper.selectMonitorVOList();
        Date yesterday = DateUtils.addDays(new Date(), -1);
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));
        List<MonitorQualifyResult> results = mongoTemplate.find(query, MonitorQualifyResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_MonitorRegis_ArchiveRate);
        calculator.calculate(tMonitorVOS);
        calculator.calculate(results);
        log.info("结束计算一机一档注册率、档案考核比");
    }

@@ -127,7 +128,7 @@
    /**
     * 视频图像资源安全，需要排在平台在线率后面。
     */
    @Transactional
    @Transactional(rollbackFor = Exception.class)
    public void videoSecurity() {
        ArrayList<ImageResourceSecurity> imageResourceSecurities = new ArrayList<>();
        List<CheckIndexVideo> list = checkIndexVideoMapper.selectAndDeptName();

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

@@ -154,6 +154,17 @@
        left join sys_dept d on p.dept_id = d.dept_id
    </select>

    <select id="selectMonitorResult" resultType="com.ycl.platform.domain.result.SYS.TMonitorResult">
        select m.id, m.serial_number as no,d.dept_id,p.province_tag,p.important_tag,p.important_command_image_tag,p.dept_tag,p.online
        from t_monitor m
        left join t_yw_point p on m.serial_number = p.serial_number
        left join sys_dept d on p.dept_id = d.dept_id
        <where>
            <if test="cameraFunType!=null">
                m.camera_fun_type like concat('%',#{cameraFunType},'%')
            </if>
        </where>
    </select>
    <select id="selectTMonitorById" parameterType="Long" resultType="com.ycl.platform.domain.vo.TMonitorVO">
        <include refid="selectTMonitorVo"/>
        where id = #{id}