工单查询优化

xiangpei

2024-08-23 0b8a348d0b978eeddfa3995b87cd11f7cbdd48a9

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

@@ -4,7 +4,9 @@
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.mongodb.client.result.DeleteResult;
import com.ycl.platform.domain.entity.*;
import com.ycl.platform.domain.result.HK.PicAccessResult;
import com.ycl.platform.domain.result.HK.SnapshotDataMonitorResult;
import com.ycl.platform.domain.result.UY.RecordMetaDSumResult;
import com.ycl.platform.domain.result.UY.VideoOnlineResult;
import com.ycl.platform.domain.vo.CalculateRuleVO;
import com.ycl.platform.domain.vo.ContractVO;
@@ -60,6 +62,7 @@
    private static final Integer Offline = -1;
    private static final String AuditStatus_Pass = "1";
    private static final String Remark = "系统生成";
    private static final Integer randomSize = 50;

    /**
     * 合同考核 在线率每日任务检测
@@ -208,11 +211,11 @@
    }

    /**
     *   检测工单表 进行合同积分扣除
     *   查出工单需要扣分的所有规则
     *   查出未扣分且已经审核完成了的工单组成map<unitId,List<WorkOrder>> 工单需要连工单故障表查出多个故障类型
     *   循环工单map，每个工单故障类型查对应的规则，根据规则和工单创建时间和审核通过时间进行扣分
     *   插入合同积分表，修改工单状态为已扣分
     * 检测工单表 进行合同积分扣除
     * 查出工单需要扣分的所有规则
     * 查出未扣分且已经审核完成了的工单组成map<unitId,List<WorkOrder>> 工单需要连工单故障表查出多个故障类型
     * 循环工单map，每个工单故障类型查对应的规则，根据规则和工单创建时间和审核通过时间进行扣分
     * 插入合同积分表，修改工单状态为已扣分
     */
    public void workOrderDeduct() {
        //查询生效合同对应所有的规则
@@ -232,11 +235,166 @@
        Map<Integer, List<CalculateRuleVO>> siteRuleMap = ruleMap.get(ContractRule.CONTRACT_RULE_Site.getName());

    }
    /**
     *  不定期检查数据 扣除积分
     */
    public void randomDeduct() {

    /**
     * 不定期检查数据 扣除积分
     * 每天一次随机数判断成功就执行
     * 海康取人脸车辆
     */
    public void randomDeductPic() {
        Random random = new Random();
        //给定随机范围
        int number = random.nextInt(randomSize);
        if (number == 0) {
            log.info("开始抽查图片完整状态");
            //准备批量打分的集合
            List<ContractScore> contractScoreList = new ArrayList<>();

            Date date = DateUtils.getDay(2024, 7, 13);
            //查图片完整性规则 获取key为合同id，value为规则的map
            Map<Integer, List<CalculateRuleVO>> contractMap = contractMapper.getCalculateRule(new Date()).stream()
                    .filter(calculateRuleVO -> ContractRule.CONTRACT_RULE_PicComplete.getName().equals(calculateRuleVO.getRuleName()))
                    .collect(Collectors.groupingBy(CalculateRuleVO::getContractId));

            //判断车辆、人脸图片是否可用
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(date)).lt(DateUtils.getDayEnd(date)));
            List<PicAccessResult> picAccessResults = mongoTemplate.find(query, PicAccessResult.class);
            List<String> serialNumbers = picAccessResults.stream().map(PicAccessResult::getExternalIndexCode).collect(Collectors.toList());
            QueryWrapper<YwPoint> queryWrapper = new QueryWrapper<>();
            queryWrapper.in("serial_number", serialNumbers);
            //获取公司所运维的设备集合，key为unitId value为设备国标码集合
            Map<Long, List<String>> unitMonitorMap = ywPointMapper.selectList(queryWrapper).stream()
                    .collect(Collectors.groupingBy(YwPoint::getUnitId,
                            Collectors.mapping(
                                    YwPoint::getSerialNumber,
                                    Collectors.toList())));
            contractMap.forEach((contractId, ruleList) -> {
                boolean deduct = false;
                String serialNumber = null;
                //此规则对应的unitId均相等
                CalculateRuleVO ruleVO = ruleList.get(0);
                Integer unitId = ruleVO.getUnitId();
                List<String> monitorList = unitMonitorMap.get(Long.parseLong(unitId + ""));
                for (PicAccessResult picAccessResult : picAccessResults) {
                    //判断是否是该公司运维
                    if (monitorList.contains(picAccessResult.getExternalIndexCode())) {
                        //存在大图不可用数据量，需要扣减
                        if (picAccessResult.getBigDisableCount() > 0) {
                            deduct = true;
                            serialNumber = picAccessResult.getExternalIndexCode();
                            break;
                        }
                    }
                }
                if (deduct) {
                    //需要扣除的分数，此规则只有一条不需要判断范围
                    Double deductScore = ruleVO.getCalcFraction();
                    ContractScore contractScore = new ContractScore();
                    contractScore.setContractId(Long.parseLong(contractId + ""));
                    contractScore.setAuditingStatus(AuditingStatus.PASS);
                    contractScore.setAuditingTime(new Date());
                    contractScore.setAuditingUser(Remark);
                    contractScore.setUnitId(Long.parseLong(ruleVO.getUnitId() + ""));
                    contractScore.setRuleId(Long.parseLong(ruleVO.getId() + ""));
                    contractScore.setRuleIds("0," + ruleVO.getId());
                    contractScore.setNum(1 + "");
                    contractScore.setDeductCategory(ruleVO.getDeductCategory().getDesc());
                    contractScore.setScore(new BigDecimal(deductScore));
                    contractScore.setRuleName(ruleVO.getRuleName() + "/" + ruleVO.getRuleCondition());
                    contractScore.setCreateTime(new Date());
                    contractScore.setUpdateTime(new Date());
                    contractScore.setRemark(Remark + "国标码为:" + serialNumber + "时间：" + new Date() + "存在大图不可用数据");
                    contractScoreList.add(contractScore);
                }
            });
            contractScoreService.saveBatch(contractScoreList);
            log.info("结束抽查图片完整状态");
        }
    }


    /**
     * 不定期检查数据 扣除积分
     * 每天一次随机数判断成功就执行
     * 优云取录像
     */
    public void randomDeductVideo() {
        Random random = new Random();
        //给定随机范围
        int number = random.nextInt(randomSize);
        if (number == 0) {
            log.info("开始抽查录像完整状态");
            //准备批量打分的集合
            List<ContractScore> contractScoreList = new ArrayList<>();

            Date date = DateUtils.getDay(2024, 7, 13);
            //查图片完整性规则 获取key为合同id，value为规则的map
            Map<Integer, List<CalculateRuleVO>> contractMap = contractMapper.getCalculateRule(new Date()).stream()
                    .filter(calculateRuleVO -> ContractRule.CONTRACT_RULE_VideoRecord.getName().equals(calculateRuleVO.getRuleName()))
                    .collect(Collectors.groupingBy(CalculateRuleVO::getContractId));

            //取录像数据
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(date)).lt(DateUtils.getDayEnd(date)));
            List<RecordMetaDSumResult> recordMetaDSumResults = mongoTemplate.find(query, RecordMetaDSumResult.class);
            List<String> serialNumbers = recordMetaDSumResults.stream().map(RecordMetaDSumResult::getDeviceId).collect(Collectors.toList());
            QueryWrapper<YwPoint> queryWrapper = new QueryWrapper<>();
            queryWrapper.in("serial_number", serialNumbers);
            //获取公司所运维的设备集合，key为unitId value为设备国标码集合
            Map<Long, List<String>> unitMonitorMap = ywPointMapper.selectList(queryWrapper).stream()
                    .collect(Collectors.groupingBy(YwPoint::getUnitId,
                            Collectors.mapping(
                                    YwPoint::getSerialNumber,
                                    Collectors.toList())));
            contractMap.forEach((contractId, ruleList) -> {
                //此规则对应的unitId均相等
                CalculateRuleVO ruleVO = ruleList.get(0);
                Integer unitId = ruleVO.getUnitId();
                List<String> monitorList = unitMonitorMap.get(Long.parseLong(unitId + ""));
                for (RecordMetaDSumResult result : recordMetaDSumResults) {
                    //判断是否是该公司运维
                    if (monitorList.contains(result.getDeviceId())) {
                        //录像状态不完整
                        if (!Objects.equals(result.getRecordStatus(), ApiConstants.UY_RecordStatus_Integrity)) {
                            for (CalculateRuleVO calculateRuleVO : ruleList) {
                                Double max = calculateRuleVO.getMax();
                                Double min = calculateRuleVO.getMin();
                                //判断范围在哪个区间
                                if (checkRange(min, max, BigDecimal.valueOf(result.getMissDuration()))) {
                                    if(calculateRuleVO.getNum() == null){
                                        calculateRuleVO.setNum(1);
                                    }else {
                                        calculateRuleVO.setNum(calculateRuleVO.getNum()+1);
                                    }
                                }
                            }
                        }
                    }
                }
                for (CalculateRuleVO calculateRuleVO : ruleList) {
                    //需要扣除的分数，此规则只有一条不需要判断范围
                    double deductScore = calculateRuleVO.getCalcFraction()*calculateRuleVO.getNum();
                    ContractScore contractScore = new ContractScore();
                    contractScore.setContractId(Long.parseLong(contractId + ""));
                    contractScore.setAuditingStatus(AuditingStatus.PASS);
                    contractScore.setAuditingTime(new Date());
                    contractScore.setAuditingUser(Remark);
                    contractScore.setUnitId(Long.parseLong(calculateRuleVO.getUnitId() + ""));
                    contractScore.setRuleId(Long.parseLong(calculateRuleVO.getId() + ""));
                    contractScore.setRuleIds("0," + calculateRuleVO.getId());
                    contractScore.setNum(calculateRuleVO.getNum() + "");
                    contractScore.setDeductCategory(calculateRuleVO.getDeductCategory().getDesc());
                    contractScore.setScore(new BigDecimal(deductScore));
                    contractScore.setRuleName(calculateRuleVO.getRuleName() + "/" + calculateRuleVO.getRuleCondition());
                    contractScore.setCreateTime(new Date());
                    contractScore.setUpdateTime(new Date());
                    contractScore.setRemark(Remark+calculateRuleVO.getNum()+"路设备违反规则");
                    contractScoreList.add(contractScore);
                }
            });
            contractScoreService.saveBatch(contractScoreList);
            log.info("结束抽查图片完整状态");
        }
    }
}