Merge remote-tracking branch 'origin/dev' into dev

aijinhui

2024-03-23 a70d0dfe221e06381b6e290d1dab85c9ab4fdc31

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

@@ -11,10 +11,7 @@
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.*;
import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarFireMapper;
@@ -22,6 +19,8 @@
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;
@@ -31,9 +30,11 @@
import com.ruoyi.alarmpoints.tube.mapper.ArdTubesDetailsMapper;
import com.ruoyi.alarmpoints.tube.mapper.ArdTubesMapper;
import com.ruoyi.alarmpoints.well.domain.ArdAlarmpointsWell;
import com.ruoyi.alarmpoints.well.domain.ArdWellGuideCamera;
import com.ruoyi.alarmpoints.well.mapper.ArdAlarmpointsWellMapper;
import com.ruoyi.alarmpoints.well.mapper.ArdWellGuideCameraMapper;
import com.ruoyi.common.config.ARDConfig;
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;
@@ -50,15 +51,18 @@
import com.ruoyi.system.service.ISysConfigService;
import com.ruoyi.utils.tube.GeoPoint;
import com.ruoyi.utils.tube.TubeTools;
import com.ruoyi.utils.websocket.util.WebSocketUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import static com.ruoyi.utils.tools.ArdTool.writeStringToFile;


/**
@@ -69,9 +73,11 @@
 * @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
@@ -84,8 +90,6 @@
    private ArdAlarmAccessMapper ardAlarmAccessMapper;
    @Resource
    private ArdAlarmExternalMapper ardAlarmExternalMapper;
    //@Resource
    //private ArdAlarmRadarMapper ardAlarmRadarMapper;
    @Resource
    private ArdAlarmRadarMoveMapper ardAlarmRadarMoveMapper;
    @Resource
@@ -111,9 +115,12 @@
    @Resource
    private RedisCache redisCache;
    @Resource
    private QueueManager queueManager;
    private QueueHandler queueHandler;
    @Resource
    private ArdEquipRadarMapper ardEquipRadarMapper;
    @Resource
    private ArdWellGuideCameraMapper ardWellGuideCameraMapper;

    //endregion

    /**
@@ -151,6 +158,8 @@
        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;
    }
@@ -323,6 +332,22 @@
                                    .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:
@@ -498,6 +523,22 @@
                                    .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:
@@ -690,6 +731,7 @@
        if (alarmData1012.size() > 0) {
            GlobalAlarmDataList.addAll(alarmData1012);
        }

        List<ArdAlarmTube> ardAlarmTubes = ardAlarmTubeMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1014 = ardAlarmTubes.stream()
                .map(ardAlarmTube -> {
@@ -708,6 +750,26 @@
        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;
    }

@@ -720,25 +782,28 @@
     * @修改人和其它信息
     */
    @Override
    public Object selectAlarmList(Integer command, String beginTime, String endTime, Integer pageNum, Integer pageSize) {
    public Object selectAlarmList(String name,Integer command, String beginTime, String endTime, Integer pageNum, Integer pageSize) {
        Map<String, Object> params = new HashMap<>();
        params.put("beginTime", beginTime);
        params.put("endTime", endTime);
        switch (command) {
            case 1001:
                ArdAlarmStealelec aas = new ArdAlarmStealelec();
                aas.setName(name);
                aas.setParams(params);
                aas.setPageNum(pageNum);
                aas.setPageSize(pageSize);
                return ardAlarmStealelecMapper.selectArdAlarmStealelecList(aas);
            case 1002:
                ArdAlarmCamera aac = new ArdAlarmCamera();
                aac.setCameraName(name);
                aac.setParams(params);
                aac.setPageNum(pageNum);
                aac.setPageSize(pageSize);
                return ardAlarmCameraMapper.selectArdAlarmCameraList(aac);
            case 1003:
                ArdAlarmRadarMove aarm = new ArdAlarmRadarMove();
                aarm.setName(name);
                aarm.setParams(params);
                aarm.setPageNum(pageNum);
                aarm.setPageSize(pageSize);
@@ -746,6 +811,7 @@
                return ardAlarmRadarMoveMapper.selectArdAlarmRadarMoveList(aarm);
            case 1004:
                ArdAlarmRadarFire aarf = new ArdAlarmRadarFire();
                aarf.setName(name);
                aarf.setParams(params);
                aarf.setPageNum(pageNum);
                aarf.setPageSize(pageSize);
@@ -753,6 +819,7 @@
                return ardAlarmRadarFireMapper.selectArdAlarmRadarFireList(aarf);
            case 1007:
                ArdAlarmRadarPump aarp = new ArdAlarmRadarPump();
                aarp.setName(name);
                aarp.setParams(params);
                aarp.setPageNum(pageNum);
                aarp.setPageSize(pageSize);
@@ -760,6 +827,7 @@
                return ardAlarmRadarPumpMapper.selectArdAlarmRadarPumpList(aarp);
            case 1005:
                ArdAlarmExternal aae = new ArdAlarmExternal();
                aae.setAlarmName(name);
                aae.setParams(params);
                aae.setPageNum(pageNum);
                aae.setPageSize(pageSize);
@@ -767,6 +835,7 @@
                return ardAlarmExternalMapper.selectArdAlarmExternalList(aae);
            case 1006:
                ArdAlarmAccess aaa = new ArdAlarmAccess();
                aaa.setAcsName(name);
                aaa.setParams(params);
                aaa.setPageNum(pageNum);
                aaa.setPageSize(pageSize);
@@ -774,28 +843,39 @@
                return ardAlarmAccessMapper.selectArdAlarmAccessList(aaa);
            case 1009:
                ArdAlarmApponekey aaak = new ArdAlarmApponekey();
                aaak.setName(name);
                aaak.setParams(params);
                aaak.setPageNum(pageNum);
                aaak.setPageSize(pageSize);
                return ardAlarmApponekeyMapper.selectArdAlarmApponekeyList(aaak);
            case 1010:
                ArdAlarmWall aaw = new ArdAlarmWall();
                aaw.setWallName(name);
                aaw.setParams(params);
                aaw.setPageNum(pageNum);
                aaw.setPageSize(pageSize);
                return ardAlarmWallMapper.selectArdAlarmWallList(aaw);
            case 1012:
                ArdAlarmDigitization3 aad3 = new ArdAlarmDigitization3();
                aad3.setfName(name);
                aad3.setParams(params);
                aad3.setPageNum(pageNum);
                aad3.setPageSize(pageSize);
                return ardAlarmDigitization3Mapper.selectArdAlarmDigitization3List(aad3);
            case 1014:
                ArdAlarmTube aat = new ArdAlarmTube();
                aat.setTubeName(name);
                aat.setParams(params);
                aat.setPageNum(pageNum);
                aat.setPageSize(pageSize);
                return ardAlarmTubeMapper.selectArdAlarmTubeList(aat);
            case 1015:
                ArdAlarmSuperBrain aasb = new ArdAlarmSuperBrain();
                aasb.setAlarmName(name);
                aasb.setParams(params);
                aasb.setPageNum(pageNum);
                aasb.setPageSize(pageSize);
                return ardAlarmSuperBrainMapper.selectArdAlarmSuperBrainList(aasb);
        }
        return null;
    }
@@ -902,6 +982,14 @@
                    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;
        }
@@ -963,10 +1051,16 @@
                        if (StringUtils.isNull(longitude) || StringUtils.isNull(latitude)) {
                            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);
                        GuidePoint guidePoint = new GuidePoint().setLongitude(longitude).setLatitude(latitude);
                        String cameraId = getCameraByNear(guidePoint);
                        if (StringUtils.isNotEmpty(cameraId)) {
                            GuideDataDto guideDataDto = new GuideDataDto()
                                    .setCameraId(cameraId)
                                    .setAlarmId(ardAlarmTube.getId())
                                    .setAlarmType("sys_tube_leak")
                                    .setReceiveTime(ardAlarmTube.getCreateTime())
                                    .setTargetPosition(guidePoint);
                            messagesEnqueued(guideDataDto);
                        }
                        //endregion
                    }
@@ -985,16 +1079,24 @@
                    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();
                    for (ArdAlarmRadar ardAlarmRadar : ardAlarmRadars) {
                        String uuid = IdUtils.simpleUUID();
                        String radarId = radarAlarmData.getRadarId();
                        String alarmpointName = ardAlarmRadar.getName();//兴趣点名称
                        Double longitude = ardAlarmRadar.getLongitude();
                        Double latitude = ardAlarmRadar.getLatitude();
                        ArdAlarmpointsWell well = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
                        if (well == null) {
                            Map<String, Object> map = new HashMap<>();
                            map.put("80000", alarmpointName);
                            WebSocketUtils.sendMessageAll(map);
                            String filePath = ARDConfig.getDownloadPath() +  "noExistWell.txt";
                            writeStringToFile(alarmpointName, filePath);
                            continue;
                        }

                        Double longitude = well.getLongitude();
                        Double latitude = well.getLatitude();
                        String targetId = ardAlarmRadar.getTargetId();
                        switch (ardAlarmRadar.getAlarmType()) {
                            case "运动目标检测":
@@ -1002,104 +1104,30 @@
                                ardAlarmRadarMove.setId(uuid);
                                ardAlarmRadarMove.setTargetId(targetId);
                                ardAlarmRadarMove.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarMove.setCreateTime(DateUtils.covertTime(new Date()));
                                ardAlarmRadarMove.setCreateTime(new Date());
                                ardAlarmRadarMove.setName(alarmpointName + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarMove.setAlarmType("运动目标检测");
                                ardAlarmRadarMove.setLongitude(longitude);
                                ardAlarmRadarMove.setLatitude(latitude);
                                ardAlarmRadarMove.setUpdateTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarMove.setRadarId(radarId);
                                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);
                                //}
                                ardAlarmRadarMove.setWellId(well.getWellId());
                                ardAlarmRadarMoveHandler(ardAlarmRadarMove);
                                break;
                            case "热源检测":
                                ArdAlarmRadarFire ardAlarmRadarFire = new ArdAlarmRadarFire();
                                ardAlarmRadarFire.setId(uuid);
                                ardAlarmRadarFire.setTargetId(targetId);
                                ardAlarmRadarFire.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarFire.setCreateTime(DateUtils.covertTime(new Date()));
                                ardAlarmRadarFire.setCreateTime(new Date());
                                ardAlarmRadarFire.setName(alarmpointName + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarFire.setAlarmType("热源检测");
                                ardAlarmRadarFire.setLongitude(longitude);
                                ardAlarmRadarFire.setLatitude(latitude);
                                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);//引导
                                    }
                                }
                                ardAlarmRadarFire.setWellId(well.getWellId());
                                ardAlarmRadarFireHandler(ardAlarmRadarFire);
                                break;
                            case "雷达抽油机停机":
                                ArdAlarmRadarPump ardAlarmRadarPump = new ArdAlarmRadarPump();
@@ -1107,48 +1135,14 @@
                                ardAlarmRadarPump.setId(uuid);
                                ardAlarmRadarPump.setTargetId(targetId);
                                ardAlarmRadarPump.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarPump.setCreateTime(DateUtils.covertTime(new Date()));
                                ardAlarmRadarPump.setCreateTime(new Date());
                                ardAlarmRadarPump.setName(ardAlarmRadar.getName() + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarPump.setAlarmType("雷达抽油机停机");
                                ardAlarmRadarPump.setUpdateTime(radarAlarmData.getAlarmTime());
                                alarmTime = ardAlarmRadarPump.getAlarmTime();
                                ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
                                if (StringUtils.isNotNull(ardAlarmpointsWell)) {
                                    ardAlarmRadarPump.setLongitude(ardAlarmpointsWell.getLongitude());
                                    ardAlarmRadarPump.setLatitude(ardAlarmpointsWell.getLatitude());
                                }
                                //
                                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);//引导
                                    }
                                }
                                ardAlarmRadarPump.setLongitude(well.getLongitude());
                                ardAlarmRadarPump.setLatitude(well.getLatitude());
                                ardAlarmRadarPump.setWellId(well.getWellId());
                                ardAlarmRadarPumpHandler(ardAlarmRadarPump);
                                break;
                        }
                    }
@@ -1161,10 +1155,11 @@
                    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) {
@@ -1173,10 +1168,18 @@
                        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);
                        GuidePoint guidePoint = new GuidePoint().setLongitude(ardAlarmExternal.getLongitude()).setLatitude(ardAlarmExternal.getLatitude());
                        //引导坐标
                        String cameraId = getCameraByNear(guidePoint);//最近相机ID
                        if (StringUtils.isNotEmpty(cameraId)) {
                            GuideDataDto guideDataDto = new GuideDataDto()
                                    .setCameraId(cameraId)
                                    .setAlarmId(ardAlarmExternal.getId())
                                    .setAlarmType("sys_external")
                                    .setReceiveTime(ardAlarmExternal.getCreateTime())
                                    .setTargetPosition(guidePoint)
                                    .setWellId(well.getId());
                            messagesEnqueued(guideDataDto);
                        }
                        //endregion
                    }
@@ -1204,10 +1207,16 @@
                        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);
                        GuidePoint guidePoint = new GuidePoint().setLongitude(ardAlarmAccess.getLongitude()).setLatitude(ardAlarmAccess.getLatitude());//引导坐标
                        String cameraId = getCameraByNear(guidePoint);//最近相机ID
                        if (StringUtils.isNotEmpty(cameraId)) {
                            GuideDataDto guideDataDto = new GuideDataDto()
                                    .setCameraId(cameraId)
                                    .setAlarmId(ardAlarmAccess.getId())
                                    .setAlarmType("sys_external")
                                    .setReceiveTime(ardAlarmAccess.getCreateTime())
                                    .setTargetPosition(guidePoint);
                            messagesEnqueued(guideDataDto);
                        }
                        //endregion
                    }
@@ -1239,6 +1248,17 @@
                    }
                    //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;
            }
        } catch (Exception ex) {
            log.error("接收报警异常:" + ex.getMessage());
@@ -1255,56 +1275,48 @@
     * 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();
            if (!IsEnableGuide(cameraId)) {
                log.info("相机:" + cameraId + "未开启报警引导功能");
                log.debug("相机:" + cameraId + "未开启报警引导功能");
                return;
            }
            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
            GuideTask guideTask = new GuideTask();
            //相机ID
            guideTask.setCameraId(cameraId);
            //报警类型
            String aType = "";
            guideTask.setCameraId(cameraId);//相机ID
            guideTask.setIsGuidePTZ(guideDataDto.getIsGuidePTZ());
            if(guideTask.getIsGuidePTZ())
            {
                guideTask.setTargetPTZ(guideDataDto.getGuidePTZ());
            }
            String alarmType = guideDataDto.getAlarmType();
            switch (alarmType) {
                case "运动目标检测":
                    aType = "sys_radar_move";
                    alarmType = "sys_radar_move";
                    break;
                case "热源检测":
                    aType = "sys_radar_fire";
                    alarmType = "sys_radar_fire";
                    break;
                case "雷达抽油机停机":
                    aType = "sys_radar_pump";
                    break;
                default:
                    aType = alarmType;
                    alarmType = "sys_radar_pump";
                    break;
            }
            guideTask.setAlarmType(aType);
            //通道(通过日夜时间研判)
            String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
            Integer channel = ArdTool.getChannelBydayNightTime(dayNightTime);
            guideTask.setChanNum(channel);
            //报警ID
            guideTask.setAlarmId(alarmId);
            //接收时间
            guideTask.setReceiveTime(fmt.format(receiveTime));
            guideTask.setAlarmType(alarmType);//报警类型
            Integer chanNo = ArdTool.getChannelBydayNightTime(redisCache.getCacheObject("sys_config:dayNightTime"));
            guideTask.setChanNo(chanNo);//通道(通过日夜时间研判)
            guideTask.setAlarmId(guideDataDto.getAlarmId()); //报警ID
            guideTask.setReceiveTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS_MS, guideDataDto.getReceiveTime()));//接收时间
            //报警优先级(通过优先级字典)
            String priority = DictUtils.getDictValue("cameras_priority", aType);
            String priority = DictUtils.getDictValue("cameras_priority", alarmType);
            if (StringUtils.isEmpty(priority)) {
                log.debug("未匹配到优先级,请检查优先级字典配置");
                return;
            }
            guideTask.setPriority(Integer.valueOf(priority));
            //报警次数
            guideTask.setNum(num);
            //录像存储位置
            guideTask.setRecordSn(recordSn);
            //目标经纬度
            guideTask.setTargetPosition(targetPosition);
            guideTask.setTargetPosition(guideDataDto.getTargetPosition());//引导井坐标
            guideTask.setWellId(guideDataDto.getWellId());//引导井ID
            //消息入队
            queueManager.addTaskToQueue(cameraId, guideTask);
            queueHandler.addTaskToQueue(cameraId, guideTask);
            //打印队列
            GuidePriorityQueue.printPriorityQueue();
        } catch (Exception ex) {
@@ -1331,7 +1343,7 @@
    /**
     * 获取附近开启报警引导功能光电
     */
    private String getNearbyCamera(double[] targetPosition) {
    private String getCameraByNear(GuidePoint guidePoint) {
        String minDistanceCameraId = "";
        try {
            //获取所有大光电
@@ -1344,6 +1356,7 @@
                    continue;
                }
                double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
                double[] targetPosition = new double[]{guidePoint.getLongitude(), guidePoint.getLatitude()};
                double distance = GisUtil.getDistance(targetPosition, camPosition);
                if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {
                    distanceMap.put(camera.getId(), distance);
@@ -1369,56 +1382,98 @@
        return minDistanceCameraId;
    }

    //雷达获取相机引导入队
    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.debug("获取到雷达塔上的光电:" + cameraIdWithTower);
            //如果雷达塔上有光电
            messagesEnqueued(cameraIdWithTower, alarmId, alarmType, createTime, 1, 1, coordinate);
    //获取相机引导入队
    private void getCameraGuideToQueue(GuideDataDto guideDataDto) {
        //获取兴趣点关联的相机
        ArdAlarmpointsWell well = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(guideDataDto.getWellId());
        ArdWellGuideCamera ardWellGuideCamera = new ArdWellGuideCamera();
        ardWellGuideCamera.setWellId(well.getId());
        List<ArdWellGuideCamera> ardWellGuideCameras = ardWellGuideCameraMapper.selectArdWellGuideCameraList(ardWellGuideCamera);
        if (ardWellGuideCameras.size() > 0) {
            //优先获取井关联相机的预置位
            ardWellGuideCamera = ardWellGuideCameras.get(0);
            guideDataDto.setIsGuidePTZ(true);
            guideDataDto.setCameraId(ardWellGuideCamera.getCameraId());
            guideDataDto.setGuidePTZ(new GuidePTZ()
                    .setP1(ardWellGuideCamera.getP1())
                    .setT1(ardWellGuideCamera.getT1())
                    .setZ1(ardWellGuideCamera.getZ1())
                    .setP2(ardWellGuideCamera.getP2())
                    .setT2(ardWellGuideCamera.getT2())
                    .setZ2(ardWellGuideCamera.getZ2())
            );
            messagesEnqueued(guideDataDto);
        } else {
            log.debug("未获取到雷达塔上的光电,无法引导");
        }
        //获取报警点关联的大光电
        ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
        if (StringUtils.isNotNull(ardAlarmpointsWell) && StringUtils.isNotEmpty(ardAlarmpointsWell.getCameraId())) {
            String cameraId = ardAlarmpointsWell.getCameraId();
            if (cameraId.equals(cameraIdWithTower)) {
                return;
            //获取雷达所在塔上的大光电
            ArdCameras cameraWithTower = ardEquipRadarMapper.getCameraByRadar(guideDataDto.getRadarId());
            if (StringUtils.isNotNull(cameraWithTower)) {
                log.debug("获取到雷达塔上的光电:" + cameraWithTower.getId());
                //如果雷达塔上有光电
                guideDataDto.setIsGuidePTZ(false);
                guideDataDto.setCameraId(cameraWithTower.getId());
                messagesEnqueued(guideDataDto);
            } else {
                log.debug("未获取到雷达塔上的光电,无法引导");
            }
            log.info("获取到报警点关联的光电:" + cameraId);
            //如果报警点关联了光电
            messagesEnqueued(cameraId, alarmId, alarmType, createTime, 1, 2, coordinate);
        } else {
            log.debug("未获取到报警点关联的光电,无法引导");
        }
    }
    //雷达移动引导

    /**
     * 雷达移动引导
     * 刘苏义
     * 2023/12/14 15:04:24
     */
    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()};//报警坐标
        GuidePoint guidePoint = new GuidePoint().setLongitude(ardAlarmRadarMove.getLongitude())
                .setLatitude(ardAlarmRadarMove.getLatitude());
        //报警坐标
        //引导入队
        radarGuideToQueue(ardAlarmRadarMove.getId(), ardAlarmRadarMove.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);//更新
        GuideDataDto guideDataDto = new GuideDataDto()
                .setRadarId(ardAlarmRadarMove.getRadarId())
                .setName(ardAlarmRadarMove.getName())
                .setAlarmId(ardAlarmRadarMove.getId())
                .setAlarmType(ardAlarmRadarMove.getAlarmType())
                .setReceiveTime(ardAlarmRadarMove.getCreateTime())
                .setWellId(ardAlarmRadarMove.getWellId())
                .setTargetPosition(guidePoint);
        getCameraGuideToQueue(guideDataDto);//获取相机入队
    }
    //雷达防火引导

    /**
     * 雷达防火引导
     * 刘苏义
     * 2023/12/14 15:04:32
     */
    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()};//报警坐标
        GuidePoint guidePoint = new GuidePoint().setLongitude(ardAlarmRadarFire.getLongitude())//报警坐标
                .setLatitude(ardAlarmRadarFire.getLatitude());
        //引导入队
        radarGuideToQueue(ardAlarmRadarFire.getId(), ardAlarmRadarFire.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);//更新
        GuideDataDto guideDataDto = new GuideDataDto()
                .setRadarId(ardAlarmRadarFire.getRadarId())
                .setName(ardAlarmRadarFire.getName())
                .setAlarmId(ardAlarmRadarFire.getId())
                .setAlarmType(ardAlarmRadarFire.getAlarmType())
                .setReceiveTime(ardAlarmRadarFire.getCreateTime())
                .setWellId(ardAlarmRadarFire.getWellId())
                .setTargetPosition(guidePoint);
        getCameraGuideToQueue(guideDataDto);//获取相机入队
    }
    //雷达抽油机停机引导

    /**
     * 雷达抽油机停机引导
     * 刘苏义
     * 2023/12/14 15:04:40
     */
    private void radarPumpGuide(ArdAlarmRadarPump ardAlarmRadarPump) {
        log.debug("雷达抽油机停机开始引导");
        if (StringUtils.isNull(ardAlarmRadarPump.getLongitude()) || StringUtils.isNull(ardAlarmRadarPump.getLatitude())) {
@@ -1426,9 +1481,139 @@
            log.debug("坐标为空不引导");
            return;
        }
        double[] coordinate = new double[]{ardAlarmRadarPump.getLongitude(), ardAlarmRadarPump.getLatitude()};//报警坐标
        GuidePoint guidePoint = new GuidePoint().setLongitude(ardAlarmRadarPump.getLongitude())
                .setLatitude(ardAlarmRadarPump.getLatitude());//报警坐标
        //引导入队
        radarGuideToQueue(ardAlarmRadarPump.getId(), ardAlarmRadarPump.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);//更新
        GuideDataDto guideDataDto = new GuideDataDto()
                .setRadarId(ardAlarmRadarPump.getRadarId())
                .setName(ardAlarmRadarPump.getName())
                .setAlarmId(ardAlarmRadarPump.getId())
                .setAlarmType(ardAlarmRadarPump.getAlarmType())
                .setReceiveTime(ardAlarmRadarPump.getCreateTime())
                .setWellId(ardAlarmRadarPump.getWellId())
                .setTargetPosition(guidePoint);
        getCameraGuideToQueue(guideDataDto);//获取相机入队
    }

    /**
     * 雷达目标移动报警处理
     * 刘苏义
     * 2023/12/14 15:03:32
     */
    private void ardAlarmRadarMoveHandler(ArdAlarmRadarMove ardAlarmRadarMove) {
        String mergeTime = ConfigUtils.getConfigValue("radarMergeTime");
        Integer radarMergeTime = mergeTime == null || "".equals(mergeTime) ? 10 : Integer.valueOf(mergeTime);
        ArdAlarmRadarMove lastMoveData = ardAlarmRadarMoveMapper.selectArdAlarmRadarLastData(ardAlarmRadarMove.getName());
        if (lastMoveData == null) {
            //入库
            ardAlarmRadarMove.setGuideTime(ardAlarmRadarMove.getAlarmTime());
            ardAlarmRadarMoveMapper.insertArdAlarmRadarMove(ardAlarmRadarMove);
            radarMoveGuide(ardAlarmRadarMove);//引导
        } else {
            //否则比对更新时间
            Date lastUpdateTime = lastMoveData.getUpdateTime();
            Date lastGuideTime = lastMoveData.getGuideTime();
            long secDatePoor = DateUtils.getSecDatePoor(ardAlarmRadarMove.getAlarmTime(), lastUpdateTime);
            if (secDatePoor <= radarMergeTime) {
                //小于10秒的新数据，更新上一条
                ArdAlarmRadarMove updateData = new ArdAlarmRadarMove();
                updateData.setId(lastMoveData.getId());
                updateData.setUpdateTime(ardAlarmRadarMove.getAlarmTime());

                //判断引导时间超过5分钟再次引导
                long secDatePoorGuide = DateUtils.getSecDatePoor(ardAlarmRadarMove.getAlarmTime(), lastGuideTime);
                if (secDatePoorGuide >= 300) {
                    updateData.setGuideTime(ardAlarmRadarMove.getAlarmTime());
                    radarMoveGuide(ardAlarmRadarMove);//引导
                }
                ardAlarmRadarMoveMapper.updateArdAlarmRadarMove(updateData);
            } else {
                //超过10秒的数据,入库
                ardAlarmRadarMove.setGuideTime(ardAlarmRadarMove.getAlarmTime());
                ardAlarmRadarMoveMapper.insertArdAlarmRadarMove(ardAlarmRadarMove);
                radarMoveGuide(ardAlarmRadarMove);//引导
            }
        }
    }

    /**
     * 雷达红外防火报警处理
     * 刘苏义
     * 2023/12/14 15:03:23
     */
    private void ardAlarmRadarFireHandler(ArdAlarmRadarFire ardAlarmRadarFire) {
        String mergeTime = ConfigUtils.getConfigValue("radarMergeTime");
        Integer radarMergeTime = mergeTime == null || "".equals(mergeTime) ? 10 : Integer.valueOf(mergeTime);
        ArdAlarmRadarFire lastFireData = ardAlarmRadarFireMapper.selectArdAlarmRadarLastData(ardAlarmRadarFire.getName());
        if (lastFireData == null) {
            //入库
            ardAlarmRadarFire.setGuideTime(ardAlarmRadarFire.getAlarmTime());
            ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
            radarFireGuide(ardAlarmRadarFire);//引导
        } else {
            //否则比对更新时间
            Date lastUpdateTime = lastFireData.getUpdateTime();
            Date lastGuideTime = lastFireData.getGuideTime();
            long secDatePoor = DateUtils.getSecDatePoor(ardAlarmRadarFire.getAlarmTime(), lastUpdateTime);
            if (secDatePoor <= radarMergeTime) {
                //小于10秒的新数据，更新上一条
                ArdAlarmRadarFire updateData = new ArdAlarmRadarFire();
                updateData.setId(lastFireData.getId());
                updateData.setUpdateTime(ardAlarmRadarFire.getAlarmTime());

                //判断引导时间超过5分钟再次引导
                long secDatePoorGuide = DateUtils.getSecDatePoor(ardAlarmRadarFire.getAlarmTime(), lastGuideTime);
                if (secDatePoorGuide >= 300) {
                    updateData.setGuideTime(ardAlarmRadarFire.getAlarmTime());
                    radarFireGuide(ardAlarmRadarFire);//引导
                }
                ardAlarmRadarFireMapper.updateArdAlarmRadarFire(updateData);
            } else {
                //超过10秒的数据,入库
                ardAlarmRadarFire.setGuideTime(ardAlarmRadarFire.getAlarmTime());
                ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
                radarFireGuide(ardAlarmRadarFire);//引导
            }
        }
    }

    /**
     * 雷达抽油机停机报警处理
     * 刘苏义
     * 2023/12/14 15:03:06
     */
    private void ardAlarmRadarPumpHandler(ArdAlarmRadarPump ardAlarmRadarPump) {
        String mergeTime = ConfigUtils.getConfigValue("radarMergeTime");
        Integer radarMergeTime = mergeTime == null || "".equals(mergeTime) ? 10 : Integer.valueOf(mergeTime);
        ArdAlarmRadarPump lastPumpData = ardAlarmRadarPumpMapper.selectArdAlarmRadarLastData(ardAlarmRadarPump.getName());
        if (lastPumpData == null) {
            //入库
            ardAlarmRadarPump.setGuideTime(ardAlarmRadarPump.getAlarmTime());
            ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
            radarPumpGuide(ardAlarmRadarPump);//引导
        } else {
            //否则比对更新时间
            Date lastUpdateTime = lastPumpData.getUpdateTime();
            Date lastGuideTime = lastPumpData.getGuideTime();
            long secDatePoor = DateUtils.getSecDatePoor(ardAlarmRadarPump.getAlarmTime(), lastUpdateTime);
            if (secDatePoor <= radarMergeTime) {
                //小于10秒的新数据，更新上一条
                ArdAlarmRadarPump updateData = new ArdAlarmRadarPump();
                updateData.setId(lastPumpData.getId());
                updateData.setUpdateTime(ardAlarmRadarPump.getAlarmTime());
                //判断引导时间超过5分钟再次引导
                long secDatePoorGuide = DateUtils.getSecDatePoor(ardAlarmRadarPump.getAlarmTime(), lastGuideTime);
                if (secDatePoorGuide >= 300) {
                    radarPumpGuide(ardAlarmRadarPump);//引导
                    updateData.setGuideTime(ardAlarmRadarPump.getAlarmTime());
                }
                ardAlarmRadarPumpMapper.updateArdAlarmRadarPump(updateData);
            } else {
                //超过10秒的数据,入库
                ardAlarmRadarPump.setGuideTime(ardAlarmRadarPump.getAlarmTime());
                ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
                radarPumpGuide(ardAlarmRadarPump);//引导
            }
        }
    }
}