1、增加指令首次下发的时候，发送RCP查询请求到RCP查询程序。

2、动态规则update bugfix
3、静态规则协议为空，生成指令时候报错NULLPOINT fix

src/main/java/com/realtime/protection/server/alertmessage/AlertMessageService.java

@@ -155,7 +155,16 @@ public class AlertMessageService {
                     dynamicTaskCommandInfoList.get(0).getTaskId(),
                     commandUUIDs));
         }
-
+        //发送RCP查询信号
+        try {
+            if (isJudged){
+                stateHandler.sendCommandRcpQuerySignal(commandUUIDs);
+            }
+        }catch (Exception e) {
+            log.info(String.format("动态任务首次指令查询RCP出错，任务id: %d,commandUUIDs: %s",
+                    dynamicTaskCommandInfoList.get(0).getTaskId(),
+                    commandUUIDs));
+        }
     }
     private String insertAlertMessageOnly(AlertMessage alertMessage){
         //alertmessage入库

src/main/java/com/realtime/protection/server/command/CommandService.java

@@ -140,18 +140,30 @@ public class CommandService {
         //设置指令是否已经研判
         Boolean success = commandMapper.setCommandJudged(commandId, isJudged);
 
-        //isJudged为true时，发送指令首次 下发信号
         try {
             List<String> commandUUIDs = Collections.singletonList(commandId);
-            if (isJudged){
+            if (!isJudged) {
-                stateHandler.sendCommandDistributeSignal(commandUUIDs);
+                return success;
             }
-        }catch (Exception e) {
+            //指令首次下发
+            try {
+                stateHandler.sendCommandDistributeSignal(commandUUIDs);
+            } catch (Exception e) {
                 log.info(String.format("动态任务研判后任务首次指令下发c3出错，任务id: %d,commandUUIDs: %s",
                         queryCommandInfoByUUID(commandId).getTaskId(),
                         commandId));
             }
-
+            //指令首次查询RCP
+            try {
+                stateHandler.sendCommandRcpQuerySignal(commandUUIDs);
+            } catch (Exception e) {
+                log.info(String.format("动态任务研判后任务首次查询RCP出错，任务id: %d,commandUUIDs: %s",
+                        queryCommandInfoByUUID(commandId).getTaskId(),
+                        commandId));
+            }
+        }catch (Exception e){
+            throw new IllegalArgumentException("指令研判状态修改失败,无效的指令");
+        }
         return success;
     }
 

src/main/java/com/realtime/protection/server/task/TaskService.java

@@ -370,7 +370,9 @@ public class TaskService {
 
         staticCommandInfos.forEach(taskCommandInfo -> {
 //            taskCommandInfo.setProtocolNum();
+            if (taskCommandInfo.getFiveTupleWithMask().getProtocol() != null) {
                 taskCommandInfo.getFiveTupleWithMask().setProtocolNum(Integer.valueOf(taskCommandInfo.getFiveTupleWithMask().getProtocol()));
+            }
 //            taskCommandInfo.setMask();
         });
 

src/main/java/com/realtime/protection/server/task/status/StateHandler.java

@@ -30,14 +30,18 @@ public class StateHandler {
 
 
     private final WebClient client = WebClient.builder()
-            .baseUrl("http://192.168.107.49:8088")
+//            .baseUrl("http://192.168.107.49:8088")
-//            .baseUrl("http://10.58.72.151:8088")
+            .baseUrl("http://10.58.72.146:8088")
             .build();
 
     //http://10.26.22.123:17011/rule
     private final WebClient client_commandDistribute = WebClient.builder()
-            .baseUrl("http://10.26.22.123:17011")
+//            .baseUrl("http://10.26.22.123:17011")
-//            .baseUrl("http://10.58.72.151:8088")
+            .baseUrl("http://10.58.72.151:17011")
+            .build();
+
+    private final WebClient client_RCPquery = WebClient.builder()
+            .baseUrl("http://10.58.72.140:8088")
             .build();
 
     protected Boolean handleStart(TaskService taskService, CommandService commandService, Long taskId) {
@@ -125,15 +129,16 @@ public class StateHandler {
     // 如果是实时任务或者研判后处置任务，那么就需要在任务启动之后，立刻向动态规则中指定的系统发送日志筛选请求。
     // 筛选完成后，系统返回日志，需要由接收端点提取字段，并且合成一条静态规则，再按照任务开始时间、结束时间和任务类型进行指令创建
     private Boolean handleJudgedTaskStart(TaskService taskService, Task task) {
-        return sendFilters(taskService, task);
+//        return sendFilters(taskService, task);
+        return true;
     }
 
     private Boolean handleDynamicTaskStart(TaskService taskService, Task task) {
         // 将所有关联的动态规则审批状态修改为“已使用”
         taskService.updateDynamicRuleAuditStatusInTask(task.getTaskId(), AuditStatusEnum.USING);
-        return sendFilters(taskService, task);
+//        return sendFilters(taskService, task);
 
-//        return true;
+        return true;
     }
 
     private Boolean handleStaticTaskStart(CommandService commandService, TaskService taskService, Task task) {
@@ -151,12 +156,18 @@ public class StateHandler {
         // 将command新建信号发送到c3下发程序
         try {
             sendCommandDistributeSignal(commandUUIDs);
-            return true;
         } catch (Exception e) {
             log.error(String.format("静态任务%d 首次指令下发c3出错",task.getTaskId()));
             return true;
         }
-
+        // 将command查询RCP信号发送到RCP查询程序
+        try {
+            sendCommandRcpQuerySignal(commandUUIDs);
+        } catch (Exception e) {
+            log.error(String.format("静态任务%d 首次指令查询RCP出错",task.getTaskId()));
+            return true;
+        }
+        return true;
     }
     public Boolean sendCommandDistributeSignal(List<String> commandUUIDs) {
 
@@ -197,6 +208,49 @@ public class StateHandler {
 
         return success.get();
     }
+
+
+    public Boolean sendCommandRcpQuerySignal(List<String> commandUUIDs) {
+
+        List<Map<String, String>> commandIDMaps = new ArrayList<>();
+        for (String commandUUID : commandUUIDs) {
+            commandIDMaps.add(Map.of("COMMAND_ID", commandUUID));
+        }
+
+        AtomicReference<Boolean> success = new AtomicReference<>(false);
+
+
+        Mono<Map> mono = client_RCPquery.post()
+                .uri("/command")
+                .bodyValue(commandIDMaps)
+                .accept(MediaType.APPLICATION_JSON)
+                .exchangeToMono(res -> {
+                    if (res.statusCode().equals(HttpStatus.OK)) {
+                        return res.bodyToMono(Map.class);
+                    }
+                    return res.createError();
+                })
+                .doOnError(WebClientResponseException.class, res -> success.set(false));
+
+
+        Map<String, Integer> response = mono.block(Duration.ofSeconds(5));
+
+        if (response == null) {
+            log.info("指令首次查询RCP返回为null");
+            return false;
+        }
+        response.forEach((commandUUID, responseCode) -> {
+            log.info("指令首次查询RCP成功, 指令uuid: " + commandUUID + ", responseCode: " + responseCode);
+            if (responseCode != 0) {
+                log.warn("指令首次查询RCP失败, 指令uuid: " + commandUUID + ", responseCode: " + responseCode);
+            }
+        });
+
+        success.set(true);
+
+        return success.get();
+    }
+
     private Boolean sendFilters(TaskService taskService, Task task) {
         List<DynamicTaskInfo> dynamicTaskInfos = taskService.getDynamicTaskInfos(task.getTaskId());
 

src/main/resources/mappers/DynamicRuleMapper.xml

@@ -165,7 +165,7 @@
         <if test="object.description != null">description = #{object.description},</if>
         <if test="object.dynamicRuleSourceSystem != null">source_system = #{object.dynamicRuleSourceSystem},</if>
         <if test="object.bwSql != null">bw_sql = #{object.bwSql},</if>
-        modify_time = NOW()
+        modify_time = NOW(),
         audit_status = #{object.auditStatus}
         where
         dynamic_rule_id = #{dynamicRuleId}