Merge branch '20220705' into 'upgraded_version'

refactor: 规则链元数据管理抽取

See merge request huang/thingsboard3.3.2!116

@@ -258,52 +258,36 @@ public class ConvertConfigServiceImpl
   }
   }
 
 
   private boolean deleteConvertConfig(List<RuleNode> nodes, RuleChainMetaData ruleChainMetaData) {
   private boolean deleteConvertConfig(List<RuleNode> nodes, RuleChainMetaData ruleChainMetaData) {
-    boolean needDelete = true;
+
     // refactoring RuleChainMetaData
     // refactoring RuleChainMetaData
     AtomicInteger matchNode = new AtomicInteger(0);
     AtomicInteger matchNode = new AtomicInteger(0);
     nodes.forEach(
     nodes.forEach(
         deleteRuleNode -> {
         deleteRuleNode -> {
           int deleteIndex = 0;
           int deleteIndex = 0;
-
-          List<RuleNode> freshedNode = new ArrayList<>();
-          List<NodeConnectionInfo> freshedConnectionInfos = new ArrayList<>();
-
+          boolean needDelete = false;
           for (RuleNode ruleNode : ruleChainMetaData.getNodes()) {
           for (RuleNode ruleNode : ruleChainMetaData.getNodes()) {
             /**被删除节点右侧节点的下标左偏移1个量*/
             /**被删除节点右侧节点的下标左偏移1个量*/
             if (deleteRuleNode.getName().equals(ruleNode.getName())
             if (deleteRuleNode.getName().equals(ruleNode.getName())
                 && deleteRuleNode.getType().equals(ruleNode.getType())) {
                 && deleteRuleNode.getType().equals(ruleNode.getType())) {
-              int firestIndex = ruleChainMetaData.getFirstNodeIndex();
-              ruleChainMetaData.setFirstNodeIndex(
-                      Math.max(firestIndex< deleteIndex?firestIndex:firestIndex-1, 0));
-
-              for (NodeConnectionInfo nodeConnectionInfo : ruleChainMetaData.getConnections()) {
-                int fromIndex = nodeConnectionInfo.getFromIndex();
-                int toIndex = nodeConnectionInfo.getToIndex();
-                if (fromIndex != deleteIndex && toIndex != deleteIndex) {
-                  nodeConnectionInfo.setFromIndex(
-                      Math.max(fromIndex > deleteIndex ? fromIndex - 1 : fromIndex, 0));
-                  nodeConnectionInfo.setToIndex(
-                      Math.max(toIndex > deleteIndex ? toIndex - 1 : toIndex, 0));
-                  freshedConnectionInfos.add(nodeConnectionInfo);
-                }
-              }
-
+              needDelete = true;
               matchNode.getAndIncrement();
               matchNode.getAndIncrement();
-            } else {
-              freshedNode.add(ruleNode);
+              break;
             }
             }
             deleteIndex++;
             deleteIndex++;
           }
           }
-          ruleChainMetaData.setConnections(freshedConnectionInfos);
-          ruleChainMetaData.setNodes(freshedNode);
+
+          if (needDelete) {
+            // Delete Rule Node
+            freshRuleChainMetaData(ruleChainMetaData,deleteIndex);
+          }
         });
         });
 
 
     if (matchNode.get() == 0) {
     if (matchNode.get() == 0) {
-      needDelete = false;
+      return false;
     } else {
     } else {
       needDeleteOriginatorFieldsAndScript(ruleChainMetaData);
       needDeleteOriginatorFieldsAndScript(ruleChainMetaData);
     }
     }
-    return needDelete;
+    return true;
   }
   }
 
 
   private boolean deleteScene(RuleNode node, RuleChainMetaData ruleChainMetaData) {
   private boolean deleteScene(RuleNode node, RuleChainMetaData ruleChainMetaData) {
@@ -318,31 +302,51 @@ public class ConvertConfigServiceImpl
     }
     }
     if (needDelete) {
     if (needDelete) {
       // Delete Rule Node
       // Delete Rule Node
-      ruleChainMetaData.getNodes().remove(deleteIndex);
-      List<NodeConnectionInfo> newConnections = new ArrayList<>();
-      int finalDeleteIndex = deleteIndex;
-      // refactor connection
-      ruleChainMetaData
-          .getConnections()
-          .forEach(
-              nodeConnectionInfo -> {
-                int fromIndex = nodeConnectionInfo.getFromIndex();
-                int toIndex = nodeConnectionInfo.getToIndex();
-                if (finalDeleteIndex != nodeConnectionInfo.getToIndex()
-                    && nodeConnectionInfo.getFromIndex() != finalDeleteIndex) {
-                  nodeConnectionInfo.setFromIndex(
-                      Math.max(fromIndex > finalDeleteIndex ? fromIndex - 1 : fromIndex, 0));
-                  nodeConnectionInfo.setToIndex(
-                      Math.max(toIndex > finalDeleteIndex ? toIndex - 1 : toIndex, 0));
-                  newConnections.add(nodeConnectionInfo);
-                }
-              });
-      ruleChainMetaData.setConnections(newConnections);
-      ruleChainMetaData.setFirstNodeIndex(ruleChainMetaData.getFirstNodeIndex() - 1);
+      freshRuleChainMetaData(ruleChainMetaData,deleteIndex);
     }
     }
     return needDelete;
     return needDelete;
   }
   }
 
 
+  /**
+   * 刷新规则链的元数据
+   * @param ruleChainMetaData   规则链元数据
+   * @param removeNodeIndex     被删除的节点下标
+   */
+  private void freshRuleChainMetaData(RuleChainMetaData ruleChainMetaData,int removeNodeIndex){
+    ruleChainMetaData.getNodes().remove(removeNodeIndex);
+
+    int firestIndex = ruleChainMetaData.getFirstNodeIndex();
+    ruleChainMetaData.setFirstNodeIndex(Math.max(firestIndex< removeNodeIndex?firestIndex:firestIndex-1, 0));
+
+    ruleChainMetaData.setConnections(freshRelation(ruleChainMetaData.getConnections(),removeNodeIndex));
+  }
+
+  /**
+   * 刷新规则连中节点间的关联关系
+   * @param connections      节点关联关系
+   * @param removeNodeIndex  被删除的节点下标
+   * @return
+   */
+  private List<NodeConnectionInfo> freshRelation(List<NodeConnectionInfo> connections,int removeNodeIndex){
+    List<NodeConnectionInfo> newConnections = new ArrayList<>();
+
+    connections.forEach(
+            oldRelation -> {
+                      int fromIndex = oldRelation.getFromIndex();
+                      int toIndex = oldRelation.getToIndex();
+                      if (removeNodeIndex != fromIndex
+                              && removeNodeIndex != toIndex) {
+                        oldRelation.setFromIndex(
+                                Math.max(fromIndex > removeNodeIndex ? fromIndex - 1 : fromIndex, 0));
+                        oldRelation.setToIndex(
+                                Math.max(toIndex > removeNodeIndex ? toIndex - 1 : toIndex, 0));
+                        newConnections.add(oldRelation);
+                      }
+                    });
+
+    return newConnections;
+  }
+
   private void addConvertConfigRuleNode(List<RuleNode> nodes, RuleChainMetaData ruleChainMetaData) {
   private void addConvertConfigRuleNode(List<RuleNode> nodes, RuleChainMetaData ruleChainMetaData) {
     // 1. GET SAVE TIMESERIES‘S NODE INDEX
     // 1. GET SAVE TIMESERIES‘S NODE INDEX
     int seriesIndex = 0;
     int seriesIndex = 0;
@@ -422,10 +426,12 @@ public class ConvertConfigServiceImpl
       }
       }
     }
     }
     if (findSons == 0) {
     if (findSons == 0) {
-      deleteOriginatorFieldsAndScript(findOriginatorIndex, findScriptIndex, ruleChainMetaData);
+      freshRuleChainMetaData(ruleChainMetaData,findOriginatorIndex > findScriptIndex?findOriginatorIndex:findScriptIndex);
+      freshRuleChainMetaData(ruleChainMetaData,findOriginatorIndex > findScriptIndex?findScriptIndex:findOriginatorIndex);
     }
     }
   }
   }
 
 
+  @Deprecated
   private void deleteOriginatorFieldsAndScript(
   private void deleteOriginatorFieldsAndScript(
       int deleteOriginatorIndex, int deleteScriptIndex, RuleChainMetaData ruleChainMetaData) {
       int deleteOriginatorIndex, int deleteScriptIndex, RuleChainMetaData ruleChainMetaData) {
     ruleChainMetaData.getNodes().remove(deleteScriptIndex);
     ruleChainMetaData.getNodes().remove(deleteScriptIndex);