blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
fuliqi
2024-09-10 7d5ea3631d163343b652bd6bd40b94b34c4194eb 
 ycl-server/src/main/java/com/ycl/task/VideoTask.java


@@ -3,23 +3,35 @@




import com.ycl.calculate.CalculationStrategy;


import com.ycl.factory.IndexCalculationFactory;


import com.ycl.platform.domain.param.UY.RecordMetaDSumParam;


import com.ycl.platform.domain.result.HK.SnapshotDataMonitorResult;


import com.ycl.platform.domain.result.UY.QueryVqdResult;


import com.ycl.platform.mapper.PlatformOnlineMapper;


import com.ycl.platform.service.PlatformOnlineService;


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;


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.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;




/**


 * 视频计算考核指标任务


@@ -27,46 +39,141 @@


 */


@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");


    //TODO：加任务


    public void siteOnlineTask() {


        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<QueryVqdResult> results = mongoTemplate.find(query, QueryVqdResult.class);


        log.info("开始计算点位在线率");


        List<TMonitorResult> tMonitorResults = monitorMapper.selectMonitorResult(CheckConstants.Rule_Category_Video);


        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_SiteOnline);


        calculator.calculate(results);


        calculator.calculate(tMonitorResults);


        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<RecordMetaDSumParam> results = mongoTemplate.find(query, RecordMetaDSumParam.class);


        List<RecordMetaDSumResult> results = mongoTemplate.find(query, RecordMetaDSumResult.class);


        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("开始计算平台在线率");


        //计算平台在线率


        //拿到今日离线时长数据


        Integer time = platformOnlineMapper.sumOffTime(DateUtils.getMouthStart(new Date()), DateUtils.getMouthEnd(new Date()));


        int num = (time / 60) % 30;


        double score = Math.max(1 - num * 0.1,0);


        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.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);




    }


}