合同积分定时任务

fuliqi

2024-08-23 620a580dbfee0d438b4505f77c9a232332f53849

合同积分定时任务

 ycl-common/src/main/java/enumeration/ErrorType.java

@@ -15,6 +15,7 @@
    DEVICE_OFFLINE("DEVICEOFFLINE", "设备离线"),
    VIDEO_LOSS("VIDEOMISS", "录像缺失"),
    VIDEO_NONE("NOVIDEO", "无录像"),
    PIC_URLABNORMAL("PICURLABNORMAL","图片访问异常"),
    POINT_INFO_ERROR("POINTINFOERRO", "点位信息错误"),
    POINT_INFO_MISS("POINTINFOMISS", "点位信息不全"),
    SIGNAL_LOSS("SIGNALMISS", "信号缺失"),

 ycl-pojo/src/main/java/com/ycl/platform/base/AbsEntity.java

@@ -23,19 +23,19 @@
    /**
     * 创建时间
     */
    @TableField(value = "create_time")
    @TableField(value = "create_time",fill = FieldFill.INSERT)
    private Date createTime;

    /**
     * 修改时间
     */
    @TableField(value = "update_time")
    @TableField(value = "update_time",fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

    /**
     * 逻辑删除
     */
    @TableField(value = "deleted")
    @TableField(value = "deleted", fill = FieldFill.INSERT)
    private Integer deleted;

}

 ycl-pojo/src/main/java/com/ycl/platform/domain/entity/WorkOrder.java

@@ -68,8 +68,8 @@
    private String ywCondition;

    @ApiModelProperty("运维检测情况/一张图")
    @TableField("yw_check_condition")
    private String ywCheckCondition;
    @TableField("yw_check_result")
    private String ywCheckResult;

    @ApiModelProperty("处理期限")
    @TableField("processing_period")

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

@@ -61,4 +61,6 @@
    private Integer unitId;
    //违规路数、个数
    private Integer num;
    //工单下发到审核通过的时间
    private long handleTime;
}

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

@@ -55,7 +55,8 @@

    /** 故障类型 */
    private List<String> errorTypeList;

    /** 故障类型 */
    private String errorType;
    /** 运维人员 */
    private Integer ywPeopleId;
    private String ywPeopleName;
@@ -80,6 +81,7 @@
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date distributeTime;

    private Date auditTime;
    /** 下发人 */
    private String realName;


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

@@ -13,6 +13,7 @@
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

@@ -71,5 +72,7 @@
     */
    List<DeviceInfoVO> hasErrorWorkOrderList();

    List<WorkOrderVO> selectPassOrder(@Param("startTime") LocalDateTime now, @Param("endTime")LocalDateTime thirtyDaysAgo, @Param("status") String status, @Param("auditStatus") String auditStatus);

    int addMany(@Param("workOrderList") List<WorkOrder> workOrderList);
}

 ycl-server/src/main/java/com/ycl/platform/service/impl/TContractServiceImpl.java

@@ -84,16 +84,16 @@
        setTemplateRule(list,null,"设备平均在线率","90%≤设备平均在线率＜95%",94D,90D,RuleDeductCategoryEnum.DEDUCT_POINTS,10.00);
        setTemplateRule(list,null,"设备平均在线率","＜90%",89D,null,RuleDeductCategoryEnum.DEDUCT_POINTS,20.00);

        setTemplateRule(list,2,"前端感知源治理工作","时钟同步",null,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.1);
        setTemplateRule(list,null,"前端感知源治理工作","OSD标识",null,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.1);
        setTemplateRule(list,null,"前端感知源治理工作","一机一档",null,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.1);
        setTemplateRule(list,2,"前端感知源治理工作","时钟同步",24D,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.1);
        setTemplateRule(list,null,"前端感知源治理工作","OSD标识",24D,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.1);
        setTemplateRule(list,null,"前端感知源治理工作","一机一档",24D,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.1);

        setTemplateRule(list,3,"存储故障","因存储设备、云存储软件等引起平台不能正常查看历史图像,须在24小时排除故障,单次故障在24小时以内",24D,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.5);
        setTemplateRule(list,null,"存储故障","因存储设备、云存储软件等引起平台不能正常查看历史图像,须在24小时排除故障,单次故障在48小时以内",null,24D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,1.0);
        setTemplateRule(list,null,"存储故障","因存储设备、云存储软件等引起平台不能正常查看历史图像,须在24小时排除故障,单次故障在48小时以内",48D,25D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,1.0);
        setTemplateRule(list,null,"存储故障","因视频或者图片丢失导致重要案事件不能回放或查看",null,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,2.0);

        setTemplateRule(list,4,"对于前端点位异常情况的处理","镜头故障或污染或树枝遮挡或枪机视角偏移正常角度或补光灯应亮未亮,24小时后未修复的",null,24D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.5);
        setTemplateRule(list,null,"对于前端点位异常情况的处理","镜头故障或污染或树枝遮挡或枪机视角偏移正常角度或补光灯应亮未亮,48小时后未修复的",null,48D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,1.0);
        setTemplateRule(list,4,"对于前端点位异常情况的处理","镜头故障或污染或树枝遮挡或枪机视角偏移正常角度或补光灯应亮未亮,24小时后未修复的",48D,25D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.5);
        setTemplateRule(list,null,"对于前端点位异常情况的处理","镜头故障或污染或树枝遮挡或枪机视角偏移正常角度或补光灯应亮未亮,48小时后未修复的",null,49D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,1.0);

        setTemplateRule(list,5,"确保录像完整不定期对所有点位录像完整性抽查","每路视频累计丢失10分钟（含）以内",10D,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.2);
        setTemplateRule(list,null,"确保录像完整不定期对所有点位录像完整性抽查","丢失10-60 分钟（含）",60D,9D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.5);

 ycl-server/src/main/java/com/ycl/platform/service/impl/WorkOrderServiceImpl.java

@@ -672,6 +672,6 @@
    public void updateImgById(Integer workOrderId, String imgPath) {
        new LambdaUpdateChainWrapper<>(baseMapper)
                .eq(WorkOrder::getId, workOrderId)
                .set(WorkOrder::getYwCheckCondition, imgPath);
                .set(WorkOrder::getYwCheckResult, imgPath);
    }
}

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

@@ -2,6 +2,7 @@


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.mongodb.client.result.DeleteResult;
import com.ycl.platform.domain.entity.*;
import com.ycl.platform.domain.result.HK.PicAccessResult;
@@ -11,14 +12,18 @@
import com.ycl.platform.domain.vo.CalculateRuleVO;
import com.ycl.platform.domain.vo.ContractVO;
import com.ycl.platform.domain.vo.ReportVO;
import com.ycl.platform.domain.vo.WorkOrderVO;
import com.ycl.platform.mapper.*;
import com.ycl.platform.service.IContractScoreService;
import com.ycl.utils.DateUtils;
import constant.ApiConstants;
import constant.RedisConstant;
import enumeration.ContractRule;
import enumeration.ErrorType;
import enumeration.general.AuditingStatus;
import enumeration.general.ErrorTypeEnum;
import enumeration.general.RuleDeductCategoryEnum;
import enumeration.general.WorkOrderStatusEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
@@ -31,6 +36,8 @@
import javax.management.monitor.Monitor;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

@@ -44,10 +51,6 @@
    @Autowired
    private MongoTemplate mongoTemplate;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private TMonitorMapper monitorMapper;
    @Autowired
    private TContractMapper contractMapper;
    @Autowired
    private YwPointMapper ywPointMapper;
@@ -57,6 +60,8 @@
    private ContractRuleRecordMapper recordMapper;
    @Autowired
    private IContractScoreService contractScoreService;
    @Autowired
    private WorkOrderMapper workOrderMapper;

    private static final Integer Online = 1;
    private static final Integer Offline = -1;
@@ -172,21 +177,7 @@
                    if (checkRange(min, max, siteOnline.multiply(new BigDecimal(100)))) {
                        //需要扣除的分数
                        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(unitId + ""));
                        contractScore.setRuleId(Long.parseLong(ruleVO.getId() + ""));
                        contractScore.setRuleIds("0," + ruleVO.getId());
                        contractScore.setNum(siteOnline + "");
                        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);
                        ContractScore contractScore = getContractScore(ruleVO, deductScore, siteOnline + "", Remark);
                        contractScoreList.add(contractScore);
                    }
                }
@@ -197,19 +188,6 @@
        log.info("结束计算合同点位在线率分数");
    }

    private boolean checkRange(Double min, Double max, BigDecimal siteOnline) {
        if (siteOnline == null) {
            return false;
        }
        if (max != null && siteOnline.compareTo(new BigDecimal(max)) > 0) {
            return false;
        }
        if (min != null && siteOnline.compareTo(new BigDecimal(min)) < 0) {
            return false;
        }
        return true;
    }

    /**
     * 检测工单表 进行合同积分扣除
     * 查出工单需要扣分的所有规则
@@ -218,6 +196,10 @@
     * 插入合同积分表，修改工单状态为已扣分
     */
    public void workOrderDeduct() {
        log.info("开始扫描工单扣分");
        //准备批量打分的集合
        List<ContractScore> contractScoreList = new ArrayList<>();
        List<String> workOrderList = new ArrayList<>();
        //查询生效合同对应所有的规则
        List<CalculateRuleVO> calculateRules = contractMapper.getCalculateRule(new Date());
        Map<String, Map<Integer, List<CalculateRuleVO>>> ruleMap = calculateRules.stream()
@@ -233,8 +215,112 @@
        Map<Integer, List<CalculateRuleVO>> storeRuleMap = ruleMap.get(ContractRule.CONTRACT_RULE_Store.getName());
        //点位异常情况处理 获取key为合同id，value为规则的map
        Map<Integer, List<CalculateRuleVO>> siteRuleMap = ruleMap.get(ContractRule.CONTRACT_RULE_Site.getName());
        //查询报备列表
        List<String> reportNumbers = reportMapper.selectNumberList(AuditStatus_Pass, DateUtils.getDate());
        //查询30天内所有未扣分、审核通过的工单
        // 获取当前日期
        LocalDateTime endTime = LocalDateTime.now();
        // 计算30天前的日期
        LocalDateTime startTime = endTime.minusDays(30);
        List<WorkOrderVO> workOrders = workOrderMapper.selectPassOrder(startTime, endTime, WorkOrderStatusEnum.AUDITING_SUCCESS.getValue(), "审核通过");
        for (WorkOrderVO workOrder : workOrders) {
            //检测是否报备过
            if (!CollectionUtils.isEmpty(reportNumbers)) {
                if(reportNumbers.contains(workOrder.getSerialNumber())) continue;
            }
            String errorType = workOrder.getErrorType();
            //存储故障 录像或图片访问异常
            if (ErrorType.VIDEO_NONE.getValue().equals(errorType) || ErrorType.PIC_URLABNORMAL.getValue().equals(errorType)) {
                if (!CollectionUtils.isEmpty(storeRuleMap)) {
                    storeRuleMap.forEach((contractId, rules) -> {
                        Integer unitId = rules.get(0).getUnitId();
                        //找到对应的规则
                        if (workOrder.getUnitId().equals(unitId)) {
                            //工单下发时间
                            Date createTime = workOrder.getDistributeTime();
                            Date auditTime = workOrder.getAuditTime();
                            double diffTime = (double) (auditTime.getTime() - createTime.getTime()) / (1000 * 60 * 60);
                            //选择时间范围内的规则
                            for (CalculateRuleVO rule : rules) {
                                if (checkRange(rule.getMin(), rule.getMax(), new BigDecimal(diffTime))) {
                                    double deductScore = rule.getCalcFraction() * Math.ceil(diffTime);
                                    ContractScore contractScore = getContractScore(rule, deductScore, Math.round(diffTime * 100) / 100 + "", Remark + "工单编号为:" + workOrder.getWorkOrderNo() + "处理超时，扣除" + deductScore + "分");
                                    contractScoreList.add(contractScore);
                                    workOrderList.add(workOrder.getWorkOrderNo());
                                }
                            }
                        }
                    });
                }
            }
            //前端感知源治理工作（时钟同步规则、OSD规则、一机一档规则）
            if (ErrorType.MONITOR_UNQUALIFY.getValue().equals(errorType) || ErrorType.OSD_ERROR.getValue().equals(errorType) || ErrorType.CLOCK_SKEW.getValue().equals(errorType)) {
                if (!CollectionUtils.isEmpty(monitorRuleMap)) {
                    monitorRuleMap.forEach((contractId, rules) -> {
                        Integer unitId = rules.get(0).getUnitId();
                        //找到对应的规则
                        if (workOrder.getUnitId().equals(unitId)) {
                            //工单下发时间
                            Date createTime = workOrder.getDistributeTime();
                            Date auditTime = workOrder.getAuditTime();
                            double diffTime = (double) (auditTime.getTime() - createTime.getTime()) / (1000 * 60 * 60);
                            //选择时间范围内的规则
                            for (CalculateRuleVO rule : rules) {
                                if (checkRange(rule.getMin(), rule.getMax(), new BigDecimal(diffTime))) {
                                    double deductScore = rule.getCalcFraction();
                                    ContractScore contractScore = getContractScore(rule, deductScore, Math.round(diffTime * 100) / 100 + "", Remark + "工单编号为:" + workOrder.getWorkOrderNo() + "处理超时，扣除" + deductScore + "分");
                                    contractScoreList.add(contractScore);
                                    workOrderList.add(workOrder.getWorkOrderNo());
                                }
                            }
                        }
                    });
                }
            }
            //点位异常情况处理（镜头异常、摄像头遮挡等）
            if (ErrorType.SCREEN_COLOR_DEVIATION.getValue().equals(errorType) || ErrorType.SNOW_STORM.getValue().equals(errorType) || ErrorType.STRIPE_INTERFERENCE.getValue().equals(errorType) || ErrorType.SCREEN_OCCLUSION.getValue().equals(errorType) || ErrorType.ABNORMAL_CLARITY.getValue().equals(errorType) || ErrorType.ABNORMAL_BRIGHTNESS.getValue().equals(errorType)) {
                if (!CollectionUtils.isEmpty(monitorRuleMap)) {
                    siteRuleMap.forEach((contractId, rules) -> {
                        Integer unitId = rules.get(0).getUnitId();
                        //设备是否是该公司运维
                        if (workOrder.getUnitId().equals(unitId)) {
                            //工单下发时间
                            Date createTime = workOrder.getDistributeTime();
                            Date auditTime = workOrder.getAuditTime();
                            double diffTime = (double) (auditTime.getTime() - createTime.getTime()) / (1000 * 60 * 60);
                            //选择时间范围内的规则
                            for (CalculateRuleVO rule : rules) {
                                if (checkRange(rule.getMin(), rule.getMax(), new BigDecimal(diffTime))) {
                                    double deductScore = 0d;
                                    if (ContractRule.CONTRACT_RULE_Store_48H.getName().equals(rule.getRuleCondition())) {
                                        //计算超时天数
                                        int day = (int) ((diffTime - 48) / 24 + 1);
                                        deductScore = rule.getCalcFraction() * (day);
                                    } else {
                                        deductScore = rule.getCalcFraction();
                                    }
                                    ContractScore contractScore = getContractScore(rule, deductScore, Math.round(diffTime * 100) / 100 + "", Remark + "工单编号为:" + workOrder.getWorkOrderNo() + "处理超时，扣除" + deductScore + "分");
                                    contractScoreList.add(contractScore);
                                    workOrderList.add(workOrder.getWorkOrderNo());
                                }
                            }

                        }
                    });
                }
            }
        }
        contractScoreService.saveBatch(contractScoreList);
        if (!CollectionUtils.isEmpty(workOrderList)) {
            //修改工单扣分状态为已扣分
            UpdateWrapper<WorkOrder> updateWrapper = new UpdateWrapper<>();
            updateWrapper.in("work_order_no", workOrderList);
            updateWrapper.set("deduct", 1);
            workOrderMapper.update(null, updateWrapper);
        }
        log.info("结束执行工单扣分");
    }


    /**
     * 不定期检查数据 扣除积分
@@ -249,7 +335,8 @@
            log.info("开始抽查图片完整状态");
            //准备批量打分的集合
            List<ContractScore> contractScoreList = new ArrayList<>();

            //查询报备列表
            List<String> reportNumbers = reportMapper.selectNumberList(AuditStatus_Pass, DateUtils.getDate());
            Date date = DateUtils.getDay(2024, 7, 13);
            //查图片完整性规则 获取key为合同id，value为规则的map
            Map<Integer, List<CalculateRuleVO>> contractMap = contractMapper.getCalculateRule(new Date()).stream()
@@ -269,45 +356,37 @@
                            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 (!CollectionUtils.isEmpty(contractMap)) {
                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 (!CollectionUtils.isEmpty(reportNumbers)) {
                            if(reportNumbers.contains(picAccessResult.getExternalIndexCode())) continue;
                        }
                        //判断是否是该公司运维
                        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);
                }
            });
                    if (deduct) {
                        //需要扣除的分数，此规则只有一条不需要判断范围
                        Double deductScore = ruleVO.getCalcFraction();
                        ContractScore contractScore = getContractScore(ruleVO, deductScore, "1", Remark + "国标码为:" + serialNumber + "时间：" + new Date() + "存在大图不可用数据");
                        contractScoreList.add(contractScore);
                    }
                });
            }
            contractScoreService.saveBatch(contractScoreList);
            log.info("结束抽查图片完整状态");
        }
@@ -327,7 +406,8 @@
            log.info("开始抽查录像完整状态");
            //准备批量打分的集合
            List<ContractScore> contractScoreList = new ArrayList<>();

            //查询报备列表
            List<String> reportNumbers = reportMapper.selectNumberList(AuditStatus_Pass, DateUtils.getDate());
            Date date = DateUtils.getDay(2024, 7, 13);
            //查图片完整性规则 获取key为合同id，value为规则的map
            Map<Integer, List<CalculateRuleVO>> contractMap = contractMapper.getCalculateRule(new Date()).stream()
@@ -347,54 +427,83 @@
                            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);
            if (!CollectionUtils.isEmpty(contractMap)) {
                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 (!CollectionUtils.isEmpty(reportNumbers)) {
                            if(reportNumbers.contains(result.getDeviceId())) continue;
                        }
                        //判断是否是该公司运维
                        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);
                }
            });
                    for (CalculateRuleVO calculateRuleVO : ruleList) {
                        if (calculateRuleVO.getNum() > 0) {
                            //需要扣除的分数，此规则只有一条不需要判断范围
                            double deductScore = calculateRuleVO.getCalcFraction() * calculateRuleVO.getNum();
                            ContractScore contractScore = getContractScore(calculateRuleVO, deductScore, calculateRuleVO.getNum() + "", Remark + calculateRuleVO.getNum() + "路设备违反规则");
                            contractScoreList.add(contractScore);
                        }
                    }
                });
            }
            contractScoreService.saveBatch(contractScoreList);
            log.info("结束抽查图片完整状态");
            log.info("结束抽查录像完整状态");
        }
    }

    private boolean checkRange(Double min, Double max, BigDecimal index) {
        if (index == null) {
            return false;
        }
        if (max == null && min == null) {
            return false;
        }
        if (max != null && index.setScale(0, RoundingMode.DOWN).compareTo(new BigDecimal(max)) > 0) {
            return false;
        }
        if (min != null && index.setScale(0, RoundingMode.UP).compareTo(new BigDecimal(min)) < 0) {
            return false;
        }
        return true;
    }

    private ContractScore getContractScore(CalculateRuleVO rule, double deductScore, String num, String remark) {
        ContractScore contractScore = new ContractScore();
        contractScore.setContractId(Long.parseLong(rule.getContractId() + ""));
        contractScore.setAuditingStatus(AuditingStatus.PASS);
        contractScore.setAuditingTime(new Date());
        contractScore.setAuditingUser(Remark);
        contractScore.setUnitId(Long.parseLong(rule.getUnitId() + ""));
        contractScore.setRuleId(Long.parseLong(rule.getId() + ""));
        contractScore.setRuleIds("0," + rule.getId());
        contractScore.setNum(num);
        contractScore.setDeductCategory(rule.getDeductCategory().getDesc());
        contractScore.setScore(new BigDecimal(deductScore));
        contractScore.setRuleName(rule.getRuleName() + "/" + rule.getRuleCondition());
        contractScore.setCreateTime(new Date());
        contractScore.setUpdateTime(new Date());
        contractScore.setRemark(remark);
        return contractScore;
    }
}

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

@@ -199,4 +199,12 @@
    </foreach>
    </insert>

    <select id="selectPassOrder" resultType="com.ycl.platform.domain.vo.WorkOrderVO">
        SELECT wo.id,wo.work_order_no,wo.unit_id,woet.error_name as errorType,woet.distribute_time,woar.create_time as auditTime
        FROM t_work_order wo
        LEFT JOIN t_work_order_error_type woet ON woet.work_order_no = wo.work_order_no
        LEFT JOIN t_work_order_auditing_record woar ON woar.work_order_id = wo.id
        WHERE wo.deleted = 0 AND wo.status = #{status}  AND woar.result = #{auditStatus}
          AND wo.deduct = 0 AND woar.create_time between #{startTime} and #{endTime}
    </select>
</mapper>