新增白名单故障类型

fuliqi

2024-12-07 636833dfe5ce1d27b30cec1e73badff884cfa1b9

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

@@ -1,24 +1,58 @@
package com.ycl.platform.service.impl;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.fastjson2.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ycl.dataListener.CurrencyDataListener;
import com.ycl.platform.domain.entity.WorkOrder;
import com.ycl.platform.domain.entity.WorkOrderWhite;
import com.ycl.platform.domain.entity.YwPoint;
import com.ycl.platform.domain.entity.YwThreshold;
import com.ycl.platform.domain.excel.ErrorExport;
import com.ycl.platform.domain.excel.PointExport;
import com.ycl.platform.domain.excel.WorkOrderWhiteExport;
import com.ycl.platform.domain.query.WorkOrderWhiteQuery;
import com.ycl.platform.domain.result.HK.FaceDeviceInspectionResult;
import com.ycl.platform.domain.result.HK.VehicleDeviceInspectionResult;
import com.ycl.platform.mapper.WorkOrderMapper;
import com.ycl.platform.domain.vo.DynamicColumnVO;
import com.ycl.platform.mapper.WorkOrderWhiteMapper;
import com.ycl.platform.mapper.YwThresholdMapper;
import com.ycl.platform.service.IYwThresholdService;
import constant.CompareConstant;
import com.ycl.platform.service.WorkOrderService;
import com.ycl.system.Result;
import com.ycl.system.page.PageUtil;
import com.ycl.utils.SecurityUtils;
import com.ycl.utils.StringUtils;
import com.ycl.utils.ip.PingUtil;
import com.ycl.utils.poi.EasyExcelImportUtils;
import com.ycl.utils.uuid.IdUtils;
import constant.PointHeaderConstant;
import constant.YwThreadConstants;
import enumeration.CompareType;
import enumeration.ErrorType;
import enumeration.general.BusinessTypeEnum;
import enumeration.general.WorkOrderStatusEnum;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;
import utils.DateUtils;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import java.io.OutputStream;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
@@ -28,9 +62,16 @@
 * @date 2024-07-19
 */
@Service
@Slf4j
public class YwThresholdServiceImpl extends ServiceImpl<YwThresholdMapper, YwThreshold> implements IYwThresholdService {
    @Autowired
    private YwThresholdMapper ywThresholdMapper;

    @Autowired
    private WorkOrderService workOrderService;

    @Autowired
    private WorkOrderWhiteMapper workOrderWhiteMapper;

    /**
     * 查询运维阈值
@@ -102,15 +143,110 @@
        return ywThresholdMapper.deleteYwThresholdById(id);
    }


    /**
     * 判断视频阈值是否满足下发条件
     *
     * @param list
     */
    @Override
    public void faceCheck(List list) {

    public void videoCheck(List list) {
    }

    @Override
    public void videoCheck(List list) {
    public void errorTypeCheckUY(List list) {
        // 平台离线故障检测
        if (CollectionUtils.isEmpty(list)) {
            Boolean ping = PingUtil.ping("", 5);
            if (!ping) {

            }
        }
        // 设备离线故障检测

        // 信号缺失故障检测

        // 画面偏色故障检测

        // 雪花干扰故障检测

        // 条纹干扰故障检测

        // 画面遮挡故障检测

        // 清晰度异常检测

        // 亮度异常故障检测
    }

    /**
     * 判断人脸阈值是否满足下发条件
     *
     * @param list
     */
    @Override
    public void faceCheck(List<FaceDeviceInspectionResult> list) {
        Map<String, YwThreshold> thresholdMap = getYwThresholdMap(BusinessTypeEnum.FACE.name());
        //准备待下发工单集合
        List<WorkOrder> distributeList = new ArrayList<>();
        //准备直接下发工单集合
        List<WorkOrder> workOrderList = new ArrayList<>();
        //处理接口数据
        for (FaceDeviceInspectionResult result : list) {
            if (result == null) {
                log.error("人脸对象数据为空");
                continue;
            }
            WorkOrder workOrder = new WorkOrder();
            //检查时钟准确率
            if (result.getSnapClock() != null) {
                Float clockPercent = result.getSnapClock().getClockPercent();
                check(YwThreadConstants.Face_ClockPercent, clockPercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.CLOCK_RIGHT.getValue());
            }
            //检查数据及时率
            if (result.getSnapTimely() != null) {
                Float timelyPercent = result.getSnapTimely().getTimelyPercent();
                check(YwThreadConstants.Face_TimelyPercent, timelyPercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.DATA_TIMELY_ERROR.getValue());
            }
            //检查持续无数据天数
            if (result.getContinueNoDataCount() != null) {
                Integer continueNoDataCount = result.getContinueNoDataCount();
                check(YwThreadConstants.Face_ContinueNoDataCount, continueNoDataCount, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.LONG_DAY_NO_DATA.getValue());
            }
            //检查不唯一数据量
            if (result.getSnapUnique() != null) {
                Integer nouniqueCount = result.getSnapUnique().getNouniqueCount();
                check(YwThreadConstants.Face_NouniqueCount, nouniqueCount, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.NOT_UNIQUE_DATA_VOLUME.getValue());
            }
            //检查人脸低评分率
            if (result.getSnapValidity() != null) {
                Float lowScorePercent = result.getSnapValidity().getLowScorePercent();
                check(YwThreadConstants.Face_LowScorePercent, lowScorePercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.FACE_LOW.getValue());
            }
            //检查建模失败率
            if (result.getSnapValidity() != null) {
                Float failPercent = result.getSnapValidity().getFailPercent();
                check(YwThreadConstants.Face_FailPercent, failPercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.MODELING_FAIL.getValue());
            }
            // 点位在线率
            if (2 == result.getSnapResult()) {
                workOrder.setSerialNumber(result.getExternalIndexCode());
                workOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                if (CollectionUtils.isEmpty(workOrder.getErrorTypeList())) {
                    workOrder.setErrorTypeList(new ArrayList<>());
                    workOrder.getErrorTypeList().add(ErrorType.DEVICE_OFFLINE.getValue());
                } else {
                    workOrder.getErrorTypeList().add(ErrorType.DEVICE_OFFLINE.getValue());
                }
            }
            if (WorkOrderStatusEnum.WAIT_DISTRIBUTE.equals(workOrder.getStatus())) {
                workOrderList.add(workOrder);
            } else if (WorkOrderStatusEnum.DISTRIBUTED.equals(workOrder.getStatus())) {
                distributeList.add(workOrder);
            }
        }
        /** 添加工单 */
        workOrderService.innerAddWorkOrder(workOrderList);
        workOrderService.innerAddWorkOrder(distributeList);
    }

    /**
@@ -120,102 +256,460 @@
     */
    @Override
    public void carCheck(List<VehicleDeviceInspectionResult> list) {
        QueryWrapper<YwThreshold> wrapper = new QueryWrapper<>();
        wrapper.eq("monitor_type", BusinessTypeEnum.CAR.name());
        List<YwThreshold> ywThresholds = ywThresholdMapper.selectList(wrapper);
        Map<String, YwThreshold> map = new HashMap<>();
        for (YwThreshold ywThreshold : ywThresholds) {
            String name = ywThreshold.getName();
            map.put(name, ywThreshold);
        }
        //时钟准确率阈值
        Float clockPercent = Float.valueOf(map.get(YwThreadConstants.Car_ClockPercent).getValue());
        Float clockPercentAuto = Float.valueOf(map.get(YwThreadConstants.Car_ClockPercent).getValueAuto());
        //数据及时率阈值
        Float timelyPercent = Float.valueOf(map.get(YwThreadConstants.Car_TimelyPercent).getValue());
        Float timelyPercentAuto = Float.valueOf(map.get(YwThreadConstants.Car_TimelyPercent).getValueAuto());
        //持续无数据天数阈值
        Integer continueNoDataCount = Integer.valueOf(map.get(YwThreadConstants.Car_ContinueNoDataCount).getValue());
        Integer continueNoDataCountAuto = Integer.valueOf(map.get(YwThreadConstants.Car_ContinueNoDataCount).getValueAuto());
        //不唯一数据量阈值
        Integer nouniqueCount = Integer.valueOf(map.get(YwThreadConstants.Car_NouniqueCount).getValue());
        Integer nouniqueCountAuto = Integer.valueOf(map.get(YwThreadConstants.Car_NouniqueCount).getValueAuto());
        //白天未识别量阈值
        Integer dayNoNumberCount = Integer.valueOf(map.get(YwThreadConstants.Car_DayNoNumberCount).getValue());
        Integer dayNoNumberCountAuto = Integer.valueOf(map.get(YwThreadConstants.Car_DayNoNumberCount).getValueAuto());
        //车辆六项属性不完整量阈值
        Integer noIntegrityCount = Integer.valueOf(map.get(YwThreadConstants.Car_NoIntegrityCount).getValue());
        Integer noIntegrityCountAuto = Integer.valueOf(map.get(YwThreadConstants.Car_NoIntegrityCount).getValueAuto());

        Map<String, YwThreshold> thresholdMap = getYwThresholdMap(BusinessTypeEnum.CAR.name());
        //准备下发工单集合
        List<WorkOrder> distributeList = new ArrayList<>();
        //准备自动生成工单集合
        List<WorkOrder> workOrderList = new ArrayList<>();
        //处理接口数据
        for (VehicleDeviceInspectionResult result : list) {
            if (result == null) {
                log.error("车辆对象数据为空");
                continue;
            }
            WorkOrder workOrder = new WorkOrder();
            //检查持续无数据天数
            Integer continueNoDataCountResult = result.getContinueNoDataCount();
            check(continueNoDataCount, continueNoDataCountAuto, result, continueNoDataCountResult, "车辆持续无数据天数为空", CompareConstant.MoreThanEq);
            Integer continueNoDataCount = result.getContinueNoDataCount();
            check(YwThreadConstants.Car_ContinueNoDataCount, continueNoDataCount, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.LONG_DAY_NO_DATA.getValue());
            //检查时钟准确率
            Float clockPercentResult = result.getSnapClock().getClockPercent();
            check(clockPercent, clockPercentAuto, result, clockPercentResult, "车辆时钟准确率为空", CompareConstant.LessThanEq);
            if (result.getSnapClock() != null) {
                Float clockPercent = result.getSnapClock().getClockPercent();
                check(YwThreadConstants.Car_ClockPercent, clockPercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.CLOCK_RIGHT.getValue());
            }
            //检查数据及时率
            Float timelyPercentResult = result.getSnapTimely().getTimelyPercent();
            check(timelyPercent, timelyPercentAuto, result, timelyPercentResult, "车辆数据及时率为空", CompareConstant.LessThanEq);
            if (result.getSnapTimely() != null) {
                Float timelyPercentResult = result.getSnapTimely().getTimelyPercent();
                check(YwThreadConstants.Car_TimelyPercent, timelyPercentResult, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.DATA_TIMELY_ERROR.getValue());
            }
            //检查不唯一数据量
            Integer nouniqueCountResult = result.getSnapUnique().getNouniqueCount();
            check(nouniqueCount, nouniqueCountAuto, result, nouniqueCountResult, "车辆不唯一数据量为空", CompareConstant.MoreThanEq);
            if (result.getSnapUnique() != null) {
                Integer nouniqueCountResult = result.getSnapUnique().getNouniqueCount();
                check(YwThreadConstants.Car_NouniqueCount, nouniqueCountResult, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.NOT_UNIQUE_DATA_VOLUME.getValue());
            }
            //检查白天未识别量
            Integer dayNoNumberCountResult = result.getSnapPlate().getDayNoNumberCount();
            check(dayNoNumberCount, dayNoNumberCountAuto, result, dayNoNumberCountResult, "车辆白天未识别量为空", CompareConstant.MoreThanEq);
            //车辆六项属性不完整量
            Integer noIntegrityCountResult = result.getIntegrity().getNoIntegrityCount();
            check(noIntegrityCount, noIntegrityCountAuto, result, noIntegrityCountResult, "车辆六项属性不完整量为空", CompareConstant.MoreThanEq);
            if (result.getSnapPlate() != null) {
                Integer dayNoNumberCountResult = result.getSnapPlate().getDayNoNumberCount();
                check(YwThreadConstants.Car_DayNoNumberCount, dayNoNumberCountResult, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.UNRECOGNIZED_DAY_VOLUME.getValue());
            }
            //车辆主要属性一致率
            if (result.getIntegrity() != null) {
                Integer noIntegrityCountResult = result.getIntegrity().getMainNoIntegrityCount();
                Integer dataCount = result.getDataCount();
                Double integrityRate = ((double) dataCount - noIntegrityCountResult) / dataCount;
                check(YwThreadConstants.Car_NoIntegrityCount, integrityRate, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.CAR_SIX.getValue());
            }
            // 点位在线率
            if (2 == result.getSnapResult()) {
                workOrder.setSerialNumber(result.getExternalIndexCode());
                workOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                if (CollectionUtils.isEmpty(workOrder.getErrorTypeList())) {
                    workOrder.setErrorTypeList(new ArrayList<>());
                    workOrder.getErrorTypeList().add(ErrorType.DEVICE_OFFLINE.getValue());
                } else {
                    workOrder.getErrorTypeList().add(ErrorType.DEVICE_OFFLINE.getValue());
                }
            }
            if (WorkOrderStatusEnum.WAIT_DISTRIBUTE.equals(workOrder.getStatus())) {
                workOrderList.add(workOrder);
            } else if (WorkOrderStatusEnum.DISTRIBUTED.equals(workOrder.getStatus())) {
                distributeList.add(workOrder);
            }
        }
        /** 添加工单 */
        workOrderService.innerAddWorkOrder(workOrderList);
        workOrderService.innerAddWorkOrder(distributeList);

    }

    /**
     * 把阈值条件查出来，转成map
     *
     * @param name
     * @return
     */
    @Override
    public Map<String, YwThreshold> getYwThresholdMap(String name) {
        return ywThresholdMapper.selectList(
                new QueryWrapper<YwThreshold>().eq("monitor_type", name)
        ).stream().collect(Collectors.toMap(
                YwThreshold::getKey,
                Function.identity()
        ));
    }

    /**
     * 白名单详情
     *
     * @param id
     * @return
     */
    @Override
    public Result selectWorkOrderWhiteDetail(Integer id) {
        WorkOrderWhite workOrderWhite = workOrderWhiteMapper.getById(id);
        List<String> errorTypeList = Arrays.asList(workOrderWhite.getErrorType().split(","));
        workOrderWhite.setErrorTypeList(errorTypeList);
        return Result.ok().data(workOrderWhite);
    }

    /**
     * 工单白名单列表
     *
     * @param query 查询
     * @return {@link List }<{@link WorkOrderWhite }>
     * @author
     */
    @Override
    public Result selectWorkOrderWhiteList(WorkOrderWhiteQuery query) {
        IPage<WorkOrderWhite> page = PageUtil.getPage(query, WorkOrderWhite.class);
        workOrderWhiteMapper.page(page, query);
        List<WorkOrderWhite> records = page.getRecords();
        records.forEach(white -> {
            List<String> errorTextList = new ArrayList<>();
            List<String> errorTypeList = Arrays.asList(white.getErrorType().split(","));
            errorTypeList.forEach(error -> {
                String errorText = ErrorType.getDescriptionByValue(error);
                errorTextList.add(errorText);
            });
            white.setErrorType(String.join(",", errorTextList));
        });
        return Result.ok().data(records).total(page.getTotal());
    }

    /**
     * 添加工单白名单
     *
     * @param workOrderWhite 白色工单
     * @return {@link Result }
     * @author
     */
    @Override
    public Result addWorkOrderWhite(WorkOrderWhite workOrderWhite) {
        // 检查是否已经存在该白名单
        WorkOrderWhite flag = workOrderWhiteMapper.selectBySerialNumber(workOrderWhite.getSerialNumber());
        if (flag != null) {
            return Result.error("该设备已存在白名单");
        } else {
            List<String> errorTypeList = workOrderWhite.getErrorTypeList();
            workOrderWhite.setErrorType(String.join(",", errorTypeList));
            workOrderWhite.setCreateBy(SecurityUtils.getUsername());
            workOrderWhiteMapper.insert(workOrderWhite);
            return Result.ok();
        }
    }

    /**
     * 修改工单白名单
     *
     * @param workOrderWhite 白色工单
     * @return {@link Result }
     * @author
     */
    @Override
    public Result updateWorkOrderWhite(WorkOrderWhite workOrderWhite) {
        WorkOrderWhite white = workOrderWhiteMapper.selectBySerialNumber(workOrderWhite.getSerialNumber());
        workOrderWhite.setId(white.getId());
        List<String> errorTypeList = workOrderWhite.getErrorTypeList();
        workOrderWhite.setErrorType(String.join(",", errorTypeList));
        workOrderWhiteMapper.updateById(workOrderWhite);
        return Result.ok();
    }

    /**
     * 批量删除工单白名单
     *
     * @param ids ids
     * @author
     */
    @Override
    public Result batchDeleteWorkOrderWhite(List<String> ids) {
        workOrderWhiteMapper.batchDelete(ids);
        return Result.ok();
    }

    /**
     * 白名单导出
     *
     * @param response
     * @throws IOException
     */
    @Override
    public void whiteExport(HttpServletResponse response) throws IOException {
        //白名单数据
        List<WorkOrderWhiteExport> data = workOrderWhiteMapper.whiteExport();
        data.forEach(white -> {
            List<String> errorTextList = new ArrayList<>();
            List<String> errorTypeList = Arrays.asList(white.getErrorType().split(","));
            errorTypeList.forEach(error -> {
                String errorText = ErrorType.getDescriptionByValue(error);
                errorTextList.add(errorText);
            });
            white.setErrorType(String.join(",", errorTextList));
        });
        //故障类型数据
        List<String> errorTextList = ErrorType.getDescriptionList();
        List<ErrorExport> errorExports = new ArrayList<>();
        errorTextList.forEach(error -> {
            ErrorExport errorExport = new ErrorExport();
            errorExport.setError(error);
            errorExports.add(errorExport);
        });
        ExcelWriter excelWriter = null;
        try (OutputStream outputStream = response.getOutputStream()) {
            excelWriter = EasyExcel.write(outputStream).build();

            WriteSheet whiteSheet = EasyExcel.writerSheet(0, "工单白名单清单").head(WorkOrderWhiteExport.class).build();
            WriteSheet errorSheet = EasyExcel.writerSheet(1, "故障类型").head(ErrorExport.class).build();

            excelWriter.write(data, whiteSheet);
            excelWriter.write(errorExports, errorSheet);
            excelWriter.finish();
            outputStream.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                excelWriter.finish();
                response.getOutputStream().close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    private void check(Integer threshold, Integer thresholdAuto, VehicleDeviceInspectionResult result, Integer thresholdResult, String message, String command) {
        if (thresholdResult != null) {
            //大于类型
            if (CompareConstant.MoreThanEq.equals(command)) {
                if (thresholdResult >= thresholdAuto) {
                    //TODO：自动下发工单
                } else if (thresholdResult >= threshold) {
                    //TODO：进入下发工单页面
    /**
     * 导入工单白名单
     *
     * @param file
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result importWhite(MultipartFile file) throws IOException {
//        Consumer<List<WorkOrderWhiteExport>> consumer = (dataList) -> {
//            try {
//                this.updateWhite(dataList);
//            } catch (ExecutionException e) {
//                e.printStackTrace();
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        };
//        EasyExcel.read(file.getInputStream(), WorkOrderWhiteExport.class, new CurrencyDataListener(consumer))
//                .sheet()
//                .headRowNumber(1)
//                .doRead();
        List<WorkOrderWhiteExport> dataList = new ArrayList<>();
        EasyExcel.read(file.getInputStream(), WorkOrderWhiteExport.class, new AnalysisEventListener<WorkOrderWhiteExport>() {
            @Override
            public void invoke(WorkOrderWhiteExport excel, AnalysisContext analysisContext) {
                // 将读取到的每一行存入reportDetails集合中
                dataList.add(excel);
            }

            @Override
            public void doAfterAllAnalysed(AnalysisContext analysisContext) {
            }
        }).sheet().doRead();

        if (CollectionUtils.isEmpty(dataList)) {
            throw new RuntimeException("导入数据不能为空");
        }
        boolean duplic = checkDuplic(dataList);
        if (duplic) throw new RuntimeException("存在重复国标设备");
        List<WorkOrderWhite> addList = new ArrayList<>();
        dataList.stream().forEach(item -> {
            WorkOrderWhite white = new WorkOrderWhite();
            //国标码
            white.setSerialNumber(item.getSerialNumber());
            //备注
            white.setRemark(item.getRemark());
            String errorType = item.getErrorType();
            if (StringUtils.isEmpty(errorType)) {
                throw new RuntimeException("国标码为" + item.getSerialNumber() + "的设备故障不能为空");
            }
            try {
                List<String> errorDataList = new ArrayList<>();
                List<String> errorExcelList = Arrays.asList(item.getErrorType().split(","));
                errorExcelList.forEach(desc -> {
                    //把中文转换为数据库存储格式
                    String errorText = ErrorType.getValueByDescription(desc);
                    //找不到抛出异常
                    if (errorText == null)
                        throw new RuntimeException("国标码为" + item.getSerialNumber() + "的设备故障类型有误");
                    errorDataList.add(errorText);
                });
                white.setErrorType(String.join(",", errorDataList));
                addList.add(white);
            } catch (Exception e) {
                throw new RuntimeException("国标码为" + item.getSerialNumber() + "的设备故障类型有误");
            }
        });
        if (!CollectionUtils.isEmpty(addList)) {
            workOrderWhiteMapper.deleteAll();
            workOrderWhiteMapper.insertBatch(addList);
        }
        return Result.ok();
    }

    /**
     * 修改白名单
     *
     * @param dataList
     * @param unitId
     */
    public void updateWhite(List<WorkOrderWhiteExport> dataList) throws ExecutionException, InterruptedException {
        if (CollectionUtils.isEmpty(dataList)) {
            throw new RuntimeException("导入数据不能为空");
        }
        //已存在的白名单
        List<String> serialNumbers = workOrderWhiteMapper.selectList().stream().map(WorkOrderWhite::getSerialNumber).collect(Collectors.toList());
        List<WorkOrderWhite> addList = new ArrayList<>();
        List<WorkOrderWhite> updateList = new ArrayList<>();
        dataList.stream().forEach(item -> {
            WorkOrderWhite white = new WorkOrderWhite();
            //国标码
            white.setSerialNumber(item.getSerialNumber());
            //备注
            white.setRemark(item.getRemark());
            String errorType = item.getErrorType();
            if (StringUtils.isEmpty(errorType)) {
                throw new RuntimeException("国标码为" + item.getSerialNumber() + "的设备故障不能为空");
            }
            try {
                List<String> errorDataList = new ArrayList<>();
                List<String> errorExcelList = Arrays.asList(item.getErrorType().split(","));
                errorExcelList.forEach(desc -> {
                    //把中文转换为数据库存储格式
                    String errorText = ErrorType.getValueByDescription(desc);
                    //找不到抛出异常
                    if (errorText == null)
                        throw new RuntimeException("国标码为" + item.getSerialNumber() + "的设备故障类型有误");
                    errorDataList.add(errorText);
                });
                white.setErrorType(String.join(",", errorDataList));
                if (!CollectionUtils.isEmpty(serialNumbers) && serialNumbers.contains(white.getSerialNumber())) {
                    updateList.add(white);
                } else {
                    addList.add(white);
                }
            } else if (CompareConstant.LessThanEq.equals(command)) {
                //小于类型
                if (thresholdResult <= thresholdAuto) {
                    //TODO：自动下发工单
                } else if (thresholdResult <= threshold) {
                    //TODO：进入下发工单页面
            } catch (Exception e) {
                throw new RuntimeException("国标码为" + item.getSerialNumber() + "的设备故障类型有误");
            }
        });
        if (!CollectionUtils.isEmpty(addList)) workOrderWhiteMapper.insertBatch(addList);
        if (!CollectionUtils.isEmpty(updateList)) workOrderWhiteMapper.updateBatch(updateList);
    }

    /**
     * 检查阈值
     *
     * @param key          某阈值标识
     * @param value        接口获取到的值
     * @param serialNumber 国标码
     * @param thresholds   阈值条件map
     * @param compareType  比较方式：>=    <=
     * @param errorType    故障类型
     * @param <T>
     */
    @Override
    public <T extends Comparable<T>> void check(String key, T value, String
            serialNumber, Map<String, YwThreshold> thresholds, WorkOrder workOrder, CompareType compareType, String
                                                        errorType) {
        Optional.ofNullable(value).ifPresentOrElse(
                v -> {
                    YwThreshold ywThreshold = thresholds.get(key);
                    //转换类型
                    //待工单阈值
                    T thresholdAutoValue = parseThreshold(ywThreshold.getValueAuto(), value.getClass());
                    //直接下发工单阈值
                    T thresholdValue = parseThreshold(ywThreshold.getValue(), value.getClass());
                    if ("percent".equals(ywThreshold.getCountType())) {
                        if (thresholdAutoValue instanceof Float) {
                            thresholdAutoValue = (T) Float.valueOf(((Float) thresholdAutoValue) / 100f);
                        }
                        if (thresholdValue instanceof Float) {
                            thresholdValue = (T) Float.valueOf(((Float) thresholdValue) / 100f);
                        }
                    }
                    //比较大小，加入到对应待处理集合
                    if (compareType.compare(v, thresholdValue)) {
                        //进入工单直接下发
                        workOrder.setSerialNumber(serialNumber);
                        workOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                        if (CollectionUtils.isEmpty(workOrder.getErrorTypeList())) {
                            workOrder.setErrorTypeList(new ArrayList<>());
                            workOrder.getErrorTypeList().add(errorType);
                        } else {
                            workOrder.getErrorTypeList().add(errorType);
                        }
                    } else if (compareType.compare(v, thresholdAutoValue)) {
                        //进入工单代下发
                        workOrder.setSerialNumber(serialNumber);
                        workOrder.setStatus(WorkOrderStatusEnum.WAIT_DISTRIBUTE);
                        if (CollectionUtils.isEmpty(workOrder.getErrorTypeList())) {
                            workOrder.setErrorTypeList(new ArrayList<>());
                            workOrder.getErrorTypeList().add(errorType);
                        } else {
                            workOrder.getErrorTypeList().add(errorType);
                        }
                    }
                },
                () -> log.error("{} 为空: {}", thresholds.get(key).getName(), serialNumber)
        );
    }

    /**
     * 所有白名单添加故障类型
     *
     * @param workOrderWhite
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result addBatch(WorkOrderWhite workOrderWhite) {
        List<String> errorTypeListAdd = workOrderWhite.getErrorTypeList();
        List<WorkOrderWhite> whites = workOrderWhiteMapper.selectList();
        for (WorkOrderWhite white : whites) {
            List<String> errorTypeList = Arrays.asList(white.getErrorType().split(","));
            for (String newError : errorTypeListAdd) {
                if (errorTypeList.contains(newError)) {
                    continue;
                } else {
                    errorTypeList.add(newError);
                }
            }
            white.setErrorType(String.join(",", errorTypeList));
        }
        if (!CollectionUtils.isEmpty(whites)) {
            workOrderWhiteMapper.deleteAll();
            workOrderWhiteMapper.insertBatch(whites);
        }
        return Result.ok();
    }

    private <T extends Comparable<T>> T parseThreshold(String thresholdStr, Class<?> type) {
        if (Integer.class.equals(type)) {
            return (T) Integer.valueOf(thresholdStr);
        } else if (Float.class.equals(type)) {
            return (T) Float.valueOf(thresholdStr);
        } else if (Double.class.equals(type)) {
            return (T) Double.valueOf(thresholdStr);
        } else if (Long.class.equals(type)) {
            return (T) Long.valueOf(thresholdStr);
        } else {
            log.error(message + result);
            throw new IllegalArgumentException("不支持转换类型" + type);
        }
    }

    private void check(Float threshold, Float thresholdAuto, VehicleDeviceInspectionResult result, Float thresholdResult, String message, String command) {
        if (thresholdResult != null) {
            //大于类型
            if (CompareConstant.MoreThanEq.equals(command)) {
                if (thresholdResult >= thresholdAuto) {
                    //TODO：自动下发工单
                } else if (thresholdResult >= threshold) {
                    //TODO：进入下发工单页面
                }
            } else if (CompareConstant.LessThanEq.equals(command)) {
                //小于类型
                if (thresholdResult <= thresholdAuto) {
                    //TODO：自动下发工单
                } else if (thresholdResult <= threshold) {
                    //TODO：进入下发工单页面
                }
    public static boolean checkDuplic(List<WorkOrderWhiteExport> dataList) {
        Set<String> serialNumbers = new HashSet<>();

        for (WorkOrderWhiteExport white : dataList) {
            String serialNumber = white.getSerialNumber();
            if (!serialNumbers.add(serialNumber)) {
                return true;
            }
        } else {
            log.error(message + result);
        }
        return false;
    }
}