Merge remote-tracking branch 'origin/master'

xiangpei

2024-08-02 168346cebced28d8bcf39e5817c7367e9976424c

Merge remote-tracking branch 'origin/master'

 document/º£¿µapi.docx

Binary files differ

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

@@ -9,6 +9,10 @@
     */
    public static final String Car_SiteOnline_ViewStability = "carSiteOnlineViewStability";
    /**
     * è½¦è¾†æŠ“拍数据准确性、url、大图可用性
     */
    public static final String Car_DataAccuracy_Url_PicUsability = "carDataAccuracyUrlPicUsability";
    /**
     * è½¦è¾†å¡å£å±žæ€§ç›‘测结果
     */
    public static final String Car_InfoAccuracy = "carInfoAccuracy";
@@ -21,13 +25,10 @@
     */
    public static final String Car_DataIntegrity = "carDataIntegrity";
    /**
     * è½¦è¾†æŠ“拍数据准确性
     */
    public static final String Car_DataAccuracy = "carDataAccuracy";
    /**
     * è½¦è¾†æ—¶é’Ÿå‡†ç¡®æ€§
     */
    public static final String Car_ClockAccuracy = "carClockAccuracy";


    /**
     * äººè„¸æ•°æ®ä¸Šä¼ åŠæ—¶æ€§
@@ -38,7 +39,16 @@
     */
    public static final String Face_SiteOnline_ViewStability = "faceSiteOnlineViewStability";
    /**
     * è½¦è¾†æŠ“拍数据准确性、url、大图可用性
     */
    public static final String Face_DataAccuracy_PicUsability = "faceDataAccuracyPicUsability";
    /**
     * äººè„¸å±žæ€§ç›‘测结果
     */
    public static final String Face_InfoAccuracy = "faceInfoAccuracy";
    /**
     * äººè„¸æ—¶é’Ÿå‡†ç¡®æ€§
     */
    public static final String Face_ClockAccuracy = "faceClockAccuracy";

}

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

@@ -28,6 +28,7 @@

/**
 * è®¡ç®—车辆时钟准确性
 * é‡‡ç”¨è½¦è¾†å…¨æ£€æŽ¥å£
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * å¾ªçŽ¯map计算时钟准确性
 * æ›´æ–°æˆ–新增
@@ -112,10 +113,10 @@
            return null;
        }
        //调用时钟准确性计算方法
        Map<String, Object> siteOnlineParam = new HashMap<>();
        siteOnlineParam.put("totalSites", stats.totalSites);
        siteOnlineParam.put("accuracySites", stats.accuracySites);
        BigDecimal clockAccuracy = clockAccuracy(siteOnlineParam);
        Map<String, Object> clockAccuracyParam = new HashMap<>();
        clockAccuracyParam.put("totalSites", stats.totalSites);
        clockAccuracyParam.put("accuracySites", stats.accuracySites);
        BigDecimal clockAccuracy = clockAccuracy(clockAccuracyParam);
        checkIndexCar.setVehicleTimingAccuracy(clockAccuracy);
        return checkIndexCar;
    }

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

@@ -24,7 +24,8 @@
import java.util.stream.Collectors;

/**
 * è®¡ç®—车辆数据完整性
 * è®¡ç®—车辆数据完整性（检测车牌号、车牌颜色啥的合不合标准
 * é‡‡ç”¨æ•°æ®å®Œæ•´æ€§ç›‘测接口
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * æ›´æ–°æˆ–新增
 */

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

@@ -23,8 +23,8 @@
import java.util.stream.Collectors;

/**
 * è½¦è¾†æ•°æ®æŠ½æ£€æŽ¥å£
 * è®¡ç®—车辆属性识别准确率、url可用性、大图可用性
 * è½¦è¾†æ•°æ®æŠ½æ£€æŽ¥å£
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * æ›´æ–°æˆ–新增
 */

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

@@ -27,6 +27,7 @@

/**
 * è®¡ç®—车辆卡口信息采集准确率  è®¾å¤‡ç¼–码、行政区划代码、安装位置、坐标经纬度信息完整准确
 * é‡‡ç”¨å¡å£å±žæ€§ç›‘测接口
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * æ›´æ–°æˆ–新增
 */

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

@@ -24,8 +24,8 @@
import java.util.stream.Collectors;

/**
 * è®¡ç®—车辆点位在线率、视图库对接稳定性
 * æŠ“拍数据量监测结果接口数据
 * è®¡ç®—车辆、人脸点位在线率、视图库对接稳定性
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * å¾ªçŽ¯map计算点位在线率
 * æ›´æ–°æˆ–新增

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

@@ -26,6 +26,7 @@

/**
 * è®¡ç®—车辆备抓拍数据上传及时性
 * æŠ“拍数据时延监测接口
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * å¾ªçŽ¯map计算数据上传及时性
 * æ›´æ–°æˆ–新增
@@ -94,7 +95,7 @@
    }

    /**
     * ç´¯è®¡æ€»ç‚¹ä½æ•°ã€ç¦»çº¿æ•°ã€æ€»æŠ“拍量
     * ç´¯è®¡æ€»æ•°æ®é‡ã€å»¶è¿Ÿæ•°æ®é‡
     */
    private void updateAreaStats(Map<String, AreaStats> areaStatsMap, String key, SnapshotDelayMonitorResult result) {
        //返回对象的引用，如果不存在会放入新的key,value

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

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

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ycl.platform.domain.entity.CheckIndexFace;
import com.ycl.platform.domain.entity.TMonitor;
import com.ycl.platform.domain.result.HK.FaceDeviceInspectionResult;
import com.ycl.platform.domain.result.HK.FaceDeviceInspectionResult;
import com.ycl.platform.mapper.CheckIndexFaceMapper;
import com.ycl.platform.service.ICheckIndexFaceService;
import com.ycl.platform.service.ITMonitorService;
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.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * è®¡ç®—人脸时钟准确性
 * é‡‡ç”¨äººè„¸å…¨æ£€æŽ¥å£
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * å¾ªçŽ¯map计算时钟准确性
 * æ›´æ–°æˆ–新增
 */
@Component
public class FaceClockAccuracyCalculation extends IndexCalculationServe implements CalculationStrategy<FaceDeviceInspectionResult> {
    @Autowired
    private CheckIndexFaceMapper CheckIndexFaceMapper;
    @Autowired
    private ITMonitorService monitorService;
    @Autowired
    private ICheckIndexFaceService checkIndexFaceService;

    //区域车辆时钟准确性的内部类
    private static class AreaStats {
        int totalSites = 0;
        int accuracySites = 0;
    }

    @Override
    public void calculate(List<FaceDeviceInspectionResult> list) {
        if (CollectionUtils.isEmpty(list)) {
            return;
        }

        //获得国标码为key的设备map
        Map<String, TMonitor> monitorMap = monitorService.list(new QueryWrapper<TMonitor>()
                        .in("serial_number", list.stream().map(FaceDeviceInspectionResult::getExternalIndexCode).collect(Collectors.toList())))
                .stream().collect(Collectors.toMap(TMonitor::getSerialNumber, Function.identity()));
        //获取省厅国标码集合
        List<String> provinceIds = getProvince();

        Map<String, AreaStats> areaStatsMap = new HashMap<>();
        for (FaceDeviceInspectionResult result : list) {
            TMonitor monitor = monitorMap.get(result.getExternalIndexCode());
            if (monitor == null) continue;

            String deptId = monitor.getDeptId().toString();
            updateAreaStats(areaStatsMap, deptId, result);

            // å¤„理省厅数据
            if (!CollectionUtils.isEmpty(provinceIds) && provinceIds.contains(monitor.getSerialNumber())) {
                String provinceKey = "Province_" + deptId;
                updateAreaStats(areaStatsMap, provinceKey, result);
            }
        }

        // æŸ¥è¯¢æ˜¯å¦index表已经存在今日数据
        List<CheckIndexFace> checkIndexFaceList = CheckIndexFaceMapper.selectToday(DateUtils.getDate());
        List<CheckIndexFace> checkIndexFaces = new ArrayList<>();
        areaStatsMap.forEach((deptId, stats) -> {
            if (stats.totalSites > 0) {
                CheckIndexFace checkIndexFace = createOrUpdateCheckIndexCar(deptId, stats, checkIndexFaceList);
                if (checkIndexFace != null) {
                    checkIndexFaces.add(checkIndexFace);
                }
            }
        });

        checkIndexFaceService.saveOrUpdateBatch(checkIndexFaces);
    }

    /**
     * ç´¯è®¡æ—¶é’Ÿåˆæ ¼è®¾å¤‡
     */
    private void updateAreaStats(Map<String, AreaStats> areaStatsMap, String key, FaceDeviceInspectionResult result) {
        //返回对象的引用，如果不存在会放入新的key,value
        AreaStats stats = areaStatsMap.computeIfAbsent(key, k -> new AreaStats());
        stats.totalSites++;
        //时钟准确率大于90%为合格设备
        if (result.getSnapClock().getClockPercent() >= 0.9) {
            stats.accuracySites++;
        }
    }

    /**
     * è½¦è¾†æ—¶é’Ÿå‡†ç¡®æ€§
     */
    private CheckIndexFace createOrUpdateCheckIndexCar(String key, AreaStats stats, List<CheckIndexFace> checkIndexFaceList) {
        CheckIndexFace checkIndexFace = getCheckIndex(key, checkIndexFaceList, CheckIndexFace.class);
        if (checkIndexFace == null) {
            return null;
        }
        //调用时钟准确性计算方法
        Map<String, Object> clockAccuracyParam = new HashMap<>();
        clockAccuracyParam.put("totalSites", stats.totalSites);
        clockAccuracyParam.put("accuracySites", stats.accuracySites);
        BigDecimal clockAccuracy = clockAccuracy(clockAccuracyParam);
        checkIndexFace.setFaceTimingAccuracy(clockAccuracy);
        return checkIndexFace;
    }
}

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

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

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ycl.platform.domain.entity.CheckIndexFace;
import com.ycl.platform.domain.entity.TMonitor;
import com.ycl.platform.domain.result.HK.FaceDeviceSamplingResult;
import com.ycl.platform.mapper.CheckIndexFaceMapper;
import com.ycl.platform.service.ICheckIndexFaceService;
import com.ycl.platform.service.ITMonitorService;
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.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * è®¡ç®—人脸抓拍图片合格性、大图可用性
 * äººè„¸æ•°æ®æŠ½æ£€æŽ¥å£
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * æ›´æ–°æˆ–新增
 */
@Component
public class FaceDeviceSampleCalculation extends IndexCalculationServe implements CalculationStrategy<FaceDeviceSamplingResult> {
    @Autowired
    private CheckIndexFaceMapper checkIndexFaceMapper;
    @Autowired
    private ITMonitorService monitorService;
    @Autowired
    private ICheckIndexFaceService checkIndexFaceService;

    //区域车辆抽检指标
    private static class AreaStats {
        int totalSites = 0;
        //图片合格的点位数
        int picQualifySites = 0;
        //图片可用的点位数
        int picUsabilitySites = 0;
    }

    @Override
    public void calculate(List<FaceDeviceSamplingResult> list) {
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        //返回以国标码为key的设备map
        //TODO：monitor去掉了deptId
        Map<String, TMonitor> monitorMap = monitorService.list(new QueryWrapper<TMonitor>()
                        .in("serial_number", list.stream().map(FaceDeviceSamplingResult::getExternalIndexCode).collect(Collectors.toList())))
                .stream().collect(Collectors.toMap(TMonitor::getSerialNumber, Function.identity()));
        //获取省厅国标码集合
        List<String> provinceIds = getProvince();
        Map<String, AreaStats> areaStatsMap = new HashMap<>();
        for (FaceDeviceSamplingResult result : list) {
            TMonitor monitor = monitorMap.get(result.getExternalIndexCode());
            if (monitor == null) continue;
            String deptId = monitor.getDeptId().toString();
            updateAreaStats(areaStatsMap, deptId, result);

            // å¤„理省厅数据
            if (!CollectionUtils.isEmpty(provinceIds) && provinceIds.contains(monitor.getSerialNumber())) {
                String provinceKey = "Province_" + deptId;
                updateAreaStats(areaStatsMap, provinceKey, result);
            }
        }

        // æŸ¥è¯¢æ˜¯å¦index表已经存在今日数据
        List<CheckIndexFace> checkIndexFaceList = checkIndexFaceMapper.selectToday(DateUtils.getDate());
        List<CheckIndexFace> checkIndexFaces = new ArrayList<>();
        areaStatsMap.forEach((deptId, stats) -> {
            if (stats.totalSites > 0) {
                CheckIndexFace checkIndexFace = createOrUpdateCheckIndexFace(deptId, stats, checkIndexFaceList);
                if (checkIndexFace != null) {
                    checkIndexFaces.add(checkIndexFace);
                }
            }
        });

        checkIndexFaceService.saveOrUpdateBatch(checkIndexFaces);
    }

    /**
     * ç´¯è®¡æŠ“拍数据准确设备数和设备总数
     */
    private void updateAreaStats(Map<String, AreaStats> areaStatsMap, String key, FaceDeviceSamplingResult result) {
        //返回对象的引用，如果不存在会放入新的key,value
        AreaStats stats = areaStatsMap.computeIfAbsent(key, k -> new AreaStats());
        FaceDeviceSamplingResult.BigUsefulness bigUseful = result.getBigUseful();
        FaceDeviceSamplingResult.FaceEligibility faceElig = result.getFaceElig();
        stats.totalSites++;
        //90%及以上数据合格则此人脸设备被视为图片合格
        if (faceElig.getFaceEligPercent() >= 0.9) {
            stats.picQualifySites++;
        }
        //大图可用率大于90%视为合格
        if (bigUseful.getBigUsefulPercent() >= 0.9) {
            stats.picUsabilitySites++;
        }
    }

    /**
     * äººè„¸å›¾ç‰‡åˆæ ¼çŽ‡ã€å¤§å›¾å¯ç”¨æ€§
     */
    private CheckIndexFace createOrUpdateCheckIndexFace(String key, AreaStats stats, List<CheckIndexFace> checkIndexFaceList) {
        CheckIndexFace checkIndexFace = getCheckIndex(key, checkIndexFaceList, CheckIndexFace.class);
        if (checkIndexFace == null) {
            return null;
        }
        //调用图片合格率计算方法
        Map<String, Object> qualifyParam = new HashMap<>();
        qualifyParam.put("totalSites", stats.totalSites);
        qualifyParam.put("picQualifySites", stats.picQualifySites);
        BigDecimal dataQualify = dataQualify(qualifyParam);
        checkIndexFace.setFacePictureQualification(dataQualify);
        //调用大图可用性计算方法
        Map<String, Object> usabilityParam = new HashMap<>();
        usabilityParam.put("totalSites", stats.totalSites);
        usabilityParam.put("picUsabilitySites", stats.picUsabilitySites);
        BigDecimal picUsability = picUsability(usabilityParam);
        checkIndexFace.setFacePictureAvailability(picUsability);
        return checkIndexFace;
    }


}

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

@@ -24,6 +24,7 @@

/**
 * äººè„¸å¡å£ä¿¡æ¯é‡‡é›†å‡†ç¡®çŽ‡  è®¾å¤‡ç¼–码、行政区划代码、安装位置、坐标经纬度信息完整准确
 * é‡‡é›†è®¾å¤‡å±žæ€§ç›‘测接口
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * æ›´æ–°æˆ–新增
 */
@@ -100,7 +101,7 @@
    }

    /**
     * è½¦è¾†ä¿¡æ¯é‡‡é›†æ­£ç¡®çŽ‡
     * äººè„¸ä¿¡æ¯é‡‡é›†æ­£ç¡®çŽ‡
     */
    private CheckIndexFace createOrUpdateCheckIndexFace(String key, AreaStats stats, List<CheckIndexFace> checkIndexFaceList) {
        CheckIndexFace checkIndexFace = getCheckIndex(key, checkIndexFaceList, CheckIndexFace.class);

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

@@ -24,13 +24,14 @@
import java.util.stream.Collectors;

/**
 * æŠ“拍数据量监测结果接口数据
 * è®¡ç®—人脸点位在线率、视图库对接稳定性
 * æŠ“拍数据量监测结果接口数据
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * å¾ªçŽ¯map计算点位在线率
 * æ›´æ–°æˆ–新增
 */
@Component
//TODD:系统配置里的区分人脸和车辆、累加次数的概念、区县不少于40路，不达标市州的当月该项成绩不能得分。
public class FaceSnapshotDataCalculation extends IndexCalculationServe implements CalculationStrategy<SnapshotDataMonitorResult> {
    @Autowired
    private CheckIndexFaceMapper checkIndexFaceMapper;

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

@@ -21,6 +21,7 @@

/**
 * è®¡ç®—人脸设备抓拍数据上传及时性
 * æŠ“拍数据时延监测接口
 * èŽ·å–分省厅、区域的map<k,v> k为deptId或者Province_deptId
 * å¾ªçŽ¯map计算数据上传及时性
 * æ›´æ–°æˆ–新增
@@ -34,7 +35,7 @@
    @Autowired
    private ICheckIndexFaceService checkIndexFaceService;

    //区域车辆点位在线指标的内部类
    //区域人脸数据上传延迟指标的内部类
    private static class AreaStats {
        int totalCount = 0;
        //0-180s
@@ -89,7 +90,7 @@
    }

    /**
     * ç´¯è®¡æ€»ç‚¹ä½æ•°ã€ç¦»çº¿æ•°ã€æ€»æŠ“拍量
     * ç´¯è®¡æ€»æ•°æ®é‡ã€å»¶è¿Ÿæ•°æ®é‡
     */
    private void updateAreaStats(Map<String, AreaStats> areaStatsMap, String key, SnapshotDelayMonitorResult result) {
        //返回对象的引用，如果不存在会放入新的key,value
@@ -100,9 +101,8 @@
        stats.delayCount3 += result.getDataDelayCount3();
    }


    /**
     * è½¦è¾†ç‚¹ä½åœ¨çº¿çŽ‡å’Œè§†å›¾åº“对接稳定性
     * äººè„¸æ•°æ®ä¸Šä¼ åŠæ—¶æ€§
     */
    private CheckIndexFace createOrUpdateCheckIndexFace(String key, AreaStats stats, List<CheckIndexFace> checkIndexFaceList) {
        CheckIndexFace checkIndexFace = getCheckIndex(key, checkIndexFaceList, CheckIndexFace.class);

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

@@ -104,6 +104,12 @@
        return picUsabilitySites.divide(totalSitesCount, 4, RoundingMode.HALF_UP);
    }

    //图片合格率
    public BigDecimal dataQualify(Map<String, Object> param) {
        BigDecimal totalSitesCount = new BigDecimal((Integer) param.get("totalSites"));
        BigDecimal picQualifySites = new BigDecimal((Integer) param.get("picQualifySites"));
        return picQualifySites.divide(totalSitesCount, 4, RoundingMode.HALF_UP);
    }

    //返回省厅国标码集合
    public List<String> getProvince() {

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

@@ -10,21 +10,31 @@
    private static final Map<String, CalculationStrategy> calculators = new HashMap<>();

    static {
        //点位在线、视图库对接稳定性
        //车辆点位在线、视图库对接稳定性
        calculators.put(CalculationStrategyConstants.Car_SiteOnline_ViewStability, new CarSnapshopDataCalculation());
        calculators.put(CalculationStrategyConstants.Face_SiteOnline_ViewStability, new FaceSnapshotDataCalculation());
        //信息准确率
        //车辆信息准确率
        calculators.put(CalculationStrategyConstants.Car_InfoAccuracy, new CarInFoAccuracyCalculation());
        calculators.put(CalculationStrategyConstants.Face_InfoAccuracy, new FaceInFoAccuracyCalculation());
        //抓拍数据上传延迟
        //车辆抓拍数据上传延迟
        calculators.put(CalculationStrategyConstants.Car_SnapshotDelay, new CarSnapshotDelayCalculation());
        calculators.put(CalculationStrategyConstants.Face_SnapshotDelay, new FaceSnapshotDelayCalculation());
        //车辆数据抓拍完整性
        calculators.put(CalculationStrategyConstants.Car_DataIntegrity,new CarDataIntegrityCalculation());
        //车辆数据抓拍准确性
        calculators.put(CalculationStrategyConstants.Car_DataAccuracy,new CarDeviceSampleCalculation());
        calculators.put(CalculationStrategyConstants.Car_DataIntegrity, new CarDataIntegrityCalculation());
        //车辆数据抓拍准确性、url、大图可用
        calculators.put(CalculationStrategyConstants.Car_DataAccuracy_Url_PicUsability, new CarDeviceSampleCalculation());
        //车辆时钟准确性
        calculators.put(CalculationStrategyConstants.Car_ClockAccuracy,new CarClockAccuracyCalculation());
        calculators.put(CalculationStrategyConstants.Car_ClockAccuracy, new CarClockAccuracyCalculation());
        //TODO：车辆目录一致

        //人脸点位在线、视图库对接稳定
        calculators.put(CalculationStrategyConstants.Face_SiteOnline_ViewStability, new FaceSnapshotDataCalculation());
        //人脸信息准确率
        calculators.put(CalculationStrategyConstants.Face_InfoAccuracy, new FaceInFoAccuracyCalculation());
        //人脸抓拍数据延迟
        calculators.put(CalculationStrategyConstants.Face_SnapshotDelay, new FaceSnapshotDelayCalculation());
        //人脸图片合格、大图可用
        calculators.put(CalculationStrategyConstants.Face_DataAccuracy_PicUsability, new FaceDeviceSampleCalculation());
        //人脸时钟准确性
        calculators.put(CalculationStrategyConstants.Face_ClockAccuracy, new FaceClockAccuracyCalculation());
        //TODO：人脸目录一致
    }

    public static CalculationStrategy getCalculator(String indexName) {

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

@@ -41,12 +41,12 @@

    public void deviceSampleTask() {
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //计算车辆卡口设备抓拍数据准确性、url可用性、大图可用性
        //计算车辆卡口设备数据识别准确性、url可用性、大图可用性
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));
        List<VehicleDeviceSamplingResult> results = mongoTemplate.find(query, VehicleDeviceSamplingResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Car_DataIntegrity);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Car_DataAccuracy_Url_PicUsability);
        calculator.calculate(results);
    }

@@ -63,7 +63,7 @@

    public void snapShopDelay() {
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //计算车辆抓拍数据上传延迟
        //计算车辆抓拍数据上传及时性
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday))
@@ -84,7 +84,7 @@
        calculator.calculate(results);
    }

    public void CarClockAccuracyTask() {
    public void clockAccuracyTask() {
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //计算车辆卡口设备时钟准确性
        Query query = new Query();

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

@@ -3,10 +3,7 @@

import com.ycl.calculate.CalculationStrategy;
import com.ycl.factory.IndexCalculationFactory;
import com.ycl.platform.domain.result.HK.CrossDetailResult;
import com.ycl.platform.domain.result.HK.MonitoringDetailResult;
import com.ycl.platform.domain.result.HK.SnapshotDataMonitorResult;
import com.ycl.platform.domain.result.HK.SnapshotDelayMonitorResult;
import com.ycl.platform.domain.result.HK.*;
import com.ycl.utils.DateUtils;
import constant.ApiConstants;
import constant.CalculationStrategyConstants;
@@ -41,9 +38,19 @@
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Face_SiteOnline_ViewStability);
        calculator.calculate(results);
    }
    public void InfoAccuracyTask(){
    public void deviceSampleTask() {
        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<FaceDeviceSamplingResult> results = mongoTemplate.find(query, FaceDeviceSamplingResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Face_DataAccuracy_PicUsability);
        calculator.calculate(results);
    }
    public void infoAccuracyTask(){
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //计算人脸卡口信息采集准确率
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));
@@ -53,7 +60,7 @@
    }
    public void snapShopDelay(){
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //计算车辆卡口信息采集准确率
        //计算人脸抓拍数据上传及时性
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday))
@@ -62,4 +69,19 @@
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Face_SnapshotDelay);
        calculator.calculate(results);
    }
    public void clockAccuracyTask() {
        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<FaceDeviceInspectionResult> results = mongoTemplate.find(query, FaceDeviceInspectionResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Face_ClockAccuracy);
        calculator.calculate(results);
    }

    public void test() {
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //TODO：一机一档 è”网卡口设备目录一致率 å–redis
    }
}