Merge remote-tracking branch 'origin/master'

aijinhui

2023-09-07 2fa66c208202f420a5f001cf0d67e5aa1bf94578

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

@@ -283,7 +283,7 @@
                            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())
@@ -592,6 +592,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,7 +663,7 @@
                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;
                }
@@ -776,7 +777,7 @@
                                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);
                                //入库
@@ -791,7 +792,7 @@
                                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);
                                //入库
@@ -806,7 +807,7 @@
                                ardAlarmRadarPump.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarPump.setCreateTime(new Date());
                                ardAlarmRadarPump.setName(ardAlarmRadar.getName() + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarPump.setAlarmType("sys_radar_pump");
                                ardAlarmRadarPump.setAlarmType("雷达抽油机停机");
                                ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
                                if (StringUtils.isNotNull(ardAlarmpointsWell)) {
                                    ardAlarmRadarPump.setLongitude(ardAlarmpointsWell.getLongitude());
@@ -918,7 +919,15 @@
            //相机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 +937,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;
@@ -1016,9 +1025,13 @@
        //获取雷达所在塔上的大光电
        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);
@@ -1031,6 +1044,10 @@
            //如果报警点关联了光电
            messagesEnqueued(cameraId, alarmId, alarmType, createTime, 1, 2, coordinate);
        }
        else
        {
            log.debug("未获取到报警点关联的光电");
        }
    }


@@ -1039,49 +1056,51 @@
        //按兴趣点去重,然后按引导逻辑进行引导入队
        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
    }
@@ -1090,48 +1109,50 @@
        //按兴趣点去重,然后按引导逻辑进行引导入队
        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
    }
@@ -1140,48 +1161,50 @@
        //按兴趣点去重,然后按引导逻辑进行引导入队
        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
    }