Merge remote-tracking branch 'origin/master'

aijinhui

2023-09-21 700e079156d633305b5e03c3a4e54b78a49add51

 ard-work/src/main/java/com/ruoyi/alarm/global/service/impl/GlobalAlarmServiceImpl.java

@@ -7,6 +7,8 @@
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;
@@ -16,7 +18,6 @@
import com.ruoyi.alarm.global.service.IGlobalAlarmService;
import com.ruoyi.alarm.radar.domain.*;
import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarFireMapper;
import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarMapper;
import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarMoveMapper;
import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarPumpMapper;
import com.ruoyi.alarm.steal.domain.ArdAlarmStealelec;
@@ -32,7 +33,9 @@
import com.ruoyi.alarmpoints.well.domain.ArdAlarmpointsWell;
import com.ruoyi.alarmpoints.well.mapper.ArdAlarmpointsWellMapper;
import com.ruoyi.common.constant.CacheConstants;
import com.ruoyi.common.core.domain.entity.SysConfig;
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;
@@ -69,6 +72,8 @@
@Slf4j(topic = "mqtt")
public class GlobalAlarmServiceImpl implements IGlobalAlarmService {
    //region 依赖注入
    @Resource
    private ArdAlarmDigitization3Mapper ardAlarmDigitization3Mapper;
    @Resource
    private ArdAlarmWallMapper ardAlarmWallMapper;
    @Resource
@@ -114,6 +119,7 @@
    private Map<String, Integer> unGuideCountMapMove = new HashMap<>();
    private Map<String, Integer> unGuideCountMapFire = new HashMap<>();
    private Map<String, Integer> unGuideCountMapPump = new HashMap<>();

    /**
     * @描述 查询所有报警的当前数量
     * @参数 []
@@ -147,6 +153,8 @@
        countMap.put("1010", count1010);
        int count1014 = ardAlarmTubeMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1014", count1014);
        int count1012 = ardAlarmDigitization3Mapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1012", count1012);
        map.put("20000", countMap);
        return map;
    }
@@ -283,7 +291,198 @@
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmWall.getId())
                                    .setName(ardAlarmWall.getWallName())
                                    .setAlarmTime(ardAlarmWall.getCreateTime())
                                    .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:
                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());
            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())
@@ -329,12 +528,12 @@
                            .setAlarmType("1001");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1001.size()>0) {
        if (alarmData1001.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1001);
        }

        List<ArdAlarmCamera> ardAlarmCameras = ardAlarmCameraMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1002= ardAlarmCameras.stream()
        List<GlobalAlarmData> alarmData1002 = ardAlarmCameras.stream()
                .map(ardAlarmCamera -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmCamera.getId())
@@ -347,12 +546,12 @@
                            .setAlarmType("1002");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1002.size()>0) {
        if (alarmData1002.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1002);
        }

        List<ArdAlarmRadarMove> ardAlarmRadarMoves = ardAlarmRadarMoveMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1003= ardAlarmRadarMoves.stream()
        List<GlobalAlarmData> alarmData1003 = ardAlarmRadarMoves.stream()
                .map(ardAlarmRadarMove -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmRadarMove.getId())
@@ -365,12 +564,12 @@
                            .setAlarmType("1003");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1003.size()>0) {
        if (alarmData1003.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1003);
        }

        List<ArdAlarmRadarFire> ardAlarmRadarFires = ardAlarmRadarFireMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1004=  ardAlarmRadarFires.stream()
        List<GlobalAlarmData> alarmData1004 = ardAlarmRadarFires.stream()
                .map(ardAlarmRadarFire -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmRadarFire.getId())
@@ -383,12 +582,12 @@
                            .setAlarmType("1004");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1004.size()>0) {
        if (alarmData1004.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1004);
        }

        List<ArdAlarmExternal> ardAlarmExternals = ardAlarmExternalMapper.selectListAllByCommand(refreshTime, "防区报警");
        List<GlobalAlarmData> alarmData1005=  ardAlarmExternals.stream()
        List<GlobalAlarmData> alarmData1005 = ardAlarmExternals.stream()
                .map(ardAlarmExternal -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmExternal.getId())
@@ -401,12 +600,12 @@
                            .setAlarmType("1005");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1005.size()>0) {
        if (alarmData1005.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1005);
        }

        List<ArdAlarmAccess> ardAlarmAccesses = ardAlarmAccessMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1006= ardAlarmAccesses.stream()
        List<GlobalAlarmData> alarmData1006 = ardAlarmAccesses.stream()
                .map(ardAlarmAccess -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmAccess.getId())
@@ -419,12 +618,12 @@
                            .setAlarmType("1006");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1006.size()>0) {
        if (alarmData1006.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1006);
        }

        List<ArdAlarmRadarPump> ardAlarmRadarPumps = ardAlarmRadarPumpMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1007= ardAlarmRadarPumps.stream()
        List<GlobalAlarmData> alarmData1007 = ardAlarmRadarPumps.stream()
                .map(ardAlarmRadarPump -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmRadarPump.getId())
@@ -437,12 +636,12 @@
                            .setAlarmType("1007");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1007.size()>0) {
        if (alarmData1007.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1007);
        }

        List<ArdAlarmApponekey> ardAlarmApponekeys = ardAlarmApponekeyMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1009= ardAlarmApponekeys.stream()
        List<GlobalAlarmData> alarmData1009 = ardAlarmApponekeys.stream()
                .map(ardAlarmApponekey -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmApponekey.getId())
@@ -455,12 +654,12 @@
                            .setAlarmType("1009");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1009.size()>0) {
        if (alarmData1009.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1009);
        }

        List<ArdAlarmWall> ardAlarmWalls = ardAlarmWallMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1010= ardAlarmWalls.stream()
        List<GlobalAlarmData> alarmData1010 = ardAlarmWalls.stream()
                .map(ardAlarmWall -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmWall.getId())
@@ -473,12 +672,30 @@
                            .setAlarmType("1010");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1010.size()>0) {
        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()
        List<GlobalAlarmData> alarmData1014 = ardAlarmTubes.stream()
                .map(ardAlarmTube -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmTube.getId())
@@ -492,11 +709,11 @@
                            .setAlarmType("1014");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1014.size()>0) {
        if (alarmData1014.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1014);
        }
        return GlobalAlarmDataList;
}
    }

    /**
     * @描述 历史报警查询
@@ -571,6 +788,12 @@
                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);
@@ -592,6 +815,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());
@@ -662,9 +886,17 @@
                ArdAlarmWall ardAlarmWall = ardAlarmWallMapper.selectArdAlarmWallById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmWall)) {
                    String userId = ardAlarmWall.getUserId();
                    String alarmTime = fmt.format(ardAlarmWall.getCreateTime());
                    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());
@@ -757,71 +989,141 @@
                    break;
                case "radar":
                    //region 处理雷达报警
                    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();
                    List<ArdAlarmRadarMove>ardAlarmRadarMoves=new ArrayList<>();
                    List<ArdAlarmRadarFire>ardAlarmRadarFires=new ArrayList<>();
                    List<ArdAlarmRadarPump>ardAlarmRadarPumps=new ArrayList<>();
                    for (ArdAlarmRadar ardAlarmRadar : ardAlarmRadars) {
                        String uuid = IdUtils.simpleUUID();
                        String radarId = radarAlarmData.getRadarId();
                        String alarmpointName = ardAlarmRadar.getName();//兴趣点名称
                        Double longitude = ardAlarmRadar.getLongitude();
                        Double latitude = ardAlarmRadar.getLatitude();
                        String targetId=ardAlarmRadar.getTargetId();
                        String targetId = ardAlarmRadar.getTargetId();
                        switch (ardAlarmRadar.getAlarmType()) {
                            case "运动目标检测":
                                ArdAlarmRadarMove ardAlarmRadarMove=new ArdAlarmRadarMove();
                                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("sys_radar_move");
                                ardAlarmRadarMove.setAlarmType("运动目标检测");
                                ardAlarmRadarMove.setLongitude(longitude);
                                ardAlarmRadarMove.setLatitude(latitude);
                                //入库
                                ardAlarmRadarMoveMapper.insertArdAlarmRadarMove(ardAlarmRadarMove);
                                ardAlarmRadarMoves.add(ardAlarmRadarMove);

                                ardAlarmRadarMove.setUpdateTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarMove.setRadarId(radarId);
                                //获取当前兴趣点当前雷达的上一条数据
                                ArdAlarmRadarMove lastMoveData = ardAlarmRadarMoveMapper.selectArdAlarmRadarLastData(ardAlarmRadarMove.getName());
                                if (lastMoveData == null) {
                                    //入库
                                    ardAlarmRadarMoveMapper.insertArdAlarmRadarMove(ardAlarmRadarMove);
                                    radarMoveGuide(ardAlarmRadarMove);//引导
                                } else {
                                    //否则比对更新时间
                                    Date lastUpdateTime = lastMoveData.getUpdateTime();
                                    Date alarmTime = ardAlarmRadarMove.getAlarmTime();
                                    long secDatePoor = DateUtils.getSecDatePoor(alarmTime,lastUpdateTime);
                                    if (secDatePoor <= radarMergeTime) {
                                        //小于10秒的新数据，更新上一条
                                        ArdAlarmRadarMove updateData = new ArdAlarmRadarMove();
                                        updateData.setId(lastMoveData.getId());
                                        updateData.setUpdateTime(alarmTime);
                                        ardAlarmRadarMoveMapper.updateArdAlarmRadarMove(updateData);
                                    } else {
                                        //超过10秒的数据,入库
                                        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 "热源检测":
                                ArdAlarmRadarFire ardAlarmRadarFire=new ArdAlarmRadarFire();
                                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("sys_radar_fire");
                                ardAlarmRadarFire.setAlarmType("热源检测");
                                ardAlarmRadarFire.setLongitude(longitude);
                                ardAlarmRadarFire.setLatitude(latitude);
                                //入库
                                ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
                                ardAlarmRadarFires.add(ardAlarmRadarFire);
                                ardAlarmRadarFire.setRadarId(radarId);
                                ardAlarmRadarFire.setUpdateTime(radarAlarmData.getAlarmTime());
                                //
                                ArdAlarmRadarFire lastFireData = ardAlarmRadarFireMapper.selectArdAlarmRadarLastData(ardAlarmRadarFire.getName());
                                if (lastFireData == null) {
                                    //入库

                                    ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
                                    radarFireGuide(ardAlarmRadarFire);//引导
                                } else {
                                    //否则比对更新时间
                                    Date lastUpdateTime = lastFireData.getUpdateTime();
                                    Date alarmTime = ardAlarmRadarFire.getAlarmTime();
                                    long secDatePoor = DateUtils.getSecDatePoor(alarmTime,lastUpdateTime);
                                    if (secDatePoor <= radarMergeTime) {
                                        //小于10秒的新数据，更新上一条
                                        ArdAlarmRadarFire updateData = new ArdAlarmRadarFire();
                                        updateData.setId(lastFireData.getId());
                                        updateData.setUpdateTime(alarmTime);
                                        ardAlarmRadarFireMapper.updateArdAlarmRadarFire(updateData);
                                    } else {
                                        //超过10秒的数据,入库
                                        ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
                                        radarFireGuide(ardAlarmRadarFire);//引导
                                    }
                                }
                                break;
                            case "雷达抽油机停机":
                                ArdAlarmRadarPump ardAlarmRadarPump=new ArdAlarmRadarPump();
                                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("sys_radar_pump");
                                ardAlarmRadarPump.setAlarmType("雷达抽油机停机");
                                ardAlarmRadarPump.setUpdateTime(radarAlarmData.getAlarmTime());
                                ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
                                if (StringUtils.isNotNull(ardAlarmpointsWell)) {
                                    ardAlarmRadarPump.setLongitude(ardAlarmpointsWell.getLongitude());
                                    ardAlarmRadarPump.setLatitude(ardAlarmpointsWell.getLatitude());
                                }
                                //入库
                                ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
                                ardAlarmRadarPumps.add(ardAlarmRadarPump);

                                //
                                ArdAlarmRadarPump lastPumpData = ardAlarmRadarPumpMapper.selectArdAlarmRadarLastData(ardAlarmRadarPump.getName());
                                if (lastPumpData == null) {
                                    //入库
                                    ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
                                    radarPumpGuide(ardAlarmRadarPump);//引导
                                } else {
                                    //否则比对更新时间
                                    Date lastUpdateTime = lastPumpData.getUpdateTime();
                                    Date alarmTime = ardAlarmRadarPump.getAlarmTime();
                                    long secDatePoor = DateUtils.getSecDatePoor(alarmTime,lastUpdateTime);
                                    if (secDatePoor <= radarMergeTime) {
                                        //小于10秒的新数据，更新上一条
                                        ArdAlarmRadarPump updateData = new ArdAlarmRadarPump();
                                        updateData.setId(lastPumpData.getId());
                                        updateData.setUpdateTime(alarmTime);
                                        ardAlarmRadarPumpMapper.updateArdAlarmRadarPump(updateData);
                                    } else {
                                        //超过10秒的数据,入库
                                        ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
                                        radarPumpGuide(ardAlarmRadarPump);//引导
                                    }
                                }
                                break;
                        }
                    }
                    radarMoveGuide(ardAlarmRadarMoves,radarAlarmData);
                    radarFireGuide(ardAlarmRadarFires,radarAlarmData);
                    radarPumpGuide(ardAlarmRadarPumps,radarAlarmData);
                    //endregion
                    break;
                case "external":
                    //region 处理外联报警
@@ -891,6 +1193,23 @@
                    }
                    //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;
            }
        } catch (Exception ex) {
            log.error("接收报警异常:" + ex.getMessage());
@@ -918,7 +1237,22 @@
            //相机ID
            guideTask.setCameraId(cameraId);
            //报警类型
            guideTask.setAlarmType(alarmType);
            String aType = "";
            switch (alarmType) {
                case "运动目标检测":
                    aType = "sys_radar_move";
                    break;
                case "热源检测":
                    aType = "sys_radar_fire";
                    break;
                case "雷达抽油机停机":
                    aType = "sys_radar_pump";
                    break;
                default:
                    aType = alarmType;
                    break;
            }
            guideTask.setAlarmType(aType);
            //通道(通过日夜时间研判)
            String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
            Integer channel = ArdTool.getChannelBydayNightTime(dayNightTime);
@@ -928,7 +1262,7 @@
            //接收时间
            guideTask.setReceiveTime(fmt.format(receiveTime));
            //报警优先级(通过优先级字典)
            String priority = DictUtils.getDictValue("cameras_priority", alarmType);
            String priority = DictUtils.getDictValue("cameras_priority", aType);
            if (StringUtils.isEmpty(priority)) {
                log.debug("未匹配到优先级,请检查优先级字典配置");
                return;
@@ -1006,19 +1340,18 @@
        return minDistanceCameraId;
    }


    /**
     * 雷达引导入队
     */
    private void radarGuideToQueue(String alarmId,String radarId, String name, String alarmType, Date createTime, double[] coordinate) {
    //雷达获取相机引导入队
    private void radarGuideToQueue(String alarmId, String radarId, String name, String alarmType, Date createTime, double[] coordinate) {
        int index = name.indexOf("(");
        String alarmpointName = name.substring(0, index);
        //获取雷达所在塔上的大光电
        String cameraIdWithTower = ardEquipRadarMapper.getCameraByRadar(radarId);
        if (StringUtils.isNotNull(cameraIdWithTower) && StringUtils.isNotEmpty(cameraIdWithTower)) {
            log.info("获取到雷达塔上的光电:" + cameraIdWithTower);
            log.debug("获取到雷达塔上的光电:" + cameraIdWithTower);
            //如果雷达塔上有光电
            messagesEnqueued(cameraIdWithTower, alarmId, alarmType, createTime, 1, 1, coordinate);
        } else {
            log.debug("未获取到雷达塔上的光电");
        }
        //获取报警点关联的大光电
        ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
@@ -1030,159 +1363,195 @@
            log.info("获取到报警点关联的光电:" + cameraId);
            //如果报警点关联了光电
            messagesEnqueued(cameraId, alarmId, alarmType, createTime, 1, 2, coordinate);
        } else {
            log.debug("未获取到报警点关联的光电");
        }
    }


    private void radarMoveGuide(List<ArdAlarmRadarMove> ardAlarmRadarMoves,RadarAlarmData radarAlarmData)
    {
    //雷达移动引导
    private void radarMoveGuide(List<ArdAlarmRadarMove> ardAlarmRadarMoves, RadarAlarmData radarAlarmData) {
        //按兴趣点去重,然后按引导逻辑进行引导入队
        ardAlarmRadarMoves = ardAlarmRadarMoves.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new java.util.TreeSet<>(java.util.Comparator.comparing(ArdAlarmRadarMove::getName))), ArrayList::new));
        for (ArdAlarmRadarMove ardAlarmRadarMove : ardAlarmRadarMoves) {
            //遍历报警数据进行引导
            if (StringUtils.isNull(ardAlarmRadarMove.getLongitude()) || StringUtils.isNull(ardAlarmRadarMove.getLatitude())) {
                //坐标为空不引导
                continue;
            }
            double[] coordinate = new double[]{ardAlarmRadarMove.getLongitude(), ardAlarmRadarMove.getLatitude()};//报警坐标
            //从redis中取出当前报警点的5分钟内是否有引导
            ArdAlarmRadarMove alarmRadarMove = redisCache.getCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName());//从redis中取出最新引导的报警数据
            if (alarmRadarMove == null) {
                //5分钟内redis中没有数据，说明5分钟内没有引导数据
                ardAlarmRadarMove.setGuideFlag(1);
                //将引导数据写入redis 设置5分钟过期
                redisCache.setCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName(), ardAlarmRadarMove, 5, TimeUnit.MINUTES);//引导数据写入redis
                unGuideCountMapMove.put(ardAlarmRadarMove.getName(), 0);
                //引导入队
                radarGuideToQueue(ardAlarmRadarMove.getId(),radarAlarmData.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);//更新
        if (ardAlarmRadarMoves.size() > 0) {
            for (ArdAlarmRadarMove ardAlarmRadarMove : ardAlarmRadarMoves) {
                //遍历报警数据进行引导
                if (StringUtils.isNull(ardAlarmRadarMove.getLongitude()) || StringUtils.isNull(ardAlarmRadarMove.getLatitude())) {
                    //坐标为空不引导
                    continue;
                }
                double[] coordinate = new double[]{ardAlarmRadarMove.getLongitude(), ardAlarmRadarMove.getLatitude()};//报警坐标
                //从redis中取出当前报警点的5分钟内是否有引导
                ArdAlarmRadarMove alarmRadarMove = redisCache.getCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName());//从redis中取出最新引导的报警数据
                if (alarmRadarMove == null) {
                    //5分钟内redis中没有数据，说明5分钟内没有引导数据
                    ardAlarmRadarMove.setGuideFlag(1);
                    //将引导数据写入redis 设置5分钟过期
                    redisCache.setCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName(), ardAlarmRadarMove, 5, TimeUnit.MINUTES);//引导数据写入redis
                    unGuideCountMapMove.put(ardAlarmRadarMove.getName(), 0);
                    //引导入队
                    radarGuideToQueue(ardAlarmRadarMove.getId(), radarAlarmData.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);//更新

            } else {
                //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                Integer count = unGuideCountMapMove.get(ardAlarmRadarMove.getName());
                if (count != null) {
                    if (count > 2) {
                        //未引导次数3次后进行引导
                        ardAlarmRadarMove.setGuideFlag(1);
                        //将引导数据写入redis 设置5分钟过期
                        redisCache.setCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName(), ardAlarmRadarMove, 5, TimeUnit.MINUTES);
                        count = 0;
                        //引导入队
                } else {
                    //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                    Integer count = unGuideCountMapMove.get(ardAlarmRadarMove.getName());
                    if (count != null) {
                        if (count > 2) {
                            //未引导次数3次后进行引导
                            ardAlarmRadarMove.setGuideFlag(1);
                            //将引导数据写入redis 设置5分钟过期
                            redisCache.setCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName(), ardAlarmRadarMove, 5, TimeUnit.MINUTES);
                            count = 0;
                            //引导入队

                        radarGuideToQueue(ardAlarmRadarMove.getId(),radarAlarmData.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);
                            radarGuideToQueue(ardAlarmRadarMove.getId(), radarAlarmData.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);
                        } else {
                            ardAlarmRadarMove.setGuideFlag(0);
                            count++;
                        }
                    } else {
                        ardAlarmRadarMove.setGuideFlag(0);
                        count++;
                        count = 0;
                    }
                } else {
                    ardAlarmRadarMove.setGuideFlag(0);
                    count = 0;
                    unGuideCountMapMove.put(ardAlarmRadarMove.getName(), count);
                }
                unGuideCountMapMove.put(ardAlarmRadarMove.getName(), count);
                //更新
                ardAlarmRadarMoveMapper.updateArdAlarmRadarMove(ardAlarmRadarMove);
            }
            //更新
            ardAlarmRadarMoveMapper.updateArdAlarmRadarMove(ardAlarmRadarMove);
        }
        //endregion
    }
    private void radarFireGuide(List<ArdAlarmRadarFire> ardAlarmRadarFires,RadarAlarmData radarAlarmData)
    {
    private void radarMoveGuide(ArdAlarmRadarMove ardAlarmRadarMove) {
        if (StringUtils.isNull(ardAlarmRadarMove.getLongitude()) || StringUtils.isNull(ardAlarmRadarMove.getLatitude())) {
            log.debug("坐标为空不引导");
            return;
        }
        double[] coordinate = new double[]{ardAlarmRadarMove.getLongitude(), ardAlarmRadarMove.getLatitude()};//报警坐标
        //引导入队
        radarGuideToQueue(ardAlarmRadarMove.getId(), ardAlarmRadarMove.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);//更新
    }

    //雷达防火引导
    private void radarFireGuide(List<ArdAlarmRadarFire> ardAlarmRadarFires, RadarAlarmData radarAlarmData) {
        //按兴趣点去重,然后按引导逻辑进行引导入队
        ardAlarmRadarFires = ardAlarmRadarFires.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new java.util.TreeSet<>(java.util.Comparator.comparing(ArdAlarmRadarFire::getName))), ArrayList::new));
        for (ArdAlarmRadarFire ardAlarmRadarFire : ardAlarmRadarFires) {
            //遍历报警数据进行引导
            if (StringUtils.isNull(ardAlarmRadarFire.getLongitude()) || StringUtils.isNull(ardAlarmRadarFire.getLatitude())) {
                //坐标为空不引导
                continue;
            }
            double[] coordinate = new double[]{ardAlarmRadarFire.getLongitude(), ardAlarmRadarFire.getLatitude()};//报警坐标
            //从redis中取出当前报警点的5分钟内是否有引导
            ArdAlarmRadarFire alarmRadarFire = redisCache.getCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName());//从redis中取出最新引导的报警数据
            if (alarmRadarFire == null) {
                //5分钟内redis中没有数据，说明5分钟内没有引导数据
                ardAlarmRadarFire.setGuideFlag(1);
                //将引导数据写入redis 设置5分钟过期
                redisCache.setCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName(), ardAlarmRadarFire, 5, TimeUnit.MINUTES);//引导数据写入redis
                unGuideCountMapFire.put(alarmRadarFire.getName(), 0);
                //引导入队
                radarGuideToQueue(ardAlarmRadarFire.getId(),radarAlarmData.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);
        if (ardAlarmRadarFires.size() > 0) {
            for (ArdAlarmRadarFire ardAlarmRadarFire : ardAlarmRadarFires) {
                //遍历报警数据进行引导
                if (StringUtils.isNull(ardAlarmRadarFire.getLongitude()) || StringUtils.isNull(ardAlarmRadarFire.getLatitude())) {
                    //坐标为空不引导
                    continue;
                }
                double[] coordinate = new double[]{ardAlarmRadarFire.getLongitude(), ardAlarmRadarFire.getLatitude()};//报警坐标
                //从redis中取出当前报警点的5分钟内是否有引导
                ArdAlarmRadarFire alarmRadarFire = redisCache.getCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName());//从redis中取出最新引导的报警数据
                if (alarmRadarFire == null) {
                    //5分钟内redis中没有数据，说明5分钟内没有引导数据
                    ardAlarmRadarFire.setGuideFlag(1);
                    //将引导数据写入redis 设置5分钟过期
                    redisCache.setCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName(), ardAlarmRadarFire, 5, TimeUnit.MINUTES);//引导数据写入redis
                    unGuideCountMapFire.put(alarmRadarFire.getName(), 0);
                    //引导入队
                    radarGuideToQueue(ardAlarmRadarFire.getId(), radarAlarmData.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);

            } else {
                //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                Integer count = unGuideCountMapFire.get(alarmRadarFire.getName());
                if (count != null) {
                    if (count > 2) {
                        //未引导次数3次后进行引导
                        ardAlarmRadarFire.setGuideFlag(1);
                        //将引导数据写入redis 设置5分钟过期
                        redisCache.setCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName(), ardAlarmRadarFire, 5, TimeUnit.MINUTES);
                        count = 0;
                        //引导入队
                        radarGuideToQueue(ardAlarmRadarFire.getId(),radarAlarmData.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);
                } else {
                    //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                    Integer count = unGuideCountMapFire.get(alarmRadarFire.getName());
                    if (count != null) {
                        if (count > 2) {
                            //未引导次数3次后进行引导
                            ardAlarmRadarFire.setGuideFlag(1);
                            //将引导数据写入redis 设置5分钟过期
                            redisCache.setCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName(), ardAlarmRadarFire, 5, TimeUnit.MINUTES);
                            count = 0;
                            //引导入队
                            radarGuideToQueue(ardAlarmRadarFire.getId(), radarAlarmData.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);
                        } else {
                            ardAlarmRadarFire.setGuideFlag(0);
                            count++;
                        }
                    } else {
                        ardAlarmRadarFire.setGuideFlag(0);
                        count++;
                        count = 0;
                    }
                } else {
                    ardAlarmRadarFire.setGuideFlag(0);
                    count = 0;
                    unGuideCountMapFire.put(ardAlarmRadarFire.getName(), count);
                }
                unGuideCountMapFire.put(ardAlarmRadarFire.getName(), count);
                //更新
                ardAlarmRadarFireMapper.updateArdAlarmRadarFire(ardAlarmRadarFire);
            }
            //更新
            ardAlarmRadarFireMapper.updateArdAlarmRadarFire(ardAlarmRadarFire);
        }
        //endregion
    }
    private void radarPumpGuide(List<ArdAlarmRadarPump> ardAlarmRadarPumps,RadarAlarmData radarAlarmData)
    {
    private void radarFireGuide(ArdAlarmRadarFire ardAlarmRadarFire) {
        if (StringUtils.isNull(ardAlarmRadarFire.getLongitude()) || StringUtils.isNull(ardAlarmRadarFire.getLatitude())) {
            log.debug("坐标为空不引导");
            return;
        }
        double[] coordinate = new double[]{ardAlarmRadarFire.getLongitude(), ardAlarmRadarFire.getLatitude()};//报警坐标
        //引导入队
        radarGuideToQueue(ardAlarmRadarFire.getId(), ardAlarmRadarFire.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);//更新
    }
    //雷达抽油机停机引导
    private void radarPumpGuide(List<ArdAlarmRadarPump> ardAlarmRadarPumps, RadarAlarmData radarAlarmData) {
        //按兴趣点去重,然后按引导逻辑进行引导入队
        ardAlarmRadarPumps = ardAlarmRadarPumps.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new java.util.TreeSet<>(java.util.Comparator.comparing(ArdAlarmRadarPump::getName))), ArrayList::new));
        for (ArdAlarmRadarPump ardAlarmRadarPump : ardAlarmRadarPumps) {
            //遍历报警数据进行引导
            if (StringUtils.isNull(ardAlarmRadarPump.getLongitude()) || StringUtils.isNull(ardAlarmRadarPump.getLatitude())) {
                //坐标为空不引导
                continue;
            }
            double[] coordinate = new double[]{ardAlarmRadarPump.getLongitude(), ardAlarmRadarPump.getLatitude()};//报警坐标
            //从redis中取出当前报警点的5分钟内是否有引导
            ArdAlarmRadarPump alarmRadarPump = redisCache.getCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName());//从redis中取出最新引导的报警数据
            if (alarmRadarPump == null) {
                //5分钟内redis中没有数据，说明5分钟内没有引导数据
                ardAlarmRadarPump.setGuideFlag(1);
                //将引导数据写入redis 设置5分钟过期
                redisCache.setCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName(), ardAlarmRadarPump, 5, TimeUnit.MINUTES);//引导数据写入redis
                unGuideCountMapPump.put(alarmRadarPump.getName(), 0);
                //引导入队
                radarGuideToQueue(ardAlarmRadarPump.getId(),radarAlarmData.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);
        if (ardAlarmRadarPumps.size() > 0) {
            for (ArdAlarmRadarPump ardAlarmRadarPump : ardAlarmRadarPumps) {
                //遍历报警数据进行引导
                if (StringUtils.isNull(ardAlarmRadarPump.getLongitude()) || StringUtils.isNull(ardAlarmRadarPump.getLatitude())) {
                    //坐标为空不引导
                    continue;
                }
                double[] coordinate = new double[]{ardAlarmRadarPump.getLongitude(), ardAlarmRadarPump.getLatitude()};//报警坐标
                //从redis中取出当前报警点的5分钟内是否有引导
                ArdAlarmRadarPump alarmRadarPump = redisCache.getCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName());//从redis中取出最新引导的报警数据
                if (alarmRadarPump == null) {
                    //5分钟内redis中没有数据，说明5分钟内没有引导数据
                    ardAlarmRadarPump.setGuideFlag(1);
                    //将引导数据写入redis 设置5分钟过期
                    redisCache.setCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName(), ardAlarmRadarPump, 5, TimeUnit.MINUTES);//引导数据写入redis
                    unGuideCountMapPump.put(alarmRadarPump.getName(), 0);
                    //引导入队
                    radarGuideToQueue(ardAlarmRadarPump.getId(), radarAlarmData.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);

            } else {
                //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                Integer count = unGuideCountMapPump.get(ardAlarmRadarPump.getName());
                if (count != null) {
                    if (count > 2) {
                        //未引导次数3次后进行引导
                        ardAlarmRadarPump.setGuideFlag(1);
                        //将引导数据写入redis 设置5分钟过期
                        redisCache.setCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName(), ardAlarmRadarPump, 5, TimeUnit.MINUTES);
                        count = 0;
                        //引导入队
                        radarGuideToQueue(ardAlarmRadarPump.getId(),radarAlarmData.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);
                } else {
                    //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                    Integer count = unGuideCountMapPump.get(ardAlarmRadarPump.getName());
                    if (count != null) {
                        if (count > 2) {
                            //未引导次数3次后进行引导
                            ardAlarmRadarPump.setGuideFlag(1);
                            //将引导数据写入redis 设置5分钟过期
                            redisCache.setCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName(), ardAlarmRadarPump, 5, TimeUnit.MINUTES);
                            count = 0;
                            //引导入队
                            radarGuideToQueue(ardAlarmRadarPump.getId(), radarAlarmData.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);
                        } else {
                            ardAlarmRadarPump.setGuideFlag(0);
                            count++;
                        }
                    } else {
                        ardAlarmRadarPump.setGuideFlag(0);
                        count++;
                        count = 0;
                    }
                } else {
                    ardAlarmRadarPump.setGuideFlag(0);
                    count = 0;
                    unGuideCountMapPump.put(ardAlarmRadarPump.getName(), count);
                }
                unGuideCountMapPump.put(ardAlarmRadarPump.getName(), count);
                //更新
                ardAlarmRadarPumpMapper.updateArdAlarmRadarPump(ardAlarmRadarPump);
            }
            //更新
            ardAlarmRadarPumpMapper.updateArdAlarmRadarPump(ardAlarmRadarPump);
        }
        //endregion
    }
    private void radarPumpGuide(ArdAlarmRadarPump ardAlarmRadarPump) {
        if (StringUtils.isNull(ardAlarmRadarPump.getLongitude()) || StringUtils.isNull(ardAlarmRadarPump.getLatitude())) {
            //坐标为空不引导
            log.debug("坐标为空不引导");
            return;
        }
        double[] coordinate = new double[]{ardAlarmRadarPump.getLongitude(), ardAlarmRadarPump.getLatitude()};//报警坐标
        //引导入队
        radarGuideToQueue(ardAlarmRadarPump.getId(), ardAlarmRadarPump.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);//更新
    }
}