修改模型3的bug

Pu Zhibing

2025-03-03 042ab498ee53e8f3c7cecf52f733e8c1c162dfb5

 guns-admin/src/main/java/com/stylefeng/guns/modular/system/service/impl/PatrolTaskServiceImpl.java

@@ -2,11 +2,13 @@

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.stylefeng.guns.core.util.ToolUtil;
import com.stylefeng.guns.modular.system.model.PatrolTask;
import com.stylefeng.guns.modular.system.model.TaskDetail;
import com.stylefeng.guns.modular.system.model.TaskDetailVehicles;
import com.stylefeng.guns.modular.system.model.TaskDetailVehiclesChannel;
import com.stylefeng.guns.modular.system.model.enums.ImageModelEnum;
import com.stylefeng.guns.modular.system.model.enums.VideoChannelEnum;
import com.stylefeng.guns.modular.system.model.vo.PatrolTaskVo;
import com.stylefeng.guns.modular.system.model.vo.VehicleVo;
import com.stylefeng.guns.modular.system.service.ITaskDetailService;
@@ -24,7 +26,9 @@
import org.quartz.SchedulerException;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import com.stylefeng.guns.modular.system.dao.PatrolTaskMapper;
import com.stylefeng.guns.modular.system.service.IPatrolTaskService;
@@ -35,12 +39,12 @@
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @author zhibing.pu
@@ -61,6 +65,12 @@
   
   @Autowired
   private QuartzUtil quartzUtil;
	
   @Value("${maxThreadCount}")
   private Integer maxThreadCount;
	
   @Resource
   private RedisTemplate redisTemplate;
   
   
   
@@ -130,6 +140,7 @@
                     
                     //添加任务车船视频通道关系数据
                     List<Integer> videoChannel = vo.getVideoChannel();
                     List<TaskDetailVehiclesChannel> list = new ArrayList<>();
                     for (Integer s : videoChannel) {
                        TaskDetailVehiclesChannel taskDetailVehiclesChannel = new TaskDetailVehiclesChannel();
                        taskDetailVehiclesChannel.setPatrolTaskId(patrolTask.getId());
@@ -137,8 +148,9 @@
                        taskDetailVehiclesChannel.setTaskDetailVehiclesId(taskDetailVehicles.getId());
                        taskDetailVehiclesChannel.setVideoChannel(s);
                        taskDetailVehiclesChannel.setSysStatus(1);
                        taskDetailVehiclesChannelService.insert(taskDetailVehiclesChannel);
                        list.add(taskDetailVehiclesChannel);
                     }
                     taskDetailVehiclesChannelService.insertBatch(list);
                  }
                  
                  //添加定时任务
@@ -170,195 +182,354 @@
   public void execute(Integer id){
      //修改状态为执行中
      TaskDetail taskDetail = taskDetailService.selectById(id);
      if(null == taskDetail){
         log.error("定时任务执行异常，无效的数据ID：{}", id);
         return;
      }
      taskDetail.setStatus(2);
      taskDetailService.updateById(taskDetail);
		
      PatrolTask patrolTask = this.selectById(taskDetail.getPatrolTaskId());
		
      //获取所有在线车船
      //2018年协议车辆在线
      List<VehicleOnline> vehicleOnlines2018 = VideoGateway.queryRuntimeInfoByCache(0);
      //2023年协议车辆在线
      List<VehicleOnline> vehicleOnlines203 = VideoGateway.locationRealTimeInfoCache(0);
		
      //获取当前任务中的车船信息
      List<TaskDetailVehicles> taskDetailVehicles = taskDetailVehiclesService.selectList(new EntityWrapper<TaskDetailVehicles>().eq("task_detail_id", id));
      int errNum = 0;
      for (TaskDetailVehicles taskDetailVehicle : taskDetailVehicles) {
         try {
            taskDetailVehicle.setStartExecutionTime(LocalDateTime.now());
            Integer taskDetailVehicleId = taskDetailVehicle.getId();
            //车船类型：1 车辆设备 2 船舶设备
            Integer vehicleType = taskDetailVehicle.getVehicleType();
            //车船id
            Integer vehicleId = taskDetailVehicle.getVehicleId();
            VehicleOnline vehicleOnline1 = null;
            for (VehicleOnline vehicleOnline : vehicleOnlines2018) {
               if(null != vehicleOnline.getVehicleId() && vehicleOnline.getVehicleId().equals(vehicleId) &&
                     null != vehicleOnline.getVehicleType() && vehicleOnline.getVehicleType().equals(vehicleType)){
                  vehicleOnline1 = vehicleOnline;
                  String vehicleGpsProtocol = vehicleOnline.getVehicleGpsProtocol();
                  vehicleOnline1.setVehicleGpsProtocol("808-guangzhou".equals(vehicleGpsProtocol) ? "1" : "2");
                  break;
               }
      if(!patrolTask.getImageModel().equals(ImageModelEnum.CONSTRUCTION_WASTE_LOAD.getCode())){
         //获取所有在线车船
         //2018年协议车辆在线
         List<VehicleOnline> vehicleOnlines2018 = VideoGateway.queryRuntimeInfoByCache(0);
         //2023年协议车辆在线
         List<VehicleOnline> vehicleOnlines203 = VideoGateway.locationRealTimeInfoCache(0);
			
         //获取当前任务中的车船信息
         List<TaskDetailVehicles> taskDetailVehicles = taskDetailVehiclesService.selectList(new EntityWrapper<TaskDetailVehicles>().eq("task_detail_id", id));
         //根据车辆数量，分组线程数
         int num;
         int threadCount;
         if(taskDetailVehicles.size() <= maxThreadCount){
            threadCount = taskDetailVehicles.size();
            num = 1;
         }else{
            num = taskDetailVehicles.size() / maxThreadCount;
            if(taskDetailVehicles.size() % maxThreadCount > 0){
               num++;
            }
            if(null == vehicleOnline1){
               for (VehicleOnline vehicleOnline : vehicleOnlines203) {
                  if(null != vehicleOnline.getVehicleId() && vehicleOnline.getVehicleId().equals(vehicleId) &&
                        null != vehicleOnline.getVehicleType() && vehicleOnline.getVehicleType().equals(vehicleType)){
                     vehicleOnline1 = vehicleOnline;
                     vehicleOnline1.setVehicleGpsProtocol(vehicleOnline.getVehicleGpsProtocol());
                     break;
                  }
               }
            threadCount = taskDetailVehicles.size() / num;
            if(taskDetailVehicles.size() % num > 0){
               threadCount++;
            }
            //不在线
            if(null == vehicleOnline1){
               taskDetailVehicle.setEndExecutionTime(LocalDateTime.now());
               taskDetailVehicle.setStatus(4);
               taskDetailVehiclesService.updateById(taskDetailVehicle);
               continue;
            }
            taskDetailVehicle.setStatus(2);
            taskDetailVehiclesService.updateById(taskDetailVehicle);
            //成功
            List<TaskDetailVehiclesChannel> taskDetailVehiclesChannels = taskDetailVehiclesChannelService.selectList(new EntityWrapper<TaskDetailVehiclesChannel>().eq("task_detail_vehicles_id", taskDetailVehicleId));
            //开始发送拍照指令，获取照片地址
            String vehicleGpsProtocol = vehicleOnline1.getVehicleGpsProtocol();
            String terminalId = vehicleOnline1.getTerminalId();
            for (TaskDetailVehiclesChannel taskDetailVehiclesChannel : taskDetailVehiclesChannels) {
               Integer videoChannel = taskDetailVehiclesChannel.getVideoChannel();
					
               if("1".equals(vehicleGpsProtocol)){
                  //2018 协议
                  String fileId = VideoGateway.cameraShot2018(terminalId, videoChannel, 0);
                  if(null == fileId){
                     log.error("2018年协议发送拍摄指令失败：terminalId-->{}，videoChannel-->{}", terminalId, videoChannel);
                     throw new RuntimeException();
                  }else{
                     //等待15秒
                     Thread.sleep(30000);
							
                     String fileUrl = VideoGateway.getCameraShotByFileId2018(terminalId, fileId, 0);
                     if(null == fileUrl){
                        log.error("2018年协议车辆获取拍摄图片失败：terminalId-->{}，fileId-->{}", terminalId, fileId);
                        //重新发送拍摄指令，如果还是没有获取到图片，标注失败
                        fileId = VideoGateway.cameraShot2018(terminalId, videoChannel, 0);
                        if(null == fileId){
                           log.error("2018年协议发送拍摄指令失败：terminalId-->{}，videoChannel-->{}", terminalId, videoChannel);
                           throw new Exception();
                        }else{
                           //等待15秒
                           Thread.sleep(30000);
									
                           fileUrl = VideoGateway.getCameraShotByFileId2018(terminalId, fileId, 0);
                           if(null == fileUrl){
                              log.error("2018年协议车辆获取拍摄图片失败：terminalId-->{}，fileId-->{}", terminalId, fileId);
                              throw new Exception();
                           }else{
                              taskDetailVehiclesChannel.setImageUrl(fileUrl);
                              taskDetailVehiclesChannel.setSysCreateTime(LocalDateTime.now());
                              taskDetailVehiclesChannel.setArtificialStatus(1);
                              //开始调模型接口得出结果
                              Map<String, Object> map = ImageModelUtil.modelCheck(fileUrl, ImageModelEnum.getImageModelEnum(patrolTask.getImageModel()));
                              Boolean b = (Boolean) map.get("b");
                              String r = map.get("r").toString();
                              taskDetailVehiclesChannel.setSysStatus(b ? 2 : 3);
                              taskDetailVehiclesChannel.setResult(r);
                              taskDetailVehiclesChannelService.updateById(taskDetailVehiclesChannel);
                           }
                        }
                     }else{
                        taskDetailVehiclesChannel.setImageUrl(fileUrl);
                        taskDetailVehiclesChannel.setSysCreateTime(LocalDateTime.now());
                        taskDetailVehiclesChannel.setArtificialStatus(1);
                        //开始调模型接口得出结果
                        Map<String, Object> map = ImageModelUtil.modelCheck(fileUrl, ImageModelEnum.getImageModelEnum(patrolTask.getImageModel()));
                        Boolean b = (Boolean) map.get("b");
                        String r = map.get("r").toString();
                        taskDetailVehiclesChannel.setSysStatus(b ? 2 : 3);
                        taskDetailVehiclesChannel.setResult(r);
                        taskDetailVehiclesChannelService.updateById(taskDetailVehiclesChannel);
                     }
                  }
               }else{
                  //2023 协议
                  String fileId = VideoGateway.cameraShot2023(vehicleId, vehicleType, terminalId, videoChannel, 0);
                  if(null == fileId){
                     log.error("2023年协议发送拍摄指令失败：terminalId-->{}，videoChannel-->{}", terminalId, videoChannel);
                     throw new Exception();
                  }else{
                     //等待15秒
                     Thread.sleep(30000);
							
                     String fileUrl = VideoGateway.getCameraShotByFileId2023(fileId, 0);
                     if(null == fileUrl){
                        log.error("2023年协议车辆获取拍摄图片失败：terminalId-->{}，fileId-->{}", terminalId, fileId);
                        //重新发送拍摄指令，如果还是没有获取图片，标注异常
                        fileId = VideoGateway.cameraShot2023(vehicleId, vehicleType, terminalId, videoChannel, 0);
                        if(null == fileId){
                           log.error("2023年协议发送拍摄指令失败：terminalId-->{}，videoChannel-->{}", terminalId, videoChannel);
                           throw new Exception();
                        }else{
                           //等待15秒
                           Thread.sleep(30000);
									
                           fileUrl = VideoGateway.getCameraShotByFileId2023(fileId, 0);
                           if(null == fileUrl){
                              log.error("2023年协议车辆获取拍摄图片失败：terminalId-->{}，fileId-->{}", terminalId, fileId);
                              throw new Exception();
                           }else{
                              taskDetailVehiclesChannel.setImageUrl(fileUrl);
                              taskDetailVehiclesChannel.setSysCreateTime(LocalDateTime.now());
                              taskDetailVehiclesChannel.setArtificialStatus(1);
                              //开始调模型接口得出结果
                              Map<String, Object> map = ImageModelUtil.modelCheck(fileUrl, ImageModelEnum.getImageModelEnum(patrolTask.getImageModel()));
                              Boolean b = (Boolean) map.get("b");
                              String r = map.get("r").toString();
                              taskDetailVehiclesChannel.setSysStatus(b ? 2 : 3);
                              taskDetailVehiclesChannel.setResult(r);
                              taskDetailVehiclesChannelService.updateById(taskDetailVehiclesChannel);
                           }
                        }
                     }else{
                        taskDetailVehiclesChannel.setImageUrl(fileUrl);
                        taskDetailVehiclesChannel.setSysCreateTime(LocalDateTime.now());
                        taskDetailVehiclesChannel.setArtificialStatus(1);
                        //开始调模型接口得出结果
                        Map<String, Object> map = ImageModelUtil.modelCheck(fileUrl, ImageModelEnum.getImageModelEnum(patrolTask.getImageModel()));
                        Boolean b = (Boolean) map.get("b");
                        String r = map.get("r").toString();
                        taskDetailVehiclesChannel.setSysStatus(b ? 2 : 3);
                        taskDetailVehiclesChannel.setResult(r);
                        taskDetailVehiclesChannelService.updateById(taskDetailVehiclesChannel);
                     }
                  }
               }
            }
            taskDetailVehicle.setEndExecutionTime(LocalDateTime.now());
            taskDetailVehicle.setStatus(3);
            taskDetailVehiclesService.updateById(taskDetailVehicle);
         }catch (Exception e){
            e.printStackTrace();
            //失败
            taskDetailVehicle.setEndExecutionTime(LocalDateTime.now());
            taskDetailVehicle.setStatus(5);
            taskDetailVehiclesService.updateById(taskDetailVehicle);
            errNum++;
         }
			
         //定义线程池
         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(threadCount, threadCount, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
         //定义多线程阻塞
         CountDownLatch countDownLatch = new CountDownLatch(threadCount);
         for (int i = 0; i < threadCount; i++) {
            int start = i * num;
            int end = (i + 1) * num;
            if((i + 1) == threadCount){
               end = taskDetailVehicles.size();
            }
            List<TaskDetailVehicles> vehicles = taskDetailVehicles.subList(start, end);
            threadPoolExecutor.execute(new Runnable() {
               @Override
               public void run() {
                  for (TaskDetailVehicles taskDetailVehicle : vehicles) {
                     try {
                        taskDetailVehicle.setStartExecutionTime(LocalDateTime.now());
                        Integer taskDetailVehicleId = taskDetailVehicle.getId();
                        //车船类型：1 车辆设备 2 船舶设备
                        Integer vehicleType = taskDetailVehicle.getVehicleType();
                        //车船id
                        Integer vehicleId = taskDetailVehicle.getVehicleId();
                        VehicleOnline vehicleOnline1 = null;
                        for (VehicleOnline vehicleOnline : vehicleOnlines2018) {
                           if(null != vehicleOnline.getVehicleId() && vehicleOnline.getVehicleId().equals(vehicleId) &&
                                 null != vehicleOnline.getVehicleType() && vehicleOnline.getVehicleType().equals(vehicleType)){
                              vehicleOnline1 = vehicleOnline;
                              String vehicleGpsProtocol = vehicleOnline.getVehicleGpsProtocol();
                              vehicleOnline1.setVehicleGpsProtocol("808-guangzhou".equals(vehicleGpsProtocol) ? "1" : "2");
                              break;
                           }
                        }
                        if(null == vehicleOnline1){
                           for (VehicleOnline vehicleOnline : vehicleOnlines203) {
                              if(null != vehicleOnline.getVehicleId() && vehicleOnline.getVehicleId().equals(vehicleId) &&
                                    null != vehicleOnline.getVehicleType() && vehicleOnline.getVehicleType().equals(vehicleType)){
                                 vehicleOnline1 = vehicleOnline;
                                 vehicleOnline1.setVehicleGpsProtocol(vehicleOnline.getVehicleGpsProtocol());
                                 break;
                              }
                           }
                        }
                        //不在线
                        if(null == vehicleOnline1){
                           taskDetailVehicle.setEndExecutionTime(LocalDateTime.now());
                           taskDetailVehicle.setStatus(4);
                           taskDetailVehiclesService.updateById(taskDetailVehicle);
                           continue;
                        }
                        taskDetailVehicle.setVehicleGpsProtocol(vehicleOnline1.getVehicleGpsProtocol());
                        taskDetailVehicle.setTerminalId(vehicleOnline1.getTerminalId());
                        taskDetailVehicle.setStatus(2);
                        taskDetailVehiclesService.updateById(taskDetailVehicle);
								
                        //成功
                        List<TaskDetailVehiclesChannel> taskDetailVehiclesChannels = taskDetailVehiclesChannelService.selectList(new EntityWrapper<TaskDetailVehiclesChannel>().eq("task_detail_vehicles_id", taskDetailVehicleId));
                        //开始发送拍照指令，获取照片地址
                        String vehicleGpsProtocol = vehicleOnline1.getVehicleGpsProtocol();
                        String terminalId = vehicleOnline1.getTerminalId();
                        for (TaskDetailVehiclesChannel taskDetailVehiclesChannel : taskDetailVehiclesChannels) {
                           Integer videoChannel = taskDetailVehiclesChannel.getVideoChannel();
                           try {
                              if("1".equals(vehicleGpsProtocol)){
                                 //2018 协议
                                 String fileId = VideoGateway.cameraShot2018(terminalId, videoChannel, 0);
                                 if(ToolUtil.isNotEmpty(fileId)){
                                    //等待30秒
                                    Thread.sleep(30000);
                                    String fileUrl = VideoGateway.getCameraShotByFileId2018(terminalId, fileId, 0);
                                    if(ToolUtil.isNotEmpty(fileUrl)){
                                       taskDetailVehiclesChannel.setImageUrl(fileUrl);
                                       taskDetailVehiclesChannel.setSysCreateTime(LocalDateTime.now());
                                       taskDetailVehiclesChannel.setArtificialStatus(1);
                                       //开始调模型接口得出结果
                                       Map<String, Object> map = ImageModelUtil.modelCheck(fileUrl, ImageModelEnum.getImageModelEnum(patrolTask.getImageModel()));
                                       Boolean b = (Boolean) map.get("b");
                                       String r = map.get("r").toString();
                                       taskDetailVehiclesChannel.setSysStatus(b ? 2 : 3);
                                       taskDetailVehiclesChannel.setResult(r);
                                       taskDetailVehiclesChannelService.updateById(taskDetailVehiclesChannel);
                                    }
                                 }
                              }else{
                                 //2023 协议
                                 String fileId = VideoGateway.cameraShot2023(vehicleId, vehicleType, terminalId, videoChannel, 0);
                                 if(ToolUtil.isNotEmpty(fileId)){
                                    //等待30秒
                                    Thread.sleep(30000);
                                    String fileUrl = VideoGateway.getCameraShotByFileId2023(fileId, 0);
                                    if(ToolUtil.isNotEmpty(fileUrl)){
                                       taskDetailVehiclesChannel.setImageUrl(fileUrl);
                                       taskDetailVehiclesChannel.setSysCreateTime(LocalDateTime.now());
                                       taskDetailVehiclesChannel.setArtificialStatus(1);
                                       //开始调模型接口得出结果
                                       Map<String, Object> map = ImageModelUtil.modelCheck(fileUrl, ImageModelEnum.getImageModelEnum(patrolTask.getImageModel()));
                                       Boolean b = (Boolean) map.get("b");
                                       String r = map.get("r").toString();
                                       taskDetailVehiclesChannel.setSysStatus(b ? 2 : 3);
                                       taskDetailVehiclesChannel.setResult(r);
                                       taskDetailVehiclesChannelService.updateById(taskDetailVehiclesChannel);
                                    }
                                 }
                              }
                           }catch (Exception e){
                              taskDetailVehiclesChannel.setResult(e.getMessage());
                              taskDetailVehiclesChannelService.updateById(taskDetailVehiclesChannel);
                           }
                        }
                        taskDetailVehicle.setEndExecutionTime(LocalDateTime.now());
                        taskDetailVehicle.setStatus(3);
                        taskDetailVehiclesService.updateById(taskDetailVehicle);
                     }catch (Exception e){
                        e.printStackTrace();
                        //失败
                        taskDetailVehicle.setEndExecutionTime(LocalDateTime.now());
                        taskDetailVehicle.setStatus(5);
                        taskDetailVehiclesService.updateById(taskDetailVehicle);
                     }
                  }
                  //当前线程执行完成后减少等待数
                  countDownLatch.countDown();
               }
            });
         }
         try {
            countDownLatch.await();
         } catch (InterruptedException e) {
            throw new RuntimeException(e);
         }
         int count = taskDetailVehiclesService.selectCount(new EntityWrapper<TaskDetailVehicles>().eq("task_detail_id", id).eq("status", 5));
         taskDetail.setStatus(count > 0 ? 4 : 3);
         taskDetailService.updateById(taskDetail);
      }
      
      taskDetail.setStatus(0 == errNum ? 3 : 4);
      taskDetailService.updateById(taskDetail);
   }
   
   
	
	
   public static void main(String[] args) {
      LocalDateTime now = LocalDateTime.now();
      now = now.plusDays(5);
      int value = now.getDayOfWeek().getValue();
      System.err.println(value);
   /**
    * 变更车辆状态
    * @param vehicleNum
    * @param vehicleStatus         状态（1=行驶中，2=已停止）
    * @param communicationNum
    * @param vehicleGpsProtocol
    * @param latitude
    * @param longitude
    */
   @Override
   public void vehicleSpeed(String vehicleNum, Integer vehicleStatus, Integer vehicleType, String communicationNum, String vehicleGpsProtocol, Double latitude, Double longitude) {
      Boolean lock = redisTemplate.hasKey("model:3:lock:" + vehicleNum + vehicleType);
      if(lock){
         return;
      }
      //添加redis 锁
      redisTemplate.opsForValue().set("model:3:lock:" + vehicleNum + vehicleType, System.currentTimeMillis(), 1, TimeUnit.MINUTES);
      List<TaskDetail> taskDetails = taskDetailService.selectList(new EntityWrapper<TaskDetail>().eq("status", 2).eq("del_flag", 0));
      if(taskDetails.size() > 0){
         Set<Integer> collect = taskDetails.stream().map(TaskDetail::getPatrolTaskId).collect(Collectors.toSet());
         List<PatrolTask> patrolTasks = this.selectList(new EntityWrapper<PatrolTask>().in("id", collect).eq("image_model", ImageModelEnum.CONSTRUCTION_WASTE_LOAD.getCode()));
         if(patrolTasks.size() > 0){
            List<Integer> collect1 = patrolTasks.stream().map(PatrolTask::getId).collect(Collectors.toList());
            List<TaskDetailVehicles> taskDetailVehicles = taskDetailVehiclesService.selectList(new EntityWrapper<TaskDetailVehicles>().eq("vehicleNum", vehicleNum)
                  .eq("vehicleType", vehicleType).eq("status", 2).in("patrol_task_id", collect1));
            if(taskDetailVehicles.size() > 0){
               TaskDetailVehicles taskDetailVehicles1 = taskDetailVehicles.get(0);
               String terminalId = taskDetailVehicles1.getTerminalId();
               Integer vehicleId = taskDetailVehicles1.getVehicleId();
               String vehicleIdUnique = taskDetailVehicles1.getVehicleIdUnique();
               //开始调用顶盖模型3次判断结果
               int loaded_cargo_num = 0;
               int empty_container_num = 0;
               String loaded_cargo_fileUrl = "";
               String empty_container_fileUrl = "";
               String r = null;
               for (int i = 0; i < 3; i++) {
                  //开始发送拍照指令，获取照片地址
                  try {
                     if("1".equals(vehicleGpsProtocol)){
                        //2018 协议
                        String fileId = VideoGateway.cameraShot2018(terminalId, VideoChannelEnum.CONTAINER.getId(), 0);
                        if(ToolUtil.isNotEmpty(fileId)){
                           //等待30秒
                           Thread.sleep(30000);
                           String fileUrl = VideoGateway.getCameraShotByFileId2018(terminalId, fileId, 0);
                           if(ToolUtil.isNotEmpty(fileUrl)){
                              //开始调模型接口得出结果
                              Map<String, Object> map = ImageModelUtil.modelCheck(fileUrl, ImageModelEnum.TOP_SEAL);
                              r = map.get("r").toString();
                              List<String> result = JSON.parseArray(r, String.class);
                              //装载状态
                              Optional<String> loaded_cargo = result.stream().filter(s -> s.contains("Loaded Cargo")).findFirst();
                              if(loaded_cargo.isPresent()){
                                 loaded_cargo_num++;
                                 loaded_cargo_fileUrl = fileUrl;
                              }
                              //非装载状态
                              Optional<String> empty_container = result.stream().filter(s -> s.contains("Empty Container")).findFirst();
                              if(empty_container.isPresent()){
                                 empty_container_num++;
                                 empty_container_fileUrl = fileUrl;
                              }
                           }
                        }
                     }else{
                        //2023 协议
                        String fileId = VideoGateway.cameraShot2023(vehicleId, vehicleType, terminalId, VideoChannelEnum.CONTAINER.getId(), 0);
                        if(ToolUtil.isNotEmpty(fileId)){
                           //等待30秒
                           Thread.sleep(30000);
                           String fileUrl = VideoGateway.getCameraShotByFileId2023(fileId, 0);
                           if(ToolUtil.isNotEmpty(fileUrl)){
                              //开始调模型接口得出结果
                              Map<String, Object> map = ImageModelUtil.modelCheck(fileUrl, ImageModelEnum.TOP_SEAL);
                              r = map.get("r").toString();
                              List<String> result = JSON.parseArray(r, String.class);
                              //装载状态
                              Optional<String> loaded_cargo = result.stream().filter(s -> s.contains("Loaded Cargo")).findFirst();
                              if(loaded_cargo.isPresent()){
                                 loaded_cargo_num++;
                                 loaded_cargo_fileUrl = fileUrl;
                              }
                              //非装载状态
                              Optional<String> empty_container = result.stream().filter(s -> s.contains("Empty Container")).findFirst();
                              if(empty_container.isPresent()){
                                 empty_container_num++;
                                 empty_container_fileUrl = fileUrl;
                              }
                           }
                        }
                     }
                  }catch (Exception e){
                     e.printStackTrace();
                     //执行失败
                     for (TaskDetailVehicles taskDetailVehicle : taskDetailVehicles) {
                        taskDetailVehicle.setStatus(5);
                        taskDetailVehicle.setEndExecutionTime(LocalDateTime.now());
                     }
                     taskDetailVehiclesService.updateBatchById(taskDetailVehicles);
                     List<Integer> collect2 = taskDetailVehicles.stream().map(TaskDetailVehicles::getId).collect(Collectors.toList());
                     //修改通道结果
                     List<TaskDetailVehiclesChannel> list = taskDetailVehiclesChannelService.selectList(new EntityWrapper<TaskDetailVehiclesChannel>().eq("task_detail_vehicles_id", collect2));
                     for (TaskDetailVehiclesChannel taskDetailVehiclesChannel : list) {
                        taskDetailVehiclesChannel.setResult(e.getMessage());
                     }
                     taskDetailVehiclesChannelService.updateBatchById(list);
							
                     //开始修改任务状态
                     Set<Integer> collect3 = taskDetailVehicles.stream().map(TaskDetailVehicles::getTaskDetailId).collect(Collectors.toSet());
                     for (Integer integer : collect3) {
                        int count = taskDetailVehiclesService.selectCount(new EntityWrapper<TaskDetailVehicles>().eq("task_detail_id", integer).in("status", Arrays.asList(1, 2)));
                        if(0 == count){
                           TaskDetail taskDetail = new TaskDetail();
                           taskDetail.setId(integer);
                           taskDetail.setStatus(4);
                           taskDetailService.updateById(taskDetail);
                        }
                     }
							
                     //删除redis锁key
                     redisTemplate.delete("model:3:lock:" + vehicleNum + vehicleType);
                     return;
                  }
               }
					
               //装载状态
               if(loaded_cargo_num > empty_container_num && 2 == vehicleStatus){
                  //装载状态下，判断车辆如果车速为0，则需要判断是否在围栏内，如果在则添加标识
                  //判断车辆是否在围栏内
                  boolean fenceByPoint = VideoGateway.getFenceByPoint(longitude.toString(), latitude.toString(), 0);
                  if(fenceByPoint){
                     redisTemplate.opsForValue().set("model:3:" + vehicleIdUnique, System.currentTimeMillis());
                  }
						
               }
					
               //空载状态
               if(empty_container_num > loaded_cargo_num){
                  //车辆空载状态，如果车辆车速大于0，且车辆有在围栏内的标识，则判定为正常倾倒
                  Boolean aBoolean = redisTemplate.hasKey("model:3:" + vehicleIdUnique);
                  if(1 == vehicleStatus){
                     for (TaskDetailVehicles taskDetailVehicle : taskDetailVehicles) {
                        taskDetailVehicle.setStatus(3);
                        taskDetailVehicle.setEndExecutionTime(LocalDateTime.now());
                     }
                     taskDetailVehiclesService.updateBatchById(taskDetailVehicles);
                     List<Integer> collect2 = taskDetailVehicles.stream().map(TaskDetailVehicles::getId).collect(Collectors.toList());
                     //修改通道结果
                     List<TaskDetailVehiclesChannel> list = taskDetailVehiclesChannelService.selectList(new EntityWrapper<TaskDetailVehiclesChannel>().eq("task_detail_vehicles_id", collect2));
                     for (TaskDetailVehiclesChannel taskDetailVehiclesChannel : list) {
                        taskDetailVehiclesChannel.setImageUrl(empty_container_fileUrl);
                        taskDetailVehiclesChannel.setSysCreateTime(LocalDateTime.now());
                        taskDetailVehiclesChannel.setArtificialStatus(1);
                        taskDetailVehiclesChannel.setSysStatus(aBoolean ? 2 : 3);
                        taskDetailVehiclesChannel.setResult(r);
                     }
                     taskDetailVehiclesChannelService.updateBatchById(list);
							
                     //开始修改任务状态
                     Set<Integer> collect3 = taskDetailVehicles.stream().map(TaskDetailVehicles::getTaskDetailId).collect(Collectors.toSet());
                     for (Integer integer : collect3) {
                        int count = taskDetailVehiclesService.selectCount(new EntityWrapper<TaskDetailVehicles>().eq("task_detail_id", integer).in("status", Arrays.asList(1, 2)));
                        if(0 == count){
                           TaskDetail taskDetail = new TaskDetail();
                           taskDetail.setId(integer);
                           taskDetail.setStatus(3);
                           taskDetailService.updateById(taskDetail);
                        }
                     }
                     //删除标识
                     redisTemplate.delete("model:3:" + vehicleIdUnique);
                  }
               }
            }
         }
      }
      //删除redis锁key
      redisTemplate.delete("model:3:lock:" + vehicleNum + vehicleType);
   }
}