白名单基础增删改查

fuliqi

2024-11-14 cfcfbf068acf9b9d509a99498346dcbcf101cdf9

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

@@ -1,16 +1,18 @@
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;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ycl.config.PlatformConfig;
import com.ycl.config.ServerConfig;
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.*;
@@ -22,12 +24,11 @@
import com.ycl.platform.service.WorkOrderAuditingRecordService;
import com.ycl.platform.service.WorkOrderService;
import com.ycl.platform.service.YwPointService;
import com.ycl.platform.wvp.StreamContent;
import com.ycl.platform.wvp.WVPResult;
import com.ycl.system.Result;
import com.ycl.system.domain.SysConfig;
import com.ycl.system.entity.SysDictData;
import com.ycl.system.mapper.SysConfigMapper;
import com.ycl.system.mapper.SysDictDataMapper;
import com.ycl.system.model.LoginUser;
import com.ycl.system.page.PageUtil;
import com.ycl.utils.DateUtils;
@@ -36,30 +37,30 @@
import com.ycl.utils.redis.RedisCache;
import com.ycl.utils.uuid.IdUtils;
import constant.Constants;
import enumeration.general.NotifyTypeEnum;
import enumeration.general.UrgentLevelEnum;
import enumeration.general.WorkOrderDistributeWayEnum;
import enumeration.general.WorkOrderStatusEnum;
import constant.RedisConstant;
import enumeration.ErrorType;
import enumeration.general.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.bytedeco.javacv.*;
import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.Frame;
import org.bytedeco.javacv.FrameGrabber;
import org.bytedeco.javacv.OpenCVFrameConverter;
import org.bytedeco.opencv.global.opencv_imgcodecs;
import org.bytedeco.opencv.opencv_core.Mat;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import pojo.CascadeOption;

import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;
@@ -77,7 +78,6 @@
@RequiredArgsConstructor
public class WorkOrderServiceImpl extends ServiceImpl<WorkOrderMapper, WorkOrder> implements WorkOrderService {

    private final WorkOrderMapper workOrderMapper;
    private final YwPointService ywPointService;
    private final WorkOrderAuditingRecordMapper workOrderAuditingRecordMapper;
    private final WorkOrderAuditingRecordService workOrderAuditingRecordService;
@@ -85,11 +85,13 @@
    private final NotifyService notifyService;
    private final WorkOrderDistributeRecordMapper workOrderDistributeRecordMapper;
    private final WorkOrderErrorTypeServiceImpl workOrderErrorTypeService;
    private final WorkOrderErrorTypeMapper workOrderErrorTypeMapper;
    private final SysConfigMapper configMapper;
    private final ServerConfig serverConfig;
    private final ReportMapper reportMapper;
    private final SysDictDataMapper dictDataMapper;

    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}")
    private String rtspServer;

@@ -100,12 +102,23 @@
    private RedisCache redisCache;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized Boolean innerAddWorkOrder(List<WorkOrder> workOrderList) {
        //避免坑(事务加锁会失效、方法内部调用事务会失效)
        WorkOrderServiceImpl self = applicationContext.getBean(WorkOrderServiceImpl.class);
        return self.batchAddWorkOrder(workOrderList);
    }

    @Transactional(rollbackFor = Exception.class)
    public Boolean batchAddWorkOrder(List<WorkOrder> workOrderList){
        int total = workOrderList.size();
        workOrderList.stream().filter(item -> {
        // 查询出白名单列表
        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;
        }
@@ -147,7 +160,7 @@
                    continue;
                } else {
                    for (String errorType : errorTypes) {
                        if (! errorNameList.contains(errorType)) {
                        if (!errorNameList.contains(errorType)) {
                            // 错误类型不一样，就新增一个错误类型，并且重置工单状态为待处理
                            WorkOrderErrorType workOrderErrorType = new WorkOrderErrorType();
                            workOrderErrorType.setWorkOrderNo(databaseWorkOrder.getWorkOrderNo());
@@ -157,7 +170,10 @@
                            willAddErrorType.add(workOrderErrorType);
                        }
                    }
                    databaseWorkOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                    //避免代下发的工单直接变成下发
                    if(!databaseWorkOrder.getStatus().equals(WorkOrderStatusEnum.WAIT_DISTRIBUTE)) {
                        databaseWorkOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                    }
                    databaseWorkOrder.setUpdateTime(now);
                    willUpdateStatusWorkOrderList.add(databaseWorkOrder);
                    updateNum++;
@@ -195,9 +211,12 @@
            return Boolean.TRUE;
        }
        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)
                .in(YwPoint::getSerialNumber, willAddSerialNumber)
                .eq(YwPoint::getExamineStatus, Boolean.TRUE)
                .isNotNull(YwPoint::getUnitId)
                .list();
        Map<String, YwPoint> pointMapping = pointList.stream().collect(Collectors.toMap(YwPoint::getSerialNumber, point -> point));
        // 查出重点点位、普通点位的处理时间
@@ -205,13 +224,14 @@
        SysConfig normal = configMapper.checkConfigKeyUnique("normal.wordkorder.alarm.time");
        // 如果即将生成工单，但是设备国标码查不到点位，则不添加？
        List<WorkOrder> notAddList = new ArrayList<>();
        //查redis今日工单数量
        int workOrderNum = 0;
        for (WorkOrder workOrder : waitAddList) {
            YwPoint point = pointMapping.get(workOrder.getSerialNumber());
            if (Objects.isNull(point)) {
                notAddList.add(workOrder);
                continue;
            }
            workOrder.setWorkOrderNo(IdUtils.randomNO(now));
            if (Objects.nonNull(point.getUnitId())) {
                workOrder.setUnitId(Math.toIntExact(point.getUnitId()));
            }
@@ -220,6 +240,39 @@
            } else {
                workOrder.setProcessingPeriod(Integer.valueOf(normal.getConfigValue()));
            }
        }
        waitAddList.removeAll(notAddList);
        if (CollectionUtils.isEmpty(waitAddList)) {
            return Boolean.TRUE;
        }
        //UUID作为value，保证上锁的线程自己解锁
        String requestId = IdUtils.fastSimpleUUID();
        try {
            for (int i = 0; i < 3; i++) {
                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;
                    break;
                } else {
                    if (i == 2) {
                        log.error("锁被占用");
                        return Boolean.FALSE;
                    }
                    //等待一段时间后继续
                    Thread.sleep(5000);
                }
            }
        } catch (InterruptedException e) {
            log.error("获取锁异常");
            return Boolean.FALSE;
        }
        //记录工单数,补充工单号
        for (WorkOrder workOrder : waitAddList) {
            //数字前面补0
            workOrderNum++;
            workOrder.setWorkOrderNo(IdUtils.workOrderNO(now, String.format("%05d", workOrderNum)));
            // 保存错误类型
            for (String errorType : workOrder.getErrorTypeList()) {
                WorkOrderErrorType workOrderErrorType = new WorkOrderErrorType();
@@ -229,14 +282,13 @@
                workOrderErrorType.setErrorName(errorType);
                waitAddErrorTypeList.add(workOrderErrorType);
            }
            log.info("即将生成的工单:{}",workOrder);
        }
        waitAddList.removeAll(notAddList);
        if (CollectionUtils.isEmpty(waitAddList)) {
            return Boolean.TRUE;
        }
        redisCache.setCacheObject(RedisConstant.WORKORDER_NUM, workOrderNum);
        redisCache.releaseLock(RedisConstant.WORKORDER_NUM_LOCK, requestId);
        // 保存工单和故障类型
        baseMapper.addMany(waitAddList);
        if (! CollectionUtils.isEmpty(waitAddErrorTypeList)) {
        if (!CollectionUtils.isEmpty(waitAddErrorTypeList)) {
            workOrderErrorTypeService.getBaseMapper().addMany(waitAddErrorTypeList);
        }
        // 如果是直接下发，添加下发记录
@@ -259,32 +311,55 @@
        log.info("传入工单总数: {}，实际添加工单数：{}, 实际修改工单数：{}", total, waitAddList.size(), updateNum);
        return Boolean.TRUE;
    }

    /**
     * 添加
     *
     * @param form
     * @return
     */
    @Override
    public Result add(WorkOrderForm form) {
        WorkOrder entity = WorkOrderForm.getEntityByForm(form, null);
        entity.setCreateTime(DateUtils.getNowDate());
        entity.setStatus(WorkOrderStatusEnum.WAIT_DISTRIBUTE);
        Date now = new Date();
        entity.setCreateTime(now);
        entity.setUpdateTime(now);
        entity.setWorkOrderNo(IdUtils.randomNO(now));
        entity.setErrorType(String.join(",", form.getErrorType()));
        List<WorkOrderErrorType> workOrderErrorTypes = form.getErrorType().stream().map(errorType -> new WorkOrderErrorType(entity.getWorkOrderNo(), errorType)).toList();
        workOrderErrorTypeService.getBaseMapper().insertWorkOrderErrorTypeList(workOrderErrorTypes);
        if(baseMapper.insert(entity) > 0) {
            return Result.ok("添加成功");
        //查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("工单正在添加，请稍后再试");
        }
        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("该设备在白名单中，不能添加工单");
        }else {
            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)));
            entity.setErrorType(String.join(",", form.getErrorType()));
            List<WorkOrderErrorType> workOrderErrorTypes = form.getErrorType().stream().map(errorType -> new WorkOrderErrorType(entity.getWorkOrderNo(), errorType)).toList();
            workOrderErrorTypeService.getBaseMapper().insertWorkOrderErrorTypeList(workOrderErrorTypes);
            if (baseMapper.insert(entity) > 0) {
                return Result.ok("添加成功");
            }
            return Result.error("添加失败");
        }
    }

    /**
     * 修改
     *
     * @param form
     * @return
     */
@@ -334,14 +409,10 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result batchAuditing(WorkOrderBatchAuditingForm form) {
        // 根据故障类型获取列表
        List<WorkOrder> list = new LambdaQueryChainWrapper<>(baseMapper)
                .in(WorkOrder::getStatus, WorkOrderStatusEnum.YW_HANDLE.getValue())
                .in(WorkOrder::getErrorType, form.getErrorTypes())
                .select(WorkOrder::getId, WorkOrder::getUnitId, WorkOrder::getWorkOrderNo, WorkOrder::getSerialNumber)
                .list();
        //根据工单编号获取工单
        List<WorkOrder> list = baseMapper.selectByNos(form.getWorkOrderNumbers());
        if (list.isEmpty()) {
            return Result.error("没有工单可以审核");
            return Result.error("没有待审核工单");
        }
        List<String> workOrderNoList = list.stream().map(WorkOrder::getWorkOrderNo).collect(Collectors.toList());
        List<String> serialNumbers = list.stream().map(WorkOrder::getSerialNumber).toList();
@@ -382,6 +453,7 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result ywCondition(WorkOrderYWConditionForm form) {

        WorkOrder workOrder = baseMapper.selectById(form.getId());
        if (Objects.isNull(workOrder)) {
            throw new ServiceException("工单不存在");
@@ -398,15 +470,46 @@
        workOrderYwConditionRecord.setYwProofMaterials(form.getYwProofMaterials());
        workOrderYwConditionRecord.setSysMsg(Boolean.FALSE);
        workOrderYwConditionRecordMapper.insert(workOrderYwConditionRecord);
        //异步获取图片
        WorkOrderServiceImpl self = applicationContext.getBean(WorkOrderServiceImpl.class);
        self.getImage(workOrder);
        return Result.ok("操作成功");
    }

    @Async("threadPoolTaskExecutor")
    public void getImage(WorkOrder workOrder) {
        List<DeviceInfo> gbDevices = new LambdaQueryChainWrapper<>(deviceInfoMapper)
                .orderByDesc(DeviceInfo::getUpdateTime)
                .last("limit 1")
                .list();
        if (CollectionUtils.isEmpty(gbDevices)) {
            return;
        }
        // 国标设备的编码就是取视频流的设备编码，国标设备就一个。国标设备的每一个通道代表一个摄像头，也就是设备id是取流的通道id
        String frameImg = null;
        try {
            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();
        }
        if (StringUtils.hasText(frameImg)) {
            WorkOrderCheckImg img = new WorkOrderCheckImg();
            img.setWorkOrderNo(workOrder.getWorkOrderNo());
            img.setImgUrl(frameImg);
            img.setCreateTime(new Date());
            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)){
                item.setUnitName("管理员");
            }
            if (Objects.nonNull(item.getSysMsg()) && item.getSysMsg()) {
                item.setCommitUserName("系统消息");
                item.setUnitName("系统消息");
            }
        });
        return ywConditionList;
@@ -415,9 +518,9 @@
    @Override
    public List<WorkOrderAuditingRecord> selectYwAuditingListByYwId(String workOrderNo) {
        return new LambdaQueryChainWrapper<>(workOrderAuditingRecordMapper)
                        .eq(WorkOrderAuditingRecord::getWorkOrderNo, workOrderNo)
                        .orderByAsc(WorkOrderAuditingRecord::getCreateTime)
                        .list();
                .eq(WorkOrderAuditingRecord::getWorkOrderNo, workOrderNo)
                .orderByAsc(WorkOrderAuditingRecord::getCreateTime)
                .list();
    }

    @Override
@@ -432,12 +535,13 @@

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @Override
    public Result remove(List<String> ids) {
        if(baseMapper.deleteBatchIds(ids) > 0) {
        if (baseMapper.deleteBatchIds(ids) > 0) {
            return Result.ok("删除成功");
        }
        return Result.error("删除失败");
@@ -445,12 +549,26 @@

    /**
     * id删除
     *
     * @param id
     * @return
     */
    @Override
    public Result removeById(String id) {
        if(baseMapper.deleteById(id) > 0) {
        WorkOrder workOrder = baseMapper.selectById(id);
        String workOrderNo = workOrder.getWorkOrderNo();
        //删除工单审核记录
        workOrderAuditingRecordMapper.delete(new QueryWrapper<WorkOrderAuditingRecord>().eq("work_order_no", workOrderNo));
        //删除工单图片记录
        workOrderCheckImgMapper.delete(new QueryWrapper<WorkOrderCheckImg>().eq("work_order_no", workOrderNo));
        //删除工单下发记录
        workOrderDistributeRecordMapper.delete(new QueryWrapper<WorkOrderDistributeRecord>().eq("work_order_no", workOrderNo));
        //删除工单故障类型
        workOrderErrorTypeMapper.delete(new QueryWrapper<WorkOrderErrorType>().eq("work_order_no", workOrderNo));
        //删除工单情况记录
        workOrderYwConditionRecordMapper.delete(new QueryWrapper<WorkOrderYwConditionRecord>().eq("work_order_no", workOrderNo));

        if (baseMapper.deleteById(id) > 0) {
            return Result.ok("删除成功");
        }
        return Result.error("删除失败");
@@ -458,18 +576,34 @@

    /**
     * 分页查询
     *
     * @param query
     * @return
     */
    @Override
    public Result page(WorkOrderQuery query) {
        IPage<WorkOrderVO> page = PageUtil.getPage(query, WorkOrderVO.class);
        query.setUnitId(SecurityUtils.getUnitId());
        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()));
        baseMapper.page(page, query);
        if (! CollectionUtils.isEmpty(page.getRecords())) {
        if (!CollectionUtils.isEmpty(page.getRecords())) {
            page.getRecords().stream().forEach(item -> {
                if (StringUtils.hasText(item.getErrorType())) {
                    item.setErrorTypeList(List.of(item.getErrorType().split(",")));
                    List<String> errorTypeList = new ArrayList<>(List.of(item.getErrorType().split(",")));
                    int index = errorTypeList.indexOf(query.getErrorTypeLabel());
                    if (index != -1) {
                        // 保存要移动的元素
                        String firstOccurrence = errorTypeList.get(index);
                        // 从列表中移除该元素（第一次出现的位置）
                        errorTypeList.remove(index);
                        // 将该元素添加到列表的首位
                        errorTypeList.add(0, firstOccurrence);
                    }
                    // 设置更新后的列表
                    item.setErrorTypeList(errorTypeList);
                }
                if (StringUtils.hasText(item.getImgListStr())) {
                    item.setImgList(List.of(item.getImgListStr().split(",")));
@@ -482,6 +616,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()));
        baseMapper.distributePage(page, query);
        return Result.ok().data(page).total(page.getTotal());
    }
@@ -497,14 +633,14 @@
                data.setStart(now.minusHours(1));
                break;
            case LAST_TWO_HOUR:
               data.setStart(now.minusHours(2));
               break;
                data.setStart(now.minusHours(2));
                break;
            case LAST_DAY:
                data.setStart(now.minusDays(1));
                break;
            default:
                break;
           }
        }
        if (Objects.isNull(data.getStart())) {
            throw new RuntimeException("无法生成快速下发的时间范围，请选择正确的快速下发方式");
        }
@@ -513,7 +649,7 @@
                .select(WorkOrder::getSerialNumber, WorkOrder::getWorkOrderNo)
                .eq(WorkOrder::getStatus, WorkOrderStatusEnum.WAIT_DISTRIBUTE)
                .eq(Objects.nonNull(data.getUnitId()), WorkOrder::getUnitId, data.getUnitId())
                .eq(WorkOrder::getErrorType, data.getErrorType())
                .in(WorkOrder::getErrorType, data.getErrorType())
                .between(WorkOrder::getCreateTime, data.getStart(), data.getEnd())
                .orderByDesc(WorkOrder::getCreateTime)
                .last("limit " + data.getFastNumLimit())
@@ -521,8 +657,12 @@
        List<String> workOrderNoList = list.stream().map(WorkOrder::getWorkOrderNo).toList();
        List<String> serialNumberList = list.stream().map(WorkOrder::getSerialNumber).toList();

        if (workOrderNoList.isEmpty()) { return Result.error("没有符合条件的工单"); }
        if (!getDistributeLock()) { return Result.error("此刻有人下发中，为避免冲突，请稍后重试"); }
        if (workOrderNoList.isEmpty()) {
            return Result.error("没有符合条件的工单");
        }
        if (!getDistributeLock()) {
            return Result.error("此刻有人下发中，为避免冲突，请稍后重试");
        }
        try {
            new LambdaUpdateChainWrapper<>(baseMapper)
                    .set(WorkOrder::getStatus, WorkOrderStatusEnum.DISTRIBUTED)
@@ -543,7 +683,9 @@
    @Transactional
    public Result selectedIdsDistribute(DistributeWorkOrderQuery query) {
        WorkOrderDistributeWayEnum distributeWayEnum = WorkOrderDistributeWayEnum.SELECTED_DISTRIBUTE;
        if (!getDistributeLock()) { return Result.error("此刻有人下发中，为避免冲突，请稍后重试"); }
        if (!getDistributeLock()) {
            return Result.error("此刻有人下发中，为避免冲突，请稍后重试");
        }
        try {
            if (query.getWorkOrderNOList().isEmpty()) {
                query.setWorkOrderNOList(new LambdaQueryChainWrapper<>(baseMapper)
@@ -556,7 +698,9 @@
                        .collect(Collectors.toList()));
                distributeWayEnum = WorkOrderDistributeWayEnum.ALL_DISTRIBUTE;
            }
            if (query.getWorkOrderNOList().isEmpty()) { return Result.error("没有工单待下发"); }
            if (query.getWorkOrderNOList().isEmpty()) {
                return Result.error("没有工单待下发");
            }
            new LambdaUpdateChainWrapper<>(baseMapper)
                    .set(WorkOrder::getStatus, WorkOrderStatusEnum.DISTRIBUTED)
                    .in(WorkOrder::getWorkOrderNo, query.getWorkOrderNOList())
@@ -567,6 +711,7 @@
            ywPointService.updateRecovery(serialNumberList, 1);
            return Result.ok("成功下发" + query.getWorkOrderNOList().size() + "条工单");
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return Result.error("操作失败");
        } finally {
            distributeUnLock();
@@ -575,6 +720,7 @@

    /**
     * 申请工单下发锁
     *
     * @return 工单下发锁申请结果
     */
    public synchronized Boolean getDistributeLock() {
@@ -595,6 +741,7 @@

    /**
     * 添加工单下发记录
     *
     * @param workOrderNoList 工单id
     */
    private void addDistributeRecord(List<String> workOrderNoList, WorkOrderDistributeWayEnum distributeWay) {
@@ -608,6 +755,7 @@

    /**
     * 根据id查找
     *
     * @param id
     * @return
     */
@@ -622,6 +770,7 @@

    /**
     * 列表
     *
     * @return
     */
    @Override
@@ -671,24 +820,107 @@

    @Override
    public List<WorkOrderRegionVO> workOrderRegion(DashboardQuery dashboardQuery) {
        return baseMapper.workOrderRegion(dashboardQuery);
        //初始化所有区域数据
        List<WorkOrderRegionVO> vos = new ArrayList<>();
        for (AreaDeptEnum value : AreaDeptEnum.values()) {
            WorkOrderRegionVO vo = new WorkOrderRegionVO();
            vo.setArea(value.getName());
            vo.setDoneNum(0);
            vo.setTodoNum(0);
            vos.add(vo);
        }
        List<WorkOrderRegionVO> workOrderRegionVOS = baseMapper.workOrderRegion(dashboardQuery);
        for (WorkOrderRegionVO vo : vos) {
            for (WorkOrderRegionVO workOrder : workOrderRegionVOS) {
                //赋值
                if (vo.getArea().equals(workOrder.getArea())) {
                    BeanUtils.copyProperties(workOrder, vo);
                }
            }
        }
        return vos;
    }


    @Override
    public String getFrameImgByDevice(String deviceId, String channelId, String workOrderNo) {
    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);
        String result = HttpUtils.sendGet(url);
        log.info("拿到取流图片响应结果：" + result);
        WVPResult wvpResult = JSON.parseObject(result, WVPResult.class);
        if(wvpResult.getCode() == 0) {
            Object imgUrl = (Object) wvpResult.getData();
            imgUrl = Objects.isNull(imgUrl) ? "" : imgUrl;
            log.info("拿到取流图片：" + imgUrl);
            return (String) imgUrl;
        }
        return null;
//        WVPResult wvpResult = JSON.parseObject(result, WVPResult.class);
//        String imgUrl = null;
//        if (wvpResult.getCode() == 0) {
//            JSONObject data = (JSONObject) wvpResult.getData();
//            String rtspUrl = data.getString("fmp4"); // 取mp4地址
//            if (StringUtils.hasText(rtspUrl)) {
//                System.out.println("目标地址：" + rtspUrl);
//                FFmpegFrameGrabber grabber = null;
//                try {
//                    grabber = new FFmpegFrameGrabber(rtspUrl);
////                    grabber.setOption("rtsp_transport", "tcp"); // 使用tcp的方式，不然会丢包很严重
////                    grabber.setVideoOption("probesize", "10000"); // 设置捕获分析的最大字节
//                    grabber.start();
//                    Frame frame = grabber.grabImage(); // 直接捕获一帧
//                    if (frame != null) {
//                        System.out.println("成功捕获一帧");
//                        // 将Frame转换为Mat
//                        OpenCVFrameConverter.ToMat converter = new OpenCVFrameConverter.ToMat();
//                        Mat mat = converter.convertToMat(frame);
//
//                        imgUrl = workOrderNo + "_" + IdUtils.fastSimpleUUID() + ".png";
//                        // 生成图片路径
//                        String imgPath = PlatformConfig.getProfile() + "/" + imgUrl;
//                        System.out.println("图片保存地址：" + imgPath);
//                        imgUrl = Constants.RESOURCE_PREFIX + "/" + imgUrl;
//                        // 保存图片
//                        opencv_imgcodecs.imwrite(imgPath, mat);
//                    } else {
//                        System.out.println("未捕获到帧");
//                    }
//                } catch (FrameGrabber.Exception e) {
//                    e.printStackTrace();
//                } finally {
//                    if (grabber != null) {
//                        try {
//                            grabber.stop(); // 停止捕获
//                        } catch (FrameGrabber.Exception e) {
//                            e.printStackTrace();
//                        }
//                    }
//                }
//            }
//        } else {
//            System.out.println("请求失败，错误码：" + wvpResult.getCode() + "--" + wvpResult.getMsg());
//        }
//        System.out.println("图片URL：" + imgUrl);
//        return imgUrl;
    }

    @Override
    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);
        String imgUrl = null;
        if (wvpResult.getCode() == 0) {
            JSONObject data = (JSONObject) wvpResult.getData();
            String rtspUrl = data.getString("fmp4"); // 取mp4地址
            String rtspUrl = data.getString("rtsp"); // 取mp4地址
            if (StringUtils.hasText(rtspUrl)) {
                System.out.println("目标地址：" + rtspUrl);
                FFmpegFrameGrabber grabber = null;
                try {
                    grabber = FFmpegFrameGrabber.createDefault(rtspUrl);
                    //设置10s超时
                    grabber.setTimeout(10000);
                    grabber.start();
                    Frame frame = grabber.grabImage(); // 直接捕获一帧
                    if (frame != null) {
@@ -725,17 +957,23 @@
            System.out.println("请求失败，错误码：" + wvpResult.getCode());
        }
        System.out.println("图片URL：" + imgUrl);
        return imgUrl;
        if (StringUtils.hasText(imgUrl)) {
            WorkOrderCheckImg img = new WorkOrderCheckImg();
            img.setWorkOrderNo(workOrderNo);
            img.setImgUrl(imgUrl);
            img.setCreateTime(new Date());
            workOrderCheckImgMapper.insert(img);
        }
    }

    @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)
@@ -743,7 +981,7 @@
    }

    @Override
    public Result processImg(String workOrderNo) {
    public Result processImg (String workOrderNo){
        WorkOrder workOrder = new LambdaQueryChainWrapper<>(baseMapper)
                .eq(WorkOrder::getWorkOrderNo, workOrderNo)
                .one();
@@ -765,7 +1003,7 @@
        if (Objects.nonNull(beforeRecord)) {
            if (now.before(beforeRecord.getBeginCreateTime())) {
                process.setBeforeReportMsg("事前报备已失效");
            } else if (now.after(beforeRecord.getEndCreateTime())){
            } else if (now.after(beforeRecord.getEndCreateTime())) {
                process.setBeforeReportMsg("事前报备未生效");
            } else {
                process.setBeforeReportMsg("已事前报备");
@@ -774,7 +1012,7 @@
        if (Objects.nonNull(afterRecord)) {
            if (now.before(afterRecord.getBeginCreateTime())) {
                process.setAfterReportMsg("事后报备已失效");
            } else if (now.after(afterRecord.getEndCreateTime())){
            } else if (now.after(afterRecord.getEndCreateTime())) {
                process.setAfterReportMsg("事后报备未生效");
            } else {
                process.setAfterReportMsg("已事后报备");
@@ -784,13 +1022,239 @@
    }

    @Override
    public Result detailByNo(String workOrderNo) {
    public Result detailByNo (String workOrderNo){
        WorkOrderDetailVO workOrder = baseMapper.detailByNo(workOrderNo);
        // 是否报备
        boolean hasReport = new LambdaQueryChainWrapper<>(reportMapper)
                .eq(Report::getSerialNumber, workOrder.getSerialNumber())
                .exists();
        workOrder.setHasReport(hasReport);
        // 故障类型
        List<SysDictData> errorList = workOrderErrorTypeService.getBaseMapper().getErrorList(workOrder.getWorkOrderNo());
        List<String> errList = errorList.stream().map(SysDictData::getDictLabel).collect(Collectors.toList());
        workOrder.setErrorTypeList(errList);
        // 检测图片
        List<WorkOrderCheckImg> imgList = new LambdaQueryChainWrapper<>(workOrderCheckImgMapper)
                .eq(WorkOrderCheckImg::getWorkOrderNo, workOrderNo)
                .orderByDesc(WorkOrderCheckImg::getCreateTime)
                .last("limit 20")
                .list();
        workOrder.setImgList(imgList);
        return Result.ok().data(workOrder);
    }

    @Override
    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");
        if (query.getEnd() != null) query.setEnd(query.getEnd() + " 23:59:59");

        return baseMapper.export(query);
    }

    /**
     * 工单白名单列表
     *
     * @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) {
        // 查出国标设备，就一条数据
        List<DeviceInfo> gbDevices = new LambdaQueryChainWrapper<>(deviceInfoMapper)
                .orderByDesc(DeviceInfo::getUpdateTime)
                .last("limit 1")
                .list();
        if (!CollectionUtils.isEmpty(gbDevices)) {
            try {
                String imgUrl = this.getFrameImgByDevice(gbDevices.get(0).getDeviceId(), serialNumber,workOrderNo);
                if (StringUtils.hasText(imgUrl)) {
                    WorkOrderCheckImg img = new WorkOrderCheckImg();
                    img.setWorkOrderNo(workOrderNo);
                    img.setImgUrl(imgUrl);
                    img.setCreateTime(new Date());
                    workOrderCheckImgMapper.insert(img);
                }
                return Result.ok().data(imgUrl);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return Result.ok();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result batchDeleteWorkOrder(List<String> workOrderNos) {
        if(!CollectionUtils.isEmpty(workOrderNos)) {
            //删除工单审核记录
            workOrderAuditingRecordMapper.delete(new QueryWrapper<WorkOrderAuditingRecord>().in("work_order_no", workOrderNos));
            //删除工单图片记录
            workOrderCheckImgMapper.delete(new QueryWrapper<WorkOrderCheckImg>().in("work_order_no", workOrderNos));
            //删除工单下发记录
            workOrderDistributeRecordMapper.delete(new QueryWrapper<WorkOrderDistributeRecord>().in("work_order_no", workOrderNos));
            //删除工单故障类型
            workOrderErrorTypeMapper.delete(new QueryWrapper<WorkOrderErrorType>().in("work_order_no", workOrderNos));
            //删除工单情况记录
            workOrderYwConditionRecordMapper.delete(new QueryWrapper<WorkOrderYwConditionRecord>().in("work_order_no", workOrderNos));
            //删除工单
            this.baseMapper.delete(new QueryWrapper<WorkOrder>().in("work_order_no", workOrderNos));
        }
        return Result.ok();
    }

    @Override
    public Result errorAll() {
        List<CascadeOption> results = new ArrayList<>();
        CascadeOption video = new CascadeOption();
        video.setLabel("视频");
        video.setValue("VIDEO");
        List<ErrorType> videoErr = ErrorType.getErrorTypesByCategory("VIDEO");
        List<ErrorType> videoErr1 = ErrorType.getErrorTypesByCategory("COMMON");
        videoErr.addAll(videoErr1);
        List<CascadeOption> videoChildren = videoErr.stream().map(item -> CascadeOption.builder()
                .value(item.getValue())
                .label(item.getDesc())
                .build()).collect(Collectors.toList());
        video.setChildren(videoChildren);

        CascadeOption car = new CascadeOption();
        car.setLabel("车辆");
        car.setValue("CAR");
        List<ErrorType> carErr = ErrorType.getErrorTypesByCategory("CAR");
        List<ErrorType> carErr1 = ErrorType.getErrorTypesByCategory("COMMON");
        List<ErrorType> carErr2 = ErrorType.getErrorTypesByCategory("CARORFACE");
        carErr.addAll(carErr1);
        carErr.addAll(carErr2);
        List<CascadeOption> carChildren = carErr.stream().map(item -> CascadeOption.builder()
                .value(item.getValue())
                .label(item.getDesc())
                .build()).collect(Collectors.toList());
        car.setChildren(carChildren);

        CascadeOption face = new CascadeOption();
        face.setLabel("人脸");
        face.setValue("FACE");
        List<ErrorType> faceErr = ErrorType.getErrorTypesByCategory("FACE");
        List<ErrorType> faceErr1 = ErrorType.getErrorTypesByCategory("COMMON");
        List<ErrorType> faceErr2 = ErrorType.getErrorTypesByCategory("CARORFACE");
        faceErr.addAll(faceErr1);
        faceErr.addAll(faceErr2);
        List<CascadeOption> faceChildren = faceErr.stream().map(item -> CascadeOption.builder()
                .value(item.getValue())
                .label(item.getDesc())
                .build()).collect(Collectors.toList());
        face.setChildren(faceChildren);

        results.add(video);
        results.add(car);
        results.add(face);
        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);
    }


}