新增故障类型

fuliqi

2024-12-08 f8751d6e701e0c3e7d8959449b67db6c35d09ec8

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

@@ -1,7 +1,6 @@
package com.ycl.platform.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
@@ -12,7 +11,6 @@
import com.ycl.config.PlatformConfig;
import com.ycl.exception.ServiceException;
import com.ycl.platform.domain.entity.*;
import com.ycl.platform.domain.excel.PointExport;
import com.ycl.platform.domain.form.*;
import com.ycl.platform.domain.query.*;
import com.ycl.platform.domain.vo.*;
@@ -65,6 +63,7 @@
import java.time.ZoneId;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
@@ -86,10 +85,10 @@
    private final WorkOrderDistributeRecordMapper workOrderDistributeRecordMapper;
    private final WorkOrderErrorTypeServiceImpl workOrderErrorTypeService;
    private final WorkOrderErrorTypeMapper workOrderErrorTypeMapper;
    private final WorkOrderWhiteMapper workOrderWhiteMapper;
    private final SysConfigMapper configMapper;
    private final ReportMapper reportMapper;
    private final WorkOrderCheckImgMapper workOrderCheckImgMapper;
    private final WorkOrderWhiteMapper workOrderWhiteMapper;
    private final DeviceInfoMapper deviceInfoMapper;
    private final ApplicationContext applicationContext;
    @Value("${rtsp.server:http://127.0.0.1:7788}")
@@ -109,19 +108,12 @@
    }

    @Transactional(rollbackFor = Exception.class)
    public Boolean batchAddWorkOrder(List<WorkOrder> workOrderList){
    public Boolean batchAddWorkOrder(List<WorkOrder> workOrderList) {
        int total = workOrderList.size();
        // 查询出白名单列表
        List<String> serialNumbers = workOrderWhiteMapper.selectList().stream().map(WorkOrderWhite::getSerialNumber).collect(Collectors.toList());
        // 遍历工单列表，判断是否在白名单中
        workOrderList = workOrderList.stream().filter(item -> !serialNumbers.contains(item.getSerialNumber()))
                .collect(Collectors.toList());
        //清理数据
        workOrderList = workOrderList.stream().filter(item -> {
            return StringUtils.hasText(item.getSerialNumber()) && Objects.nonNull(item.getStatus()) && !CollectionUtils.isEmpty(item.getErrorTypeList());
        }).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(workOrderList)) {
            return Boolean.TRUE;
        }
        // 根据国标码去重
        workOrderList = workOrderList.stream()
                .collect(Collectors.toMap(
@@ -129,6 +121,12 @@
                        p -> p,
                        (existing, replacement) -> existing // 冲突时保留第一个
                )).values().stream().collect(Collectors.toList());
        //检查白名单
        workOrderList = checkWhite(workOrderList);

        if (CollectionUtils.isEmpty(workOrderList)) {
            return Boolean.TRUE;
        }
        List<String> serialNumberList = workOrderList.stream().map(WorkOrder::getSerialNumber).collect(Collectors.toList());
        // 查出数据库中国标码对应的未完成的工单
        List<WorkOrder> inDatabaseWorkOrderList = baseMapper.getNotFinishedWorkOrders(serialNumberList);
@@ -171,20 +169,20 @@
                        }
                    }
                    //避免代下发的工单直接变成下发
                    if(!databaseWorkOrder.getStatus().equals(WorkOrderStatusEnum.WAIT_DISTRIBUTE)) {
                    if (!databaseWorkOrder.getStatus().equals(WorkOrderStatusEnum.WAIT_DISTRIBUTE)) {
                        databaseWorkOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                        // 同时新增一个运维处理信息，表明此工单被调整
                        WorkOrderYwConditionRecord ywRecord = new WorkOrderYwConditionRecord();
                        ywRecord.setWorkOrderNo(databaseWorkOrder.getWorkOrderNo());
                        ywRecord.setCommitUser(1);
                        ywRecord.setYwCondition("故障类型更新，工单状态调整为待处理");
                        ywRecord.setCreateTime(new Date());
                        ywRecord.setSysMsg(Boolean.TRUE);
                        willAddMsg.add(ywRecord);
                    }
                    databaseWorkOrder.setUpdateTime(now);
                    willUpdateStatusWorkOrderList.add(databaseWorkOrder);
                    updateNum++;
                    // 同时新增一个运维处理信息，表明此工单被调整
                    WorkOrderYwConditionRecord ywRecord = new WorkOrderYwConditionRecord();
                    ywRecord.setWorkOrderNo(databaseWorkOrder.getWorkOrderNo());
                    ywRecord.setCommitUser(1);
                    ywRecord.setYwCondition("故障类型更新，工单状态调整为待处理");
                    ywRecord.setCreateTime(new Date());
                    ywRecord.setSysMsg(Boolean.TRUE);
                    willAddMsg.add(ywRecord);
                }
            } else {
                workOrder.setCreateTime(new Date());
@@ -213,7 +211,7 @@
        List<String> willAddSerialNumber = waitAddList.stream().map(WorkOrder::getSerialNumber).collect(Collectors.toList());
        //只生成考核设备、且有运维单位的工单
        List<YwPoint> pointList = new LambdaQueryChainWrapper<>(ywPointService.getBaseMapper())
                .select(YwPoint::getUnitId, YwPoint::getSerialNumber, YwPoint::getImportantTag, YwPoint::getImportantTag, YwPoint::getProvinceTag, YwPoint::getImportantCommandImageTag)
                .select(YwPoint::getUnitId, YwPoint::getSerialNumber, YwPoint::getImportantTag, YwPoint::getImportantTag, YwPoint::getImportantCommandImageTag)
                .in(YwPoint::getSerialNumber, willAddSerialNumber)
                .eq(YwPoint::getExamineStatus, Boolean.TRUE)
                .isNotNull(YwPoint::getUnitId)
@@ -282,7 +280,7 @@
                workOrderErrorType.setErrorName(errorType);
                waitAddErrorTypeList.add(workOrderErrorType);
            }
            log.info("即将生成的工单:{}",workOrder);
            log.info("即将生成的工单:{}", workOrder);
        }
        redisCache.setCacheObject(RedisConstant.WORKORDER_NUM, workOrderNum);
        redisCache.releaseLock(RedisConstant.WORKORDER_NUM_LOCK, requestId);
@@ -311,6 +309,8 @@
        log.info("传入工单总数: {}，实际添加工单数：{}, 实际修改工单数：{}", total, waitAddList.size(), updateNum);
        return Boolean.TRUE;
    }


    /**
     * 添加
     *
@@ -319,31 +319,97 @@
     */
    @Override
    public Result add(WorkOrderForm form) {
        //查redis今日工单数量
        int workOrderNum = 0;
        //UUID作为value，保证上锁的线程自己解锁
        String requestId = IdUtils.fastSimpleUUID();
        boolean result = redisCache.acquireLock(RedisConstant.WORKORDER_NUM_LOCK, requestId, 10000);
        if (result) {
            //查今日工单量
            Object redisNum = redisCache.getCacheObject(RedisConstant.WORKORDER_NUM);
            workOrderNum = redisNum == null ? 0 : (Integer) redisNum;
            workOrderNum++;
            redisCache.setCacheObject(RedisConstant.WORKORDER_NUM, workOrderNum);
            redisCache.releaseLock(RedisConstant.WORKORDER_NUM_LOCK, requestId);
        } else {
            return Result.error("工单正在添加，请稍后再试");
        //检查白名单
        List<WorkOrder> data = new ArrayList<>();
        WorkOrder workOrder = WorkOrderForm.getEntityByForm(form, null);
        data.add(workOrder);
        //校验白名单并排除在白名单的故障类型
        data = checkWhite(data);
        if (CollectionUtils.isEmpty(data)) {
            return Result.error("该设备的故障类型在白名单中，不能添加工单");
        }
        WorkOrder entity = WorkOrderForm.getEntityByForm(form, null);
        // 查询出白名单列表
        List<String> serialNumbers = workOrderWhiteMapper.selectList().stream().map(WorkOrderWhite::getSerialNumber).collect(Collectors.toList());
        // 遍历工单列表，判断是否在白名单中
         if (serialNumbers.contains(entity.getSerialNumber())){
            return Result.error("该设备在白名单中，不能添加工单");
        WorkOrder entity = data.get(0);
        String serialNumber = entity.getSerialNumber();
        Date now = new Date();
        List<WorkOrder> inDatabaseWorkOrderList = baseMapper.getNotFinishedWorkOrders(Arrays.asList(serialNumber));
        inDatabaseWorkOrderList.stream().forEach(item -> {
            if (StringUtils.hasText(item.getErrorType())) {
                item.setErrorTypeList(List.of(item.getErrorType().split(",")));
            } else {
                item.setErrorTypeList(new ArrayList<>(1));
            }
        });
        // 因故障类型不一致而要更新状态的工单
        List<WorkOrder> willUpdateStatusWorkOrderList = new ArrayList<>(48);
        // 更改工单类型而要增加的系统运维处理信息
        List<WorkOrderYwConditionRecord> willAddMsg = new ArrayList<>(48);
        // 即将要添加的错误类型
        List<WorkOrderErrorType> willAddErrorType = new ArrayList<>(96);
        if(!CollectionUtils.isEmpty(inDatabaseWorkOrderList)){
            WorkOrder workOrderInDB = inDatabaseWorkOrderList.get(0);
            List<String> errorNameList = workOrderInDB.getErrorTypeList();
            List<String> errorTypes = entity.getErrorTypeList();
            if(errorNameList.containsAll(errorTypes)){
                return Result.error("已有同种故障类型工单");
            }else {
                for (String errorType : errorTypes) {
                    if(!errorNameList.contains(errorType)){
                        // 错误类型不一样，就新增一个错误类型，并且重置工单状态为待处理
                        WorkOrderErrorType workOrderErrorType = new WorkOrderErrorType();
                        workOrderErrorType.setWorkOrderNo(workOrderInDB.getWorkOrderNo());
                        workOrderErrorType.setCreateTime(now);
                        workOrderErrorType.setUpdateTime(now);
                        workOrderErrorType.setErrorName(errorType);
                        willAddErrorType.add(workOrderErrorType);
                    }
                }
                //避免代下发的工单直接变成下发
                if (!workOrderInDB.getStatus().equals(WorkOrderStatusEnum.WAIT_DISTRIBUTE)) {
                    workOrderInDB.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                    // 同时新增一个运维处理信息，表明此工单被调整
                    WorkOrderYwConditionRecord ywRecord = new WorkOrderYwConditionRecord();
                    ywRecord.setWorkOrderNo(workOrderInDB.getWorkOrderNo());
                    ywRecord.setCommitUser(1);
                    ywRecord.setYwCondition("故障类型更新，工单状态调整为待处理");
                    ywRecord.setCreateTime(new Date());
                    ywRecord.setSysMsg(Boolean.TRUE);
                    willAddMsg.add(ywRecord);
                }
                workOrderInDB.setUpdateTime(now);
                willUpdateStatusWorkOrderList.add(workOrderInDB);
                //修改故障类型
                if (willAddErrorType.size() > 0) {
                    workOrderErrorTypeService.getBaseMapper().addMany(willAddErrorType);
                }
                //增加运维情况
                if (willAddMsg.size() > 0) {
                    workOrderYwConditionRecordMapper.insertMany(willAddMsg);
                }
                //更改工单状态
                if (willUpdateStatusWorkOrderList.size() > 0) {
                    this.baseMapper.updateMany(willUpdateStatusWorkOrderList);
                }
            }
            return Result.ok("添加成功");
        }else {
            //数据库没有正在进行的工单
            //查redis今日工单数量
            int workOrderNum = 0;
            //UUID作为value，保证上锁的线程自己解锁
            String requestId = IdUtils.fastSimpleUUID();
            boolean result = redisCache.acquireLock(RedisConstant.WORKORDER_NUM_LOCK, requestId, 10000);
            if (result) {
                //查今日工单量
                Object redisNum = redisCache.getCacheObject(RedisConstant.WORKORDER_NUM);
                workOrderNum = redisNum == null ? 0 : (Integer) redisNum;
                workOrderNum++;
                redisCache.setCacheObject(RedisConstant.WORKORDER_NUM, workOrderNum);
                redisCache.releaseLock(RedisConstant.WORKORDER_NUM_LOCK, requestId);
            } else {
                return Result.error("工单正在添加，请稍后再试");
            }
            entity.setCreateTime(DateUtils.getNowDate());
            entity.setStatus(WorkOrderStatusEnum.WAIT_DISTRIBUTE);
            Date now = new Date();
            entity.setCreateTime(now);
            entity.setUpdateTime(now);
            entity.setWorkOrderNo(IdUtils.workOrderNO(now, String.format("%05d", workOrderNum)));
@@ -352,10 +418,12 @@
            workOrderErrorTypeService.getBaseMapper().insertWorkOrderErrorTypeList(workOrderErrorTypes);
            if (baseMapper.insert(entity) > 0) {
                return Result.ok("添加成功");
            }else {
                return Result.error("添加失败");
            }
            return Result.error("添加失败");
        }
    }


    /**
     * 修改
@@ -488,7 +556,7 @@
        // 国标设备的编码就是取视频流的设备编码，国标设备就一个。国标设备的每一个通道代表一个摄像头，也就是设备id是取流的通道id
        String frameImg = null;
        try {
            log.info("国标平台:{},设备编码:{},工单号:{}",gbDevices.get(0).getDeviceId(), workOrder.getSerialNumber(), workOrder.getWorkOrderNo());
            log.info("国标平台:{},设备编码:{},工单号:{}", gbDevices.get(0).getDeviceId(), workOrder.getSerialNumber(), workOrder.getWorkOrderNo());
            frameImg = this.getFrameImgByDevice(gbDevices.get(0).getDeviceId(), workOrder.getSerialNumber(), workOrder.getWorkOrderNo());
        } catch (Exception e) {
            e.printStackTrace();
@@ -501,11 +569,12 @@
            workOrderCheckImgMapper.insert(img);
        }
    }

    @Override
    public List<WorkOrderYwConditionRecordVO> selectYwConditionByYwId(String workOrderNo) {
        List<WorkOrderYwConditionRecordVO> ywConditionList = workOrderYwConditionRecordMapper.selectYwConditionByYwId(workOrderNo);
        ywConditionList.stream().forEach(item -> {
            if(item.getUserId().equals(1)){
            if (item.getUserId().equals(1)) {
                item.setUnitName("管理员");
            }
            if (Objects.nonNull(item.getSysMsg()) && item.getSysMsg()) {
@@ -583,11 +652,11 @@
    @Override
    public Result page(WorkOrderQuery query) {
        IPage<WorkOrderVO> page = PageUtil.getPage(query, WorkOrderVO.class);
        if(query.getUnitId()==null) {
        if (query.getUnitId() == null) {
            query.setUnitId(SecurityUtils.getUnitId());
        }
        if(query.getStart()!=null) query.setStart(DateUtils.getDayStart(query.getStart()));
        if(query.getEnd()!=null) query.setEnd(DateUtils.getDayEnd(query.getEnd()));
        if (query.getStart() != null) query.setStart(DateUtils.getDayStart(query.getStart()));
        if (query.getEnd() != null) query.setEnd(DateUtils.getDayEnd(query.getEnd()));
        baseMapper.page(page, query);
        if (!CollectionUtils.isEmpty(page.getRecords())) {
            page.getRecords().stream().forEach(item -> {
@@ -616,8 +685,8 @@
    @Override
    public Result distributePage(DistributeWorkOrderQuery query) {
        IPage<WorkOrderVO> page = PageUtil.getPage(query, WorkOrderVO.class);
        if(query.getStart()!=null) query.setStart(DateUtils.getDayStart(query.getStart()));
        if(query.getEnd()!=null) query.setEnd(DateUtils.getDayEnd(query.getEnd()));
        if (query.getStart() != null) query.setStart(DateUtils.getDayStart(query.getStart()));
        if (query.getEnd() != null) query.setEnd(DateUtils.getDayEnd(query.getEnd()));
        baseMapper.distributePage(page, query);
        return Result.ok().data(page).total(page.getTotal());
    }
@@ -687,6 +756,7 @@
            return Result.error("此刻有人下发中，为避免冲突，请稍后重试");
        }
        try {
            //这是全部下发
            if (query.getWorkOrderNOList().isEmpty()) {
                query.setWorkOrderNOList(new LambdaQueryChainWrapper<>(baseMapper)
                        .eq(WorkOrder::getStatus, WorkOrderStatusEnum.WAIT_DISTRIBUTE)
@@ -845,11 +915,11 @@
    @Override
    public String getFrameImgByDevice(String deviceId, String channelId, String workOrderNo) throws Exception {
        String url = String.format(this.rtspServer + "/api/play/start/img/%s/%s", deviceId, channelId);
        log.info("访问路径{}",url);
        log.info("访问路径{}", url);
        String result = HttpUtils.sendGet(url);
        log.info("拿到取流图片响应结果：" + result);
        WVPResult wvpResult = JSON.parseObject(result, WVPResult.class);
        if(wvpResult.getCode() == 0) {
        if (wvpResult.getCode() == 0) {
            Object imgUrl = (Object) wvpResult.getData();
            imgUrl = Objects.isNull(imgUrl) ? "" : imgUrl;
            log.info("拿到取流图片：" + imgUrl);
@@ -906,7 +976,7 @@
    }

    @Override
    public void saveFrameImgByDevice (String deviceId, String channelId, String workOrderNo){
    public void saveFrameImgByDevice(String deviceId, String channelId, String workOrderNo) {
        String url = String.format(this.rtspServer + "/api/play/start/%s/%s", deviceId, channelId);
        String result = HttpUtils.sendGet(url);
        WVPResult wvpResult = JSON.parseObject(result, WVPResult.class);
@@ -967,13 +1037,13 @@
    }

    @Override
    public List<DeviceInfoVO> hasErrorWorkOrderList (Date start, Date end){
    public List<DeviceInfoVO> hasErrorWorkOrderList(Date start, Date end) {
        List<DeviceInfoVO> list = baseMapper.hasErrorWorkOrderList(start, end);
        return list;
    }

    @Override
    public void updateImgById (Integer workOrderId, String imgPath){
    public void updateImgById(Integer workOrderId, String imgPath) {
        new LambdaUpdateChainWrapper<>(baseMapper)
                .eq(WorkOrder::getId, workOrderId)
                .set(WorkOrder::getYwCheckResult, imgPath)
@@ -981,7 +1051,7 @@
    }

    @Override
    public Result processImg (String workOrderNo){
    public Result processImg(String workOrderNo) {
        WorkOrder workOrder = new LambdaQueryChainWrapper<>(baseMapper)
                .eq(WorkOrder::getWorkOrderNo, workOrderNo)
                .one();
@@ -1022,7 +1092,7 @@
    }

    @Override
    public Result detailByNo (String workOrderNo){
    public Result detailByNo(String workOrderNo) {
        WorkOrderDetailVO workOrder = baseMapper.detailByNo(workOrderNo);
        // 是否报备
        boolean hasReport = new LambdaQueryChainWrapper<>(reportMapper)
@@ -1044,8 +1114,8 @@
    }

    @Override
    public List<WorkOrderVO> export (WorkOrderExportQuery query){
        if(query.getUnitId()==null) {
    public List<WorkOrderVO> export(WorkOrderExportQuery query) {
        if (query.getUnitId() == null) {
            query.setUnitId(SecurityUtils.getUnitId());
        }
        if (query.getStart() != null) query.setStart(query.getStart() + " 00:00:00");
@@ -1055,107 +1125,13 @@
    }

    /**
     * 工单白名单列表
     *
     * @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 = JSONArray.parseArray(white.getErrorType(), String.class);
            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(JSONArray.toJSONString(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(JSONArray.toJSONString(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 dataList 数据列表
     * @author
     */
    @Override
    public void batchImportWhite(List<PointExport> dataList) {
//        // 获得所有需要新增的白名单对象
//        List<WorkOrderWhite> whitelist = dataList.stream().map(pointExport ->
//                        new WorkOrderWhite(pointExport.getSerialNumber(), pointExport.getPointName(), SecurityUtils.getUsername()))
//                .collect(Collectors.toList());
//        // 获得所有已存在的白名单设备编码
//        List<String> serialNumbers = workOrderWhiteMapper.selectList().stream().map(WorkOrderWhite::getSerialNumber).collect(Collectors.toList());
//        // 筛选出新增、修改的白名单对象
//        List<WorkOrderWhite> updateWhiteList = whitelist.stream().filter(white -> serialNumbers.contains(white.getSerialNumber())).collect(Collectors.toList());
//        List<WorkOrderWhite> insertWhiteList = whitelist.stream().filter(white ->!serialNumbers.contains(white.getSerialNumber())).collect(Collectors.toList());
//        // 新增/修改白名单设备记录
//        updateWhiteList.stream().forEach(white -> workOrderWhiteMapper.updateBySerialNumber(white));
//        insertWhiteList.stream().forEach(white -> workOrderWhiteMapper.insert(white));
    }

    /**
     * 检测工单按钮
     *
     * @param workOrderNo
     * @return
     */
    @Override
    public Result checkImage(String workOrderNo,String serialNumber) {
    public Result checkImage(String workOrderNo, String serialNumber) {
        // 查出国标设备，就一条数据
        List<DeviceInfo> gbDevices = new LambdaQueryChainWrapper<>(deviceInfoMapper)
                .orderByDesc(DeviceInfo::getUpdateTime)
@@ -1163,7 +1139,7 @@
                .list();
        if (!CollectionUtils.isEmpty(gbDevices)) {
            try {
                String imgUrl = this.getFrameImgByDevice(gbDevices.get(0).getDeviceId(), serialNumber,workOrderNo);
                String imgUrl = this.getFrameImgByDevice(gbDevices.get(0).getDeviceId(), serialNumber, workOrderNo);
                if (StringUtils.hasText(imgUrl)) {
                    WorkOrderCheckImg img = new WorkOrderCheckImg();
                    img.setWorkOrderNo(workOrderNo);
@@ -1182,7 +1158,7 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result batchDeleteWorkOrder(List<String> workOrderNos) {
        if(!CollectionUtils.isEmpty(workOrderNos)) {
        if (!CollectionUtils.isEmpty(workOrderNos)) {
            //删除工单审核记录
            workOrderAuditingRecordMapper.delete(new QueryWrapper<WorkOrderAuditingRecord>().in("work_order_no", workOrderNos));
            //删除工单图片记录
@@ -1248,12 +1224,22 @@
        return Result.ok().data(results);
    }

    @Override
    public Result selectWorkOrderWhiteDetail(Integer id) {
        WorkOrderWhite workOrderWhite = workOrderWhiteMapper.getById(id);
        List<String> errorList = JSONArray.parseArray(workOrderWhite.getErrorType(), String.class);
        workOrderWhite.setErrorTypeList(errorList);
        return Result.ok().data(workOrderWhite);
    //白名单校验
    private List<WorkOrder> checkWhite(List<WorkOrder> workOrderList) {
        // 查询出白名单列表
        Map<String, WorkOrderWhite> whiteMap = workOrderWhiteMapper.selectList().stream().collect(Collectors.toMap(WorkOrderWhite::getSerialNumber, Function.identity()));
        workOrderList = workOrderList.stream()
                .filter(workOrder -> {
                    List<String> errorTypeList = workOrder.getErrorTypeList();
                    WorkOrderWhite white = whiteMap.get(workOrder.getSerialNumber());
                    if (white != null) {
                        List<String> whiteErrorListSet = Arrays.asList(white.getErrorType().split(","));
                        errorTypeList.removeIf(whiteErrorListSet::contains);
                    }
                    return !errorTypeList.isEmpty(); // 只保留 errorTypeList 非空的 WorkOrder
                })
                .collect(Collectors.toList());
        return workOrderList;
    }