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

package/out/concepts/App__.js

@@ -45,12 +45,17 @@ const DataSource__1 = __importDefault(require("./DataSource__"));
 const Structure__1 = __importDefault(require("./Structure__"));
 const Enum__1 = __importDefault(require("./Enum__"));
 const Logic__1 = __importDefault(require("./Logic__"));
+const OverriddenLogic__1 = __importDefault(require("./OverriddenLogic__"));
 const Interface__1 = __importDefault(require("./Interface__"));
+const AuthInterface__1 = __importDefault(require("./AuthInterface__"));
 const Frontend__1 = __importDefault(require("./Frontend__"));
+const Backend__1 = __importDefault(require("./Backend__"));
 const Process__1 = __importDefault(require("./Process__"));
 const Role__1 = __importDefault(require("./Role__"));
 const Configuration__1 = __importDefault(require("./Configuration__"));
 const Module__1 = __importDefault(require("./Module__"));
+const AuthLogic__1 = __importDefault(require("./AuthLogic__"));
+const AuthLogicForCallInterface__1 = __importDefault(require("./AuthLogicForCallInterface__"));
 /**
  * 应用
  */
@@ -112,13 +117,21 @@ let App = App_1 = class App extends BaseNode_1.default {
      */
     logics = [];
     /**
-     * 接口列表
+     * 逻辑列表
+     */
+    overriddenLogics = [];
+    /**
+     * interfaces
      */
     interfaces = [];
     /**
      * 端列表
      */
     frontends = [];
+    /**
+     * 后端
+     */
+    backend = new Backend__1.default();
     /**
      * 流程列表
      */
@@ -143,6 +156,14 @@ let App = App_1 = class App extends BaseNode_1.default {
      * 集成
      */
     integration = undefined;
+    /**
+     * 暴露接口的接口鉴权
+     */
+    authLogics = [];
+    /**
+     * 调用接口的鉴权模板
+     */
+    authLogicsForCallInterface = [];
     /**
      * @param source 需要合并的部分参数
      */
@@ -418,6 +439,119 @@ let App = App_1 = class App extends BaseNode_1.default {
         });
         return node;
     }
+    _insertAuthLogicInAuthLogicsAt(options, index) {
+        const authLogicOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'authLogics' };
+        let authLogic;
+        if (!options) {
+            authLogic = AuthLogic__1.default.from({
+                ...authLogicOptions,
+                name: this.getAuthLogicUniqueName(),
+            }, this, 'authLogics');
+        }
+        else if (typeof options === 'string') {
+            authLogic = AuthLogic__1.default.from({
+                ...authLogicOptions,
+                name: options,
+            }, this, 'authLogics');
+        }
+        else if (options instanceof AuthLogic__1.default) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogic = options;
+            Object.assign(authLogic, relationOptions);
+        }
+        else {
+            authLogic = AuthLogic__1.default.from({
+                ...authLogicOptions,
+                ...options,
+            }, this, 'authLogics');
+        }
+        this.authLogics.splice(index, 0, authLogic);
+        return authLogic;
+    }
+    insertAuthLogicInAuthLogicsAt(options, index) {
+        const node = this._insertAuthLogicInAuthLogicsAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogics',
+        });
+        return node;
+    }
+    _addAuthLogicInAuthLogics(options) {
+        const index = this.authLogics.length;
+        return this._insertAuthLogicInAuthLogicsAt(options, index);
+    }
+    addAuthLogicInAuthLogics(options) {
+        const node = this._addAuthLogicInAuthLogics(options);
+        const index = this.authLogics.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogics',
+        });
+        return node;
+    }
+    getOverriddenLogicExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.overriddenLogics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getOverriddenLogicUniqueName(name = 'overriddenLogic1') {
+        return utils.unique(name, this.getOverriddenLogicExistingNames(), undefined, true);
+    }
+    _insertOverriddenLogicAt(options, index) {
+        const overriddenLogicOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'overriddenLogics' };
+        let overriddenLogic;
+        if (!options) {
+            overriddenLogic = OverriddenLogic__1.default.from({
+                ...overriddenLogicOptions,
+                name: this.getOverriddenLogicUniqueName(),
+            }, this, 'overriddenLogics');
+        }
+        else if (typeof options === 'string') {
+            overriddenLogic = OverriddenLogic__1.default.from({
+                ...overriddenLogicOptions,
+                name: options,
+            }, this, 'overriddenLogics');
+        }
+        else if (options instanceof OverriddenLogic__1.default) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            overriddenLogic = options;
+            Object.assign(overriddenLogic, relationOptions);
+        }
+        else {
+            overriddenLogic = OverriddenLogic__1.default.from({
+                ...overriddenLogicOptions,
+                ...options,
+            }, this, 'overriddenLogics');
+        }
+        this.overriddenLogics.splice(index, 0, overriddenLogic);
+        return overriddenLogic;
+    }
+    insertOverriddenLogicAt(options, index) {
+        const node = this._insertOverriddenLogicAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'overriddenLogics',
+        });
+        return node;
+    }
+    _addOverriddenLogic(options) {
+        const index = 0;
+        return this._insertOverriddenLogicAt(options, index);
+    }
+    addOverriddenLogic(options) {
+        const node = this._addOverriddenLogic(options);
+        const index = this.overriddenLogics.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'overriddenLogics',
+        });
+        return node;
+    }
     getInterfaceExistingNames(excludedList = []) {
         const excludedSet = new Set(excludedList);
         return (this.interfaces || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -425,7 +559,7 @@ let App = App_1 = class App extends BaseNode_1.default {
     getInterfaceUniqueName(name = 'Interface1') {
         return utils.unique(name, this.getInterfaceExistingNames(), undefined, true);
     }
-    _insertInterfaceAt(options, index) {
+    _insertInterfaceInInterfacesAt(options, index) {
         const itfaceOptions = {};
         const relationOptions = { parentNode: this, parentKey: 'interfaces' };
         let itface;
@@ -455,8 +589,61 @@ let App = App_1 = class App extends BaseNode_1.default {
         this.interfaces.splice(index, 0, itface);
         return itface;
     }
-    insertInterfaceAt(options, index) {
-        const node = this._insertInterfaceAt(options, index);
+    insertInterfaceInInterfacesAt(options, index) {
+        const node = this._insertInterfaceInInterfacesAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+    _addInterfaceInInterfaces(options) {
+        const index = 0;
+        return this._insertInterfaceInInterfacesAt(options, index);
+    }
+    addInterfaceInInterfaces(options) {
+        const node = this._addInterfaceInInterfaces(options);
+        const index = this.interfaces.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+    _insertAuthInterfaceInInterfacesAt(options, index) {
+        const itfaceOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+        let itface;
+        if (!options) {
+            itface = AuthInterface__1.default.from({
+                ...itfaceOptions,
+                name: this.getAuthInterfaceUniqueName(),
+            }, this, 'interfaces');
+        }
+        else if (typeof options === 'string') {
+            itface = AuthInterface__1.default.from({
+                ...itfaceOptions,
+                name: options,
+            }, this, 'interfaces');
+        }
+        else if (options instanceof AuthInterface__1.default) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            itface = options;
+            Object.assign(itface, relationOptions);
+        }
+        else {
+            itface = AuthInterface__1.default.from({
+                ...itfaceOptions,
+                ...options,
+            }, this, 'interfaces');
+        }
+        this.interfaces.splice(index, 0, itface);
+        return itface;
+    }
+    insertAuthInterfaceInInterfacesAt(options, index) {
+        const node = this._insertAuthInterfaceInInterfacesAt(options, index);
         node.create({
             index,
             parentNode: this,
@@ -464,12 +651,12 @@ let App = App_1 = class App extends BaseNode_1.default {
         });
         return node;
     }
-    _addInterface(options) {
+    _addAuthInterfaceInInterfaces(options) {
         const index = 0;
-        return this._insertInterfaceAt(options, index);
+        return this._insertAuthInterfaceInInterfacesAt(options, index);
     }
-    addInterface(options) {
-        const node = this._addInterface(options);
+    addAuthInterfaceInInterfaces(options) {
+        const node = this._addAuthInterfaceInInterfaces(options);
         const index = this.interfaces.indexOf(node);
         node.create({
             index,
@@ -771,6 +958,66 @@ let App = App_1 = class App extends BaseNode_1.default {
         });
         return node;
     }
+    getAuthLogicForCallInterfaceExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.authLogicsForCallInterface || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getAuthLogicForCallInterfaceUniqueName(name = 'authLogicForCallInterface1') {
+        return utils.unique(name, this.getAuthLogicForCallInterfaceExistingNames(), undefined, false);
+    }
+    _insertAuthLogicForCallInterfaceAt(options, index) {
+        const authLogicForCallInterfaceOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
+        let authLogicForCallInterface;
+        if (!options) {
+            authLogicForCallInterface = AuthLogicForCallInterface__1.default.from({
+                ...authLogicForCallInterfaceOptions,
+                name: this.getAuthLogicForCallInterfaceUniqueName(),
+            }, this, 'authLogicsForCallInterface');
+        }
+        else if (typeof options === 'string') {
+            authLogicForCallInterface = AuthLogicForCallInterface__1.default.from({
+                ...authLogicForCallInterfaceOptions,
+                name: options,
+            }, this, 'authLogicsForCallInterface');
+        }
+        else if (options instanceof AuthLogicForCallInterface__1.default) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogicForCallInterface = options;
+            Object.assign(authLogicForCallInterface, relationOptions);
+        }
+        else {
+            authLogicForCallInterface = AuthLogicForCallInterface__1.default.from({
+                ...authLogicForCallInterfaceOptions,
+                ...options,
+            }, this, 'authLogicsForCallInterface');
+        }
+        this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
+        return authLogicForCallInterface;
+    }
+    insertAuthLogicForCallInterfaceAt(options, index) {
+        const node = this._insertAuthLogicForCallInterfaceAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogicsForCallInterface',
+        });
+        return node;
+    }
+    _addAuthLogicForCallInterface(options) {
+        const index = this.authLogicsForCallInterface.length;
+        return this._insertAuthLogicForCallInterfaceAt(options, index);
+    }
+    addAuthLogicForCallInterface(options) {
+        const node = this._addAuthLogicForCallInterface(options);
+        const index = this.authLogicsForCallInterface.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogicsForCallInterface',
+        });
+        return node;
+    }
     removeDataSource(options) {
         let dataSource;
         if (typeof options === 'string') {
@@ -892,6 +1139,19 @@ let App = App_1 = class App extends BaseNode_1.default {
         }
         return logic.delete();
     }
+    removeAuthLogicInAuthLogics(options) {
+        let authLogic;
+        if (typeof options === 'string') {
+            authLogic = this.authLogics.find((item) => item.name === options);
+            if (!authLogic) {
+                throw new Error('找不到开放接口的鉴权逻辑 ' + options);
+            }
+        }
+        else {
+            authLogic = options;
+        }
+        return authLogic.delete();
+    }
     __removeLogic(logic) {
         const parentKey = logic.parentKey;
         const params = {
@@ -915,7 +1175,56 @@ let App = App_1 = class App extends BaseNode_1.default {
         }
         return params;
     }
-    removeInterface(options) {
+    removeOverriddenLogic(options) {
+        let overriddenLogic;
+        if (typeof options === 'string') {
+            overriddenLogic = this.overriddenLogics.find((item) => item.name === options);
+            if (!overriddenLogic) {
+                throw new Error('找不到逻辑 ' + options);
+            }
+        }
+        else {
+            overriddenLogic = options;
+        }
+        return overriddenLogic.delete();
+    }
+    __removeOverriddenLogic(overriddenLogic) {
+        const parentKey = overriddenLogic.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: overriddenLogic,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(overriddenLogic);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === overriddenLogic) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeInterfaceInInterfaces(options) {
+        let itface;
+        if (typeof options === 'string') {
+            itface = this.interfaces.find((item) => item.name === options);
+            if (!itface) {
+                throw new Error('找不到接口 ' + options);
+            }
+        }
+        else {
+            itface = options;
+        }
+        return itface.delete();
+    }
+    removeAuthInterfaceInInterfaces(options) {
         let itface;
         if (typeof options === 'string') {
             itface = this.interfaces.find((item) => item.name === options);
@@ -987,6 +1296,42 @@ let App = App_1 = class App extends BaseNode_1.default {
         }
         return params;
     }
+    removeBackend(options) {
+        let backend;
+        if (typeof options === 'string') {
+            backend = this.backend;
+            if (!backend) {
+                throw new Error('找不到后端 ' + options);
+            }
+        }
+        else {
+            backend = options;
+        }
+        return backend.delete();
+    }
+    __removeBackend(backend) {
+        const parentKey = backend.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: backend,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(backend);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === backend) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
     removeProcess(options) {
         let process;
         if (typeof options === 'string') {
@@ -1180,6 +1525,42 @@ let App = App_1 = class App extends BaseNode_1.default {
         }
         return params;
     }
+    removeAuthLogicForCallInterface(options) {
+        let authLogicForCallInterface;
+        if (typeof options === 'string') {
+            authLogicForCallInterface = this.authLogicsForCallInterface.find((item) => item.name === options);
+            if (!authLogicForCallInterface) {
+                throw new Error('找不到调用的鉴权逻辑 ' + options);
+            }
+        }
+        else {
+            authLogicForCallInterface = options;
+        }
+        return authLogicForCallInterface.delete();
+    }
+    __removeAuthLogic(authLogic) {
+        const parentKey = authLogic.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: authLogic,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(authLogic);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === authLogic) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
@@ -1390,7 +1771,25 @@ let App = App_1 = class App extends BaseNode_1.default {
             // 同名的依赖库 只启用第一个
             // (options as Module).enable = hasSameVersion;
         }
+        //  导入依赖库的时候如果有logic 且logic 可以被覆写 需要在app overideLogic 新增一个
+        // 但是导入局部模板的时候已经手动新增了 这里就不需要了
+        // 当依赖库被删除 的时候同样要删除 overideLogic
+        // 支持局部模板导出导入overideLogic
+        // 只复制 depLogic  输入输出参数
         const node = this.addModuleInDependencies(options);
+        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) {
@@ -1658,6 +2057,16 @@ let App = App_1 = class App extends BaseNode_1.default {
         return sysPrefixPath;
     }
     __databaseTypeMap = {};
+    getAuthLogicExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.authLogics || []).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
+    }
 };
 __decorate([
     (0, decorators_1.property)()
@@ -1702,11 +2111,17 @@ __decorate([
     (0, decorators_1.property)('Logic')
 ], App.prototype, "logics", void 0);
 __decorate([
-    (0, decorators_1.property)('Interface')
+    (0, decorators_1.property)('OverriddenLogic')
+], App.prototype, "overriddenLogics", void 0);
+__decorate([
+    (0, decorators_1.property)('Interface | AuthInterface')
 ], App.prototype, "interfaces", void 0);
 __decorate([
     (0, decorators_1.property)('Frontend')
 ], App.prototype, "frontends", void 0);
+__decorate([
+    (0, decorators_1.property)('Backend')
+], App.prototype, "backend", void 0);
 __decorate([
     (0, decorators_1.property)('Process')
 ], App.prototype, "processes", void 0);
@@ -1725,6 +2140,12 @@ __decorate([
 __decorate([
     (0, decorators_1.property)('Integration')
 ], App.prototype, "integration", void 0);
+__decorate([
+    (0, decorators_1.property)('AuthLogic')
+], App.prototype, "authLogics", void 0);
+__decorate([
+    (0, decorators_1.property)('AuthLogicForCallInterface')
+], App.prototype, "authLogicsForCallInterface", void 0);
 __decorate([
     (0, decorators_1.excludedInJSON)()
 ], App.prototype, "officialType", void 0);