@lcap/nasl 3.2.0-beta.3 → 3.3.0-alpha

package/src/server/extendBaseNode.ts

@@ -1,528 +1,533 @@
-import { FileNode, NaslServer } from './naslServer';
 import * as tsProtocol from 'typescript/lib/protocol';
+import { FileNode, NaslServer } from './naslServer';
 import { MinRange } from './translator';
-import { BaseNode, CallLogic, Destination, EnumItem, Interface, Logic, Param, Process, Role, Structure, View, ViewElement, Frontend, TypeAnnotation, StructureProperty, App, AuthInterface, CallAuthInterface, Connector, MsgTriggerLauncher } from '../concepts';
+import {
+  BaseNode,
+  CallLogic,
+  Destination,
+  EnumItem,
+  Interface,
+  Logic,
+  Param,
+  Process,
+  Role,
+  Structure,
+  View,
+  ViewElement,
+  Frontend,
+  TypeAnnotation,
+  StructureProperty,
+  App,
+  AuthInterface,
+  CallAuthInterface,
+  Connector,
+  MsgTriggerLauncher,
+  Connection,
+} from '../concepts';
 import { EventPayload, invokeCommand, registerCommand } from '../common';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 import { extendSentryMonitorNaslNode } from '../sentry';
 
 interface SetNameNode extends BaseNode {
-    setName(name: string): any;
-    [propname: string]: any;
+  setName(name: string): any;
+  [propname: string]: any;
 }
 
 BaseNode.prototype.findReadOnlyLogicUsage = function () {
-    let targetNode;
+  let targetNode;
 
-    if (this.parentNode.concept === 'Namespace' || this.parentNode.parentNode.concept === 'Namespace') {
-        const sourceMap = this.parentNode.concept === 'Namespace' ? this.parentNode.parentNode.sourceMap : this.parentNode.parentNode.parentNode.sourceMap;
-        for (const item of sourceMap) {
-            const logic = item[0] as Logic;
-            if (this.concept === 'Logic') {
-                if (logic instanceof Logic)
-                    if (logic.calleewholeKey === (this as Logic).calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            } else {
-                if (logic instanceof Logic)
-                    if (logic.calleewholeKey === (this.parentNode as Logic).calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            }
+  if (this.parentNode.concept === 'Namespace' || this.parentNode.parentNode.concept === 'Namespace') {
+    const sourceMap =
+      this.parentNode.concept === 'Namespace' ? this.parentNode.parentNode.sourceMap : this.parentNode.parentNode.parentNode.sourceMap;
+    for (const item of sourceMap) {
+      const logic = item[0] as Logic;
+      if (this.concept === 'Logic') {
+        if (logic instanceof Logic)
+          if (logic.calleewholeKey === (this as Logic).calleewholeKey) {
+            targetNode = logic;
+            break;
+          }
+      } else if (logic instanceof Logic)
+        if (logic.calleewholeKey === (this.parentNode as Logic).calleewholeKey) {
+          targetNode = logic;
+          break;
         }
-    } else if (this.parentNode.concept === 'Module') {
-        // 父级是模块的还是用它本身去查找引用
-        targetNode = this;
-    } else {
-        const sourceMap = this.parentNode.sourceMap;
-        for (const item of sourceMap) {
-            const logic = item[0] as Logic;
-            if (logic.calleewholeKey && logic.calleewholeKey === (this as Logic).calleewholeKey) {
-                targetNode = logic;
-                break;
-            }
-        }
-        if (!targetNode)
-            for (const item of sourceMap) {
-                const logic = item[0] as Logic;
-                if (logic.getNamespace && logic.getNamespace() === (this as Logic).getNamespace()) {
-                    targetNode = logic;
-                    break;
-                }
-            }
     }
-
-    try {
-        const app = this.getAncestor('App');
-        const naslServer = (app as any).naslServer as NaslServer;
-        return naslServer.findReferences(targetNode || this);
-    } catch (err) {
-        console.log(err);
+  } else if (this.parentNode.concept === 'Module') {
+    // 父级是模块的还是用它本身去查找引用
+    targetNode = this;
+  } else {
+    const { sourceMap } = this.parentNode;
+    for (const item of sourceMap) {
+      const logic = item[0] as Logic;
+      if (logic.calleewholeKey && logic.calleewholeKey === (this as Logic).calleewholeKey) {
+        targetNode = logic;
+        break;
+      }
     }
+    if (!targetNode)
+      for (const item of sourceMap) {
+        const logic = item[0] as Logic;
+        if (logic.getNamespace && logic.getNamespace() === (this as Logic).getNamespace()) {
+          targetNode = logic;
+          break;
+        }
+      }
+  }
+
+  try {
+    const app = this.getAncestor('App');
+    const naslServer = (app as any).naslServer as NaslServer;
+    return naslServer.findReferences(targetNode || this);
+  } catch (err) {
+    console.log(err);
+  }
 };
 // 查找引用
 BaseNode.prototype.findUsage = function findUsage() {
-    try {
-        const app = this.getAncestor('App');
-        const naslServer = (app as any).naslServer as NaslServer;
-        return naslServer.findReferences(this);
-    } catch (err) {
-        console.log(err);
-    }
+  try {
+    const app = this.getAncestor('App');
+    const naslServer = (app as any).naslServer as NaslServer;
+    return naslServer.findReferences(this);
+  } catch (err) {
+    console.log(err);
+  }
 };
 
 // 通过当前节点，查找被引用的节点
 BaseNode.prototype.nodeFindRefNodes = function nodeFindRefNodes() {
-    try {
-        const app = this.getAncestor('App');
-        const naslServer = (app as any).naslServer as NaslServer;
-        return naslServer.nodeFindRefNodes(this);
-    } catch (err) {
-        console.log(err);
-    }
+  try {
+    const app = this.getAncestor('App');
+    const naslServer = (app as any).naslServer as NaslServer;
+    return naslServer.nodeFindRefNodes(this);
+  } catch (err) {
+    console.log(err);
+  }
 };
 
 BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = false) {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const app = this.getAncestor('App');
-        const naslServer = (app as any).naslServer as NaslServer;
-        const refsList = await naslServer._isHaveRef(this);
-        // 是不是有引用有的话，就返回
-        /**
-         * @param this 当前重命名的节点
-         * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
-         * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
-         * @returns 找到的引用
-         */
-        const res = naslServer._renamePrepare(this, refsList, newValue);
-        // 针对外部接口的鉴权方式，sourceMap 定位仅仅 定位到 CallAuthInterfacer
-        // 因此这里需要保存this来做上下文判断
-        const _this = this;
-        if (res.length <= 1) {
-            if (this.concept === 'enumItem') {
-                (this as any).setValue(newValue);
-            } else
-                (this as SetNameNode).setName(newValue);
+  try {
+    /**
+     * 查找这个节点是不是有依赖
+     */
+    const app = this.getAncestor('App');
+    const naslServer = (app as any).naslServer as NaslServer;
+    const refsList = await naslServer._isHaveRef(this);
+    // 是不是有引用有的话，就返回
+    /**
+     * @param this 当前重命名的节点
+     * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+     * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+     * @returns 找到的引用
+     */
+    const res = naslServer._renamePrepare(this, refsList, newValue);
+    // 针对外部接口的鉴权方式，sourceMap 定位仅仅 定位到 CallAuthInterfacer
+    // 因此这里需要保存this来做上下文判断
+    const _this = this;
+    if (res.length <= 1) {
+      if (this.concept === 'enumItem') {
+        (this as any).setValue(newValue);
+      } else (this as SetNameNode).setName(newValue);
+    } else {
+      const callback = (value: boolean) => {
+        if (value) {
+          const App = this.rootNode;
+          // 收集修改
+          App.emit('collect:start', {
+            actionMsg: '重命名并更新引用',
+          });
+          res.forEach((item) => {
+            const itemNode = item.node as SetNameNode;
+            // MsgTriggerLauncher 比较特殊，实际更名的应该为成员表达式
+            if (itemNode instanceof MsgTriggerLauncher) {
+              itemNode.callBackLogic.setName(newValue);
+              return;
+            }
+            if (item.newValue) {
+              // 如果有指定的修改方法，就用那个，没有就修改名字
+              if (item.setTypeMethods) {
+                const func = itemNode && itemNode[item.setTypeMethods];
+                typeof func === 'function' && itemNode[item.setTypeMethods](item.newValue);
+              } else {
+                itemNode.setName?.(item.newValue);
+              }
+            } else if (_this.concept === 'AuthLogicForCallInterface' && itemNode.concept === 'CallAuthInterface') {
+              const { calleewholeKey } = itemNode;
+              const targetItf: AuthInterface = getNodeByNodeCallee(App, calleewholeKey);
+              targetItf.setAuthLogic(newValue);
+              // 需要触发更新，否则对应的ts文件不会更新会导致鉴权方式找不到报错
+              itemNode.update({});
+            } else {
+              item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
+            }
+          });
+          // 结束修改 ，批量操作
+          App.emit('collect:end');
         } else {
-            const callback = (value: boolean) => {
-                if (value) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '重命名并更新引用',
-                    });
-                    res.forEach((item) => {
-                        const itemNode = item.node as SetNameNode;
-                        // MsgTriggerLauncher 比较特殊，实际更名的应该为成员表达式
-                        if (itemNode instanceof MsgTriggerLauncher) {
-                            itemNode.callBackLogic.setName(newValue);
-                            return;
-                        }
-                        if (item.newValue) {
-                            // 如果有指定的修改方法，就用那个，没有就修改名字
-                            if (item.setTypeMethods) {
-                                const func = itemNode && itemNode[item.setTypeMethods];
-                                typeof func === 'function' && itemNode[item.setTypeMethods](item.newValue);
-                            } else {
-                                itemNode.setName?.(item.newValue);
-                            }
-                        } else {
-                            if (_this.concept === 'AuthLogicForCallInterface' && itemNode.concept === 'CallAuthInterface') {
-                                const { calleewholeKey } = itemNode;
-                                const targetItf: AuthInterface = getNodeByNodeCallee(App, calleewholeKey);
-                                targetItf.setAuthLogic(newValue);
-                                // 需要触发更新，否则对应的ts文件不会更新会导致鉴权方式找不到报错
-                                itemNode.update({});
-                            } else {
-                                item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                } else {
-                    (this as SetNameNode).setName(newValue);
-                }
-            };
-            const confirmParms = {
-                actionType: 'rename',
-                node: this,
-                newValue,
-            };
-            /**
-             * nasl和vue的通信，回退，要触发vue的watch。
-             * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
-             * 先修改之
-             */
-            const closeCallBack = () => {
-                if (this.concept === 'EnumItem') {
-                    const oldValue = (this as EnumItem).value;
-                    (this as EnumItem).value = oldValue + ' ';
-                    setTimeout(() => {
-                        (this as EnumItem).value = oldValue;
-                    }, 0);
-                } else {
-                    const oldValue = this.name;
-                    this.name = oldValue + ' ';
-                    setTimeout(() => {
-                        this.name = oldValue;
-                    }, 0);
-                }
-            };
-            updateAll ? callback(true) : invokeCommand('tsConfirm.open', confirmParms, callback, closeCallBack);
-
-            return;
+          (this as SetNameNode).setName(newValue);
+        }
+      };
+      const confirmParms = {
+        actionType: 'rename',
+        node: this,
+        newValue,
+      };
+      /**
+       * nasl和vue的通信，回退，要触发vue的watch。
+       * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
+       * 先修改之
+       */
+      const closeCallBack = () => {
+        if (this.concept === 'EnumItem') {
+          const oldValue = (this as EnumItem).value;
+          (this as EnumItem).value = `${oldValue} `;
+          setTimeout(() => {
+            (this as EnumItem).value = oldValue;
+          }, 0);
+        } else {
+          const oldValue = this.name;
+          this.name = `${oldValue} `;
+          setTimeout(() => {
+            this.name = oldValue;
+          }, 0);
         }
-    } catch (err) {
-        console.log(err);
+      };
+      updateAll ? callback(true) : invokeCommand('tsConfirm.open', confirmParms, callback, closeCallBack);
     }
+  } catch (err) {
+    console.log(err);
+  }
 };
 
 /**
  * 准备删除
  */
 BaseNode.prototype.prepareDelete = async function prepareDelete(cb?: Function) {
-    try {
+  try {
+    /**
+     * 查找这个节点是不是有依赖
+     */
+    const app = this.getAncestor('App');
+    const naslServer = (app as any).naslServer as NaslServer;
+    const node = this;
+    let refsList = await naslServer._isHaveRef(node);
+    // 删除的时候过滤一把组件删除提示
+    refsList = refsList.filter(
+      (item) =>
+        // 因为ui组件本身会多渲染一次,就先过滤一个
+        !item.lineText.includes(': nasl.ui.')
+    );
+    // delete的弹框展示
+    const confirmParms = {
+      actionType: 'delete',
+      tipFlag: false,
+      node,
+      icon: 'warning',
+    };
+    let callback = null;
+    if (refsList.length <= 1 || (node instanceof Param && node.parentNode instanceof Logic && refsList.length <= 2)) {
+      // 平台类型直接删除然后return
+      if (node instanceof ViewElement) {
+        this.delete();
+        return;
+      }
+      callback = () => {
+        // Structure 和 Interface是内部有delete方法
+        if (node instanceof Structure || node instanceof Interface) {
+          (this as any).deleteLogincAndModule();
+        } else if (node instanceof Connection) {
+          delConnection(node);
+          if (cb) {
+            cb();
+          }
+        } else {
+          this.delete();
+        }
+      };
+    } else {
+      // 如果有依赖就有一个查找引用提示
+      confirmParms.tipFlag = true;
+      const node = this;
+
+      // 删除页面或者流程
+      if (node instanceof View || node instanceof Process || node instanceof Frontend) {
         /**
-         * 查找这个节点是不是有依赖
+         * 查找这个页面是不是有依赖
          */
-        const app = this.getAncestor('App');
-        const naslServer = (app as any).naslServer as NaslServer;
-        const node = this;
-        let refsList = await naslServer._isHaveRef(node);
-        // 删除的时候过滤一把组件删除提示
-        refsList = refsList.filter((item) =>
-            // 因为ui组件本身会多渲染一次,就先过滤一个
-            !(item.lineText.includes(': nasl.ui.')));
-        // delete的弹框展示
-        const confirmParms = {
-            actionType: 'delete',
-            tipFlag: false,
-            node,
-            icon: 'warning',
-        };
-        let callback = null;
-        if (refsList.length <= 1 || (node instanceof Param && node.parentNode instanceof Logic && refsList.length <= 2)) {
-            // 平台类型直接删除然后return
-            if (node instanceof ViewElement) {
-                this.delete();
-                return;
+        let viewPath = (this as FileNode).getEmbeddedFilePath();
+        viewPath = viewPath.slice(0, viewPath.length - 3);
+        const find = refsList.find((record) => !record.file.includes(viewPath));
+        // 如果没有别的文件的依赖，就直接delete
+        if (!find) {
+          if (node instanceof Process) {
+            const App = this.rootNode;
+            App.emit('collect:start', {
+              actionMsg: `删除流程${node.name}`,
+            });
+            await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
+            this.delete();
+            App.emit('collect:end');
+          } else {
+            this.delete();
+            if (node instanceof Frontend) {
+              return;
             }
-            callback = () => {
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof Structure || node instanceof Interface) {
-                    (this as any).deleteLogincAndModule();
-                } else if (node instanceof Connector) {
-                    delConnector(node, this);
-                    if (cb) {
-                        cb();
-                    }
-                } else {
-                    this.delete();
-                }
-            };
-        } else {
-            // 如果有依赖就有一个查找引用提示
-            confirmParms.tipFlag = true;
-            const node = this;
-
-            // 删除页面或者流程
-            if (node instanceof View || node instanceof Process || node instanceof Frontend) {
-                /**
-                 * 查找这个页面是不是有依赖
-                 */
-                let viewPath = (this as FileNode).getEmbeddedFilePath();
-                viewPath = viewPath.slice(0, viewPath.length - 3);
-                const find = refsList.find((record) => !record.file.includes(viewPath));
-                // 如果没有别的文件的依赖，就直接delete
-                if (!find) {
-                    if (node instanceof Process) {
-                        const App = this.rootNode;
-                        App.emit('collect:start', {
-                            actionMsg: `删除流程${node.name}`,
-                        });
-                        await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
-                        this.delete();
-                        App.emit('collect:end');
-                    } else {
-                        this.delete();
-                        if (node instanceof Frontend) {
-                            return;
-                        }
-                    }
-                    return;
-                } else {
-                    if (node instanceof Frontend) {
-                        let viewPath = (this as FileNode).getEmbeddedFilePath();
-                        viewPath = viewPath.slice(0, viewPath.length - 3);
-                        const refsTempList = refsList.filter((record) => !record.file.includes(viewPath));
-                        // 删除流程节点绑定的该端的页面跳转
-                        const result = refsTempList
-                            .map((record) => {
-                                const fileNode = naslServer.file2NodeMap.get(record.file);
-                                if (fileNode) {
-                                    const minRange = naslServer._findMinRange(record, fileNode as FileNode);
-                                    if (minRange?.node?.parentNode?.parentNode?.concept === 'ProcessElement') {
-                                        return minRange.node.parentNode;
-                                    }
-                                }
-                                return null;
-                            }).filter((record) => !!record);
-                        const App = this.rootNode;
-                        App.emit('collect:start', {
-                            actionMsg: `删除端${node.name}`,
-                        });
-                        await Promise.all(result.map((ele) => ele.delete()));
-                        this.delete();
-                        App.emit('collect:end');
-                        return;
-                    }
+          }
+          return;
+        }
+        if (node instanceof Frontend) {
+          let viewPath = (this as FileNode).getEmbeddedFilePath();
+          viewPath = viewPath.slice(0, viewPath.length - 3);
+          const refsTempList = refsList.filter((record) => !record.file.includes(viewPath));
+          // 删除流程节点绑定的该端的页面跳转
+          const result = refsTempList
+            .map((record) => {
+              const fileNode = naslServer.file2NodeMap.get(record.file);
+              if (fileNode) {
+                const minRange = naslServer._findMinRange(record, fileNode as FileNode);
+                if (minRange?.node?.parentNode?.parentNode?.concept === 'ProcessElement') {
+                  return minRange.node.parentNode;
                 }
+              }
+              return null;
+            })
+            .filter((record) => !!record);
+          const App = this.rootNode;
+          App.emit('collect:start', {
+            actionMsg: `删除端${node.name}`,
+          });
+          await Promise.all(result.map((ele) => ele.delete()));
+          this.delete();
+          App.emit('collect:end');
+          return;
+        }
+      }
+      callback = async () => {
+        // removeParam
+        // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
+        if (node instanceof Param) {
+          const App = this.rootNode;
+          const { parentNode } = this;
+          // 收集修改
+          App.emit('collect:start', {
+            actionMsg: '删除参数',
+          });
+          const Index = node.getIndexOfParent();
+          this.delete();
+          refsList.forEach((record) => {
+            const fileNode = naslServer.file2NodeMap.get(record.file);
+            if (!fileNode) return null;
+            const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
+            if (minRange) {
+              /**
+               * 调用方是 调用逻辑或者跳转页面， 去删除对应位置的内容
+               * 如果是跳转页面，因为流程下的特殊翻译，需要过滤下 非页面下的参数修改，查找到页面跳转
+               */
+              if (
+                minRange.node instanceof CallLogic ||
+                (node.parentNode instanceof View && minRange.node instanceof Destination) ||
+                minRange.node instanceof CallAuthInterface
+              ) {
+                minRange.node.deleteCalleeArg(Index);
+              }
             }
-            callback = async () => {
-                // removeParam
-                // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
-                if (node instanceof Param) {
-                    const App = this.rootNode;
-                    const parentNode = this.parentNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除参数',
-                    });
-                    const Index = node.getIndexOfParent();
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
-                        if (minRange) {
-                            /**
-                             * 调用方是 调用逻辑或者跳转页面， 去删除对应位置的内容
-                             * 如果是跳转页面，因为流程下的特殊翻译，需要过滤下 非页面下的参数修改，查找到页面跳转
-                             */
-                            if (minRange.node instanceof CallLogic || (node.parentNode instanceof View && minRange.node instanceof Destination) || minRange.node instanceof CallAuthInterface) {
-                                minRange.node.deleteCalleeArg(Index);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除logic节点，如果有对应的interface要一起删除
-                if (node instanceof Logic) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除逻辑并删除导出的接口',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof Interface) {
-                                minRange.node.delete();
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除权限节点
-                if (node instanceof Role) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除权限',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof View || minRange.node instanceof ViewElement) {
-                                // oldName旧的节点存的值
-                                // newValue用户输入值
-                                // node.bindRoles 存的
-                                const str = minRange.node.bindRoles.toString().replace(this.name, '');
-                                const newBindRoles = str.split(',').filter((item) => !!item);
-                                minRange.node.setBindRoles(newBindRoles);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
+          });
+          // 结束修改 ，批量操作
+          App.emit('collect:end');
+          return;
+        }
+        // 删除logic节点，如果有对应的interface要一起删除
+        if (node instanceof Logic) {
+          const App = this.rootNode;
+          // 收集修改
+          App.emit('collect:start', {
+            actionMsg: '删除逻辑并删除导出的接口',
+          });
+          this.delete();
+          refsList.forEach((record) => {
+            const fileNode = naslServer.file2NodeMap.get(record.file);
+            if (!fileNode) return null;
+            const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
+            if (minRange) {
+              if (minRange.node instanceof Interface) {
+                minRange.node.delete();
+              }
+            }
+          });
+          // 结束修改 ，批量操作
+          App.emit('collect:end');
+          return;
+        }
+        // 删除权限节点
+        if (node instanceof Role) {
+          const App = this.rootNode;
+          // 收集修改
+          App.emit('collect:start', {
+            actionMsg: '删除权限',
+          });
+          this.delete();
+          refsList.forEach((record) => {
+            const fileNode = naslServer.file2NodeMap.get(record.file);
+            if (!fileNode) return null;
+            const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
+            if (minRange) {
+              if (minRange.node instanceof View || minRange.node instanceof ViewElement) {
+                // oldName旧的节点存的值
+                // newValue用户输入值
+                // node.bindRoles 存的
+                const str = minRange.node.bindRoles.toString().replace(this.name, '');
+                const newBindRoles = str.split(',').filter((item) => !!item);
+                minRange.node.setBindRoles(newBindRoles);
+              }
+            }
+          });
+          // 结束修改 ，批量操作
+          App.emit('collect:end');
+          return;
+        }
 
-                // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
-                if (node instanceof View) {
-                    this.delete();
-                }
-                if (node instanceof Process) {
-                    const App = this.rootNode;
-                    App.emit('collect:start', {
-                        actionMsg: `删除流程${node.name}`,
-                    });
-                    await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
-                    this.delete();
-                    App.emit('collect:end');
-                }
+        // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
+        if (node instanceof View) {
+          this.delete();
+        }
+        if (node instanceof Process) {
+          const App = this.rootNode;
+          App.emit('collect:start', {
+            actionMsg: `删除流程${node.name}`,
+          });
+          await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
+          this.delete();
+          App.emit('collect:end');
+        }
 
-                if (node instanceof Connector) {
-                    delConnector(node, this);
-                    if (cb) {
-                        cb();
-                    }
-                }
-                // 其余的都直接调用删除
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof Structure || node instanceof Interface) {
-                    (this as any).deleteLogincAndModule();
-                } else {
-                    this.delete();
-                }
-            };
+        if (node instanceof Connection) {
+          delConnection(node);
+          if (cb) {
+            cb();
+          }
+          return;
+        }
+        // 其余的都直接调用删除
+        // Structure 和 Interface是内部有delete方法
+        if (node instanceof Structure || node instanceof Interface) {
+          (this as any).deleteLogincAndModule();
+        } else {
+          this.delete();
         }
-        invokeCommand('tsConfirm.open', confirmParms, callback);
-    } catch (err) {
-        console.log(err);
+      };
     }
+    invokeCommand('tsConfirm.open', confirmParms, callback);
+  } catch (err) {
+    console.log(err);
+  }
 };
 
 /** 删除连接器 */
-function delConnector(node: Connector, context:BaseNode) {
-    const app = context.rootNode as App;
-    const configGroup = app.configuration.groups.find((item) => item.name === 'connector');
-    const connectorsProperties = configGroup?.properties || [];
-    app.emit('collect:start', {
-        actionMsg: '删除连接器',
-    });
-
-    // 删除 configProperty
-    const delNames: string[] = [];
-    connectorsProperties.forEach((item) => {
-        if (item.name.startsWith(node.name)) {
-            delNames.push(item.name);
-        }
-    });
-    delNames.forEach((name) => {
-        configGroup.removeConfigProperty(name);
-    });
-
-    context.delete();
-
-    app.emit('collect:end');
+function delConnection(node: Connection) {
+  const app = node.rootNode as App;
+  app.emit('collect:start', {
+    actionMsg: '删除连接器',
+  });
+  node.delete();
+  app.emit('collect:end');
 }
 
 /**
  * 如果添加需要触发查找引用并且在之后，对内容产生影响
  */
 BaseNode.prototype.addParamsPrepare = async function addParamsPrepare(needAdd = true) {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const app = this.getAncestor('App');
-        const naslServer = (app as any).naslServer as NaslServer;
-        const refsList = await naslServer._isHaveRef(this);
-        return naslServer._addParamsPrepare(this, refsList, needAdd);
-    } catch (err) {
-        console.log(err);
-    }
+  try {
+    /**
+     * 查找这个节点是不是有依赖
+     */
+    const app = this.getAncestor('App');
+    const naslServer = (app as any).naslServer as NaslServer;
+    const refsList = await naslServer._isHaveRef(this);
+    return naslServer._addParamsPrepare(this, refsList, needAdd);
+  } catch (err) {
+    console.log(err);
+  }
 };
 
 /**
  * 在原型上增加方法来调用
  */
 BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnotation(outTime?: number) {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const app = this.getAncestor('App');
-        const naslServer = (app as any).naslServer as NaslServer;
-        return naslServer.getCurrentTypeAnnotation(this, outTime || 2000);
-    } catch (err) {
-        console.log(err);
-    }
+  try {
+    /**
+     * 查找这个节点是不是有依赖
+     */
+    const app = this.getAncestor('App');
+    const naslServer = (app as any).naslServer as NaslServer;
+    return await naslServer.getCurrentTypeAnnotation(this, outTime || 2000);
+  } catch (err) {
+    console.log(err);
+  }
 };
 
 function newNode(node: BaseNode, parentNode: BaseNode, needNewStructure: boolean) {
-    if (needNewStructure && node?.toJSON) {
-        return (BaseNode.from(node.toJSON(), parentNode, '') as Structure);
-    }
-    return (node as Structure);
+  if (needNewStructure && node?.toJSON) {
+    return BaseNode.from(node.toJSON(), parentNode, '') as Structure;
+  }
+  return node as Structure;
 }
 /**
  * 获取下一级变量
  */
 
 BaseNode.prototype.getSelectRef = function getSelectRef(newTypeAnnotation: TypeAnnotation, needNewStructure = false) {
-    try {
-        const typeAnnotation = newTypeAnnotation || (this as any).typeAnnotation || this.__TypeAnnotation;
-        const { typeName, typeKind, typeNamespace, typeArguments, properties: typeProperties } = typeAnnotation;
-        const parentNode = this;
-        let completionChildren: any;
-        if (typeKind === 'reference') {
-            if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process' || typeNamespace === 'nasl.auth' || typeNamespace === 'nasl.http') {
-                const node = newNode(getNaslNodeByNodeCallee(typeNamespace, typeName), parentNode, needNewStructure);
-                const properties = (node as Structure)?.properties || [];
-                completionChildren = properties;
-            } else if (typeNamespace.endsWith('.enums')) {
-                completionChildren = [];
-            } else {
-                let app: App;
-                if (this.concept === 'App') {
-                    app = (this as App);
-                } else {
-                    app = this.rootNode || typeAnnotation.app;
-                }
-                const node = newNode(getNodeByNodeCallee(app, typeNamespace + '.' + typeName), parentNode, needNewStructure);
-                const properties = node?.properties || [];
-                completionChildren = properties;
-            }
-        } else if (typeKind === 'generic') {
-            const node = newNode(getNaslNodeByNodeCallee(typeNamespace, typeName), parentNode, needNewStructure);
-            const properties = (node?.properties && [...node?.properties]) || [];
-            for (let i = 0; i < properties.length; i++) {
-                const item = properties[i];
-                if (item?.typeAnnotation?.typeKind === 'typeParam') {
-                    if (item.name === 'columnItem' && typeArguments[1]) {
-                        item.typeAnnotation = TypeAnnotation.from(typeArguments[1].toJSON(), node, 'typeAnnotation');
-                    } else {
-                        item.typeAnnotation = TypeAnnotation.from(typeArguments[0].toJSON(), node, 'typeAnnotation');
-                    }
-                    properties[i];
-                }
-            }
-            completionChildren = properties;
-        } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
-            const node = newNode(getNaslNodeByNodeCallee(typeNamespace, typeName), parentNode, needNewStructure);
-            const properties = (node?.properties && [...node?.properties]) || [];
-            completionChildren = properties;
-        } else if (typeKind === 'anonymousStructure' && typeProperties?.length) {
-            const node = newNode(typeAnnotation, parentNode, needNewStructure);
-            const properties = (node?.properties && [...node?.properties]) || [];
-            completionChildren = properties;
+  try {
+    const typeAnnotation = newTypeAnnotation || (this as any).typeAnnotation || this.__TypeAnnotation;
+    const { typeName, typeKind, typeNamespace, typeArguments, properties: typeProperties } = typeAnnotation;
+    const parentNode = this;
+    let completionChildren: any;
+    if (typeKind === 'reference') {
+      if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process' || typeNamespace === 'nasl.auth' || typeNamespace === 'nasl.http') {
+        const node = newNode(getNaslNodeByNodeCallee(typeNamespace, typeName), parentNode, needNewStructure);
+        const properties = (node as Structure)?.properties || [];
+        completionChildren = properties;
+      } else if (typeNamespace.endsWith('.enums')) {
+        completionChildren = [];
+      } else {
+        let app: App;
+        if (this.concept === 'App') {
+          app = this as App;
+        } else {
+          app = this.rootNode || typeAnnotation.app;
+        }
+        const node = newNode(getNodeByNodeCallee(app, `${typeNamespace}.${typeName}`), parentNode, needNewStructure);
+        const properties = node?.properties || [];
+        completionChildren = properties;
+      }
+    } else if (typeKind === 'generic') {
+      const node = newNode(getNaslNodeByNodeCallee(typeNamespace, typeName), parentNode, needNewStructure);
+      const properties = (node?.properties && [...node?.properties]) || [];
+      for (let i = 0; i < properties.length; i++) {
+        const item = properties[i];
+        if (item?.typeAnnotation?.typeKind === 'typeParam') {
+          if (item.name === 'columnItem' && typeArguments[1]) {
+            item.typeAnnotation = TypeAnnotation.from(typeArguments[1].toJSON(), node, 'typeAnnotation');
+          } else {
+            item.typeAnnotation = TypeAnnotation.from(typeArguments[0].toJSON(), node, 'typeAnnotation');
+          }
+          properties[i];
         }
-        return completionChildren;
-    } catch (err) {
-        console.log(err);
+      }
+      completionChildren = properties;
+    } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+      const node = newNode(getNaslNodeByNodeCallee(typeNamespace, typeName), parentNode, needNewStructure);
+      const properties = (node?.properties && [...node?.properties]) || [];
+      completionChildren = properties;
+    } else if (typeKind === 'anonymousStructure' && typeProperties?.length) {
+      const node = newNode(typeAnnotation, parentNode, needNewStructure);
+      const properties = (node?.properties && [...node?.properties]) || [];
+      completionChildren = properties;
     }
+    return completionChildren;
+  } catch (err) {
+    console.log(err);
+  }
 };
 
 extendSentryMonitorNaslNode(BaseNode);