~liusuyi/ruoyi-api.git

			@@ -7,20 +7,24 @@
			import com.ruoyi.alarm.apponekey.mapper.ArdAlarmApponekeyMapper;
			import com.ruoyi.alarm.camera.domain.ArdAlarmCamera;
			import com.ruoyi.alarm.camera.mapper.ArdAlarmCameraMapper;
			import com.ruoyi.alarm.digitization3.domain.ArdAlarmDigitization3;
			import com.ruoyi.alarm.digitization3.mapper.ArdAlarmDigitization3Mapper;
			import com.ruoyi.alarm.external.domain.ArdAlarmExternal;
			import com.ruoyi.alarm.external.mapper.ArdAlarmExternalMapper;
			import com.ruoyi.alarm.global.domain.GlobalAlarmCondition;
			import com.ruoyi.alarm.global.domain.GlobalAlarmData;
			import com.ruoyi.alarm.global.domain.GuidePriorityQueue;
			import com.ruoyi.alarm.global.domain.GuideTask;
			import com.ruoyi.alarm.global.domain.*;
			import com.ruoyi.alarm.global.service.IGlobalAlarmService;
			import com.ruoyi.alarm.radar.domain.ArdAlarmRadar;
			import com.ruoyi.alarm.radar.domain.RadarAlarmData;
			import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarMapper;
			import com.ruoyi.alarm.radar.domain.*;
			import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarFireMapper;
			import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarMoveMapper;
			import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarPumpMapper;
			import com.ruoyi.alarm.steal.domain.ArdAlarmStealelec;
			import com.ruoyi.alarm.steal.mapper.ArdAlarmStealelecMapper;
			import com.ruoyi.alarm.superbrain.domain.ArdAlarmSuperBrain;
			import com.ruoyi.alarm.superbrain.mapper.ArdAlarmSuperBrainMapper;
			import com.ruoyi.alarm.tube.domain.ArdAlarmTube;
			import com.ruoyi.alarm.tube.mapper.ArdAlarmTubeMapper;
			import com.ruoyi.alarm.wall.domain.ArdAlarmWall;
			import com.ruoyi.alarm.wall.mapper.ArdAlarmWallMapper;
			import com.ruoyi.alarmpoints.tube.domain.ArdTubes;
			import com.ruoyi.alarmpoints.tube.domain.ArdTubesDetails;
			import com.ruoyi.alarmpoints.tube.mapper.ArdTubesDetailsMapper;
			@@ -29,21 +33,21 @@
			import com.ruoyi.alarmpoints.well.mapper.ArdAlarmpointsWellMapper;
			import com.ruoyi.common.constant.CacheConstants;
			import com.ruoyi.common.core.redis.RedisCache;
			import com.ruoyi.common.utils.ConfigUtils;
			import com.ruoyi.common.utils.DateUtils;
			import com.ruoyi.common.utils.DictUtils;
			import com.ruoyi.common.utils.StringUtils;
			import com.ruoyi.constant.CamPriority;
			import com.ruoyi.device.external.domain.ArdEquipExternal;
			import com.ruoyi.device.external.mapper.ArdEquipExternalMapper;
			import com.ruoyi.device.radar.mapper.ArdEquipRadarMapper;
			import com.ruoyi.utils.gis.GisUtil;
			import com.ruoyi.utils.tools.ArdTool;
			import com.ruoyi.utils.tools.GisTool;
			import com.ruoyi.common.utils.uuid.IdUtils;
			import com.ruoyi.device.camera.domain.ArdCameras;
			import com.ruoyi.device.camera.mapper.ArdCamerasMapper;
			import com.ruoyi.system.service.ISysConfigService;
			import com.ruoyi.utils.tube.GeoPoint;
			import com.ruoyi.utils.tube.TubeTools;
			import lombok.AllArgsConstructor;
			import lombok.Data;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.scheduling.annotation.Async;
			import org.springframework.stereotype.Service;
			@@ -51,9 +55,8 @@
			import javax.annotation.Resource;
			import java.text.SimpleDateFormat;
			import java.util.*;
			import java.util.concurrent.PriorityBlockingQueue;
			import java.util.concurrent.TimeUnit;
			import java.util.stream.Collectors;


			/**
			* @Description: 全局报警业务
			@@ -63,9 +66,15 @@
			* @Version: 1.0
			**/
			@Service
			@Slf4j(topic = "mqtt")
			@Slf4j(topic = "alarm")
			public class GlobalAlarmServiceImpl implements IGlobalAlarmService {
			//region 依赖注入
			@Resource
			private ArdAlarmSuperBrainMapper ardAlarmSuperBrainMapper;
			@Resource
			private ArdAlarmDigitization3Mapper ardAlarmDigitization3Mapper;
			@Resource
			private ArdAlarmWallMapper ardAlarmWallMapper;
			@Resource
			private ArdAlarmApponekeyMapper ardAlarmApponekeyMapper;
			@Resource
			@@ -74,8 +83,14 @@
			private ArdAlarmAccessMapper ardAlarmAccessMapper;
			@Resource
			private ArdAlarmExternalMapper ardAlarmExternalMapper;
			//@Resource
			//private ArdAlarmRadarMapper ardAlarmRadarMapper;
			@Resource
			private ArdAlarmRadarMapper ardAlarmRadarMapper;
			private ArdAlarmRadarMoveMapper ardAlarmRadarMoveMapper;
			@Resource
			private ArdAlarmRadarFireMapper ardAlarmRadarFireMapper;
			@Resource
			private ArdAlarmRadarPumpMapper ardAlarmRadarPumpMapper;
			@Resource
			private ArdAlarmStealelecMapper ardAlarmStealelecMapper;
			@Resource
			@@ -96,6 +111,8 @@
			private RedisCache redisCache;
			@Resource
			private QueueManager queueManager;
			@Resource
			private ArdEquipRadarMapper ardEquipRadarMapper;
			//endregion

			/**
			@@ -115,11 +132,11 @@
			countMap.put("1001", count1001);
			int count1002 = ardAlarmCameraMapper.selectCountByAlarmTime(refreshTime);
			countMap.put("1002", count1002);
			int count1003 = ardAlarmRadarMapper.selectCountByAlarmTime(refreshTime, "运动目标检测");
			int count1003 = ardAlarmRadarMoveMapper.selectCountByAlarmTime(refreshTime);
			countMap.put("1003", count1003);
			int count1004 = ardAlarmRadarMapper.selectCountByAlarmTime(refreshTime, "热源检测");
			int count1004 = ardAlarmRadarFireMapper.selectCountByAlarmTime(refreshTime);
			countMap.put("1004", count1004);
			int count1007 = ardAlarmRadarMapper.selectCountByAlarmTime(refreshTime, "雷达抽油机停机");
			int count1007 = ardAlarmRadarPumpMapper.selectCountByAlarmTime(refreshTime);
			countMap.put("1007", count1007);
			int count1005 = ardAlarmExternalMapper.selectCountByAlarmTime(refreshTime, "防区报警");
			countMap.put("1005", count1005);
			@@ -127,8 +144,14 @@
			countMap.put("1006", count1006);
			int count1009 = ardAlarmApponekeyMapper.selectCountByAlarmTime(refreshTime);
			countMap.put("1009", count1009);
			int count1010 = ardAlarmWallMapper.selectCountByAlarmTime(refreshTime);
			countMap.put("1010", count1010);
			int count1014 = ardAlarmTubeMapper.selectCountByAlarmTime(refreshTime);
			countMap.put("1014", count1014);
			int count1012 = ardAlarmDigitization3Mapper.selectCountByAlarmTime(refreshTime);
			countMap.put("1012", count1012);
			int count1015 = ardAlarmSuperBrainMapper.selectCountByAlarmTime(refreshTime);
			countMap.put("1015", count1015);
			map.put("20000", countMap);
			return map;
			}
			@@ -175,31 +198,31 @@
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1003:
			List<ArdAlarmRadar> ardAlarmRadars = ardAlarmRadarMapper.selectListAllByCommand(refreshTime, "运动目标检测");
			return ardAlarmRadars.stream()
			.map(ardAlarmRadar -> {
			List<ArdAlarmRadarMove> ardAlarmRadarMoves = ardAlarmRadarMoveMapper.selectListAllByCommand(refreshTime);
			return ardAlarmRadarMoves.stream()
			.map(ardAlarmRadarMove -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmRadar.getId())
			.setName(ardAlarmRadar.getName())
			.setAlarmTime(ardAlarmRadar.getAlarmTime())
			.setLongitude(ardAlarmRadar.getLongitude())
			.setLatitude(ardAlarmRadar.getLatitude())
			.setCount(ardAlarmRadar.getCount())
			.setTotal(ardAlarmRadar.getTotal());
			.setId(ardAlarmRadarMove.getId())
			.setName(ardAlarmRadarMove.getName())
			.setAlarmTime(ardAlarmRadarMove.getAlarmTime())
			.setLongitude(ardAlarmRadarMove.getLongitude())
			.setLatitude(ardAlarmRadarMove.getLatitude())
			.setCount(ardAlarmRadarMove.getCount())
			.setTotal(ardAlarmRadarMove.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1004:
			ardAlarmRadars = ardAlarmRadarMapper.selectListAllByCommand(refreshTime, "热源检测");
			return ardAlarmRadars.stream()
			.map(ardAlarmRadar -> {
			List<ArdAlarmRadarFire> ardAlarmRadarFires = ardAlarmRadarFireMapper.selectListAllByCommand(refreshTime);
			return ardAlarmRadarFires.stream()
			.map(ardAlarmRadarFire -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmRadar.getId())
			.setName(ardAlarmRadar.getName())
			.setAlarmTime(ardAlarmRadar.getAlarmTime())
			.setLongitude(ardAlarmRadar.getLongitude())
			.setLatitude(ardAlarmRadar.getLatitude())
			.setCount(ardAlarmRadar.getCount())
			.setTotal(ardAlarmRadar.getTotal());
			.setId(ardAlarmRadarFire.getId())
			.setName(ardAlarmRadarFire.getName())
			.setAlarmTime(ardAlarmRadarFire.getAlarmTime())
			.setLongitude(ardAlarmRadarFire.getLongitude())
			.setLatitude(ardAlarmRadarFire.getLatitude())
			.setCount(ardAlarmRadarFire.getCount())
			.setTotal(ardAlarmRadarFire.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1005:
			@@ -231,17 +254,17 @@
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1007:
			ardAlarmRadars = ardAlarmRadarMapper.selectListAllByCommand(refreshTime, "雷达抽油机停机");
			return ardAlarmRadars.stream()
			.map(ardAlarmRadar -> {
			List<ArdAlarmRadarPump> ardAlarmRadarPumps = ardAlarmRadarPumpMapper.selectListAllByCommand(refreshTime);
			return ardAlarmRadarPumps.stream()
			.map(ardAlarmRadarPump -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmRadar.getId())
			.setName(ardAlarmRadar.getName())
			.setAlarmTime(ardAlarmRadar.getAlarmTime())
			.setLongitude(ardAlarmRadar.getLongitude())
			.setLatitude(ardAlarmRadar.getLatitude())
			.setCount(ardAlarmRadar.getCount())
			.setTotal(ardAlarmRadar.getTotal());
			.setId(ardAlarmRadarPump.getId())
			.setName(ardAlarmRadarPump.getName())
			.setAlarmTime(ardAlarmRadarPump.getAlarmTime())
			.setLongitude(ardAlarmRadarPump.getLongitude())
			.setLatitude(ardAlarmRadarPump.getLatitude())
			.setCount(ardAlarmRadarPump.getCount())
			.setTotal(ardAlarmRadarPump.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1009:
			@@ -256,6 +279,36 @@
			.setLatitude(ardAlarmApponekey.getLatitude())
			.setCount(ardAlarmApponekey.getCount())
			.setTotal(ardAlarmApponekey.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1010:
			List<ArdAlarmWall> ardAlarmWalls = ardAlarmWallMapper.selectListAllByCommand(refreshTime);
			return ardAlarmWalls.stream()
			.map(ardAlarmWall -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmWall.getId())
			.setName(ardAlarmWall.getWallName())
			.setAlarmTime(ardAlarmWall.getAlarmTime())
			.setLongitude(ardAlarmWall.getLongitude())
			.setLatitude(ardAlarmWall.getLatitude())
			.setCount(ardAlarmWall.getCount())
			.setTotal(ardAlarmWall.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1012:
			List<ArdAlarmDigitization3> ardAlarmDigitization3s = ardAlarmDigitization3Mapper.selectListAllByCommand(refreshTime);
			return ardAlarmDigitization3s.stream()
			.map(ardAlarmDigitization3 -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmDigitization3.getId())
			.setName(ardAlarmDigitization3.getWellNo())
			.setAlarmType(ardAlarmDigitization3.getAlarmType())
			.setAlarmTime(ardAlarmDigitization3.getAlarmTime())
			.setLongitude(ardAlarmDigitization3.getLongitude())
			.setLatitude(ardAlarmDigitization3.getLatitude())
			.setAltitude(ardAlarmDigitization3.getAltitude())
			.setCount(ardAlarmDigitization3.getCount())
			.setTotal(ardAlarmDigitization3.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1014:
			@@ -273,9 +326,443 @@
			.setTotal(ardAlarmTube.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1015:
			List<ArdAlarmSuperBrain> ardAlarmSuperBrains = ardAlarmSuperBrainMapper.selectListAllByCommand(refreshTime);
			return ardAlarmSuperBrains.stream()
			.map(ardAlarmSuperBrain -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmSuperBrain.getId())
			.setName(ardAlarmSuperBrain.getAlarmType())
			.setAlarmType(ardAlarmSuperBrain.getAlarmType())
			.setAlarmTime(ardAlarmSuperBrain.getAlarmTime())
			.setLongitude(ardAlarmSuperBrain.getLongitude())
			.setLatitude(ardAlarmSuperBrain.getLatitude())
			.setAltitude(ardAlarmSuperBrain.getAltitude())
			.setCount(ardAlarmSuperBrain.getCount())
			.setTotal(ardAlarmSuperBrain.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			default:
			return null;
			}
			}

			/**
			* 获取热力图数据
			* 刘苏义
			* 2023/9/16 8:38:54
			*/
			@Override
			public List<GlobalAlarmData> selectThermalMap(GlobalAlarmCondition condition) {
			String refreshTime = condition.getRefreshTime();
			switch (condition.getCommand()) {
			case 1001:
			List<ArdAlarmStealelec> ardAlarmStealelecs = ardAlarmStealelecMapper.selectListAllByCommand(refreshTime);
			return ardAlarmStealelecs.stream()
			.map(ardAlarmStealelec -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmStealelec.getId())
			.setName(ardAlarmStealelec.getDescribe())
			.setAlarmTime(ardAlarmStealelec.getStartTime())
			.setLongitude(ardAlarmStealelec.getLongitude())
			.setLatitude(ardAlarmStealelec.getLatitude())
			.setAltitude(ardAlarmStealelec.getAltitude())
			.setCount(ardAlarmStealelec.getCount())
			.setTotal(ardAlarmStealelec.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1002:
			List<ArdAlarmCamera> ardAlarmCameras = ardAlarmCameraMapper.selectListAllByCommand(refreshTime);
			return ardAlarmCameras.stream()
			.map(ardAlarmCamera -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmCamera.getId())
			.setName(ardAlarmCamera.getCameraName())
			.setAlarmTime(ardAlarmCamera.getAlarmTime())
			.setLongitude(ardAlarmCamera.getLongitude())
			.setLatitude(ardAlarmCamera.getLatitude())
			.setCount(ardAlarmCamera.getCount())
			.setTotal(ardAlarmCamera.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1003:
			//从缓存获取数据
			//String key = "radar_alarm:" + DateUtils.getDate();
			//List<ArdAlarmRadarMove> ardAlarmRadarMoves = redisCache.getCacheList(key);
			//Map<String, List<ArdAlarmRadarMove>> groupedData = ardAlarmRadarMoves.stream()
			// .collect(Collectors.groupingBy(ArdAlarmRadarMove::getName));
			//List<GlobalAlarmData> globalAlarmDataList = new ArrayList<>();
			//for (String name : groupedData.keySet()) {
			// List<ArdAlarmRadarMove> ardAlarmRadarMove = groupedData.get(name);
			// GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			// .setId(ardAlarmRadarMove.get(0).getId())
			// .setName(name)
			// .setAlarmTime(ardAlarmRadarMove.get(0).getAlarmTime())
			// .setLongitude(ardAlarmRadarMove.get(0).getLongitude())
			// .setLatitude(ardAlarmRadarMove.get(0).getLatitude())
			// .setTotal(ardAlarmRadarMove.size());
			// globalAlarmDataList.add(globalAlarmData);
			//}
			//return globalAlarmDataList;
			//从数据库获取
			List<ArdAlarmRadarMove> ardAlarmRadarMoves = ardAlarmRadarMoveMapper.selectListAllByCommand(refreshTime);
			return ardAlarmRadarMoves.stream()
			.map(ardAlarmRadarMove -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmRadarMove.getId())
			.setName(ardAlarmRadarMove.getName())
			.setAlarmTime(ardAlarmRadarMove.getAlarmTime())
			.setLongitude(ardAlarmRadarMove.getLongitude())
			.setLatitude(ardAlarmRadarMove.getLatitude())
			.setCount(ardAlarmRadarMove.getCount())
			.setTotal(ardAlarmRadarMove.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1004:
			List<ArdAlarmRadarFire> ardAlarmRadarFires = ardAlarmRadarFireMapper.selectListAllByCommand(refreshTime);
			return ardAlarmRadarFires.stream()
			.map(ardAlarmRadarFire -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmRadarFire.getId())
			.setName(ardAlarmRadarFire.getName())
			.setAlarmTime(ardAlarmRadarFire.getAlarmTime())
			.setLongitude(ardAlarmRadarFire.getLongitude())
			.setLatitude(ardAlarmRadarFire.getLatitude())
			.setCount(ardAlarmRadarFire.getCount())
			.setTotal(ardAlarmRadarFire.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1005:
			List<ArdAlarmExternal> ardAlarmExternals = ardAlarmExternalMapper.selectListAllByCommand(refreshTime, "防区报警");
			return ardAlarmExternals.stream()
			.map(ardAlarmExternal -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmExternal.getId())
			.setName(ardAlarmExternal.getAlarmName())
			.setAlarmTime(ardAlarmExternal.getAlarmTime())
			.setLongitude(ardAlarmExternal.getLongitude())
			.setLatitude(ardAlarmExternal.getLatitude())
			.setCount(ardAlarmExternal.getCount())
			.setTotal(ardAlarmExternal.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1006:
			List<ArdAlarmAccess> ardAlarmAccesses = ardAlarmAccessMapper.selectListAllByCommand(refreshTime);
			return ardAlarmAccesses.stream()
			.map(ardAlarmAccess -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmAccess.getId())
			.setName(ardAlarmAccess.getAcsName())
			.setAlarmTime(ardAlarmAccess.getAlarmTime())
			.setLongitude(ardAlarmAccess.getLongitude())
			.setLatitude(ardAlarmAccess.getLatitude())
			.setCount(ardAlarmAccess.getCount())
			.setTotal(ardAlarmAccess.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1007:
			List<ArdAlarmRadarPump> ardAlarmRadarPumps = ardAlarmRadarPumpMapper.selectListAllByCommand(refreshTime);
			return ardAlarmRadarPumps.stream()
			.map(ardAlarmRadarPump -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmRadarPump.getId())
			.setName(ardAlarmRadarPump.getName())
			.setAlarmTime(ardAlarmRadarPump.getAlarmTime())
			.setLongitude(ardAlarmRadarPump.getLongitude())
			.setLatitude(ardAlarmRadarPump.getLatitude())
			.setCount(ardAlarmRadarPump.getCount())
			.setTotal(ardAlarmRadarPump.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1009:
			List<ArdAlarmApponekey> ardAlarmApponekeys = ardAlarmApponekeyMapper.selectListAllByCommand(refreshTime);
			return ardAlarmApponekeys.stream()
			.map(ardAlarmApponekey -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmApponekey.getId())
			.setName(ardAlarmApponekey.getName())
			.setAlarmTime(ardAlarmApponekey.getCreateTime())
			.setLongitude(ardAlarmApponekey.getLongitude())
			.setLatitude(ardAlarmApponekey.getLatitude())
			.setCount(ardAlarmApponekey.getCount())
			.setTotal(ardAlarmApponekey.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1010:
			List<ArdAlarmWall> ardAlarmWalls = ardAlarmWallMapper.selectListAllByCommand(refreshTime);
			return ardAlarmWalls.stream()
			.map(ardAlarmWall -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmWall.getId())
			.setName(ardAlarmWall.getWallName())
			.setAlarmTime(ardAlarmWall.getAlarmTime())
			.setLongitude(ardAlarmWall.getLongitude())
			.setLatitude(ardAlarmWall.getLatitude())
			.setCount(ardAlarmWall.getCount())
			.setTotal(ardAlarmWall.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1014:
			List<ArdAlarmTube> ardAlarmTubes = ardAlarmTubeMapper.selectListAllByCommand(refreshTime);
			return ardAlarmTubes.stream()
			.map(ardAlarmTube -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmTube.getId())
			.setName(ardAlarmTube.getTubeName())
			.setAlarmTime(ardAlarmTube.getAlarmTime())
			.setLongitude(ardAlarmTube.getLongitude())
			.setLatitude(ardAlarmTube.getLatitude())
			.setAltitude(ardAlarmTube.getAltitude())
			.setCount(ardAlarmTube.getCount())
			.setTotal(ardAlarmTube.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			case 1015:
			List<ArdAlarmSuperBrain> ardAlarmSuperBrains = ardAlarmSuperBrainMapper.selectListAllByCommand(refreshTime);
			return ardAlarmSuperBrains.stream()
			.map(ardAlarmSuperBrain -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmSuperBrain.getId())
			.setName(ardAlarmSuperBrain.getAlarmType())
			.setAlarmType(ardAlarmSuperBrain.getAlarmType())
			.setAlarmTime(ardAlarmSuperBrain.getAlarmTime())
			.setLongitude(ardAlarmSuperBrain.getLongitude())
			.setLatitude(ardAlarmSuperBrain.getLatitude())
			.setAltitude(ardAlarmSuperBrain.getAltitude())
			.setCount(ardAlarmSuperBrain.getCount())
			.setTotal(ardAlarmSuperBrain.getTotal());
			return globalAlarmData;
			}).collect(Collectors.toList());
			default:
			return null;
			}
			}

			@Override
			public List<GlobalAlarmData> selectAlarmLogsAll() {
			List<GlobalAlarmData> GlobalAlarmDataList = new ArrayList<>();
			String refreshTime = configService.selectConfigByKey("refreshTime");
			List<ArdAlarmStealelec> ardAlarmStealelecs = ardAlarmStealelecMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1001 = ardAlarmStealelecs.stream()
			.map(ardAlarmStealelec -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmStealelec.getId())
			.setName(ardAlarmStealelec.getDescribe())
			.setAlarmTime(ardAlarmStealelec.getStartTime())
			.setLongitude(ardAlarmStealelec.getLongitude())
			.setLatitude(ardAlarmStealelec.getLatitude())
			.setAltitude(ardAlarmStealelec.getAltitude())
			.setCount(ardAlarmStealelec.getCount())
			.setTotal(ardAlarmStealelec.getTotal())
			.setAlarmType("1001");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1001.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1001);
			}

			List<ArdAlarmCamera> ardAlarmCameras = ardAlarmCameraMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1002 = ardAlarmCameras.stream()
			.map(ardAlarmCamera -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmCamera.getId())
			.setName(ardAlarmCamera.getCameraName())
			.setAlarmTime(ardAlarmCamera.getAlarmTime())
			.setLongitude(ardAlarmCamera.getLongitude())
			.setLatitude(ardAlarmCamera.getLatitude())
			.setCount(ardAlarmCamera.getCount())
			.setTotal(ardAlarmCamera.getTotal())
			.setAlarmType("1002");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1002.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1002);
			}

			List<ArdAlarmRadarMove> ardAlarmRadarMoves = ardAlarmRadarMoveMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1003 = ardAlarmRadarMoves.stream()
			.map(ardAlarmRadarMove -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmRadarMove.getId())
			.setName(ardAlarmRadarMove.getName())
			.setAlarmTime(ardAlarmRadarMove.getAlarmTime())
			.setLongitude(ardAlarmRadarMove.getLongitude())
			.setLatitude(ardAlarmRadarMove.getLatitude())
			.setCount(ardAlarmRadarMove.getCount())
			.setTotal(ardAlarmRadarMove.getTotal())
			.setAlarmType("1003");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1003.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1003);
			}

			List<ArdAlarmRadarFire> ardAlarmRadarFires = ardAlarmRadarFireMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1004 = ardAlarmRadarFires.stream()
			.map(ardAlarmRadarFire -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmRadarFire.getId())
			.setName(ardAlarmRadarFire.getName())
			.setAlarmTime(ardAlarmRadarFire.getAlarmTime())
			.setLongitude(ardAlarmRadarFire.getLongitude())
			.setLatitude(ardAlarmRadarFire.getLatitude())
			.setCount(ardAlarmRadarFire.getCount())
			.setTotal(ardAlarmRadarFire.getTotal())
			.setAlarmType("1004");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1004.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1004);
			}

			List<ArdAlarmExternal> ardAlarmExternals = ardAlarmExternalMapper.selectListAllByCommand(refreshTime, "防区报警");
			List<GlobalAlarmData> alarmData1005 = ardAlarmExternals.stream()
			.map(ardAlarmExternal -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmExternal.getId())
			.setName(ardAlarmExternal.getAlarmName())
			.setAlarmTime(ardAlarmExternal.getAlarmTime())
			.setLongitude(ardAlarmExternal.getLongitude())
			.setLatitude(ardAlarmExternal.getLatitude())
			.setCount(ardAlarmExternal.getCount())
			.setTotal(ardAlarmExternal.getTotal())
			.setAlarmType("1005");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1005.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1005);
			}

			List<ArdAlarmAccess> ardAlarmAccesses = ardAlarmAccessMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1006 = ardAlarmAccesses.stream()
			.map(ardAlarmAccess -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmAccess.getId())
			.setName(ardAlarmAccess.getAcsName())
			.setAlarmTime(ardAlarmAccess.getAlarmTime())
			.setLongitude(ardAlarmAccess.getLongitude())
			.setLatitude(ardAlarmAccess.getLatitude())
			.setCount(ardAlarmAccess.getCount())
			.setTotal(ardAlarmAccess.getTotal())
			.setAlarmType("1006");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1006.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1006);
			}

			List<ArdAlarmRadarPump> ardAlarmRadarPumps = ardAlarmRadarPumpMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1007 = ardAlarmRadarPumps.stream()
			.map(ardAlarmRadarPump -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmRadarPump.getId())
			.setName(ardAlarmRadarPump.getName())
			.setAlarmTime(ardAlarmRadarPump.getAlarmTime())
			.setLongitude(ardAlarmRadarPump.getLongitude())
			.setLatitude(ardAlarmRadarPump.getLatitude())
			.setCount(ardAlarmRadarPump.getCount())
			.setTotal(ardAlarmRadarPump.getTotal())
			.setAlarmType("1007");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1007.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1007);
			}

			List<ArdAlarmApponekey> ardAlarmApponekeys = ardAlarmApponekeyMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1009 = ardAlarmApponekeys.stream()
			.map(ardAlarmApponekey -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmApponekey.getId())
			.setName(ardAlarmApponekey.getName())
			.setAlarmTime(ardAlarmApponekey.getCreateTime())
			.setLongitude(ardAlarmApponekey.getLongitude())
			.setLatitude(ardAlarmApponekey.getLatitude())
			.setCount(ardAlarmApponekey.getCount())
			.setTotal(ardAlarmApponekey.getTotal())
			.setAlarmType("1009");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1009.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1009);
			}

			List<ArdAlarmWall> ardAlarmWalls = ardAlarmWallMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1010 = ardAlarmWalls.stream()
			.map(ardAlarmWall -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmWall.getId())
			.setName(ardAlarmWall.getWallName())
			.setAlarmTime(ardAlarmWall.getCreateTime())
			.setLongitude(ardAlarmWall.getLongitude())
			.setLatitude(ardAlarmWall.getLatitude())
			.setCount(ardAlarmWall.getCount())
			.setTotal(ardAlarmWall.getTotal())
			.setAlarmType("1010");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1010.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1010);
			}

			List<ArdAlarmDigitization3> ardAlarmDigitization3s = ardAlarmDigitization3Mapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1012 = ardAlarmDigitization3s.stream()
			.map(ardAlarmDigitization3 -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmDigitization3.getId())
			.setName(ardAlarmDigitization3.getWellNo())
			.setAlarmTime(ardAlarmDigitization3.getAlarmTime())
			.setLongitude(ardAlarmDigitization3.getLongitude())
			.setLatitude(ardAlarmDigitization3.getLatitude())
			.setAltitude(ardAlarmDigitization3.getAltitude())
			.setCount(ardAlarmDigitization3.getCount())
			.setTotal(ardAlarmDigitization3.getTotal())
			.setAlarmType("1012");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1012.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1012);
			}

			List<ArdAlarmTube> ardAlarmTubes = ardAlarmTubeMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1014 = ardAlarmTubes.stream()
			.map(ardAlarmTube -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmTube.getId())
			.setName(ardAlarmTube.getTubeName())
			.setAlarmTime(ardAlarmTube.getAlarmTime())
			.setLongitude(ardAlarmTube.getLongitude())
			.setLatitude(ardAlarmTube.getLatitude())
			.setAltitude(ardAlarmTube.getAltitude())
			.setCount(ardAlarmTube.getCount())
			.setTotal(ardAlarmTube.getTotal())
			.setAlarmType("1014");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1014.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1014);
			}

			List<ArdAlarmSuperBrain> ardAlarmSuperBrains = ardAlarmSuperBrainMapper.selectListAllByCommand(refreshTime);
			List<GlobalAlarmData> alarmData1015 = ardAlarmSuperBrains.stream()
			.map(ardAlarmSuperBrain -> {
			GlobalAlarmData globalAlarmData = new GlobalAlarmData()
			.setId(ardAlarmSuperBrain.getId())
			.setName(ardAlarmSuperBrain.getAlarmType())
			.setAlarmTime(ardAlarmSuperBrain.getAlarmTime())
			.setLongitude(ardAlarmSuperBrain.getLongitude())
			.setLatitude(ardAlarmSuperBrain.getLatitude())
			.setAltitude(ardAlarmSuperBrain.getAltitude())
			.setCount(ardAlarmSuperBrain.getCount())
			.setTotal(ardAlarmSuperBrain.getTotal())
			.setAlarmType("1015");
			return globalAlarmData;
			}).collect(Collectors.toList());
			if (alarmData1015.size() > 0) {
			GlobalAlarmDataList.addAll(alarmData1015);
			}

			return GlobalAlarmDataList;
			}

			/**
			@@ -305,26 +792,26 @@
			aac.setPageSize(pageSize);
			return ardAlarmCameraMapper.selectArdAlarmCameraList(aac);
			case 1003:
			ArdAlarmRadar aar = new ArdAlarmRadar();
			aar.setParams(params);
			aar.setPageNum(pageNum);
			aar.setPageSize(pageSize);
			aar.setAlarmType("运动目标检测");
			return ardAlarmRadarMapper.selectArdAlarmRadarList(aar);
			ArdAlarmRadarMove aarm = new ArdAlarmRadarMove();
			aarm.setParams(params);
			aarm.setPageNum(pageNum);
			aarm.setPageSize(pageSize);
			aarm.setAlarmType("运动目标检测");
			return ardAlarmRadarMoveMapper.selectArdAlarmRadarMoveList(aarm);
			case 1004:
			ArdAlarmRadar aarr = new ArdAlarmRadar();
			aarr.setParams(params);
			aarr.setPageNum(pageNum);
			aarr.setPageSize(pageSize);
			aarr.setAlarmType("热源检测");
			return ardAlarmRadarMapper.selectArdAlarmRadarList(aarr);
			ArdAlarmRadarFire aarf = new ArdAlarmRadarFire();
			aarf.setParams(params);
			aarf.setPageNum(pageNum);
			aarf.setPageSize(pageSize);
			aarf.setAlarmType("热源检测");
			return ardAlarmRadarFireMapper.selectArdAlarmRadarFireList(aarf);
			case 1007:
			ArdAlarmRadar aarrr = new ArdAlarmRadar();
			aarrr.setParams(params);
			aarrr.setPageNum(pageNum);
			aarrr.setPageSize(pageSize);
			aarrr.setAlarmType("雷达抽油机停机");
			return ardAlarmRadarMapper.selectArdAlarmRadarList(aarrr);
			ArdAlarmRadarPump aarp = new ArdAlarmRadarPump();
			aarp.setParams(params);
			aarp.setPageNum(pageNum);
			aarp.setPageSize(pageSize);
			aarp.setAlarmType("雷达抽油机停机");
			return ardAlarmRadarPumpMapper.selectArdAlarmRadarPumpList(aarp);
			case 1005:
			ArdAlarmExternal aae = new ArdAlarmExternal();
			aae.setParams(params);
			@@ -345,12 +832,30 @@
			aaak.setPageNum(pageNum);
			aaak.setPageSize(pageSize);
			return ardAlarmApponekeyMapper.selectArdAlarmApponekeyList(aaak);
			case 1010:
			ArdAlarmWall aaw = new ArdAlarmWall();
			aaw.setParams(params);
			aaw.setPageNum(pageNum);
			aaw.setPageSize(pageSize);
			return ardAlarmWallMapper.selectArdAlarmWallList(aaw);
			case 1012:
			ArdAlarmDigitization3 aad3 = new ArdAlarmDigitization3();
			aad3.setParams(params);
			aad3.setPageNum(pageNum);
			aad3.setPageSize(pageSize);
			return ardAlarmDigitization3Mapper.selectArdAlarmDigitization3List(aad3);
			case 1014:
			ArdAlarmTube aat = new ArdAlarmTube();
			aat.setParams(params);
			aat.setPageNum(pageNum);
			aat.setPageSize(pageSize);
			return ardAlarmTubeMapper.selectArdAlarmTubeList(aat);
			case 1015:
			ArdAlarmSuperBrain aasb = new ArdAlarmSuperBrain();
			aasb.setParams(params);
			aasb.setPageNum(pageNum);
			aasb.setPageSize(pageSize);
			return ardAlarmSuperBrainMapper.selectArdAlarmSuperBrainList(aasb);
			}
			return null;
			}
			@@ -366,6 +871,7 @@
			@Override
			public Object updateAlarmViewTime(GlobalAlarmCondition condition) {
			SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			SimpleDateFormat fmtms = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
			switch (condition.getCommand()) {
			case 1001:
			ArdAlarmStealelec ardAlarmStealelec = ardAlarmStealelecMapper.selectByPrimaryKey(condition.getId());
			@@ -384,15 +890,28 @@
			return ardAlarmCamera;
			}
			case 1003:
			ArdAlarmRadarMove ardAlarmRadarMove = ardAlarmRadarMoveMapper.selectArdAlarmRadarMoveById(condition.getId());
			if (StringUtils.isNotNull(ardAlarmRadarMove)) {
			String name = ardAlarmRadarMove.getName();
			String alarmTime = fmt.format(ardAlarmRadarMove.getAlarmTime());
			ardAlarmRadarMoveMapper.updateViewTimeByCondition(name, alarmTime, DateUtils.getTime());
			return ardAlarmRadarMove;
			}
			case 1004:
			ArdAlarmRadarFire ardAlarmRadarFire = ardAlarmRadarFireMapper.selectArdAlarmRadarFireById(condition.getId());
			if (StringUtils.isNotNull(ardAlarmRadarFire)) {
			String name = ardAlarmRadarFire.getName();
			String alarmTime = fmt.format(ardAlarmRadarFire.getAlarmTime());
			ardAlarmRadarFireMapper.updateViewTimeByCondition(name, alarmTime, DateUtils.getTime());
			return ardAlarmRadarFire;
			}
			case 1007:
			ArdAlarmRadar ardAlarmRadar = ardAlarmRadarMapper.selectArdAlarmRadarById(condition.getId());
			if (StringUtils.isNotNull(ardAlarmRadar)) {
			String name = ardAlarmRadar.getName();
			String alarmType = ardAlarmRadar.getAlarmType();
			String alarmTime = fmt.format(ardAlarmRadar.getAlarmTime());
			ardAlarmRadarMapper.updateViewTimeByCondition(name, alarmType, alarmTime, DateUtils.getTime());
			return ardAlarmRadar;
			ArdAlarmRadarPump ardAlarmRadarPump = ardAlarmRadarPumpMapper.selectArdAlarmRadarPumpById(condition.getId());
			if (StringUtils.isNotNull(ardAlarmRadarPump)) {
			String name = ardAlarmRadarPump.getName();
			String alarmTime = fmt.format(ardAlarmRadarPump.getAlarmTime());
			ardAlarmRadarPumpMapper.updateViewTimeByCondition(name, alarmTime, DateUtils.getTime());
			return ardAlarmRadarPump;
			}
			case 1005:
			ArdAlarmExternal ardAlarmExternal = ardAlarmExternalMapper.selectArdAlarmExternalById(condition.getId());
			@@ -419,6 +938,22 @@
			ardAlarmApponekeyMapper.updateViewTimeByUserId(userId, alarmTime, DateUtils.getTime());
			return ardAlarmApponekey;
			}
			case 1010:
			ArdAlarmWall ardAlarmWall = ardAlarmWallMapper.selectArdAlarmWallById(condition.getId());
			if (StringUtils.isNotNull(ardAlarmWall)) {
			String userId = ardAlarmWall.getUserId();
			String alarmTime = fmtms.format(ardAlarmWall.getAlarmTime());
			ardAlarmWallMapper.updateViewTimeByUserId(userId, alarmTime, DateUtils.getTime());
			return ardAlarmWall;
			}
			case 1012:
			ArdAlarmDigitization3 ardAlarmDigitization3 = ardAlarmDigitization3Mapper.selectArdAlarmDigitization3ById(condition.getId());
			if (StringUtils.isNotNull(ardAlarmDigitization3)) {
			String wellNo = ardAlarmDigitization3.getWellNo();
			String alarmTime = fmtms.format(ardAlarmDigitization3.getAlarmTime());
			ardAlarmDigitization3Mapper.updateViewTimeByWellNo(wellNo, alarmTime, DateUtils.getTime());
			return ardAlarmDigitization3;
			}
			case 1014:
			ArdAlarmTube ardAlarmTube = ardAlarmTubeMapper.selectArdAlarmTubeById(condition.getId());
			if (StringUtils.isNotNull(ardAlarmTube)) {
			@@ -427,12 +962,19 @@
			ardAlarmTubeMapper.updateViewTimeByTubeId(tubeId, alarmTime, DateUtils.getTime());
			return ardAlarmTube;
			}
			case 1015:
			ArdAlarmSuperBrain ardAlarmSuperBrain = ardAlarmSuperBrainMapper.selectArdAlarmSuperBrainById(condition.getId());
			if (StringUtils.isNotNull(ardAlarmSuperBrain)) {
			String alarmType = ardAlarmSuperBrain.getAlarmType();
			String alarmTime = fmt.format(ardAlarmSuperBrain.getAlarmTime());
			ardAlarmSuperBrainMapper.updateViewTimeByAlarmType(alarmType, alarmTime, DateUtils.getTime());
			return ardAlarmSuperBrain;
			}
			default:
			return null;
			}
			}

			private Map<String,Integer> guideCountMap=new HashMap<>();
			/**
			* @描述异步处理接收的报警
			* @参数 [topic, message]
			@@ -490,9 +1032,17 @@
			return;
			}
			double[] coordinate = new double[]{longitude, latitude};
			String nearbyCameraId = getNearbyCamera(new double[]{ardAlarmTube.getLongitude(), ardAlarmTube.getLatitude()});
			if (StringUtils.isNotEmpty(nearbyCameraId)) {
			messagesEnqueued(nearbyCameraId, ardAlarmTube.getId(), "sys_tube_leak", ardAlarmTube.getCreateTime(), 1, 1, coordinate);
			String cameraId = getCameraByNear(new double[]{ardAlarmTube.getLongitude(), ardAlarmTube.getLatitude()});
			if (StringUtils.isNotEmpty(cameraId)) {
			GuideDataDto guideDataDto = new GuideDataDto()
			.setAlarmId(cameraId)
			.setAlarmId(ardAlarmTube.getId())
			.setAlarmType("sys_tube_leak")
			.setReceiveTime(ardAlarmTube.getCreateTime())
			.setNum(1)
			.setRecordSn(1)
			.setTargetPosition(coordinate);
			messagesEnqueued(guideDataDto);
			}
			//endregion
			}
			@@ -502,6 +1052,7 @@
			//region 处理通用光电报警
			ArdAlarmCamera ardAlarmCamera = JSONObject.parseObject(message, ArdAlarmCamera.class);
			ardAlarmCamera.setId(IdUtils.simpleUUID());
			ardAlarmCamera.setCreateTime(new Date());
			int aac = ardAlarmCameraMapper.insertArdAlarmCamera(ardAlarmCamera);
			if (aac > 0) {
			log.debug("camera入库成功：" + ardAlarmCamera);
			@@ -510,117 +1061,186 @@
			break;
			case "radar":
			//region 处理雷达报警
			// 开始时间
			long stime = System.currentTimeMillis();
			String mergeTime = ConfigUtils.getConfigValue("radarMergeTime");
			Integer radarMergeTime = mergeTime == null \|\| "".equals(mergeTime) ? 10 : Integer.valueOf(mergeTime);
			RadarAlarmData radarAlarmData = JSONObject.parseObject(message, RadarAlarmData.class);
			List<ArdAlarmRadar> ardAlarmRadars = radarAlarmData.getArdAlarmRadars();
			for (ArdAlarmRadar ardAlarmRadar : ardAlarmRadars) {
			String uuid = IdUtils.simpleUUID();
			ardAlarmRadar.setId(uuid);//报警ID
			ardAlarmRadar.setAlarmTime(radarAlarmData.getAlarmTime());//报警时间
			String radarId = radarAlarmData.getRadarId();
			String alarmpointName = ardAlarmRadar.getName();//兴趣点名称
			ardAlarmRadar.setName(ardAlarmRadar.getName() + "(" + radarAlarmData.getRadarName() + ")");//报警点名称
			ardAlarmRadar.setCreateTime(new Date());//接收时间

			String alarmType = "";
			ArdAlarmpointsWell well = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
			if (well == null) {
			return;
			}
			Double guideP = well.getGuideP();
			Double guideT = well.getGuideT();
			Double guideZ = well.getGuideZ();
			Double longitude = well.getLongitude();
			Double latitude = well.getLatitude();
			String targetId = ardAlarmRadar.getTargetId();
			GuidePTZ guidePTZ = new GuidePTZ();
			switch (ardAlarmRadar.getAlarmType()) {
			case "运动目标检测":
			alarmType = "sys_radar_move";
			ArdAlarmRadarMove ardAlarmRadarMove = new ArdAlarmRadarMove();
			ardAlarmRadarMove.setId(uuid);
			ardAlarmRadarMove.setTargetId(targetId);
			ardAlarmRadarMove.setAlarmTime(radarAlarmData.getAlarmTime());
			ardAlarmRadarMove.setCreateTime(new Date());
			ardAlarmRadarMove.setName(alarmpointName + "(" + radarAlarmData.getRadarName() + ")");
			ardAlarmRadarMove.setAlarmType("运动目标检测");
			ardAlarmRadarMove.setLongitude(longitude);
			ardAlarmRadarMove.setLatitude(latitude);
			ardAlarmRadarMove.setUpdateTime(radarAlarmData.getAlarmTime());
			ardAlarmRadarMove.setRadarId(radarId);

			guidePTZ.setP(guideP);
			guidePTZ.setT(guideT);
			guidePTZ.setZ(guideZ);
			ardAlarmRadarMove.setGuidePTZ(guidePTZ);
			Date alarmTime = ardAlarmRadarMove.getAlarmTime();
			//获取当前兴趣点当前雷达的上一条数据
			ArdAlarmRadarMove lastMoveData = ardAlarmRadarMoveMapper.selectArdAlarmRadarLastData(ardAlarmRadarMove.getName());
			if (lastMoveData == null) {
			//入库
			ardAlarmRadarMove.setGuideTime(alarmTime);
			ardAlarmRadarMoveMapper.insertArdAlarmRadarMove(ardAlarmRadarMove);
			radarMoveGuide(ardAlarmRadarMove);//引导
			} else {
			//否则比对更新时间
			Date lastUpdateTime = lastMoveData.getUpdateTime();
			Date lastGuideTime = lastMoveData.getGuideTime();
			long secDatePoor = DateUtils.getSecDatePoor(alarmTime, lastUpdateTime);
			if (secDatePoor <= radarMergeTime) {
			//小于10秒的新数据，更新上一条
			ArdAlarmRadarMove updateData = new ArdAlarmRadarMove();
			updateData.setId(lastMoveData.getId());
			updateData.setUpdateTime(alarmTime);

			//判断引导时间超过5分钟再次引导
			long secDatePoorGuide = DateUtils.getSecDatePoor(alarmTime, lastGuideTime);
			if (secDatePoorGuide >= 300) {
			updateData.setGuideTime(alarmTime);
			radarMoveGuide(ardAlarmRadarMove);//引导
			}
			ardAlarmRadarMoveMapper.updateArdAlarmRadarMove(updateData);
			} else {
			//超过10秒的数据,入库
			ardAlarmRadarMove.setGuideTime(alarmTime);
			ardAlarmRadarMoveMapper.insertArdAlarmRadarMove(ardAlarmRadarMove);
			radarMoveGuide(ardAlarmRadarMove);//引导
			}
			}
			//入缓存
			//String key = "radar_alarm:" + DateUtils.getDate();
			//if (redisCache.hasKey(key)) {
			// redisCache.setCacheList(key, ardAlarmRadarMove, -1, TimeUnit.HOURS);
			//} else {
			// Integer expiryTimeInSeconds = DateUtils.getDayRemainingTime(ardAlarmRadarMove.getCreateTime());
			// redisCache.setCacheList(key, ardAlarmRadarMove, expiryTimeInSeconds, TimeUnit.SECONDS);
			//}
			break;
			case "热源检测":
			alarmType = "sys_radar_fire";
			ArdAlarmRadarFire ardAlarmRadarFire = new ArdAlarmRadarFire();
			ardAlarmRadarFire.setId(uuid);
			ardAlarmRadarFire.setTargetId(targetId);
			ardAlarmRadarFire.setAlarmTime(radarAlarmData.getAlarmTime());
			ardAlarmRadarFire.setCreateTime(new Date());
			ardAlarmRadarFire.setName(alarmpointName + "(" + radarAlarmData.getRadarName() + ")");
			ardAlarmRadarFire.setAlarmType("热源检测");
			ardAlarmRadarFire.setLongitude(longitude);
			ardAlarmRadarFire.setLatitude(latitude);
			guidePTZ.setP(guideP);
			guidePTZ.setT(guideT);
			guidePTZ.setZ(guideZ);
			ardAlarmRadarFire.setGuidePTZ(guidePTZ);
			ardAlarmRadarFire.setRadarId(radarId);
			ardAlarmRadarFire.setUpdateTime(radarAlarmData.getAlarmTime());
			//
			ArdAlarmRadarFire lastFireData = ardAlarmRadarFireMapper.selectArdAlarmRadarLastData(ardAlarmRadarFire.getName());
			alarmTime = ardAlarmRadarFire.getAlarmTime();
			if (lastFireData == null) {
			//入库
			ardAlarmRadarFire.setGuideTime(alarmTime);
			ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
			radarFireGuide(ardAlarmRadarFire);//引导
			} else {
			//否则比对更新时间
			Date lastUpdateTime = lastFireData.getUpdateTime();
			Date lastGuideTime = lastFireData.getGuideTime();
			long secDatePoor = DateUtils.getSecDatePoor(alarmTime, lastUpdateTime);
			if (secDatePoor <= radarMergeTime) {
			//小于10秒的新数据，更新上一条
			ArdAlarmRadarFire updateData = new ArdAlarmRadarFire();
			updateData.setId(lastFireData.getId());
			updateData.setUpdateTime(alarmTime);

			//判断引导时间超过5分钟再次引导
			long secDatePoorGuide = DateUtils.getSecDatePoor(alarmTime, lastGuideTime);
			if (secDatePoorGuide >= 300) {
			updateData.setGuideTime(alarmTime);
			radarFireGuide(ardAlarmRadarFire);//引导
			}
			ardAlarmRadarFireMapper.updateArdAlarmRadarFire(updateData);
			} else {
			//超过10秒的数据,入库
			ardAlarmRadarFire.setGuideTime(alarmTime);
			ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
			radarFireGuide(ardAlarmRadarFire);//引导
			}
			}
			break;
			case "雷达抽油机停机":
			alarmType = "sys_radar_pumpshutdown";
			ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
			if (StringUtils.isNotNull(ardAlarmpointsWell)) {
			ardAlarmRadar.setLongitude(ardAlarmpointsWell.getLongitude());
			ardAlarmRadar.setLatitude(ardAlarmpointsWell.getLatitude());
			ArdAlarmRadarPump ardAlarmRadarPump = new ArdAlarmRadarPump();
			ardAlarmRadarPump.setRadarId(radarId);
			ardAlarmRadarPump.setId(uuid);
			ardAlarmRadarPump.setTargetId(targetId);
			ardAlarmRadarPump.setAlarmTime(radarAlarmData.getAlarmTime());
			ardAlarmRadarPump.setCreateTime(new Date());
			ardAlarmRadarPump.setName(ardAlarmRadar.getName() + "(" + radarAlarmData.getRadarName() + ")");
			ardAlarmRadarPump.setAlarmType("雷达抽油机停机");
			ardAlarmRadarPump.setUpdateTime(radarAlarmData.getAlarmTime());
			alarmTime = ardAlarmRadarPump.getAlarmTime();
			ardAlarmRadarPump.setLongitude(well.getLongitude());
			ardAlarmRadarPump.setLatitude(well.getLatitude());
			guidePTZ.setP(guideP);
			guidePTZ.setT(guideT);
			guidePTZ.setZ(guideZ);
			ardAlarmRadarPump.setGuidePTZ(guidePTZ);
			//
			ArdAlarmRadarPump lastPumpData = ardAlarmRadarPumpMapper.selectArdAlarmRadarLastData(ardAlarmRadarPump.getName());
			if (lastPumpData == null) {
			//入库
			ardAlarmRadarPump.setGuideTime(alarmTime);
			ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
			radarPumpGuide(ardAlarmRadarPump);//引导
			} else {
			//否则比对更新时间
			Date lastUpdateTime = lastPumpData.getUpdateTime();
			Date lastGuideTime = lastPumpData.getGuideTime();
			long secDatePoor = DateUtils.getSecDatePoor(alarmTime, lastUpdateTime);
			if (secDatePoor <= radarMergeTime) {
			//小于10秒的新数据，更新上一条
			ArdAlarmRadarPump updateData = new ArdAlarmRadarPump();
			updateData.setId(lastPumpData.getId());
			updateData.setUpdateTime(alarmTime);
			//判断引导时间超过5分钟再次引导
			long secDatePoorGuide = DateUtils.getSecDatePoor(alarmTime, lastGuideTime);
			if (secDatePoorGuide >= 300) {
			radarPumpGuide(ardAlarmRadarPump);//引导
			updateData.setGuideTime(alarmTime);
			}
			ardAlarmRadarPumpMapper.updateArdAlarmRadarPump(updateData);
			} else {
			//超过10秒的数据,入库
			ardAlarmRadarPump.setGuideTime(alarmTime);
			ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
			radarPumpGuide(ardAlarmRadarPump);//引导
			}
			}
			break;
			}
			if (StringUtils.isNull(ardAlarmRadar.getLongitude()) \|\| StringUtils.isNull(ardAlarmRadar.getLatitude())) {
			continue;
			}
			double[] coordinate = new double[]{ardAlarmRadar.getLongitude(), ardAlarmRadar.getLatitude()};//报警坐标

			//判断当前报警点5分钟内是否已引导
			ardAlarmRadar.setGuideFlag(1);
			// ArdAlarmRadar AlarmRadar = ardAlarmRadarMapper.getArdAlarmRadarWithGuide(ardAlarmRadar);
			ArdAlarmRadar AlarmRadar = redisCache.getCacheObject("global_alarm:"+ardAlarmRadar.getName());//从redis中取出最新引导的报警数据
			if (AlarmRadar==null) {
			//5分钟内未引导直接入库
			ardAlarmRadarMapper.insertArdAlarmRadar(ardAlarmRadar);
			redisCache.setCacheObject("global_alarm:"+ardAlarmRadar.getName(),ardAlarmRadar,5, TimeUnit.MINUTES);//引导数据写入redis
			guideCountMap.put(ardAlarmRadar.getName(),0);
			//获取雷达所在塔上的大光电
			String cameraIdWithTower = ardAlarmRadarMapper.getCameraByRadar(radarAlarmData.getRadarId());
			if (StringUtils.isNotNull(cameraIdWithTower) && StringUtils.isNotEmpty(cameraIdWithTower)) {
			log.info("获取到雷达塔上的光电:" + cameraIdWithTower);
			//如果雷达塔上有光电
			messagesEnqueued(cameraIdWithTower, uuid, alarmType, ardAlarmRadar.getCreateTime(), 1, 1, coordinate);
			}
			//获取报警点关联的大光电
			ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
			if (StringUtils.isNotNull(ardAlarmpointsWell) && StringUtils.isNotEmpty(ardAlarmpointsWell.getCameraId())) {
			String cameraId = ardAlarmpointsWell.getCameraId();
			if (cameraId.equals(cameraIdWithTower)) {
			return;
			}
			log.info("获取到报警点关联的光电:" + cameraId);
			//如果报警点关联了光电
			messagesEnqueued(cameraId, uuid, alarmType, ardAlarmRadar.getCreateTime(), 1, 2, coordinate);
			}
			} else {
			//获取当前报警点的未引导次数
			Integer count = guideCountMap.get(ardAlarmRadar.getName());
			if(count!=null)
			{
			if(count>2)
			{
			ardAlarmRadar.setGuideFlag(1);
			redisCache.setCacheObject("global_alarm:"+ardAlarmRadar.getName(),ardAlarmRadar,5, TimeUnit.MINUTES);//引导数据写入redis
			count=0;

			//获取雷达所在塔上的大光电
			String cameraIdWithTower = ardAlarmRadarMapper.getCameraByRadar(radarAlarmData.getRadarId());
			if (StringUtils.isNotNull(cameraIdWithTower) && StringUtils.isNotEmpty(cameraIdWithTower)) {
			log.info("获取到雷达塔上的光电:" + cameraIdWithTower);
			//如果雷达塔上有光电
			messagesEnqueued(cameraIdWithTower, uuid, alarmType, ardAlarmRadar.getCreateTime(), count, 1, coordinate);
			}
			//获取报警点关联的大光电
			ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
			if (StringUtils.isNotNull(ardAlarmpointsWell) && StringUtils.isNotEmpty(ardAlarmpointsWell.getCameraId())) {
			String cameraId = ardAlarmpointsWell.getCameraId();
			if (cameraId.equals(cameraIdWithTower)) {
			return;
			}
			log.info("获取到报警点关联的光电:" + cameraId);
			//如果报警点关联了光电
			messagesEnqueued(cameraId, uuid, alarmType, ardAlarmRadar.getCreateTime(), count, 2, coordinate);
			}
			}
			else
			{
			ardAlarmRadar.setGuideFlag(0);
			count++;
			}
			}
			else
			{
			ardAlarmRadar.setGuideFlag(0);
			count=0;
			}
			guideCountMap.put(ardAlarmRadar.getName(),count);
			ardAlarmRadarMapper.insertArdAlarmRadar(ardAlarmRadar);
			}
			// 结束时间
			long etime = System.currentTimeMillis();
			// 计算执行时间
			log.info("雷达报警处理时长："+(etime-stime)+"毫秒");
			}

			//endregion
			break;
			case "external":
			@@ -630,10 +1250,10 @@
			ardAlarmExternal.setCreateTime(new Date());//接收时间
			//外联防区名称就是兴趣点，查兴趣点坐标
			String defenseName = ardAlarmExternal.getDefenseName();
			ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(defenseName);
			if (StringUtils.isNotNull(ardAlarmpointsWell)) {
			ardAlarmExternal.setLongitude(ardAlarmpointsWell.getLongitude());
			ardAlarmExternal.setLatitude(ardAlarmpointsWell.getLatitude());
			ArdAlarmpointsWell well = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(defenseName);
			if (StringUtils.isNotNull(well)) {
			ardAlarmExternal.setLongitude(well.getLongitude());
			ardAlarmExternal.setLatitude(well.getLatitude());
			}
			int aae = ardAlarmExternalMapper.insertArdAlarmExternal(ardAlarmExternal);
			if (aae > 0) {
			@@ -642,10 +1262,23 @@
			if (StringUtils.isNull(ardAlarmExternal.getLongitude()) \|\| StringUtils.isNull(ardAlarmExternal.getLatitude())) {
			return;
			}
			double[] guideCoordinate = new double[]{ardAlarmExternal.getLongitude(), ardAlarmExternal.getLatitude()};//引导坐标
			String nearbyCameraId = getNearbyCamera(guideCoordinate);//最近相机ID
			if (StringUtils.isNotEmpty(nearbyCameraId)) {
			messagesEnqueued(nearbyCameraId, ardAlarmExternal.getId(), "sys_external", ardAlarmExternal.getCreateTime(), 1, 1, guideCoordinate);
			double[] coordinate = new double[]{ardAlarmExternal.getLongitude(), ardAlarmExternal.getLatitude()};//引导坐标
			GuidePTZ guidePTZ = new GuidePTZ()
			.setP(well.getGuideP())
			.setT(well.getGuideT())
			.setZ(well.getGuideZ());
			String cameraId = getCameraByNear(coordinate);//最近相机ID
			if (StringUtils.isNotEmpty(cameraId)) {
			GuideDataDto guideDataDto = new GuideDataDto()
			.setAlarmId(cameraId)
			.setAlarmId(ardAlarmExternal.getId())
			.setAlarmType("sys_external")
			.setReceiveTime(ardAlarmExternal.getCreateTime())
			.setNum(1)
			.setRecordSn(1)
			.setTargetPosition(coordinate)
			.setGuidePTZ(guidePTZ);
			messagesEnqueued(guideDataDto);
			}
			//endregion
			}
			@@ -673,10 +1306,18 @@
			if (StringUtils.isNull(ardAlarmAccess.getLongitude()) \|\| StringUtils.isNull(ardAlarmAccess.getLatitude())) {
			return;
			}
			double[] guideCoordinate = new double[]{ardAlarmAccess.getLongitude(), ardAlarmAccess.getLatitude()};//引导坐标
			String nearbyCameraId = getNearbyCamera(guideCoordinate);//最近相机ID
			if (StringUtils.isNotEmpty(nearbyCameraId)) {
			messagesEnqueued(nearbyCameraId, ardAlarmAccess.getId(), "sys_access_control", ardAlarmAccess.getCreateTime(), 1, 1, guideCoordinate);
			double[] coordinate = new double[]{ardAlarmAccess.getLongitude(), ardAlarmAccess.getLatitude()};//引导坐标
			String cameraId = getCameraByNear(coordinate);//最近相机ID
			if (StringUtils.isNotEmpty(cameraId)) {
			GuideDataDto guideDataDto = new GuideDataDto()
			.setAlarmId(cameraId)
			.setAlarmId(ardAlarmAccess.getId())
			.setAlarmType("sys_external")
			.setReceiveTime(ardAlarmAccess.getCreateTime())
			.setNum(1)
			.setRecordSn(1)
			.setTargetPosition(coordinate);
			messagesEnqueued(guideDataDto);
			}
			//endregion
			}
			@@ -688,6 +1329,34 @@
			int aaak = ardAlarmApponekeyMapper.insertArdAlarmApponekey(ardAlarmApponekey);
			if (aaak > 0) {
			log.debug("apponekey入库成功：" + ardAlarmApponekey);
			}
			//endregion
			break;
			case "digitization3":
			//region 三厂数字化报警
			ArdAlarmDigitization3 ardAlarmDigitization3 = JSONObject.parseObject(message, ArdAlarmDigitization3.class);
			//获取经纬度
			ArdAlarmpointsWell Well = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(ardAlarmDigitization3.getWellNo());
			if (Well != null) {
			ardAlarmDigitization3.setLongitude(Well.getLongitude());
			ardAlarmDigitization3.setLatitude(Well.getLatitude());
			ardAlarmDigitization3.setAltitude(Well.getAltitude());
			}
			ardAlarmDigitization3.setCreateTime(new Date());
			int aad = ardAlarmDigitization3Mapper.insertArdAlarmDigitization3(ardAlarmDigitization3);
			if (aad > 0) {
			log.debug("digitization3入库成功：" + ardAlarmDigitization3);
			}
			//endregion
			break;
			case "superBrain":
			//region 超脑报警
			ArdAlarmSuperBrain ardAlarmSuperBrain = JSONObject.parseObject(message, ArdAlarmSuperBrain.class);
			ardAlarmSuperBrain.setId(IdUtils.simpleUUID());
			ardAlarmSuperBrain.setCreateTime(new Date());
			int sbRes = ardAlarmSuperBrainMapper.insertArdAlarmSuperBrain(ardAlarmSuperBrain);
			if (sbRes > 0) {
			log.debug("superBrain入库成功：" + ardAlarmSuperBrain);
			}
			//endregion
			break;
			@@ -707,36 +1376,56 @@
			* recordSn 录像存储位置 1-recordUrl1 2-recordUrl2
			* targetPosition 报警点位置坐标
			*/
			private void messagesEnqueued(String cameraId, String alarmId, String alarmType, Date receiveTime, Integer num, Integer recordSn, double[] targetPosition) {
			private void messagesEnqueued(GuideDataDto guideDataDto) {
			try {
			String cameraId = guideDataDto.getCameraId();
			String alarmType = guideDataDto.getAlarmType();
			if (!IsEnableGuide(cameraId)) {
			log.info("相机:" + cameraId + "未开启报警引导功能");
			return;
			}

			SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
			GuideTask guideTask = new GuideTask();
			//相机ID
			guideTask.setCameraId(cameraId);
			//报警类型
			switch (alarmType) {
			case "运动目标检测":
			alarmType = "sys_radar_move";
			break;
			case "热源检测":
			alarmType = "sys_radar_fire";
			break;
			case "雷达抽油机停机":
			alarmType = "sys_radar_pump";
			break;
			}
			guideTask.setAlarmType(alarmType);
			//通道(通过日夜时间研判)
			String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
			Integer channel = ArdTool.getChannelBydayNightTime(dayNightTime);
			guideTask.setChanNum(channel);
			//报警ID
			guideTask.setAlarmId(alarmId);
			guideTask.setAlarmId(guideDataDto.getAlarmId());
			//接收时间
			guideTask.setReceiveTime(fmt.format(receiveTime));
			guideTask.setReceiveTime(fmt.format(guideDataDto.getReceiveTime()));
			//报警优先级(通过优先级字典)
			Integer priority = CamPriority.priorityMap.get(alarmType);
			guideTask.setPriority(priority);
			String priority = DictUtils.getDictValue("cameras_priority", alarmType);
			if (StringUtils.isEmpty(priority)) {
			log.debug("未匹配到优先级,请检查优先级字典配置");
			return;
			}
			guideTask.setPriority(Integer.valueOf(priority));
			//报警次数
			guideTask.setNum(num);
			guideTask.setNum(guideDataDto.getNum());
			//录像存储位置
			guideTask.setRecordSn(recordSn);
			guideTask.setRecordSn(guideDataDto.getRecordSn());
			//目标经纬度
			guideTask.setTargetPosition(targetPosition);
			guideTask.setTargetPosition(guideDataDto.getTargetPosition());
			//目标PTZ
			if (guideDataDto.getGuidePTZ() != null) {
			guideTask.setGuidePTZ(guideDataDto.getGuidePTZ());
			}
			//消息入队
			queueManager.addTaskToQueue(cameraId, guideTask);
			//打印队列
			@@ -754,7 +1443,7 @@
			private Boolean IsEnableGuide(String cameraId) {
			boolean enabled = false;
			ArdCameras ardCameras = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
			if(ardCameras!=null) {
			if (ardCameras != null) {
			if (ardCameras.getCamAlarmGuideEnable().equals(1)) {
			enabled = true;
			}
			@@ -765,68 +1454,139 @@
			/**
			* 获取附近开启报警引导功能光电
			*/
			private String getNearbyCamera(double[] targetPosition) {
			private String getCameraByNear(double[] targetPosition) {
			String minDistanceCameraId = "";
			//获取所有大光电
			List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(new ArdCameras("1"));
			//统计所有大光电可视范围内与报警点的距离
			Map<String, Double> distanceMap = new HashMap<>();
			Map<String, Integer> guideMap = new HashMap<>();
			for (ArdCameras camera : ardCamerasList) {
			double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
			double distance = GisTool.getDistance(targetPosition, camPosition);
			if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {
			distanceMap.put(camera.getId(), distance);
			if (StringUtils.isNull(camera.getCamAlarmGuideEnable())) {
			camera.setCamAlarmGuideEnable(0);
			try {
			//获取所有大光电
			List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(new ArdCameras("1"));
			//统计所有大光电可视范围内与报警点的距离
			Map<String, Double> distanceMap = new HashMap<>();
			Map<String, Integer> guideMap = new HashMap<>();
			for (ArdCameras camera : ardCamerasList) {
			if (camera.getCamMaxVisibleDistance() == null) {
			continue;
			}
			guideMap.put(camera.getId(), camera.getCamAlarmGuideEnable());
			double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
			double distance = GisUtil.getDistance(targetPosition, camPosition);
			if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {
			distanceMap.put(camera.getId(), distance);
			if (StringUtils.isNull(camera.getCamAlarmGuideEnable())) {
			camera.setCamAlarmGuideEnable(0);
			}
			guideMap.put(camera.getId(), camera.getCamAlarmGuideEnable());
			}
			}
			}
			if (distanceMap.size() > 0) {
			log.debug("尝试查找最近光电");
			//获取距离字典中最近的一个相机ID
			minDistanceCameraId = ArdTool.getKeyByMinValue(distanceMap);
			log.debug("查找到最近光电:" + minDistanceCameraId);
			if (guideMap.get(minDistanceCameraId).equals(0)) {
			log.debug("该光电未开启报警引导");
			return " ";
			if (distanceMap.size() > 0) {
			log.debug("尝试查找最近光电");
			//获取距离字典中最近的一个相机ID
			minDistanceCameraId = ArdTool.getKeyByMinValue(distanceMap);
			log.debug("查找到最近光电:" + minDistanceCameraId);
			if (guideMap.get(minDistanceCameraId).equals(0)) {
			log.debug("该光电未开启报警引导");
			return " ";
			}
			}
			} catch (Exception ex) {
			log.error("获取附近开启报警引导功能光电异常:" + ex.getMessage());
			}
			return minDistanceCameraId;
			}

			public static void main(String[] args) {
			Comparator<Obj> PriorityDescCom = Comparator.comparingInt(Obj::getPriority).reversed();
			Comparator<Obj> NumDescCom = Comparator.comparingInt(Obj::getNum).reversed();
			Comparator<Obj> receiveTimeAscCom = Comparator.comparing(Obj::getAlarmTime);
			Comparator<Obj> comparator = PriorityDescCom.thenComparing(NumDescCom).thenComparing(receiveTimeAscCom);

			PriorityBlockingQueue<Obj> priorityQueue = new PriorityBlockingQueue<>(1000, comparator);

			priorityQueue.add(new Obj(999, 1, "2023-07-01 16:00:01"));
			priorityQueue.add(new Obj(999, 2, "2023-07-01 16:00:01"));
			priorityQueue.add(new Obj(999, 3, "2023-07-01 16:00:01"));

			List<Obj> elements = new ArrayList<>(priorityQueue);
			elements.sort(priorityQueue.comparator()); // 使用队列的比较器进行排序
			for (Obj task : elements) {
			log.info("正在排队【priority】" + task.getPriority() + "【num】" + task.getNum() + "【alarmTime】" + task.getAlarmTime());
			//获取相机引导入队
			private void getCameraGuideToQueue(GuideDataDto guideDataDto) {
			int index = guideDataDto.getName().indexOf("(");
			String alarmpointName = guideDataDto.getName().substring(0, index);
			//获取雷达所在塔上的大光电
			ArdCameras cameraWithTower = ardEquipRadarMapper.getCameraByRadar(guideDataDto.getRadarId());
			if (StringUtils.isNotNull(cameraWithTower)) {
			log.debug("获取到雷达塔上的光电:" + cameraWithTower.getId());
			//如果雷达塔上有光电
			guideDataDto.setCameraId(cameraWithTower.getId());
			messagesEnqueued(guideDataDto);
			} else {
			log.debug("未获取到雷达塔上的光电,无法引导");
			}
			log.info("===================================================================");
			priorityQueue.add(new Obj(999, 5, "2023-07-01 16:00:01"));
			PriorityBlockingQueue queue = new PriorityBlockingQueue<>(priorityQueue);
			while (queue.size() > 0) {
			Obj task = (Obj) queue.poll();
			log.info("正在排队【priority】" + task.getPriority() + "【num】" + task.getNum() + "【alarmTime】" + task.getAlarmTime());
			//获取报警点关联的大光电
			ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
			if (StringUtils.isNotNull(ardAlarmpointsWell) && StringUtils.isNotEmpty(ardAlarmpointsWell.getCameraId())) {
			String cameraId = ardAlarmpointsWell.getCameraId();
			if (cameraId.equals(cameraWithTower.getId())) {
			return;
			}
			log.debug("获取到报警点关联的光电:" + cameraId);
			//如果报警点关联了光电
			guideDataDto.setCameraId(cameraId);
			guideDataDto.setRecordSn(2);//兴趣点光电引导录像存储第二个路径
			messagesEnqueued(guideDataDto);
			} else {
			log.debug("未获取到报警点关联的光电,无法引导");
			}
			}

			@Data
			@AllArgsConstructor
			static class Obj {
			Integer priority;
			Integer num;
			String alarmTime;
			//雷达移动引导
			private void radarMoveGuide(ArdAlarmRadarMove ardAlarmRadarMove) {
			log.debug("雷达移动开始引导");
			if (StringUtils.isNull(ardAlarmRadarMove.getLongitude()) \|\| StringUtils.isNull(ardAlarmRadarMove.getLatitude())) {
			log.debug("坐标为空不引导");
			return;
			}
			double[] coordinate = new double[]{ardAlarmRadarMove.getLongitude(), ardAlarmRadarMove.getLatitude()};//报警坐标
			//引导入队
			GuideDataDto guideDataDto = new GuideDataDto()
			.setRadarId( ardAlarmRadarMove.getRadarId())
			.setName(ardAlarmRadarMove.getName())
			.setAlarmId(ardAlarmRadarMove.getId())
			.setAlarmType(ardAlarmRadarMove.getAlarmType())
			.setReceiveTime(ardAlarmRadarMove.getCreateTime())
			.setNum(1)
			.setRecordSn(1)
			.setTargetPosition(coordinate)
			.setGuidePTZ(ardAlarmRadarMove.getGuidePTZ());
			getCameraGuideToQueue(guideDataDto);//获取相机入队
			}

			//雷达防火引导
			private void radarFireGuide(ArdAlarmRadarFire ardAlarmRadarFire) {
			log.debug("雷达防火开始引导");
			if (StringUtils.isNull(ardAlarmRadarFire.getLongitude()) \|\| StringUtils.isNull(ardAlarmRadarFire.getLatitude())) {
			log.debug("坐标为空不引导");
			return;
			}
			double[] coordinate = new double[]{ardAlarmRadarFire.getLongitude(), ardAlarmRadarFire.getLatitude()};//报警坐标
			//引导入队
			GuideDataDto guideDataDto = new GuideDataDto()
			.setRadarId( ardAlarmRadarFire.getRadarId())
			.setName(ardAlarmRadarFire.getName())
			.setAlarmId(ardAlarmRadarFire.getId())
			.setAlarmType(ardAlarmRadarFire.getAlarmType())
			.setReceiveTime(ardAlarmRadarFire.getCreateTime())
			.setNum(1)
			.setRecordSn(1)
			.setTargetPosition(coordinate)
			.setGuidePTZ(ardAlarmRadarFire.getGuidePTZ());
			getCameraGuideToQueue(guideDataDto);//获取相机入队
			}

			//雷达抽油机停机引导
			private void radarPumpGuide(ArdAlarmRadarPump ardAlarmRadarPump) {
			log.debug("雷达抽油机停机开始引导");
			if (StringUtils.isNull(ardAlarmRadarPump.getLongitude()) \|\| StringUtils.isNull(ardAlarmRadarPump.getLatitude())) {
			//坐标为空不引导
			log.debug("坐标为空不引导");
			return;
			}
			double[] coordinate = new double[]{ardAlarmRadarPump.getLongitude(), ardAlarmRadarPump.getLatitude()};//报警坐标
			//引导入队
			GuideDataDto guideDataDto = new GuideDataDto()
			.setRadarId( ardAlarmRadarPump.getRadarId())
			.setName(ardAlarmRadarPump.getName())
			.setAlarmId(ardAlarmRadarPump.getId())
			.setAlarmType(ardAlarmRadarPump.getAlarmType())
			.setReceiveTime(ardAlarmRadarPump.getCreateTime())
			.setNum(1)
			.setRecordSn(1)
			.setTargetPosition(coordinate)
			.setGuidePTZ(ardAlarmRadarPump.getGuidePTZ());
			getCameraGuideToQueue(guideDataDto);//获取相机入队
			}
			}