@lcap/nasl 3.4.0-beta.3 → 3.4.0-beta.4

package/src/concepts/Connector__.ts

@@ -13,6 +13,10 @@ import Logic from './Logic__';
 import ConnectorTrigger from './ConnectorTrigger__';
 import Structure from './Structure__';
 import Namespace from './Namespace__';
+import AuthLogic from './AuthLogic__';
+import AuthLogicForCallInterface from './AuthLogicForCallInterface__';
+import TriggerLauncher from './TriggerLauncher__';
+import Connection from './Connection__';
 import Module from './Module__';
 import View from './View__';
 import ProcessElement from './ProcessElement__';
@@ -30,6 +34,9 @@ export class Connector extends Module {
   /** 类名 */
   static readonly ConceptName = 'Connector';
 
+  /** 继承链 */
+  static readonly inheritanceChain = ['Module', 'BaseNode'];
+
   /**
    * 产品概念
    */
@@ -133,6 +140,52 @@ export class Connector extends Module {
   })
   namespaces: Array<Namespace> = [];
 
+  /**
+   * 暴露接口的接口鉴权
+   */
+  @property({
+    objectRef: 'AuthLogic',
+    isArray: true,
+    defaultValue: [],
+  })
+  authLogics: Array<AuthLogic> = [];
+
+  /**
+   * 调用接口的鉴权模板
+   */
+  @property({
+    objectRef: 'AuthLogicForCallInterface',
+    isArray: true,
+    defaultValue: [],
+  })
+  authLogicsForCallInterface: Array<AuthLogicForCallInterface> = [];
+
+  /**
+   * 触发器启动器列表
+   */
+  @property({
+    objectRef: 'TriggerLauncher',
+    isArray: true,
+    defaultValue: [],
+  })
+  triggerLaunchers: Array<TriggerLauncher> = [];
+
+  /**
+   * 连接列表
+   */
+  @property({
+    objectRef: 'Connection',
+    isArray: true,
+    defaultValue: [],
+  })
+  connections: Array<Connection> = [];
+
+  /**
+   * isLocal
+   */
+  @property()
+  isLocal: boolean = true;
+
   /**
    * 祖先 Module
    */
@@ -175,7 +228,7 @@ export class Connector extends Module {
    */
   constructor(source?: Partial<Connector>) {
     source = Object.assign({}, Connector.getDefaultOptions(), source);
-    super(source as any);
+    super(source);
     super.subConstructor(source);
   }
 
@@ -316,6 +369,18 @@ export class Connector extends Module {
     });
   }
 
+  /**
+   * 设置isLocal
+   */
+  setIsLocal(isLocal: boolean) {
+    const object = {
+      isLocal,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
   getParamExistingNames(excludedList: Array<Param> = []) {
     const excludedSet = new Set(excludedList);
     return ((this.properties as Param[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -482,23 +547,23 @@ export class Connector extends Module {
    * @internal
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _insertLogicAt(name: string, index: number): Logic;
+  _insertLogicInLogicsAt(name: string, index: number): Logic;
 
   /**
    * 插入逻辑
    * @internal
    * @param logicOptions 逻辑参数
    */
-  _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+  _insertLogicInLogicsAt(logicOptions: Partial<Logic>, index: number): Logic;
 
   /**
    * 插入逻辑
    * @internal
    * @param logic 已有的逻辑实例
    */
-  _insertLogicAt(logic: Logic, index: number): Logic;
+  _insertLogicInLogicsAt(logic: Logic, index: number): Logic;
 
-  _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+  _insertLogicInLogicsAt(options: string | Partial<Logic> | Logic, index: number) {
     const logicOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'logics' };
     let logic: Logic;
@@ -542,22 +607,22 @@ export class Connector extends Module {
    * 插入逻辑
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  insertLogicAt(name: string, index: number): Logic;
+  insertLogicInLogicsAt(name: string, index: number): Logic;
 
   /**
    * 插入逻辑
    * @param logicOptions 逻辑参数
    */
-  insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+  insertLogicInLogicsAt(logicOptions: Partial<Logic>, index: number): Logic;
 
   /**
    * 插入逻辑
    * @param logic 已有的逻辑实例
    */
-  insertLogicAt(logic: Logic, index: number): Logic;
+  insertLogicInLogicsAt(logic: Logic, index: number): Logic;
 
-  insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
-    const node = this._insertLogicAt(options as any, index);
+  insertLogicInLogicsAt(options: string | Partial<Logic> | Logic, index: number) {
+    const node = this._insertLogicInLogicsAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -571,25 +636,25 @@ export class Connector extends Module {
    * @internal
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _addLogic(name?: string): Logic;
+  _addLogicInLogics(name?: string): Logic;
 
   /**
    * 添加逻辑
    * @internal
    * @param logicOptions 逻辑参数
    */
-  _addLogic(logicOptions: Partial<Logic>): Logic;
+  _addLogicInLogics(logicOptions: Partial<Logic>): Logic;
 
   /**
    * 添加逻辑
    * @internal
    * @param logic 已有的逻辑实例
    */
-  _addLogic(logic: Logic): Logic;
+  _addLogicInLogics(logic: Logic): Logic;
 
-  _addLogic(options?: string | Partial<Logic> | Logic) {
+  _addLogicInLogics(options?: string | Partial<Logic> | Logic) {
     const index = this.logics.length;
-    return this._insertLogicAt(options as any, index);
+    return this._insertLogicInLogicsAt(options as any, index);
   }
 
   /**
@@ -597,22 +662,22 @@ export class Connector extends Module {
    * @internal
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  addLogic(name?: string): Logic;
+  addLogicInLogics(name?: string): Logic;
 
   /**
    * 添加逻辑
    * @param logicOptions 逻辑参数
    */
-  addLogic(logicOptions: Partial<Logic>): Logic;
+  addLogicInLogics(logicOptions: Partial<Logic>): Logic;
 
   /**
    * 添加逻辑
    * @param logic 已有的逻辑实例
    */
-  addLogic(logic: Logic): Logic;
+  addLogicInLogics(logic: Logic): Logic;
 
-  addLogic(options?: string | Partial<Logic> | Logic) {
-    const node = this._addLogic(options as any);
+  addLogicInLogics(options?: string | Partial<Logic> | Logic) {
+    const node = this._addLogicInLogics(options as any);
     const index = this.logics.indexOf(node);
     node.create({
       index,
@@ -1083,6 +1148,314 @@ export class Connector extends Module {
     return node;
   }
 
+  getTriggerLauncherExistingNames(excludedList: Array<TriggerLauncher> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.triggerLaunchers as TriggerLauncher[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
+  }
+  getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
+    return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入触发器启动器
+   * @internal
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   */
+  _insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
+
+  /**
+   * 插入触发器启动器
+   * @internal
+   * @param triggerLauncherOptions 触发器启动器参数
+   */
+  _insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
+
+  /**
+   * 插入触发器启动器
+   * @internal
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  _insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
+
+  _insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
+    const triggerLauncherOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
+    let triggerLauncher: TriggerLauncher;
+    if (!options) {
+      triggerLauncher = TriggerLauncher.from(
+        {
+          ...triggerLauncherOptions,
+          name: this.getTriggerLauncherUniqueName(),
+        },
+        this,
+        'triggerLaunchers',
+      );
+    } else if (typeof options === 'string') {
+      triggerLauncher = TriggerLauncher.from(
+        {
+          ...triggerLauncherOptions,
+          name: options,
+        },
+        this,
+        'triggerLaunchers',
+      );
+    } else if (options instanceof TriggerLauncher) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      triggerLauncher = options;
+      Object.assign(triggerLauncher, relationOptions);
+    } else {
+      triggerLauncher = TriggerLauncher.from(
+        {
+          ...triggerLauncherOptions,
+          ...options,
+        },
+        this,
+        'triggerLaunchers',
+      );
+    }
+    this.triggerLaunchers.splice(index, 0, triggerLauncher);
+    return triggerLauncher;
+  }
+
+  /**
+   * 插入触发器启动器
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   */
+  insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
+
+  /**
+   * 插入触发器启动器
+   * @param triggerLauncherOptions 触发器启动器参数
+   */
+  insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
+
+  /**
+   * 插入触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
+
+  insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
+    const node = this._insertTriggerLauncherAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'triggerLaunchers',
+    });
+    return node;
+  }
+
+  /**
+   * 添加触发器启动器
+   * @internal
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   */
+  _addTriggerLauncher(name?: string): TriggerLauncher;
+
+  /**
+   * 添加触发器启动器
+   * @internal
+   * @param triggerLauncherOptions 触发器启动器参数
+   */
+  _addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
+
+  /**
+   * 添加触发器启动器
+   * @internal
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  _addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
+
+  _addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
+    const index = 0;
+    return this._insertTriggerLauncherAt(options as any, index);
+  }
+
+  /**
+   * 添加触发器启动器
+   * @internal
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   */
+  addTriggerLauncher(name?: string): TriggerLauncher;
+
+  /**
+   * 添加触发器启动器
+   * @param triggerLauncherOptions 触发器启动器参数
+   */
+  addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
+
+  /**
+   * 添加触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
+
+  addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
+    const node = this._addTriggerLauncher(options as any);
+    const index = this.triggerLaunchers.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'triggerLaunchers',
+    });
+    return node;
+  }
+
+  getConnectionExistingNames(excludedList: Array<Connection> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.connections as Connection[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getConnectionUniqueName(name = 'connection1') {
+    return utils.unique(name, this.getConnectionExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入连接
+   * @internal
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   */
+  _insertConnectionAt(name: string, index: number): Connection;
+
+  /**
+   * 插入连接
+   * @internal
+   * @param connectionOptions 连接参数
+   */
+  _insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+
+  /**
+   * 插入连接
+   * @internal
+   * @param connection 已有的连接实例
+   */
+  _insertConnectionAt(connection: Connection, index: number): Connection;
+
+  _insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
+    const connectionOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'connections' };
+    let connection: Connection;
+    if (!options) {
+      connection = Connection.from(
+        {
+          ...connectionOptions,
+          name: this.getConnectionUniqueName(),
+        },
+        this,
+        'connections',
+      );
+    } else if (typeof options === 'string') {
+      connection = Connection.from(
+        {
+          ...connectionOptions,
+          name: options,
+        },
+        this,
+        'connections',
+      );
+    } else if (options instanceof Connection) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      connection = options;
+      Object.assign(connection, relationOptions);
+    } else {
+      connection = Connection.from(
+        {
+          ...connectionOptions,
+          ...options,
+        },
+        this,
+        'connections',
+      );
+    }
+    this.connections.splice(index, 0, connection);
+    return connection;
+  }
+
+  /**
+   * 插入连接
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   */
+  insertConnectionAt(name: string, index: number): Connection;
+
+  /**
+   * 插入连接
+   * @param connectionOptions 连接参数
+   */
+  insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+
+  /**
+   * 插入连接
+   * @param connection 已有的连接实例
+   */
+  insertConnectionAt(connection: Connection, index: number): Connection;
+
+  insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
+    const node = this._insertConnectionAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'connections',
+    });
+    return node;
+  }
+
+  /**
+   * 添加连接
+   * @internal
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   */
+  _addConnection(name?: string): Connection;
+
+  /**
+   * 添加连接
+   * @internal
+   * @param connectionOptions 连接参数
+   */
+  _addConnection(connectionOptions: Partial<Connection>): Connection;
+
+  /**
+   * 添加连接
+   * @internal
+   * @param connection 已有的连接实例
+   */
+  _addConnection(connection: Connection): Connection;
+
+  _addConnection(options?: string | Partial<Connection> | Connection) {
+    const index = 0;
+    return this._insertConnectionAt(options as any, index);
+  }
+
+  /**
+   * 添加连接
+   * @internal
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   */
+  addConnection(name?: string): Connection;
+
+  /**
+   * 添加连接
+   * @param connectionOptions 连接参数
+   */
+  addConnection(connectionOptions: Partial<Connection>): Connection;
+
+  /**
+   * 添加连接
+   * @param connection 已有的连接实例
+   */
+  addConnection(connection: Connection): Connection;
+
+  addConnection(options?: string | Partial<Connection> | Connection) {
+    const node = this._addConnection(options as any);
+    const index = this.connections.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'connections',
+    });
+    return node;
+  }
+
   /**
    * 删除输入参数
    * @param name 输入参数名称
@@ -1124,7 +1497,8 @@ export class Connector extends Module {
       // @ts-ignore
       const n = param.__v_raw || param;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -1210,6 +1584,60 @@ export class Connector extends Module {
     return testConnectorLogic.delete();
   }
 
+  /**
+   * 删除鉴权逻辑
+   * @param name 鉴权逻辑名称
+   */
+  removeAuthLogicInAuthLogics(name: string): void;
+
+  /**
+   * 删除鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  removeAuthLogicInAuthLogics(authLogic: AuthLogic): void;
+
+  removeAuthLogicInAuthLogics(options: string | AuthLogic) {
+    let authLogic: AuthLogic;
+    if (typeof options === 'string') {
+      authLogic = (this.authLogics as AuthLogic[]).find((item) => item.name === options);
+      if (!authLogic) {
+        throw new Error('找不到鉴权逻辑 ' + options);
+      }
+    } else {
+      authLogic = options;
+    }
+    return authLogic.delete();
+  }
+
+  /**
+   * 删除调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称
+   */
+  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(name: string): void;
+
+  /**
+   * 删除调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+  ): void;
+
+  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(options: string | AuthLogicForCallInterface) {
+    let authLogicForCallInterface: AuthLogicForCallInterface;
+    if (typeof options === 'string') {
+      authLogicForCallInterface = (this.authLogicsForCallInterface as AuthLogicForCallInterface[]).find(
+        (item) => item.name === options,
+      );
+      if (!authLogicForCallInterface) {
+        throw new Error('找不到调用接口的鉴权逻辑 ' + options);
+      }
+    } else {
+      authLogicForCallInterface = options;
+    }
+    return authLogicForCallInterface.delete();
+  }
+
   __removeLogic(logic: Logic) {
     const parentKey = logic.parentKey;
     const params: Params = {
@@ -1226,7 +1654,8 @@ export class Connector extends Module {
       // @ts-ignore
       const n = logic.__v_raw || logic;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -1278,7 +1707,8 @@ export class Connector extends Module {
       // @ts-ignore
       const n = connectorTrigger.__v_raw || connectorTrigger;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -1330,7 +1760,8 @@ export class Connector extends Module {
       // @ts-ignore
       const n = structure.__v_raw || structure;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -1382,7 +1813,8 @@ export class Connector extends Module {
       // @ts-ignore
       const n = namespace.__v_raw || namespace;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -1393,6 +1825,102 @@ export class Connector extends Module {
     return params;
   }
 
+  /**
+   * 删除触发器启动器
+   * @param name 触发器启动器名称
+   */
+  removeTriggerLauncher(name: string): void;
+
+  /**
+   * 删除触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  removeTriggerLauncher(triggerLauncher: TriggerLauncher): void;
+
+  removeTriggerLauncher(options: string | TriggerLauncher) {
+    let triggerLauncher: TriggerLauncher;
+    if (typeof options === 'string') {
+      triggerLauncher = (this.triggerLaunchers as TriggerLauncher[]).find((item) => item.name === options);
+      if (!triggerLauncher) {
+        throw new Error('找不到触发器启动器 ' + options);
+      }
+    } else {
+      triggerLauncher = options;
+    }
+    return triggerLauncher.delete();
+  }
+
+  __removeTriggerLauncher(triggerLauncher: TriggerLauncher) {
+    const parentKey = triggerLauncher.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: triggerLauncher,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(triggerLauncher);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === triggerLauncher) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除连接
+   * @param name 连接名称
+   */
+  removeConnection(name: string): void;
+
+  /**
+   * 删除连接
+   * @param connection 已有的连接实例
+   */
+  removeConnection(connection: Connection): void;
+
+  removeConnection(options: string | Connection) {
+    let connection: Connection;
+    if (typeof options === 'string') {
+      connection = (this.connections as Connection[]).find((item) => item.name === options);
+      if (!connection) {
+        throw new Error('找不到连接 ' + options);
+      }
+    } else {
+      connection = options;
+    }
+    return connection.delete();
+  }
+
+  __removeConnection(connection: Connection) {
+    const parentKey = connection.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: connection,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(connection);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === connection) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
@@ -1422,6 +1950,363 @@ export class Connector extends Module {
   getNamespaceUniqueTitle(name = '分组1') {
     return utils.unique(name, this.getNamespaceExistingTitles(), undefined, false);
   }
+
+  // ================  为解决循环引用而将之前的自动生成代码移动到这里  START =================
+  getAuthLogicForCallInterfaceExistingNames(excludedList: Array<AuthLogicForCallInterface> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.authLogicsForCallInterface as AuthLogicForCallInterface[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
+  }
+
+  getAuthLogicForCallInterfaceUniqueName(name = 'authLogicForCallInterface1') {
+    return utils.unique(name, this.getAuthLogicForCallInterfaceExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @internal
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @internal
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   */
+  _insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @internal
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  _insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  _insertAuthLogicForCallInterfaceAt(
+    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+    index: number,
+  ) {
+    const authLogicForCallInterfaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
+    let authLogicForCallInterface: AuthLogicForCallInterface;
+    if (!options) {
+      throw Error('请先调用from方法创建AuthLogicForCallInterface实例');
+    } else if (typeof options === 'string') {
+      throw Error('请先调用from方法创建AuthLogicForCallInterface实例');
+      // FIXME : dont change
+    } else if (options.concept === 'AuthLogicForCallInterface') {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      authLogicForCallInterface = options as any;
+      Object.assign(authLogicForCallInterface, relationOptions);
+    } else {
+      throw Error('请先调用from方法创建AuthLogicForCallInterface实例');
+    }
+    this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
+    return authLogicForCallInterface;
+  }
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   */
+  insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  insertAuthLogicForCallInterfaceAt(
+    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+    index: number,
+  ) {
+    const node = this._insertAuthLogicForCallInterfaceAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'authLogicsForCallInterface',
+    });
+    return node;
+  }
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @internal
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @internal
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   */
+  _addAuthLogicForCallInterface(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @internal
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  _addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
+
+  _addAuthLogicForCallInterface(options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface) {
+    const index = this.authLogicsForCallInterface.length;
+    return this._insertAuthLogicForCallInterfaceAt(options as any, index);
+  }
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @internal
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   */
+  addAuthLogicForCallInterface(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
+
+  addAuthLogicForCallInterface(options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface) {
+    const node = this._addAuthLogicForCallInterface(options as any);
+    const index = this.authLogicsForCallInterface.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'authLogicsForCallInterface',
+    });
+    return node;
+  }
+
+  /**
+   * 删除调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称
+   */
+  removeAuthLogicForCallInterface(name: string): void;
+
+  /**
+   * 删除调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  removeAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): void;
+
+  removeAuthLogicForCallInterface(options: string | AuthLogicForCallInterface) {
+    let authLogicForCallInterface: AuthLogicForCallInterface;
+    if (typeof options === 'string') {
+      authLogicForCallInterface = (this.authLogicsForCallInterface as AuthLogicForCallInterface[]).find(
+        (item) => item.name === options,
+      );
+      if (!authLogicForCallInterface) {
+        throw new Error('找不到调用接口的鉴权逻辑 ' + options);
+      }
+    } else {
+      authLogicForCallInterface = options;
+    }
+    return authLogicForCallInterface.delete();
+  }
+
+  __removeAuthLogic(authLogic: AuthLogic) {
+    const parentKey = authLogic.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: authLogic,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(authLogic);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === authLogic) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 插入鉴权逻辑
+   * @internal
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
+
+  /**
+   * 插入鉴权逻辑
+   * @internal
+   * @param authLogicOptions 鉴权逻辑参数
+   */
+  _insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+
+  /**
+   * 插入鉴权逻辑
+   * @internal
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  _insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+
+  _insertAuthLogicInAuthLogicsAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
+    const relationOptions = { parentNode: this, parentKey: 'authLogics' };
+    let authLogic: AuthLogic;
+    if (!options) {
+      // authLogic = AuthLogic.from({
+      //     ...authLogicOptions,
+      //     name: this.getAuthLogicUniqueName(),
+      // }, this, 'authLogics');
+      throw Error('请先调用from方法');
+    } else if (typeof options === 'string') {
+      // authLogic = AuthLogic.from({
+      //     ...authLogicOptions,
+      //     name: options,
+      // }, this, 'authLogics');
+      // FIXME : dont change
+      throw Error('请先调用from方法');
+    } else if (options.concept === 'AuthLogic') {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      authLogic = options as any;
+      Object.assign(authLogic, relationOptions);
+    } else {
+      // authLogic = AuthLogic.from({
+      //     ...authLogicOptions,
+      //     ...options,
+      // }, this, 'authLogics');
+      throw Error('请先调用from方法');
+    }
+    this.authLogics.splice(index, 0, authLogic);
+    return authLogic;
+  }
+
+  /**
+   * 插入鉴权逻辑
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
+
+  /**
+   * 插入鉴权逻辑
+   * @param authLogicOptions 鉴权逻辑参数
+   */
+  insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+
+  /**
+   * 插入鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+
+  insertAuthLogicInAuthLogicsAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
+    const node = this._insertAuthLogicInAuthLogicsAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'authLogics',
+    });
+    return node;
+  }
+
+  /**
+   * 添加鉴权逻辑
+   * @internal
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _addAuthLogicInAuthLogics(name?: string): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @internal
+   * @param authLogicOptions 鉴权逻辑参数
+   */
+  _addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @internal
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  _addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
+
+  _addAuthLogicInAuthLogics(options?: string | Partial<AuthLogic> | AuthLogic) {
+    const index = this.authLogics.length;
+    return this._insertAuthLogicInAuthLogicsAt(options as any, index);
+  }
+
+  /**
+   * 添加鉴权逻辑
+   * @internal
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  addAuthLogicInAuthLogics(name?: string): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @param authLogicOptions 鉴权逻辑参数
+   */
+  addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
+
+  addAuthLogicInAuthLogics(options?: string | Partial<AuthLogic> | AuthLogic) {
+    const node = this._addAuthLogicInAuthLogics(options as any);
+    const index = this.authLogics.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'authLogics',
+    });
+    return node;
+  }
+
+  getAuthLogicExistingNames(excludedList: Array<AuthLogic> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.authLogics as AuthLogic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getAuthLogicUniqueName(name = 'authentication1') {
+    return utils.unique(name, this.getAuthLogicExistingNames(), undefined, true);
+  }
+
+  // ================  为解决循环引用而将之前的自动生成代码移动到这里  END =================
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓