@lcap/nasl 2.22.0-beta.5 → 3.0.0-beta.1

package/src/concepts/App__.ts

@@ -34,13 +34,18 @@ import DataSource from './DataSource__';
 import Structure from './Structure__';
 import Enum from './Enum__';
 import Logic from './Logic__';
+import OverriddenLogic from './OverriddenLogic__';
 import Interface from './Interface__';
+import AuthInterface from './AuthInterface__';
 import Frontend from './Frontend__';
+import Backend from './Backend__';
 import Process from './Process__';
 import Role from './Role__';
 import Configuration from './Configuration__';
 import Module from './Module__';
 import Integration from './Integration__';
+import AuthLogic from './AuthLogic__';
+import AuthLogicForCallInterface from './AuthLogicForCallInterface__';
 
 /**
  * 应用
@@ -132,10 +137,16 @@ export class App extends BaseNode {
     logics: Array<Logic> = [];
 
     /**
-     * 接口列表
+     * 逻辑列表
+     */
+    @property('OverriddenLogic')
+    overriddenLogics: Array<OverriddenLogic> = [];
+
+    /**
+     * interfaces
      */
-    @property('Interface')
-    interfaces: Array<Interface> = [];
+    @property('Interface | AuthInterface')
+    interfaces: Array<Interface | AuthInterface> = [];
 
     /**
      * 端列表
@@ -143,6 +154,12 @@ export class App extends BaseNode {
     @property('Frontend')
     frontends: Array<Frontend> = [];
 
+    /**
+     * 后端
+     */
+    @property('Backend')
+    backend: Backend = new Backend();
+
     /**
      * 流程列表
      */
@@ -179,6 +196,18 @@ export class App extends BaseNode {
     @property('Integration')
     integration: Integration = undefined;
 
+    /**
+     * 暴露接口的接口鉴权
+     */
+    @property('AuthLogic')
+    authLogics: Array<AuthLogic> = [];
+
+    /**
+     * 调用接口的鉴权模板
+     */
+    @property('AuthLogicForCallInterface')
+    authLogicsForCallInterface: Array<AuthLogicForCallInterface> = [];
+
     /**
      * @param source 需要合并的部分参数
      */
@@ -781,6 +810,280 @@ export class App extends BaseNode {
         return node;
     }
 
+    /**
+    * 插入开放接口的鉴权逻辑
+    * @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 authLogicOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'authLogics' };
+        let authLogic: AuthLogic;
+        if (!options) {
+            authLogic = AuthLogic.from({
+                ...authLogicOptions,
+                name: this.getAuthLogicUniqueName(),
+            }, this, 'authLogics');
+        } else if (typeof options === 'string') {
+            authLogic = AuthLogic.from({
+                ...authLogicOptions,
+                name: options,
+            }, this, 'authLogics');
+        } else if (options instanceof AuthLogic) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogic = options;
+            Object.assign(authLogic, relationOptions);
+        } else {
+            authLogic = AuthLogic.from({
+                ...authLogicOptions,
+                ...options,
+            }, this, 'authLogics');
+        }
+        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;
+    }
+
+    getOverriddenLogicExistingNames(excludedList: Array<OverriddenLogic> = []) {
+        const excludedSet = new Set(excludedList);
+        return ((this.overriddenLogics as OverriddenLogic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getOverriddenLogicUniqueName(name = 'overriddenLogic1') {
+        return utils.unique(name, this.getOverriddenLogicExistingNames(), undefined, true);
+    }
+
+    /**
+    * 插入逻辑
+    * @internal
+    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+    */
+    _insertOverriddenLogicAt(name: string, index: number): OverriddenLogic;
+
+    /**
+    * 插入逻辑
+    * @internal
+    * @param overriddenLogicOptions 逻辑参数
+    */
+    _insertOverriddenLogicAt(overriddenLogicOptions: Partial<OverriddenLogic>, index: number): OverriddenLogic;
+
+    /**
+    * 插入逻辑
+    * @internal
+    * @param overriddenLogic 已有的逻辑实例
+    */
+    _insertOverriddenLogicAt(overriddenLogic: OverriddenLogic, index: number): OverriddenLogic;
+
+    _insertOverriddenLogicAt(options: string | Partial<OverriddenLogic> | OverriddenLogic, index: number) {
+        const overriddenLogicOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'overriddenLogics' };
+        let overriddenLogic: OverriddenLogic;
+        if (!options) {
+            overriddenLogic = OverriddenLogic.from({
+                ...overriddenLogicOptions,
+                name: this.getOverriddenLogicUniqueName(),
+            }, this, 'overriddenLogics');
+        } else if (typeof options === 'string') {
+            overriddenLogic = OverriddenLogic.from({
+                ...overriddenLogicOptions,
+                name: options,
+            }, this, 'overriddenLogics');
+        } else if (options instanceof OverriddenLogic) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            overriddenLogic = options;
+            Object.assign(overriddenLogic, relationOptions);
+        } else {
+            overriddenLogic = OverriddenLogic.from({
+                ...overriddenLogicOptions,
+                ...options,
+            }, this, 'overriddenLogics');
+        }
+        this.overriddenLogics.splice(index, 0, overriddenLogic);
+        return overriddenLogic;
+    }
+
+    /**
+     * 插入逻辑
+     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+     */
+    insertOverriddenLogicAt(name: string, index: number): OverriddenLogic;
+
+    /**
+     * 插入逻辑
+     * @param overriddenLogicOptions 逻辑参数
+     */
+    insertOverriddenLogicAt(overriddenLogicOptions: Partial<OverriddenLogic>, index: number): OverriddenLogic;
+
+    /**
+     * 插入逻辑
+     * @param overriddenLogic 已有的逻辑实例
+     */
+    insertOverriddenLogicAt(overriddenLogic: OverriddenLogic, index: number): OverriddenLogic;
+
+    insertOverriddenLogicAt(options: string | Partial<OverriddenLogic> | OverriddenLogic, index: number) {
+        const node = this._insertOverriddenLogicAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'overriddenLogics',
+        });
+        return node;
+    }
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+     */
+    _addOverriddenLogic(name?: string): OverriddenLogic;
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param overriddenLogicOptions 逻辑参数
+     */
+    _addOverriddenLogic(overriddenLogicOptions: Partial<OverriddenLogic>): OverriddenLogic;
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param overriddenLogic 已有的逻辑实例
+     */
+    _addOverriddenLogic(overriddenLogic: OverriddenLogic): OverriddenLogic;
+
+    _addOverriddenLogic(options?: string | Partial<OverriddenLogic> | OverriddenLogic) {
+        const index = 0;
+        return this._insertOverriddenLogicAt(options as any, index);
+    }
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+     */
+    addOverriddenLogic(name?: string): OverriddenLogic;
+
+    /**
+     * 添加逻辑
+     * @param overriddenLogicOptions 逻辑参数
+     */
+    addOverriddenLogic(overriddenLogicOptions: Partial<OverriddenLogic>): OverriddenLogic;
+
+    /**
+     * 添加逻辑
+     * @param overriddenLogic 已有的逻辑实例
+     */
+    addOverriddenLogic(overriddenLogic: OverriddenLogic): OverriddenLogic;
+
+    addOverriddenLogic(options?: string | Partial<OverriddenLogic> | OverriddenLogic) {
+        const node = this._addOverriddenLogic(options as any);
+        const index = this.overriddenLogics.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'overriddenLogics',
+        });
+        return node;
+    }
+
     getInterfaceExistingNames(excludedList: Array<Interface> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.interfaces as Interface[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -794,23 +1097,23 @@ export class App extends BaseNode {
     * @internal
     * @param name 接口名称，如果不填会自动生成一个唯一名称
     */
-    _insertInterfaceAt(name: string, index: number): Interface;
+    _insertInterfaceInInterfacesAt(name: string, index: number): Interface;
 
     /**
     * 插入接口
     * @internal
     * @param itfaceOptions 接口参数
     */
-    _insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+    _insertInterfaceInInterfacesAt(itfaceOptions: Partial<Interface>, index: number): Interface;
 
     /**
     * 插入接口
     * @internal
     * @param itface 已有的接口实例
     */
-    _insertInterfaceAt(itface: Interface, index: number): Interface;
+    _insertInterfaceInInterfacesAt(itface: Interface, index: number): Interface;
 
-    _insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
+    _insertInterfaceInInterfacesAt(options: string | Partial<Interface> | Interface, index: number) {
         const itfaceOptions: any = {};
         const relationOptions = { parentNode: this, parentKey: 'interfaces' };
         let itface: Interface;
@@ -842,22 +1145,155 @@ export class App extends BaseNode {
      * 插入接口
      * @param name 接口名称，如果不填会自动生成一个唯一名称
      */
-    insertInterfaceAt(name: string, index: number): Interface;
+    insertInterfaceInInterfacesAt(name: string, index: number): Interface;
+
+    /**
+     * 插入接口
+     * @param itfaceOptions 接口参数
+     */
+    insertInterfaceInInterfacesAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+
+    /**
+     * 插入接口
+     * @param itface 已有的接口实例
+     */
+    insertInterfaceInInterfacesAt(itface: Interface, index: number): Interface;
+
+    insertInterfaceInInterfacesAt(options: string | Partial<Interface> | Interface, index: number) {
+        const node = this._insertInterfaceInInterfacesAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+
+    /**
+     * 添加接口
+     * @internal
+     * @param name 接口名称，如果不填会自动生成一个唯一名称
+     */
+    _addInterfaceInInterfaces(name?: string): Interface;
+
+    /**
+     * 添加接口
+     * @internal
+     * @param itfaceOptions 接口参数
+     */
+    _addInterfaceInInterfaces(itfaceOptions: Partial<Interface>): Interface;
+
+    /**
+     * 添加接口
+     * @internal
+     * @param itface 已有的接口实例
+     */
+    _addInterfaceInInterfaces(itface: Interface): Interface;
+
+    _addInterfaceInInterfaces(options?: string | Partial<Interface> | Interface) {
+        const index = 0;
+        return this._insertInterfaceInInterfacesAt(options as any, index);
+    }
+
+    /**
+     * 添加接口
+     * @internal
+     * @param name 接口名称，如果不填会自动生成一个唯一名称
+     */
+    addInterfaceInInterfaces(name?: string): Interface;
+
+    /**
+     * 添加接口
+     * @param itfaceOptions 接口参数
+     */
+    addInterfaceInInterfaces(itfaceOptions: Partial<Interface>): Interface;
+
+    /**
+     * 添加接口
+     * @param itface 已有的接口实例
+     */
+    addInterfaceInInterfaces(itface: Interface): Interface;
+
+    addInterfaceInInterfaces(options?: string | Partial<Interface> | Interface) {
+        const node = this._addInterfaceInInterfaces(options as any);
+        const index = this.interfaces.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+
+    /**
+    * 插入接口
+    * @internal
+    * @param name 接口名称，如果不填会自动生成一个唯一名称
+    */
+    _insertAuthInterfaceInInterfacesAt(name: string, index: number): AuthInterface;
+
+    /**
+    * 插入接口
+    * @internal
+    * @param itfaceOptions 接口参数
+    */
+    _insertAuthInterfaceInInterfacesAt(itfaceOptions: Partial<AuthInterface>, index: number): AuthInterface;
+
+    /**
+    * 插入接口
+    * @internal
+    * @param itface 已有的接口实例
+    */
+    _insertAuthInterfaceInInterfacesAt(itface: AuthInterface, index: number): AuthInterface;
+
+    _insertAuthInterfaceInInterfacesAt(options: string | Partial<AuthInterface> | AuthInterface, index: number) {
+        const itfaceOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+        let itface: AuthInterface;
+        if (!options) {
+            itface = AuthInterface.from({
+                ...itfaceOptions,
+                name: this.getAuthInterfaceUniqueName(),
+            }, this, 'interfaces');
+        } else if (typeof options === 'string') {
+            itface = AuthInterface.from({
+                ...itfaceOptions,
+                name: options,
+            }, this, 'interfaces');
+        } else if (options instanceof AuthInterface) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            itface = options;
+            Object.assign(itface, relationOptions);
+        } else {
+            itface = AuthInterface.from({
+                ...itfaceOptions,
+                ...options,
+            }, this, 'interfaces');
+        }
+        this.interfaces.splice(index, 0, itface);
+        return itface;
+    }
+
+    /**
+     * 插入接口
+     * @param name 接口名称，如果不填会自动生成一个唯一名称
+     */
+    insertAuthInterfaceInInterfacesAt(name: string, index: number): AuthInterface;
 
     /**
      * 插入接口
      * @param itfaceOptions 接口参数
      */
-    insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+    insertAuthInterfaceInInterfacesAt(itfaceOptions: Partial<AuthInterface>, index: number): AuthInterface;
 
     /**
      * 插入接口
      * @param itface 已有的接口实例
      */
-    insertInterfaceAt(itface: Interface, index: number): Interface;
+    insertAuthInterfaceInInterfacesAt(itface: AuthInterface, index: number): AuthInterface;
 
-    insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
-        const node = this._insertInterfaceAt(options as any, index);
+    insertAuthInterfaceInInterfacesAt(options: string | Partial<AuthInterface> | AuthInterface, index: number) {
+        const node = this._insertAuthInterfaceInInterfacesAt(options as any, index);
         node.create({
             index,
             parentNode: this,
@@ -871,25 +1307,25 @@ export class App extends BaseNode {
      * @internal
      * @param name 接口名称，如果不填会自动生成一个唯一名称
      */
-    _addInterface(name?: string): Interface;
+    _addAuthInterfaceInInterfaces(name?: string): AuthInterface;
 
     /**
      * 添加接口
      * @internal
      * @param itfaceOptions 接口参数
      */
-    _addInterface(itfaceOptions: Partial<Interface>): Interface;
+    _addAuthInterfaceInInterfaces(itfaceOptions: Partial<AuthInterface>): AuthInterface;
 
     /**
      * 添加接口
      * @internal
      * @param itface 已有的接口实例
      */
-    _addInterface(itface: Interface): Interface;
+    _addAuthInterfaceInInterfaces(itface: AuthInterface): AuthInterface;
 
-    _addInterface(options?: string | Partial<Interface> | Interface) {
+    _addAuthInterfaceInInterfaces(options?: string | Partial<AuthInterface> | AuthInterface) {
         const index = 0;
-        return this._insertInterfaceAt(options as any, index);
+        return this._insertAuthInterfaceInInterfacesAt(options as any, index);
     }
 
     /**
@@ -897,22 +1333,22 @@ export class App extends BaseNode {
      * @internal
      * @param name 接口名称，如果不填会自动生成一个唯一名称
      */
-    addInterface(name?: string): Interface;
+    addAuthInterfaceInInterfaces(name?: string): AuthInterface;
 
     /**
      * 添加接口
      * @param itfaceOptions 接口参数
      */
-    addInterface(itfaceOptions: Partial<Interface>): Interface;
+    addAuthInterfaceInInterfaces(itfaceOptions: Partial<AuthInterface>): AuthInterface;
 
     /**
      * 添加接口
      * @param itface 已有的接口实例
      */
-    addInterface(itface: Interface): Interface;
+    addAuthInterfaceInInterfaces(itface: AuthInterface): AuthInterface;
 
-    addInterface(options?: string | Partial<Interface> | Interface) {
-        const node = this._addInterface(options as any);
+    addAuthInterfaceInInterfaces(options?: string | Partial<AuthInterface> | AuthInterface) {
+        const node = this._addAuthInterfaceInInterfaces(options as any);
         const index = this.interfaces.indexOf(node);
         node.create({
             index,
@@ -1619,6 +2055,147 @@ export class App extends BaseNode {
         return node;
     }
 
+    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) {
+            authLogicForCallInterface = AuthLogicForCallInterface.from({
+                ...authLogicForCallInterfaceOptions,
+                name: this.getAuthLogicForCallInterfaceUniqueName(),
+            }, this, 'authLogicsForCallInterface');
+        } else if (typeof options === 'string') {
+            authLogicForCallInterface = AuthLogicForCallInterface.from({
+                ...authLogicForCallInterfaceOptions,
+                name: options,
+            }, this, 'authLogicsForCallInterface');
+        } else if (options instanceof AuthLogicForCallInterface) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogicForCallInterface = options;
+            Object.assign(authLogicForCallInterface, relationOptions);
+        } else {
+            authLogicForCallInterface = AuthLogicForCallInterface.from({
+                ...authLogicForCallInterfaceOptions,
+                ...options,
+            }, this, 'authLogicsForCallInterface');
+        }
+        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 数据源名称
@@ -1788,6 +2365,31 @@ export class App extends BaseNode {
         return logic.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();
+    }
+
     __removeLogic(logic: Logic) {
         const parentKey = logic.parentKey;
         const params: Params = {
@@ -1811,19 +2413,67 @@ export class App extends BaseNode {
         return params;
     }
 
+    /**
+    * 删除逻辑
+    * @param name 逻辑名称
+    */
+    removeOverriddenLogic(name: string): void;
+
+    /**
+     * 删除逻辑
+     * @param overriddenLogic 已有的逻辑实例
+     */
+    removeOverriddenLogic(overriddenLogic: OverriddenLogic): void;
+
+    removeOverriddenLogic(options: string | OverriddenLogic) {
+        let overriddenLogic: OverriddenLogic;
+        if (typeof options === 'string') {
+            overriddenLogic = (this.overriddenLogics as OverriddenLogic[]).find((item) => item.name === options);
+            if (!overriddenLogic) {
+                throw new Error('找不到逻辑 ' + options);
+            }
+        } else {
+            overriddenLogic = options;
+        }
+        return overriddenLogic.delete();
+    }
+
+    __removeOverriddenLogic(overriddenLogic: OverriddenLogic) {
+        const parentKey = overriddenLogic.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: overriddenLogic,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(overriddenLogic);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === overriddenLogic) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
     /**
     * 删除接口
     * @param name 接口名称
     */
-    removeInterface(name: string): void;
+    removeInterfaceInInterfaces(name: string): void;
 
     /**
      * 删除接口
      * @param itface 已有的接口实例
      */
-    removeInterface(itface: Interface): void;
+    removeInterfaceInInterfaces(itface: Interface): void;
 
-    removeInterface(options: string | Interface) {
+    removeInterfaceInInterfaces(options: string | Interface) {
         let itface: Interface;
         if (typeof options === 'string') {
             itface = (this.interfaces as Interface[]).find((item) => item.name === options);
@@ -1836,6 +2486,31 @@ export class App extends BaseNode {
         return itface.delete();
     }
 
+    /**
+    * 删除接口
+    * @param name 接口名称
+    */
+    removeAuthInterfaceInInterfaces(name: string): void;
+
+    /**
+     * 删除接口
+     * @param itface 已有的接口实例
+     */
+    removeAuthInterfaceInInterfaces(itface: AuthInterface): void;
+
+    removeAuthInterfaceInInterfaces(options: string | AuthInterface) {
+        let itface: AuthInterface;
+        if (typeof options === 'string') {
+            itface = (this.interfaces as AuthInterface[]).find((item) => item.name === options);
+            if (!itface) {
+                throw new Error('找不到接口 ' + options);
+            }
+        } else {
+            itface = options;
+        }
+        return itface.delete();
+    }
+
     __removeInterface(itface: Interface) {
         const parentKey = itface.parentKey;
         const params: Params = {
@@ -1907,6 +2582,54 @@ export class App extends BaseNode {
         return params;
     }
 
+    /**
+    * 删除后端
+    * @param name 后端名称
+    */
+    removeBackend(name: string): void;
+
+    /**
+     * 删除后端
+     * @param backend 已有的后端实例
+     */
+    removeBackend(backend: Backend): void;
+
+    removeBackend(options: string | Backend) {
+        let backend: Backend;
+        if (typeof options === 'string') {
+            backend = this.backend;
+            if (!backend) {
+                throw new Error('找不到后端 ' + options);
+            }
+        } else {
+            backend = options;
+        }
+        return backend.delete();
+    }
+
+    __removeBackend(backend: Backend) {
+        const parentKey = backend.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: backend,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(backend);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === backend) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
     /**
     * 删除流程
     * @param name 流程名称
@@ -2172,6 +2895,54 @@ export class App extends BaseNode {
         return params;
     }
 
+    /**
+    * 删除调用的鉴权逻辑
+    * @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;
+    }
+
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
@@ -2426,7 +3197,26 @@ export class App extends BaseNode {
             // 同名的依赖库 只启用第一个
             // (options as Module).enable = hasSameVersion;
         }
+        //  导入依赖库的时候如果有logic 且logic 可以被覆写 需要在app overideLogic 新增一个
+        // 但是导入局部模板的时候已经手动新增了 这里就不需要了
+        // 当依赖库被删除 的时候同样要删除 overideLogic
+        // 支持局部模板导出导入overideLogic
+        // 只复制 depLogic  输入输出参数
         const node = this.addModuleInDependencies(options as any);
+
+        if (node?.logics && node?.logics.length > 0) {
+            node.logics.forEach((logic) => {
+                if (logic?.overridable) {
+                    const existing = this.overriddenLogics.find((ol) => ol.name === logic.name);
+                    !existing && this.addOverriddenLogic({
+                        name: logic.name,
+                        overriddenModule: node.name,
+                        returns: logic.returns.map((r) => r.toJSON()),
+                        params: logic.params.map((r) => r.toJSON()),
+                    });
+                }
+            });
+        }
         // 启用的依赖库才创建数据源
         // if (node.enable && node.dataSources) {
         if (node.dataSources) {
@@ -2662,7 +3452,7 @@ export class App extends BaseNode {
     getJavaLogicUniqueName(name = 'javalogic1') {
         return utils.unique(name, this.getLogicExistingNames(), undefined, true);
     }
-    
+
     getJavaLogicClassUniqueName(name = 'Javalogic1') {
         return utils.unique(name, this.getLogicExistingNames(), undefined, true) + 'Service';
     }
@@ -2706,6 +3496,18 @@ export class App extends BaseNode {
     }
     __databaseTypeMap: any = {};
 
+    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);
+    }
+
+    getAuthInterfaceUniqueName(name = 'authInterface1') {
+        // never used
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓