blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
xiangpei
2024-08-28 d9d70577933e9cd021b4ff6d26c576d6dbd9161a 
 ycl-server/src/main/java/com/ycl/platform/service/impl/WorkOrderServiceImpl.java


@@ -29,6 +29,7 @@


import com.ycl.system.Result;


import com.ycl.system.domain.SysConfig;


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,13 +37,16 @@


import com.ycl.utils.http.HttpUtils;


import com.ycl.utils.redis.RedisCache;


import com.ycl.utils.uuid.IdUtils;


import enumeration.general.*;


import enumeration.general.NotifyTypeEnum;


import enumeration.general.UrgentLevelEnum;


import enumeration.general.WorkOrderDistributeWayEnum;


import enumeration.general.WorkOrderStatusEnum;


import lombok.RequiredArgsConstructor;


import lombok.extern.slf4j.Slf4j;


import org.apache.commons.lang3.ObjectUtils;


import org.bytedeco.javacv.FFmpegFrameGrabber;


import org.bytedeco.javacv.Frame;


import org.bytedeco.javacv.Java2DFrameConverter;


import org.bytedeco.javacv.*;


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;


@@ -53,12 +57,14 @@


import org.springframework.util.StringUtils;




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.*;


import java.util.concurrent.TimeUnit;


import java.util.stream.Collectors;




/**


@@ -79,9 +85,11 @@


    private final WorkOrderYwConditionRecordMapper workOrderYwConditionRecordMapper;


    private final NotifyService notifyService;


    private final WorkOrderDistributeRecordMapper workOrderDistributeRecordMapper;


    private final TMonitorMapper monitorMapper;


    private final WorkOrderErrorTypeServiceImpl workOrderErrorTypeService;


    private final SysConfigMapper configMapper;


    private final ServerConfig serverConfig;


    private final ReportMapper reportMapper;


    private final SysDictDataMapper dictDataMapper;




    @Value("${rtsp.server:http://127.0.0.1:7788}")


    private String rtspServer;


@@ -105,37 +113,73 @@


        List<String> serialNumberList = workOrderList.stream().map(WorkOrder::getSerialNumber).collect(Collectors.toList());


        // 查出数据库中国标码对应的未完成的工单


        List<WorkOrder> inDatabaseWorkOrderList = new LambdaQueryChainWrapper<>(baseMapper)


                .select(WorkOrder::getId, WorkOrder::getSerialNumber, WorkOrder::getStatus, WorkOrder::getErrorType)


                .select(WorkOrder::getId, WorkOrder::getSerialNumber, WorkOrder::getStatus, WorkOrder::getWorkOrderNo)


                .in(WorkOrder::getSerialNumber, serialNumberList)


                .ne(WorkOrder::getStatus, WorkOrderStatusEnum.AUDITING_SUCCESS)


                .list();


        Map<String, WorkOrder> mapping = inDatabaseWorkOrderList.stream().collect((Collectors.toMap(WorkOrder::getSerialNumber, workOrder -> workOrder)));


        List<WorkOrder> waitAddList = new ArrayList<>(48);


        List<WorkOrderErrorType> waitAddErrorTypeList = new ArrayList<>(48);


        Integer updateNum = 0;


        // TODO 查询是否报备过，更新故障类型


        Date now = new Date();


        // 因故障类型不一致而要更新状态的工单


        List<WorkOrder> willUpdateStatusWorkOrderList = new ArrayList<>(48);


        // 更改工单类型而要增加的系统运维处理信息


        List<WorkOrderYwConditionRecord> willAddMsg = new ArrayList<>(48);


        // 即将要添加的错误类型


        List<WorkOrderErrorType> willAddErrorType = new ArrayList<>(96);


        for (WorkOrder workOrder : workOrderList) {


            WorkOrder databaseWorkOrder = mapping.get(workOrder.getSerialNumber());


            if (Objects.nonNull(databaseWorkOrder)) {


                String errorType = databaseWorkOrder.getErrorType();


                if (workOrder.getErrorType().equals(errorType)) {


                List<String> errorNameList = workOrderErrorTypeService.getBaseMapper().getNotFinishWorkOrderErrors(workOrder.getWorkOrderNo());


                List<String> errorTypes = workOrder.getErrorTypeList();


                if (errorNameList.containsAll(errorTypes)) {


                    // 如果，国标码、故障类型都一样，则跳过不处理


                    continue;


                } else {


                    // 错误类型不一样，就更新错误类型，并且重置工单状态为待处理


                    errorType = errorType + "," + workOrder.getErrorType();


                    databaseWorkOrder.setErrorType(errorType);


                    for (String errorType : errorTypes) {


                        if (! errorNameList.contains(errorType)) {


                            // 错误类型不一样，就新增一个错误类型，并且重置工单状态为待处理


                            WorkOrderErrorType workOrderErrorType = new WorkOrderErrorType();


                            workOrderErrorType.setWorkOrderNo(databaseWorkOrder.getWorkOrderNo());


                            workOrderErrorType.setCreateTime(now);


                            workOrderErrorType.setUpdateTime(now);


                            workOrderErrorType.setErrorName(errorType);


                            willAddErrorType.add(workOrderErrorType);


                        }


                    }


                    databaseWorkOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);


                    Date now = new Date();


                    databaseWorkOrder.setUpdateTime(now);


                    baseMapper.updateById(databaseWorkOrder);


                    willUpdateStatusWorkOrderList.add(databaseWorkOrder);


                    updateNum++;


                    // 同时新增一个运维处理信息，表明此工单被调整 TODO


                    // 同时新增一个运维处理信息，表明此工单被调整


                    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());


                workOrder.setUpdateTime(new Date());


//                // 如果报备过，使用最新报备的错误类型


//                Report report = reportMapper.checkPointReported(workOrder.getSerialNumber());


//                if (Objects.nonNull(report)) {


//                    workOrder.setErrorType(report.getErrorType());


//                }


                waitAddList.add(workOrder);


            }


        }


        if (willAddErrorType.size() > 0) {


            workOrderErrorTypeService.getBaseMapper().addMany(willAddErrorType);


        }


        if (willAddMsg.size() > 0) {


            workOrderYwConditionRecordMapper.insertMany(willAddMsg);


        }


        if (willUpdateStatusWorkOrderList.size() > 0) {


            this.baseMapper.updateMany(willUpdateStatusWorkOrderList);


        }


        if (CollectionUtils.isEmpty(waitAddList)) {


            return Boolean.TRUE;


@@ -157,32 +201,50 @@


                notAddList.add(workOrder);


                continue;


            }


            workOrder.setWorkOrderNo(IdUtils.timeAddRandomNO(5));


            workOrder.setUnitId(Math.toIntExact(point.getUnitId()));


            workOrder.setWorkOrderNo(IdUtils.randomNO());


            if (Objects.nonNull(point.getUnitId())) {


                workOrder.setUnitId(Math.toIntExact(point.getUnitId()));


            }


            if (point.getImportantTag() || point.getImportantCommandImageTag()) {


                workOrder.setProcessingPeriod(Integer.valueOf(important.getConfigValue()));


            } else {


                workOrder.setProcessingPeriod(Integer.valueOf(normal.getConfigValue()));


            }


            // 保存错误类型


            for (String errorType : workOrder.getErrorTypeList()) {


                WorkOrderErrorType workOrderErrorType = new WorkOrderErrorType();


                workOrderErrorType.setWorkOrderNo(workOrder.getWorkOrderNo());


                workOrderErrorType.setCreateTime(now);


                workOrderErrorType.setUpdateTime(now);


                workOrderErrorType.setErrorName(errorType);


                waitAddErrorTypeList.add(workOrderErrorType);


            }


        }


        waitAddList.removeAll(notAddList);


        if (CollectionUtils.isEmpty(waitAddList)) {


            return Boolean.TRUE;


        }


        this.saveBatch(waitAddList);


        // 保存工单和故障类型


        baseMapper.addMany(waitAddList);


        if (! CollectionUtils.isEmpty(waitAddErrorTypeList)) {


            workOrderErrorTypeService.getBaseMapper().addMany(waitAddErrorTypeList);


        }


        // 如果是直接下发，添加下发记录


        if (WorkOrderStatusEnum.DISTRIBUTED.equals(waitAddList.get(0).getStatus())) {


            ArrayList<String> list = new ArrayList<>();


            List<WorkOrderDistributeRecord> distributedRecordList = waitAddList.stream().map(item -> {


                list.add(item.getSerialNumber());


                WorkOrderDistributeRecord workOrderDistributeRecord = new WorkOrderDistributeRecord();


                workOrderDistributeRecord.setWorkOrderId(item.getId());


                workOrderDistributeRecord.setWorkOrderNo(item.getWorkOrderNo());


                workOrderDistributeRecord.setDistributeWay(WorkOrderDistributeWayEnum.DIRECT_DISTRIBUTE);


                workOrderDistributeRecord.setUserId(1L);


                Date now = new Date();


                workOrderDistributeRecord.setCreateTime(now);


                workOrderDistributeRecord.setUpdateTime(now);


                return workOrderDistributeRecord;


            }).collect(Collectors.toList());


            workOrderDistributeRecordMapper.insertBatch(distributedRecordList);


            // 同步点位状态


            ywPointService.updateRecovery(list, 1);


        }


        log.info("传入工单总数: {}，实际添加工单数：{}, 实际修改工单数：{}", total, waitAddList.size(), updateNum);


        return Boolean.TRUE;


@@ -196,12 +258,15 @@


    @Override


    public Result add(WorkOrderForm form) {


        WorkOrder entity = WorkOrderForm.getEntityByForm(form, null);


        entity.setWorkOrderNo(IdUtils.timeAddRandomNO(5));


        entity.setWorkOrderNo(IdUtils.randomNO());


        entity.setCreateTime(DateUtils.getNowDate());


        entity.setStatus(WorkOrderStatusEnum.WAIT_DISTRIBUTE);


        Date now = new Date();


        entity.setCreateTime(now);


        entity.setUpdateTime(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("添加成功");


        }


@@ -237,7 +302,7 @@


        baseMapper.updateById(workOrder);


        // 添加一条审核记录


        WorkOrderAuditingRecord workOrderAuditingRecord = new WorkOrderAuditingRecord();


        workOrderAuditingRecord.setWorkOrderId(workOrder.getId());


        workOrderAuditingRecord.setWorkOrderNo(workOrder.getWorkOrderNo());


        workOrderAuditingRecord.setAuditingUser(SecurityUtils.getLoginUser().getUserId().intValue());


        workOrderAuditingRecord.setResult(form.getAuditingResult().getDesc());


        workOrderAuditingRecord.setRemark(form.getAuditingRemark());


@@ -251,7 +316,7 @@


        notifyService.save(notify);


        // 同步点位状态


        if (form.getAuditingResult() == WorkOrderStatusEnum.AUDITING_SUCCESS) {


            ywPointService.updateRecovery(Arrays.asList(workOrder.getSerialNumber()), 0);


            ywPointService.updateRecovery(Collections.singletonList(workOrder.getSerialNumber()), 0);


        }


        return Result.ok("操作成功");


    }


@@ -263,22 +328,23 @@


        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)


                .select(WorkOrder::getId, WorkOrder::getUnitId, WorkOrder::getWorkOrderNo, WorkOrder::getSerialNumber)


                .list();


        if (list.isEmpty()) {


            return Result.error("没有工单可以审核");


        }


        List<Integer> ids = list.stream().map(WorkOrder::getId).collect(Collectors.toList());


        List<String> workOrderNoList = list.stream().map(WorkOrder::getWorkOrderNo).collect(Collectors.toList());


        List<String> serialNumbers = list.stream().map(WorkOrder::getSerialNumber).toList();


        // 工单状态


        LambdaUpdateWrapper<WorkOrder> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();


        lambdaUpdateWrapper.in(WorkOrder::getId, ids);


        lambdaUpdateWrapper.in(WorkOrder::getWorkOrderNo, workOrderNoList);


        lambdaUpdateWrapper.set(WorkOrder::getStatus, form.getAuditingResult());


        baseMapper.update(lambdaUpdateWrapper);


        // 添加多条审核记录


        List<WorkOrderAuditingRecord> workOrderAuditingRecords = new ArrayList<>();


        for (Integer id : ids) {


        for (String workOrderNo : workOrderNoList) {


            WorkOrderAuditingRecord workOrderAuditingRecord = new WorkOrderAuditingRecord();


            workOrderAuditingRecord.setWorkOrderId(id);


            workOrderAuditingRecord.setWorkOrderNo(workOrderNo);


            workOrderAuditingRecord.setAuditingUser(SecurityUtils.getLoginUser().getUserId().intValue());


            workOrderAuditingRecord.setResult(form.getAuditingResult().getDesc());


            workOrderAuditingRecord.setRemark(form.getAuditingRemark());


@@ -294,6 +360,10 @@


                    UrgentLevelEnum.WARNING,


                    workOrder.getWorkOrderNo());


            notifies.add(notify);


        }


        // 同步点位状态


        if (form.getAuditingResult() == WorkOrderStatusEnum.AUDITING_SUCCESS) {


            ywPointService.updateRecovery(serialNumbers, 0);


        }


        notifyService.saveBatch(notifies);


        return Result.ok("操作成功");


@@ -312,25 +382,31 @@


        baseMapper.updateById(workOrder);


        // 添加一条运维情况记录


        WorkOrderYwConditionRecord workOrderYwConditionRecord = new WorkOrderYwConditionRecord();


        workOrderYwConditionRecord.setWorkOrderId(workOrder.getId());


        workOrderYwConditionRecord.setWorkOrderNo(workOrder.getWorkOrderNo());


        workOrderYwConditionRecord.setCommitUser(SecurityUtils.getLoginUser().getUserId().intValue());


        workOrderYwConditionRecord.setYwCondition(form.getYwCondition());


        workOrderYwConditionRecord.setYwProofMaterials(form.getYwProofMaterials());


        workOrderYwConditionRecord.setSysMsg(Boolean.FALSE);


        workOrderYwConditionRecordMapper.insert(workOrderYwConditionRecord);


        return Result.ok("操作成功");


    }




    @Override


    public Result selectYwConditionByYwId(Integer id) {


        List<WorkOrderYwConditionRecordVO> ywConditionList = workOrderYwConditionRecordMapper.selectYwConditionByYwId(id);


    public Result selectYwConditionByYwId(String workOrderNo) {


        List<WorkOrderYwConditionRecordVO> ywConditionList = workOrderYwConditionRecordMapper.selectYwConditionByYwId(workOrderNo);


        ywConditionList.stream().forEach(item -> {


            if (Objects.nonNull(item.getSysMsg()) && item.getSysMsg()) {


                item.setCommitUserName("系统消息");


            }


        });


        return Result.ok().data(ywConditionList);


    }




    @Override


    public Result selectYwAuditingListByYwId(String id) {


    public Result selectYwAuditingListByYwId(String workOrderNo) {


        return Result.ok().data(


                new LambdaQueryChainWrapper<>(workOrderAuditingRecordMapper)


                        .eq(WorkOrderAuditingRecord::getWorkOrderId, id)


                        .eq(WorkOrderAuditingRecord::getWorkOrderNo, workOrderNo)


                        .orderByAsc(WorkOrderAuditingRecord::getCreateTime)


                        .list());


    }


@@ -380,6 +456,13 @@


    public Result page(WorkOrderQuery query) {


        IPage<WorkOrderVO> page = PageUtil.getPage(query, WorkOrderVO.class);


        baseMapper.page(page, query);


        if (! CollectionUtils.isEmpty(page.getRecords())) {


            page.getRecords().stream().forEach(item -> {


                if (StringUtils.hasText(item.getErrorType())) {


                    item.setErrorTypeList(List.of(item.getErrorType().split(",")));


                }


            });


        }


        return Result.ok().data(page.getRecords()).total(page.getTotal());


    }




@@ -413,7 +496,7 @@




        // 查询符合条件的工单


        List<WorkOrder> list = new LambdaQueryChainWrapper<>(baseMapper)


                .select(WorkOrder::getSerialNumber, WorkOrder::getSerialNumber)


                .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())


@@ -421,20 +504,20 @@


                .orderByDesc(WorkOrder::getCreateTime)


                .last("limit " + data.getFastNumLimit())


                .list();


        List<Integer> ids = list.stream().map(WorkOrder::getId).toList();


        List<String> workOrderNoList = list.stream().map(WorkOrder::getWorkOrderNo).toList();


        List<String> serialNumberList = list.stream().map(WorkOrder::getSerialNumber).toList();




        if (ids.isEmpty()) { return Result.error("没有符合条件的工单"); }


        if (workOrderNoList.isEmpty()) { return Result.error("没有符合条件的工单"); }


        if (!getDistributeLock()) { return Result.error("此刻有人下发中，为避免冲突，请稍后重试"); }


        try {


            new LambdaUpdateChainWrapper<>(baseMapper)


                    .set(WorkOrder::getStatus, WorkOrderStatusEnum.DISTRIBUTED)


                    .in(WorkOrder::getId, ids)


                    .in(WorkOrder::getWorkOrderNo, workOrderNoList)


                    .update();


            addDistributeRecord(ids, WorkOrderDistributeWayEnum.FAST_DISTRIBUTE);


            addDistributeRecord(workOrderNoList, WorkOrderDistributeWayEnum.FAST_DISTRIBUTE);


            // 同步点位状态


            ywPointService.updateRecovery(serialNumberList, 1);


            return Result.ok("成功下发" + ids.size() + "条工单");


            return Result.ok("成功下发" + workOrderNoList.size() + "条工单");


        } catch (Exception e) {


            return Result.error("操作失败");


        } finally {


@@ -448,27 +531,27 @@


        WorkOrderDistributeWayEnum distributeWayEnum = WorkOrderDistributeWayEnum.SELECTED_DISTRIBUTE;


        if (!getDistributeLock()) { return Result.error("此刻有人下发中，为避免冲突，请稍后重试"); }


        try {


            if (query.getIds().isEmpty()) {


                query.setIds(new LambdaQueryChainWrapper<>(baseMapper)


            if (query.getWorkOrderNOList().isEmpty()) {


                query.setWorkOrderNOList(new LambdaQueryChainWrapper<>(baseMapper)


                        .eq(WorkOrder::getStatus, WorkOrderStatusEnum.WAIT_DISTRIBUTE)


                        .eq(Objects.nonNull(query.getUnitId()), WorkOrder::getUnitId, query.getUnitId())


                        .select(WorkOrder::getId)


                        .select(WorkOrder::getWorkOrderNo)


                        .list()


                        .stream()


                        .map(WorkOrder::getId)


                        .map(WorkOrder::getWorkOrderNo)


                        .collect(Collectors.toList()));


                distributeWayEnum = WorkOrderDistributeWayEnum.ALL_DISTRIBUTE;


            }


            if (query.getIds().isEmpty()) { return Result.error("没有工单待下发"); }


            if (query.getWorkOrderNOList().isEmpty()) { return Result.error("没有工单待下发"); }


            new LambdaUpdateChainWrapper<>(baseMapper)


                    .set(WorkOrder::getStatus, WorkOrderStatusEnum.DISTRIBUTED)


                    .in(WorkOrder::getId, query.getIds())


                    .in(WorkOrder::getWorkOrderNo, query.getWorkOrderNOList())


                    .update();


            addDistributeRecord(query.getIds(), distributeWayEnum);


            addDistributeRecord(query.getWorkOrderNOList(), distributeWayEnum);


            // 同步点位状态


            List<String> serialNumberList = new LambdaQueryChainWrapper<>(baseMapper).select(WorkOrder::getSerialNumber).in(WorkOrder::getId, query.getIds()).list().stream().map(WorkOrder::getSerialNumber).toList();


            List<String> serialNumberList = new LambdaQueryChainWrapper<>(baseMapper).select(WorkOrder::getSerialNumber).in(WorkOrder::getWorkOrderNo, query.getWorkOrderNOList()).list().stream().map(WorkOrder::getSerialNumber).toList();


            ywPointService.updateRecovery(serialNumberList, 1);


            return Result.ok("成功下发" + query.getIds().size() + "条工单");


            return Result.ok("成功下发" + query.getWorkOrderNOList().size() + "条工单");


        } catch (Exception e) {


            return Result.error("操作失败");


        } finally {


@@ -482,7 +565,7 @@


     */


    public synchronized Boolean getDistributeLock() {


        if (Objects.isNull(redisCache.getCacheObject(DISTRIBUTE_LOCK_KEY))) {


            redisCache.setCacheObject(DISTRIBUTE_LOCK_KEY, "1");


            redisCache.setCacheObject(DISTRIBUTE_LOCK_KEY, "1", 30, TimeUnit.SECONDS);


            return true;


        } else {


            return false;


@@ -498,13 +581,13 @@




    /**


     * 添加工单下发记录


     * @param ids 工单id


     * @param workOrderNoList 工单id


     */


    private void addDistributeRecord(List<Integer> ids, WorkOrderDistributeWayEnum distributeWay) {


    private void addDistributeRecord(List<String> workOrderNoList, WorkOrderDistributeWayEnum distributeWay) {


        LoginUser loginUser = SecurityUtils.getLoginUser();


        workOrderDistributeRecordMapper.insertBatch(


                ids.stream()


                        .map(id -> new WorkOrderDistributeRecord(id, loginUser.getUserId(), distributeWay))


                workOrderNoList.stream()


                        .map(no -> new WorkOrderDistributeRecord(no, loginUser.getUserId(), distributeWay))


                        .toList()


        );


    }


@@ -580,31 +663,54 @@




    @Override


    public String getFrameImgByDevice(String deviceId, String channelId) {


        String url = String.format(this.rtspServer + "/start/%s/%s", deviceId, channelId);


        String url = String.format(this.rtspServer + "/api/play/start/%s/%s", deviceId, channelId);


        String result = HttpUtils.sendGet(url);


        log.error("拿到取流响应结果：" + result);


        WVPResult wvpResult = JSON.parseObject(result, WVPResult.class);


        if (0 == wvpResult.getCode()) {


            log.error("请求成功");


            StreamContent data = (StreamContent) wvpResult.getData();


            String rtspUrl = data.getRtsp();


            log.error("目标地址：" + rtspUrl);


            if (StringUtils.hasText(rtspUrl)) {


                try {


                    // 创建FFmpegFrameGrabber对象


                    FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(rtspUrl);


                    grabber.start(); // 开始捕获


                    FFmpegFrameGrabber grabber = FFmpegFrameGrabber.createDefault(rtspUrl);


                    grabber.setOption("rtsp_transport", "tcp"); // 使用tcp的方式，不然会丢包很严重


                    grabber.setImageWidth(960);


                    grabber.setImageHeight(540);


                    grabber.start();


                    CanvasFrame canvasFrame = new CanvasFrame("正茂");// 创建窗口


                    canvasFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗口关闭程序是否也跟随关闭


                    canvasFrame.setAlwaysOnTop(true);




                    Frame frame;


                    if ((frame = grabber.grabFrame()) != null) {


                        // 将帧转换为图片


                        Java2DFrameConverter converter = new Java2DFrameConverter();


                        BufferedImage image = converter.convert(frame);


                        File outputfile = new File(serverConfig.getUrl() + PlatformConfig.getUploadPath() + deviceId + IdUtils.fastSimpleUUID() + ".png");


                        ImageIO.write(image, "png", outputfile);


                        String imgPath = outputfile.getAbsolutePath();


                        System.out.println("Saved " + imgPath);


                        return imgPath;


                    OpenCVFrameConverter.ToMat converter = new OpenCVFrameConverter.ToMat();


                    int ex = 0;


                    String imgPath = null;


                    while (true) {


                        if (ex > 1) {


                            break;


                        }


                        Frame frame = grabber.grabImage();


                        canvasFrame.showImage(frame);


                        //程序到这里其实已经实现了预览的功能了，下面的方法就是将流保存成图片




                        //opencv_core.Mat


                        Mat mat = converter.convertToMat(frame);


                        imgPath = serverConfig.getUrl() + PlatformConfig.getUploadPath() + deviceId + IdUtils.fastSimpleUUID() + ".png";


                        opencv_imgcodecs.imwrite(imgPath, mat);




                        ex++;


                        try {


                            Thread.sleep(1000);


                        }


                        catch (InterruptedException e)


                        {


                            e.printStackTrace();


                        } // 1000毫秒刷新一次圖像


                    }


                    grabber.stop(); // 停止捕获


                    grabber.release(); // 释放资源


                    return imgPath;


                } catch (IOException e) {


                    e.printStackTrace();


                }


@@ -623,6 +729,6 @@


    public void updateImgById(Integer workOrderId, String imgPath) {


        new LambdaUpdateChainWrapper<>(baseMapper)


                .eq(WorkOrder::getId, workOrderId)


                .set(WorkOrder::getYwCheckCondition, imgPath);


                .set(WorkOrder::getYwCheckResult, imgPath);


    }


}