zxl
2025-02-19 002372c5cfd2c9b9881fda5e527c2b6c4ee4d599
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
package com.ycl.task;
 
 
import com.ycl.calculate.CalculationStrategy;
import com.ycl.factory.IndexCalculationFactory;
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.form.VideoExportForm;
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;
import com.ycl.platform.mapper.*;
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.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
 
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
 
/**
 * 视频计算考核指标任务
 * 凌晨执行计算昨天数据
 */
@Slf4j
@Component("videoTask")
@RequiredArgsConstructor
public class VideoTask {
    @Autowired
    private MongoTemplate mongoTemplate;
    @Autowired
    private PlatformOnlineMapper platformOnlineMapper;
    @Autowired
    private TMonitorMapper monitorMapper;
 
    private final IImageResourceSecurityService imageResourceSecurityService;
    private final CheckIndexVideoMapper checkIndexVideoMapper;
    private final ImageResourceSecurityDetailMapper imageResourceSecurityDetailMapper;
    private final ImageResourceSecurityMapper imageResourceSecurityMapper;
 
    private static final BigDecimal NUM = new BigDecimal("0.15");
 
    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<String> videoIds = monitorMapper.getVideoIds();
        if(!CollectionUtils.isEmpty(results)){
            results = results.stream().filter(result -> videoIds.contains(result.getNo())).collect(Collectors.toList());
        }
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_SiteOnline);
        calculator.calculate(results);
        log.info("结束计算点位在线率");
    }
 
    public void videoUsabilityTask() {
        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<RecordMetaDSumResult> results = mongoTemplate.find(query, RecordMetaDSumResult.class);
        //优云上有车辆和人脸的设备数据,需要过滤出视频设备
        List<String> videoIds = monitorMapper.getVideoIds();
        if(!CollectionUtils.isEmpty(results)){
            results = results.stream().filter(result -> videoIds.contains(result.getNo())).collect(Collectors.toList());
        }
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_Usability);
        calculator.calculate(results);
        log.info("结束计算录像可用率和重点录像可用率");
    }
 
    public void oneMonitorFileTask() {
        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<MonitorQualifyResult> results = mongoTemplate.find(query, MonitorQualifyResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_MonitorRegis_ArchiveRate);
        calculator.calculate(results);
        log.info("结束计算一机一档注册率、档案考核比");
    }
 
    public void oneMonitorQualifyTask() {
        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<MonitorQualifyResult> results = mongoTemplate.find(query, MonitorQualifyResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_MonitorQualify);
        calculator.calculate(results);
        log.info("结束计算一机一档合格率");
    }
 
    public void platformOnlineTask() {
        log.info("开始计算平台在线率");
        //计算平台在线率
        List<PlatformOnlineVO> list = platformOnlineMapper.yesterdayData(DateUtils.getMouthStart(new Date()), DateUtils.getMouthEnd(new Date()));
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_PlatformOnline);
        calculator.calculate(list);
        log.info("结束计算平台在线率");
    }
 
    public void osdTask() {
        log.info("开始计算Osd标注、时间准确率");
        //计算Osd标注、时间准确率
        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<OsdCheckResult> results = mongoTemplate.find(query, OsdCheckResult.class);
 
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_OsdTime);
        calculator.calculate(results);
        log.info("结束计算Osd标注、时间准确率");
    }
 
    /**
     * 视频图像资源安全,需要排在平台在线率后面。
     */
    @Transactional(rollbackFor = Exception.class)
    public void videoSecurity() {
        ArrayList<ImageResourceSecurity> imageResourceSecurities = new ArrayList<>();
        List<CheckIndexVideo> list = checkIndexVideoMapper.selectAndDeptName();
        List<ImageResourceSecurityDetail> detail = imageResourceSecurityDetailMapper.getList();
 
        // 每个部门循环一次计算数据
        for (CheckIndexVideo checkIndexVideo : list) {
            ImageResourceSecurity imageResourceSecurity = new ImageResourceSecurity();
            imageResourceSecurity.setDeptId(checkIndexVideo.getDeptId());
            // 直接取指标
            imageResourceSecurity.setPlatformOnline(checkIndexVideo.getPlatformOnline());
            imageResourceSecurity.setPropertyAccuracy(checkIndexVideo.getMonitorQualification());
            // 获取当前部门的detail进行计算
            List<ImageResourceSecurityDetail> detailList = detail.stream().filter(imageResourceSecurityDetail -> Objects.equals(imageResourceSecurityDetail.getDeptId(), checkIndexVideo.getDeptId())).toList();
            int score = 100;
            int count = 0;
            // 循环detail计算
            for (ImageResourceSecurityDetail imageResourceSecurityDetail : detailList) {
                // 扣除分数
                score -= imageResourceSecurityDetail.getAlarmCategory().getScore();
                // 统计数量
                if (Integer.parseInt(imageResourceSecurityDetail.getAlarmLevel().getValue()) > 1) {
                    count++;
                }
            }
            imageResourceSecurity.setWeakPassword(BigDecimal.valueOf(score).divide(new BigDecimal(100), 4, RoundingMode.HALF_UP));
            // 获取字典值-总数
            int onlineAssetsTotal = Integer.parseInt(DictUtils.getDictValue("online_assets_total", checkIndexVideo.getDeptName()));
            imageResourceSecurity.setRiskProperty(BigDecimal.valueOf(count / onlineAssetsTotal));
            imageResourceSecurity.setCreateTime(DateUtils.getNowDate());
            imageResourceSecurities.add(imageResourceSecurity);
            //获取最近一次数据手动打分
            ImageResourceSecurity latest = imageResourceSecurityMapper.getLatest(checkIndexVideo.getDeptId(),new Date());
            imageResourceSecurity.setBoundaryIntegrity(latest ==null?BigDecimal.ONE:latest.getBoundaryIntegrity());
            // 更新指标数据
            checkIndexVideo.setImageResourceSecurity(
                    imageResourceSecurity.getPlatformOnline()
                            .add(imageResourceSecurity.getPropertyAccuracy()
                                    .add(imageResourceSecurity.getWeakPassword()
                                            .add(imageResourceSecurity.getRiskProperty()))).multiply(NUM)
                            .add(imageResourceSecurity.getBoundaryIntegrity()).multiply(new BigDecimal("0.45"))
            );
            checkIndexVideoMapper.updateById(checkIndexVideo);
        }
        imageResourceSecurityService.saveBatch(imageResourceSecurities);
 
    }
}