win库+大屏考核指标查询bug

fuliqi

2024-10-10 d268f82d25c25ebdc7a1ea30614f6cda6d3a9ae3

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

@@ -1,94 +1,417 @@
package com.ycl.task;

import com.alibaba.fastjson2.JSONObject;
import com.ycl.platform.domain.param.HK.FaceDeviceInspectionParam;
import com.ycl.platform.domain.param.HK.VehicleDeviceInspectionParam;
import com.ycl.platform.domain.result.HK.FaceDeviceInspectionResult;
import com.ycl.platform.domain.result.HK.VehicleDeviceInspectionResult;
import com.ycl.web.HKClient;
import com.mongodb.client.result.DeleteResult;
import com.ycl.feign.HkApiUtil;
import com.ycl.platform.domain.param.HK.*;
import com.ycl.platform.domain.result.HK.*;
import com.ycl.platform.service.*;
import com.ycl.utils.DateUtils;
import constant.ApiConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
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.util.CollectionUtils;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Objects;


//海康对接数据任务
@Slf4j
@Component("HKTask")
public class HKTask {

    @Value("${HK.host}")
    public String host;
    @Value("${HK.appKey}")
    public String appKey;
    @Value("${HK.appSecret}")
    public String appSecret;
    @Autowired
    private MongoTemplate mongoTemplate;

    @Autowired
    private HKClient hkClient;

    private final static Integer pageNo = 1;
    private final static Integer pageSize = 5000;
    //成功状态码
    private final static String successCode = "0";
    private IYwThresholdService ywThresholdService;
    @Autowired
    private YwPointService pointService;

    //车辆设备全检指标监测结果
    public void VehicleDeviceInspectionTask() {
    public void vehicleDeviceInspectionTask() {
        log.info("开始执行车辆设备全检指标监测结果数据同步");
        VehicleDeviceInspectionParam param = new VehicleDeviceInspectionParam();
        param.setPageNO(pageNo).setPageSize(pageSize).setDate(getToday());
        JSONObject jsonObject = hkClient.VehicleDeviceInspection(param);
        if (jsonObject != null && successCode.equals(jsonObject.getString("code"))) {
            JSONObject data = jsonObject.getJSONObject("data");
            if (data == null) {
                throw new RuntimeException("车辆设备全检指标监测结果数据为空");
            }
            List<VehicleDeviceInspectionResult> list = data.getList("list", VehicleDeviceInspectionResult.class);
            list.forEach(item ->item.setCreateTime(new Date()));
            if (CollectionUtils.isEmpty(list)) {
                throw new RuntimeException("车辆设备全检指标监测结果数据为空");
            }
            //TODO:同步的数据可能需要工单阈值等处理

        param.setPageNo(ApiConstants.PageNo);
        param.setPageSize(ApiConstants.HKPageSize);
        param.setDate(DateUtils.getDate());
        param.setDataType(ApiConstants.HK_DataType_CAR);
        List<VehicleDeviceInspectionResult> list = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v2/data/vehFullAmount/query", param, VehicleDeviceInspectionResult.class);
        if (!CollectionUtils.isEmpty(list)) {
            //如果存在之前的数据先删除
            Query query = new Query(Criteria.where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, VehicleDeviceInspectionResult.class);
            list.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(list);
            //存放在mongo中
            mongoTemplate.insert(list);
        } else {
            log.error("同步车辆设备全检指标监测结果失败", jsonObject);
            mongoTemplate.insertAll(list);
            //同步的数据进行工单阈值处理
            ywThresholdService.carCheck(list);
        }
        // 本地测试
//        Query query = new Query(Criteria.where("mongoCreateTime").lt(DateUtils.getDayEnd(new Date())));
//        ywThresholdService.carCheck(mongoTemplate.find(query, VehicleDeviceInspectionResult.class));
        log.info("结束车辆设备全检指标监测结果数据同步");
    }


    public void FaceDeviceInspectionTask() {
    //人脸设备全检指标监测结果
    public void faceDeviceInspectionTask() {
        log.info("开始执行人脸设备全检指标监测结果数据同步");
        FaceDeviceInspectionParam param = new FaceDeviceInspectionParam();
        param.setPageNO(pageNo).setPageSize(pageSize).setDate(getToday());
        JSONObject jsonObject = hkClient.FaceDeviceInspection(param);
        if (jsonObject != null && successCode.equals(jsonObject.getString("code"))) {
            JSONObject data = jsonObject.getJSONObject("data");
            if (data == null) {
                throw new RuntimeException("人脸设备全检指标监测结果数据为空");
            }
            List<FaceDeviceInspectionResult> list = data.getList("list", FaceDeviceInspectionResult.class);
            list.forEach(item ->item.setCreateTime(new Date()));
            if (CollectionUtils.isEmpty(list)) {
                throw new RuntimeException("人脸设备全检指标监测结果数据为空");
            }
            //TODO:同步的数据可能需要工单阈值等处理

        param.setPageNo(ApiConstants.PageNo);
        param.setPageSize(ApiConstants.HKPageSize);
        param.setDate(DateUtils.getDate());
        List<FaceDeviceInspectionResult> list = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v2/data/faceFullAmount/query", param, FaceDeviceInspectionResult.class);
        if (!CollectionUtils.isEmpty(list)) {
            //如果存在之前的数据先删除
            Query query = new Query(Criteria.where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, FaceDeviceInspectionResult.class);
            list.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(list);
            //存放在mongo中
            mongoTemplate.insert(list);
        } else {
            log.error("同步人脸设备全检指标监测结果失败", jsonObject);
            mongoTemplate.insertAll(list);
            //同步的数据进行工单阈值处理
            ywThresholdService.faceCheck(list);
        }
//        Query query = new Query(Criteria.where("mongoCreateTime").lt(DateUtils.getDayEnd(new Date())));
//        ywThresholdService.faceCheck(mongoTemplate.find(query, FaceDeviceInspectionResult.class));
        log.info("结束人脸设备全检指标监测结果数据同步");
    }


    private String getToday() {
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String today = sdf.format(date);
        return today;
    // 抓拍数据量监测结果
    public void snapshotDataMonitorTask() {
        log.info("开始执行抓拍数据量检测结果数据同步");
        /** 车辆数据 */
        SnapshotDataMonitorParam carParam = new SnapshotDataMonitorParam();
        carParam.setPageNo(ApiConstants.PageNo);
        carParam.setPageSize(ApiConstants.HKPageSize);
        carParam.setDate(DateUtils.getDate());
        carParam.setDataType(ApiConstants.HK_DataType_CAR);
        List<SnapshotDataMonitorResult> carList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v1/data/snapCountDetail/query", carParam, SnapshotDataMonitorResult.class);
        if (!CollectionUtils.isEmpty(carList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date()))
                    .and("dataType").is(ApiConstants.HK_DataType_CAR));
            DeleteResult result = mongoTemplate.remove(query, SnapshotDataMonitorResult.class);
            carList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(carList);
            //存放在mongo中
            carList.forEach(item -> item.setDataType(ApiConstants.HK_DataType_CAR));
            mongoTemplate.insertAll(carList);
        }

        /** 人脸数据 */
        SnapshotDataMonitorParam faceParam = new SnapshotDataMonitorParam();
        faceParam.setPageNo(ApiConstants.PageNo);
        faceParam.setPageSize(ApiConstants.HKPageSize);
        faceParam.setDate(DateUtils.getDate());
        faceParam.setDataType(ApiConstants.HK_DataType_FACE);
        List<SnapshotDataMonitorResult> faceList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v1/data/snapCountDetail/query", faceParam, SnapshotDataMonitorResult.class);
        if (!CollectionUtils.isEmpty(faceList)) {
            log.info("结果数据大小：{}",faceList.size());
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date()))
                    .and("dataType").is(ApiConstants.HK_DataType_FACE));
            DeleteResult result = mongoTemplate.remove(query, SnapshotDataMonitorResult.class);
            faceList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(faceList);
            //存放在mongo中
            faceList.forEach(item -> item.setDataType(ApiConstants.HK_DataType_FACE));
            mongoTemplate.insertAll(faceList);
        }
        log.info("结束抓拍数据量检测结果数据同步");
    }

    //采集设备属性监测结果(人脸)
    public void monitorDetailTask() {
        log.info("开始执行采集设备属性监测结果数据同步");
        //人脸卡口信息采集准确率
        MonitoringDetailParam param = new MonitoringDetailParam();
        param.setPageNo(ApiConstants.PageNo);
        param.setPageSize(ApiConstants.HKPageSize);
        param.setDate(DateUtils.getDate());
        List<MonitoringDetailResult> faceList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v1/device/cameraExpDetailInfo/query", param, MonitoringDetailResult.class);
        if (!CollectionUtils.isEmpty(faceList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, MonitoringDetailResult.class);
            faceList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(faceList);
            //存放在mongo中
            mongoTemplate.insertAll(faceList);
        }
        log.info("结束采集设备属性监测结果数据同步");
    }

    //卡口属性监测结果
    public void crossDetailTask() {
        log.info("开始执行卡口属性监测结果数据同步");
        //车辆卡口信息采集准确率
        CrossDetailParam param = new CrossDetailParam();
        param.setPageNo(ApiConstants.PageNo);
        param.setPageSize(ApiConstants.HKPageSize);
        param.setDate(DateUtils.getDate());
        List<CrossDetailResult> faceList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v1/device/crossExpDetailInfo/query", param, CrossDetailResult.class);
        if (!CollectionUtils.isEmpty(faceList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, CrossDetailResult.class);
            faceList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(faceList);
            //存放在mongo中
            mongoTemplate.insertAll(faceList);
        }
        log.info("结束卡口属性监测结果数据同步");
    }

    //数据完整性监测结果
    public void dataIntegrityMonitoringTask() {
        log.info("开始执行数据完整性监测结果数据同步");
        //车辆卡口设备抓拍数据完整性
        DataIntegrityMonitoringParam param = new DataIntegrityMonitoringParam();
        param.setPageNo(ApiConstants.PageNo);
        param.setPageSize(ApiConstants.HKPageSize);
        param.setDate(DateUtils.getDate());
        param.setDataType(ApiConstants.HK_DataType_CAR);
        List<DataIntegrityMonitoringResult> faceList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v1/data/attributeIntegrity/query", param, DataIntegrityMonitoringResult.class);

        if (!CollectionUtils.isEmpty(faceList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, DataIntegrityMonitoringResult.class);
            faceList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(faceList);
            //存放在mongo中
            mongoTemplate.insertAll(faceList);
        }
        log.info("结束数据完整性监测结果数据同步");
    }

    //属性识别准确监测结果
    public void attrRecognitionMonitorTask() {
        log.info("开始执行属性识别准确监测结果数据同步");
        //车辆卡口设备抓拍数据准确性
        AttrRecognitionParam param = new AttrRecognitionParam();
        param.setPageNo(ApiConstants.PageNo);
        param.setPageSize(ApiConstants.HKPageSize);
        param.setDate(DateUtils.getDate());
        param.setDataType(ApiConstants.HK_DataType_CAR);
        List<AttrRecognitionMonitorResult> faceList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v1/data/attributeRecognition/query", param, AttrRecognitionMonitorResult.class);

        if (!CollectionUtils.isEmpty(faceList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, AttrRecognitionMonitorResult.class);
            faceList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(faceList);
            //存放在mongo中
            mongoTemplate.insertAll(faceList);
        }
        log.info("结束属性识别准确监测结果数据同步");

    }

    //抓拍数据时延监测结果
    public void snapshopDelayMonitorTask() {
        log.info("开始执行抓拍数据时延监测结果数据同步");
        //车辆卡口设备抓拍数据上传及时性
        /** 车辆数据 */
        SnapshotDelayMonitorParam carParam = new SnapshotDelayMonitorParam();
        carParam.setPageNo(ApiConstants.PageNo);
        carParam.setPageSize(ApiConstants.HKPageSize);
        carParam.setDate(DateUtils.getDate());
        carParam.setDataType(ApiConstants.HK_DataType_CAR);
        List<SnapshotDelayMonitorResult> carList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v1/data/snapAgingDetail/query", carParam, SnapshotDelayMonitorResult.class);

        if (!CollectionUtils.isEmpty(carList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date()))
                    .and("dataType").is(ApiConstants.HK_DataType_CAR));
            DeleteResult result = mongoTemplate.remove(query, SnapshotDelayMonitorResult.class);
            //存放在mongo中
            carList.forEach(item -> item.setDataType(ApiConstants.HK_DataType_CAR));
            carList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(carList);
            mongoTemplate.insertAll(carList);
        }

        /** 人脸数据 */
        SnapshotDelayMonitorParam faceParam = new SnapshotDelayMonitorParam();
        faceParam.setPageNo(ApiConstants.PageNo);
        faceParam.setPageSize(ApiConstants.HKPageSize);
        faceParam.setDate(DateUtils.getDate());
        faceParam.setDataType(ApiConstants.HK_DataType_FACE);
        List<SnapshotDelayMonitorResult> faceList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v1/data/snapAgingDetail/query", faceParam, SnapshotDelayMonitorResult.class);

        if (!CollectionUtils.isEmpty(faceList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date()))
                    .and("dataType").is(ApiConstants.HK_DataType_FACE));
            DeleteResult result = mongoTemplate.remove(query, SnapshotDelayMonitorResult.class);
            //存放在mongo中
            faceList.forEach(item -> item.setDataType(ApiConstants.HK_DataType_FACE));
            mongoTemplate.insertAll(faceList);
        }
        log.info("结束抓拍数据时延监测结果数据同步");
    }

    //图片访问监测结果
    public void picAccessTask() {
        log.info("开始执行图片访问监测结果数据同步");
        //车辆卡口信息采集准确率、车辆卡口设备url可用性
        PicAccessParam param = new PicAccessParam();
        param.setPageNo(ApiConstants.PageNo);
        param.setPageSize(ApiConstants.HKPageSize);
        param.setDate(DateUtils.getDate());
        param.setDataType(ApiConstants.HK_DataType_CAR);
        List<PicAccessResult> faceList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v1/data/picAccessDetail/query", param, PicAccessResult.class);

        if (!CollectionUtils.isEmpty(faceList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, PicAccessResult.class);
            faceList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(faceList);
            //存放在mongo中
            mongoTemplate.insertAll(faceList);
        }
        log.info("结束图片访问监测结果数据同步");
    }

    //车辆设备抽检指标监测结果
    public void vehicleDeviceSamplingTask() {
        log.info("开始执行车辆设备抽检指标监测结果数据同步");
        //车辆卡口信息采集准确率、车辆卡口设备url可用性
        VehicleDeviceSamplingParam param = new VehicleDeviceSamplingParam();
        param.setPageNo(ApiConstants.PageNo);
        param.setPageSize(ApiConstants.HKPageSize);
        param.setDate(DateUtils.getDate());
        param.setDataType(ApiConstants.HK_DataType_CAR);
        List<VehicleDeviceSamplingResult> faceList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v2/data/vehSampleAmount/query", param, VehicleDeviceSamplingResult.class);

        if (!CollectionUtils.isEmpty(faceList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, VehicleDeviceSamplingResult.class);
            faceList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(faceList);
            //存放在mongo中
            mongoTemplate.insertAll(faceList);
        }
        log.info("结束车辆设备抽检指标监测结果数据同步");
    }


    //人脸设备抽检指标监测结果
    public void faceDeviceSamplingTask() {
        log.info("开始执行人脸设备抽检指标监测结果数据同步");
        FaceDeviceSamplingParam param = new FaceDeviceSamplingParam();
        param.setPageNo(ApiConstants.PageNo);
        param.setPageSize(ApiConstants.HKPageSize);
        param.setDate(DateUtils.getDate());
        List<FaceDeviceSamplingResult> faceList = HkApiUtil.sendAPI(host,appKey,appSecret,"/api/dqd/service/rs/v2/data/faceSampleAmount/query", param, FaceDeviceSamplingResult.class);

        if (!CollectionUtils.isEmpty(faceList)) {
            //如果今天存在之前的数据先删除
            Query query = new Query(Criteria
                    .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, FaceDeviceSamplingResult.class);
            faceList.stream().forEach(item -> {
                if (Objects.nonNull(item.getExternalIndexCode())) {
                    item.setNo(item.getExternalIndexCode());
                }
            });
            pointService.setDeviceTagByGB(faceList);
            //存放在mongo中
            mongoTemplate.insertAll(faceList);
        }
        log.info("结束人脸设备抽检指标监测结果数据同步");
    }

    //解析数据
    private <T> List<T> getDataList(JSONObject jsonObject, Class<T> resultClass, String message) {
        if (jsonObject != null && ApiConstants.HKSuccessCode.equals(jsonObject.getString("code"))) {
            log.info("数据格式"+jsonObject);
            JSONObject data = jsonObject.getJSONObject("data");
            if (data == null) {
                log.error(message, jsonObject);
                return null;
            }
            List<T> list = data.getList("list", resultClass);
            if (CollectionUtils.isEmpty(list)) {
                log.error(message, data);
                return null;
            }
            return list;
        } else {
            log.error(message);
        }
        return null;
    }
}