@lcap/nasl 1.0.0-alpha.8 → 1.0.1

package/src/concepts/Process__.ts

@@ -1,9 +1,10 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
-import { process2LogicNamespace, genLaunchProcess, genUserTaskLogic, userTask2LogicNamespace } from '../server/getProcesses';
-
+import { genLaunchProcess, genUserTaskLogic, userTask2LogicNamespace, syncMemberExpression } from '../server/getProcesses';
+import { process2LogicNamespace } from '../server/process2LogicNamespace';
 import Namespace from './Namespace__';
 import Logic from './Logic__';
 import Variable from './Variable__';
+import Identifier from './Identifier__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -154,7 +155,7 @@ export class Process extends BaseNode {
         return (this.params || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getParamUniqueName(name = 'param1') {
-        return utils.unique(name, this.getParamExistingNames());
+        return utils.unique(name, this.getParamExistingNames(), undefined, false);
     }
 
     /**
@@ -193,7 +194,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'params');
         } else if (options instanceof Param) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             param = options;
             Object.assign(param, relationOptions);
         } else {
@@ -281,7 +282,7 @@ export class Process extends BaseNode {
 
     addParam(options?: string | Partial<Param> | Param) {
         const node = this._addParam(options as any);
-        const index = this.params.length;
+        const index = this.params.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -296,7 +297,7 @@ export class Process extends BaseNode {
         return (this.returns || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getReturnUniqueName(name = 'ret1') {
-        return utils.unique(name, this.getReturnExistingNames());
+        return utils.unique(name, this.getReturnExistingNames(), undefined, false);
     }
 
     /**
@@ -335,7 +336,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'returns');
         } else if (options instanceof Return) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             ret = options;
             Object.assign(ret, relationOptions);
         } else {
@@ -423,7 +424,7 @@ export class Process extends BaseNode {
 
     addReturn(options?: string | Partial<Return> | Return) {
         const node = this._addReturn(options as any);
-        const index = this.returns.length;
+        const index = this.returns.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -438,7 +439,7 @@ export class Process extends BaseNode {
         return (this.constants || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getConstantUniqueName(name = 'constant1') {
-        return utils.unique(name, this.getConstantExistingNames());
+        return utils.unique(name, this.getConstantExistingNames(), undefined, false);
     }
 
     /**
@@ -477,7 +478,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'constants');
         } else if (options instanceof Constant) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             constant = options;
             Object.assign(constant, relationOptions);
         } else {
@@ -565,7 +566,7 @@ export class Process extends BaseNode {
 
     addConstant(options?: string | Partial<Constant> | Constant) {
         const node = this._addConstant(options as any);
-        const index = this.constants.length;
+        const index = this.constants.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -580,7 +581,7 @@ export class Process extends BaseNode {
         return (this.elements || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getElementUniqueName(name = 'element1') {
-        return utils.unique(name, this.getElementExistingNames());
+        return utils.unique(name, this.getElementExistingNames(), undefined, false);
     }
 
     /**
@@ -619,7 +620,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'elements');
         } else if (options instanceof ProcessElement) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             element = options;
             Object.assign(element, relationOptions);
         } else {
@@ -707,7 +708,7 @@ export class Process extends BaseNode {
 
     addElement(options?: string | Partial<ProcessElement> | ProcessElement) {
         const node = this._addElement(options as any);
-        const index = this.elements.length;
+        const index = this.elements.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -974,7 +975,29 @@ export class Process extends BaseNode {
     }
 
     get logics() {
-        return [genLaunchProcess(this)];
+        // return [
+        //     genLaunchProcess(this),
+        //     ...this.elements.filter(el => el.type === 'UserTask').map(el => {
+        //         return {
+        //             name: el.name,
+        //             complete: genUserTaskLogic(el),
+        //         }
+        //     })
+        // ];
+        const ns = process2LogicNamespace(this);
+        let logics: Logic[] = [];
+        ns.children.map((subns) => {
+            logics = logics.concat(subns.logics);
+        });
+
+        return [
+            ...ns.logics,
+            ...logics,
+        ];
+    }
+
+    toUserTaskPropertyGetterTS(userTask: ProcessElement) {
+        return `let ${userTask.name} = elements.${userTask.name};`;
     }
 
     @withSourceMap()
@@ -985,6 +1008,14 @@ export class Process extends BaseNode {
         const tab2 = indent(state.tabSize + 2);
         const tab3 = indent(state.tabSize + 3);
         // code += `${tab1}namespace variables{\n`;
+
+        code += `${tab1}export namespace logics {\n`;
+        const logic = genLaunchProcess(this);
+        // sourceMap 映射
+        logic.parentNode = this;
+        code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 2 }));
+        code += `${tab1}}\n`;
+
         this.params.forEach((property) => {
             code += `${tab1}export let `;
             code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
@@ -1002,63 +1033,16 @@ export class Process extends BaseNode {
             code += ';\n';
         });
 
+        code += `${tab1}export const elements = {\n`;
 
-        // code += `${tab1}}\n`;
-
-        // this.elements.forEach((ele) => {
-        //     if (ele.type === 'UserTask') {
-        //         code += `${tab1}${ele.name}: nasl.process.UserTask;\n`;
-        //     }
-        // });
-
-        // code += `${tab1}constructor(`;
-        // this.params.forEach((param, index) => {
-        //     code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        //     if (index !== this.params.length - 1)
-        //         code += ', ';
-        // });
-        // code += `) {\n`;
-
-        code += `${tab1}export namespace logics {\n`;
-        const logic = genLaunchProcess(this);
-        code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 3 }));
-        code += `${tab1}}\n`;
-
-        code += `${tab1}export namespace elements {\n`
         this.elements.forEach((ele) => {
-            if (ele.type === 'UserTask') {
-                code += `${tab2}export namespace ${ele.name}{\n`;
+            code += '\n';
+            if (ele.type === 'UserTask' || ele.type === 'ExclusiveGateway' || ele.type === 'AutoTask') {
                 code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
-                ele.bindAttrs.forEach((attr) => {
-                    if(attr.name === 'destination') {
-                        code += attr.destination.toEmbeddedTSNormalFunction(shiftState(state, code, { tabSize: state.tabSize + 2 }))
-                    } else {
-                        code += attr.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize }));
-                    }
-                });
-
-                const logic = genUserTaskLogic(ele);
-                code += `${tab3}export namespace logics {\n`;
-
-                code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 4 }));
-
-                code += `${tab3}}\n`;
-
-                code += `${tab2}}\n`;
-
-                
-            }
-            if (ele.type === 'ExclusiveGateway') {
-                code += `${tab2}export namespace ${ele.name}{\n`;
-                code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
-                code += ele.logic.toEmbeddedTSNoExport(shiftState(state, code, { tabSize: state.tabSize + 3 }));
-                code += `${tab2}}\n`;
             }
         });
         code += `${tab1}}\n`;
-
-        // code += `${tab1}}\n`;
-        code += `${tab0}}\n`;
+        code += `}\n`;
         return code;
     }
 
@@ -1066,31 +1050,13 @@ export class Process extends BaseNode {
         let code = `namespace ${this.getNamespace('processes')} {\n`;
 
         const state = createCompilerState(code, { tabSize: 1 });
-        const tab1 = indent(state.tabSize);
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
-        /* const ns = process2LogicNamespace(this);
-        ns.path = `${this.getNamespace('logics')}.${ns.name}`;
-        code += `\nnamespace ${ns.path} {\n`;
-        ns.logics.forEach((logic) => {
-            code += logic.toEmbeddedTS(shiftState(state, code)) + '\n';
-        });
-        this.elements.forEach((ele) => {
-            if (ele.type === 'UserTask') {
-                const uns = userTask2LogicNamespace(ele);
-                code += `${tab1}export namespace ${uns.name} {\n`;
-
-                uns.logics.forEach((logic) => {
-                    code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
-                });
-
-                code += `${tab1}}\n`;
-            }
-        });
-
-        code += '}\n';*/
-
         return {
             code,
             filePath: this.getEmbeddedFilePath(),
@@ -1115,29 +1081,31 @@ export class Process extends BaseNode {
             elements: [
                 {
                     concept: 'ProcessElement',
-                    name: 'start',
+                    name: 'Start',
                     type: 'StartNoneEvent',
                     bounds: {
                         concept: 'Rect',
-                        x: 0, y: 0
-                    }
+                        x: 0, y: 0,
+                    },
                 },
                 {
                     concept: 'ProcessElement',
-                    name: 'end',
+                    name: 'End',
                     type: 'EndNoneEvent',
                     bounds: {
                         concept: 'Rect',
-                        x: 0, y: 180
-                    }
+                        x: 0, y: 180,
+                    },
                 },
                 {
                     concept: 'ProcessElement',
+                    name: 'SequenceFlow',
                     type: 'SequenceFlow',
-                    sourceRef: 'start',
-                    targetRef: 'end',
+                    sourceRef: 'Start',
+                    targetRef: 'End',
+                    waypoints: [{ x: 0, y: 0 }, { x: 100, y: 100 }],
                 },
-            ]
+            ],
         };
     }
     //================================================================================
@@ -1152,3 +1120,22 @@ export default Process;
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
 //================================================================================
+Process.prototype.setName = function (name: string) {
+    const App = this.rootNode;
+    const oldName = this.name;
+    App.emit('collect:start', {
+        actionMsg: '设置名称',
+    });
+    syncMemberExpression(this, (node) => {
+        if (node.object instanceof Identifier && node.object.name === oldName) {
+            node.object.update({
+                name,
+            });
+        }
+    });
+    this.update({
+        name,
+        field: 'name',
+    });
+    App.emit('collect:end');
+};

package/src/concepts/QueryAggregateExpression__.ts

@@ -138,7 +138,7 @@ export class QueryAggregateExpression extends LogicItem {
         //     code += `[__EMPTY_AGGREGATE_NAME__, '']`;
 
         // return code;
-        return `${this.asName || '__EMPTY_AGGREGATE_ALIAS__'}`;
+        return `__${this.asName || '__EMPTY_AGGREGATE_ALIAS__'}`;
     }
 
     setName(asName: string) {

package/src/concepts/QueryFromExpression__.ts

@@ -99,7 +99,7 @@ export class QueryFromExpression extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'joinParts' };
         let queryJoinExpression: QueryJoinExpression;
         if (options instanceof QueryJoinExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryJoinExpression = options;
             Object.assign(queryJoinExpression, relationOptions);
         } else {
@@ -173,7 +173,7 @@ export class QueryFromExpression extends LogicItem {
 
     addJoinPart(options?: Partial<QueryJoinExpression> | QueryJoinExpression) {
         const node = this._addJoinPart(options as any);
-        const index = this.joinParts.length;
+        const index = this.joinParts.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/QueryJoinExpression__.ts

@@ -93,7 +93,7 @@ export class QueryJoinExpression extends LogicItem {
         return (this.onExpressions || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getBinaryExpressionUniqueName(name = 'binaryExpression1') {
-        return utils.unique(name, this.getBinaryExpressionExistingNames());
+        return utils.unique(name, this.getBinaryExpressionExistingNames(), undefined, false);
     }
 
     /**
@@ -132,7 +132,7 @@ export class QueryJoinExpression extends LogicItem {
                 name: options,
             }, this, 'onExpressions');
         } else if (options instanceof BinaryExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             binaryExpression = options;
             Object.assign(binaryExpression, relationOptions);
         } else {
@@ -220,7 +220,7 @@ export class QueryJoinExpression extends LogicItem {
 
     addBinaryExpressionInOnExpressions(options?: string | Partial<BinaryExpression> | BinaryExpression) {
         const node = this._addBinaryExpressionInOnExpressions(options as any);
-        const index = this.onExpressions.length;
+        const index = this.onExpressions.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -250,7 +250,7 @@ export class QueryJoinExpression extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'joinParts' };
         let queryJoinExpression: QueryJoinExpression;
         if (options instanceof QueryJoinExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryJoinExpression = options;
             Object.assign(queryJoinExpression, relationOptions);
         } else {
@@ -324,7 +324,7 @@ export class QueryJoinExpression extends LogicItem {
 
     addJoinPartInJoinParts(options?: Partial<QueryJoinExpression> | QueryJoinExpression) {
         const node = this._addJoinPartInJoinParts(options as any);
-        const index = this.joinParts.length;
+        const index = this.joinParts.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/QueryLimitExpression__.ts

@@ -168,8 +168,8 @@ export class QueryLimitExpression extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         const { pageElement, pageSizeElement } = this;
-        let code = '';
-        code += `[${pageElement.toEmbeddedTS(shiftState(state, code))}, `;
+        let code = '[';
+        code += `${pageElement.toEmbeddedTS(shiftState(state, code))}, `;
         code += `${pageSizeElement.toEmbeddedTS(shiftState(state, code))}]`;
         return code;
     }

package/src/concepts/QuerySelectExpression__.ts

@@ -74,7 +74,7 @@ export class QuerySelectExpression extends LogicItem {
         return (this.selectElements || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getQueryAggregateExpressionUniqueName(name = 'queryAggregateExpression1') {
-        return utils.unique(name, this.getQueryAggregateExpressionExistingNames());
+        return utils.unique(name, this.getQueryAggregateExpressionExistingNames(), undefined, false);
     }
 
     /**
@@ -113,7 +113,7 @@ export class QuerySelectExpression extends LogicItem {
                 name: options,
             }, this, 'selectElements');
         } else if (options instanceof QueryAggregateExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryAggregateExpression = options;
             Object.assign(queryAggregateExpression, relationOptions);
         } else {
@@ -201,7 +201,7 @@ export class QuerySelectExpression extends LogicItem {
 
     addQueryAggregateExpression(options?: string | Partial<QueryAggregateExpression> | QueryAggregateExpression) {
         const node = this._addQueryAggregateExpression(options as any);
-        const index = this.selectElements.length;
+        const index = this.selectElements.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/Return__.ts

@@ -5,6 +5,7 @@ import Entity from './Entity__';
 import EntityProperty from './EntityProperty__';
 import Structure from './Structure__';
 import StructureProperty from './StructureProperty__';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -233,13 +234,26 @@ export class Return extends BaseNode {
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = this.name;
+        let code = this.name || '__return';
         if (this.typeAnnotation) {
             code += ': ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
+        // if (this.defaultValue) {
+        //     code += ` = ${this.defaultValue}`;
+        // }
+        return code;
+    }
+
+    @withSourceMap()
+    toEmbeddedTSInProcess(state?: TranslatorState): string {
+        let code = this.name;
+        if (this.typeAnnotation) {
+            code += ': undefined as ';
+            code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+        }
         if (this.defaultValue) {
-            code += ` = ${this.defaultValue}`;
+            code += `: ${this.defaultValue}`;
         }
         return code;
     }
@@ -264,15 +278,19 @@ export class Return extends BaseNode {
             if (!typeAnnotation)
                 throw new Error('找不到类型：' + typeAnnotation);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
-
+        // 处理下拉属性
+        try {
+            this.completionChildren = this.getSelectRef();
+        } catch (err) {
+            this.completionChildren = [];
+            console.log(err);
+        }
         const object = {
             typeAnnotation,
-            // 处理下拉属性
-            // completionChildren: this.getSelectRef(),
         };
 
         return this.update({
@@ -297,34 +315,47 @@ export class Return extends BaseNode {
     get readonly() {
         return !!this.module;
     }
-
+    get hasChildren() {
+        const { typeKind, typeNamespace } = this.typeAnnotation;
+        if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
+            return [{}];
+        }
+        return null;
+    }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        const moduleNames = typeNamespace.split('.');
-        let completionChildren;
-        if (typeKind === 'reference') {
-            let type: 'entities' | 'structures';
-            if (typeNamespace.endsWith('entities')) {
-                type = 'entities';
-            } else if (typeNamespace.endsWith('structures')) {
-                // 数据结构比较复杂，会有
-                type = 'structures';
-            }
-            // 内置模块
-            // if (typeNamespace.startsWith('nasl.')) {
-            // } else {
-            const data = this.app[type] as Array<Entity | Structure>;
-            if (data) {
-                const properties = data.find((item) => item.name === typeName)?.properties;
-                completionChildren = properties;
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                if (typeNamespace === 'nasl.collection') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
             } else {
                 completionChildren = undefined;
             }
-            // }
-        } else {
-            completionChildren = undefined;
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
         }
-        return completionChildren;
     }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

package/src/concepts/Role__.ts

@@ -36,6 +36,12 @@ export class Role extends BaseNode {
     @property()
     uuid: string = uuidv4().replace(/-/g, '');
 
+    /**
+     * 创建时间
+     */
+    @property()
+    createdTime: string = undefined;
+
     /**
      * 角色描述
      */
@@ -105,9 +111,6 @@ export class Role extends BaseNode {
 
     get tsName() {
         let tsName = this.name;
-        if (/^\d/.test(tsName)) {
-            tsName = '$' + tsName;
-        }
         // 匹配所有特殊字符都转为_
         tsName = tsName.replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, '_');
         return tsName;
@@ -132,7 +135,11 @@ export class Role extends BaseNode {
         let code = `namespace ${this.getNamespace()} {\n`;
 
         const state = createCompilerState(code, { tabSize: 1 });
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
         return {

package/src/concepts/SqlQueryComponent__.ts

@@ -128,8 +128,8 @@ export class SqlQueryComponent extends LogicItem {
     //================================================================================
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = `(function(): nasl.collection.PageOf<`
-        code +=`${this.typeAnnotation ? this.typeAnnotation.toEmbeddedTS(shiftState(state, code)): 'unknown'}> {\n`;
+        let code = `(function(): nasl.collection.List<`
+        code +=`${this.typeAnnotation ? this.typeAnnotation.toEmbeddedTS(shiftState(state, code)): '__IDENTIFIER__'}> {\n`;
         code += '\n';
         code += indent(state.tabSize + 1) + 'return;\n';
         code += indent(state.tabSize) + '})();\n';