@lcap/nasl 2.14.0 → 2.15.1

package/src/common/BaseNode.ts

@@ -804,6 +804,10 @@ export class BaseNode extends EventEmitter {
                     parentNode,
                     parentKey,
                 });
+                
+                if(this.concept === 'ViewElement')
+                    this.name = (this as unknown as ViewElement).getViewElementUniqueName(this.name);
+
                 list.splice(index, 0, this);
                 this.create({
                     index,
@@ -827,7 +831,7 @@ export class BaseNode extends EventEmitter {
         function traverse(node: BaseNode) {
             cb(node);
 
-            const propertyMap = getConceptPropertyMap(node.concept);
+            const propertyMap = getConceptPropertyMap(node?.concept);
             if (!propertyMap)
                 return;
 

package/src/concepts/App__.ts

@@ -3,6 +3,8 @@ export interface AssetsInfo {
     css: Array<string>;
     names?: Array<string>;
 }
+import { getNaslNodeByNodeCallee } from '../automate/engine/utils';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -2664,8 +2666,13 @@ export class App extends BaseNode {
 
     findNodeByCompleteName(completeName: string) {
         const nameArr = completeName?.split('.') || [];
-        const start = nameArr.shift();
         let node: any = this;
+        // 先处理平台的
+        if (completeName.startsWith('nasl')) {
+            node = getNaslNodeByNodeCallee(nameArr.splice(0, nameArr.length - 1).join('.'), nameArr[nameArr.length - 1]);
+            return node;
+        }
+        const start = nameArr.shift();
         const mod = 0;
         const modulesMap: any = {
             extensions: node.dependencies,

package/src/concepts/Assignee__.ts

@@ -657,7 +657,7 @@ export class Assignee extends LogicItem {
         // let code = `const plainuser = [];\n`
         // code += `const dynamicuser = [];\n`
         let code = prevCode;
-        if (!this.users.length && !this.dynamicUsers.length && !this.logicUsers.length)
+        if (!this.users.length && !this.dynamicUsers.length && !this.logicUsers.length && !this.roles.length)
             code += tab + '__UsersEmpty__;\n';
         if (Array.isArray(this.logicUsers)) {
             this.logicUsers.forEach((logic) => {

package/src/concepts/BindAttribute__.ts

@@ -677,7 +677,9 @@ export class BindAttribute extends BaseNode {
                 } else {
                     str += `:${name}${this.sync ? '.sync' : ''}="${value}"`;
                 }
-            }
+            } else if(this.type === 'string' && this.value === '')
+                str = `${name}="${this.value}"`;
+            
             return str;
         }
     }

package/src/concepts/BindEvent__.ts

@@ -579,10 +579,14 @@ export class BindEvent extends BaseNode {
                 const logicName = logic.name;
                 logic.name = '__' + logic.view.name + (logic.parentNode as BindEvent).element.name + logic.name;
                 logic.name = logic.name.replace(/-/g, '');
-                code += logic.toEmbeddedTS(shiftState(state, code, {
-                    tabSize: (state?.tabSize || 0) + 2,
-                }), 'noExport');
-                logic.name = logicName;
+                try {
+                    code += logic.toEmbeddedTS(shiftState(state, code, {
+                        tabSize: (state?.tabSize || 0) + 2,
+                    }), 'noExport');
+                } finally {
+                    // 翻译logic可能出错
+                    logic.name = logicName;
+                }
             } else {
                 code += logic.toEmbeddedTS(shiftState(state, code, {
                     tabSize: (state?.tabSize || 0) + 2,

package/src/concepts/CallLogic__.ts

@@ -779,12 +779,12 @@ var __parseType = (root, prop) => {
                         code += `JSON.parse`;
                         break;
                 }
-            } else if (calleeNamespace === 'nasl.browser' || calleeNamespace === 'nasl.auth' || calleeNamespace === 'nasl.configuration' || calleeNamespace === 'nasl.process') {
+            } else if (calleeNamespace === 'nasl.browser' || calleeNamespace === 'nasl.auth' || calleeNamespace === 'nasl.configuration' || calleeNamespace === 'nasl.process' || calleeNamespace === 'nasl.io') {
                 code += `this.$global.${this.calleeName}`;
             } else {
                 code += `this.${this.calleeName}`;
             }
-            if (calleeNamespace === 'nasl.process') {
+            if (calleeNamespace === 'nasl.process' || calleeNamespace === 'nasl.auth') {
                 code += '({';
                 this.arguments
                     ?.filter((arg) => arg?.expression)
@@ -797,9 +797,8 @@ var __parseType = (root, prop) => {
             } else {
                 code += '(';
                 this.arguments
-                    ?.filter((arg) => arg?.expression)
                     .forEach((arg, index) => {
-                        code += arg?.toJS(shiftState(state, code));
+                        code += arg?.toJS(shiftState(state, code)) || 'undefined';
                         if (index !== this.arguments?.length - 1)
                             code += ', ';
                     });

package/src/concepts/EnumItem__.ts

@@ -120,7 +120,7 @@ export class EnumItem extends BaseNode {
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        return `static ${this.value}: ${this.enumeration.name}`;
+        return `static '${this.value}': ${this.enumeration.name}`;
     }
     setName(value: string) {
         this.setValue(value);

package/src/concepts/Interface__.ts

@@ -15,6 +15,8 @@ import InterfaceParam from './InterfaceParam__';
 import Return from './Return__';
 import Module from './Module__';
 import App from './App__';
+import TypeAnnotation from './TypeAnnotation__';
+import Structure from './Structure__';
 
 /**
  * 接口
@@ -131,7 +133,7 @@ export class Interface extends BaseNode {
         });
     }
 
-        getInterfaceParamUniqueName(name = 'interfaceParam1') {
+    getInterfaceParamUniqueName(name = 'interfaceParam1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
 
@@ -268,7 +270,6 @@ export class Interface extends BaseNode {
         return node;
     }
 
-
     getReturnUniqueName(name = 'result') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -406,9 +407,6 @@ export class Interface extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
     * 删除接口参数
     * @param name 接口参数名称
@@ -457,8 +455,6 @@ export class Interface extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除输出参数
     * @param name 输出参数名称
@@ -545,10 +541,73 @@ export class Interface extends BaseNode {
 
     /* 删除空数据模块 */
     deleteLogincAndModule() {
+        this.rootNode.emit('collect:start', {
+            actionMsg: `删除接口“${this.name}”`,
+        });
+
         this.delete();
+        this.deleteStructures();
+
         if (this.module && this.module.interfaces.length === 0 && this.module.structures.length === 0) {
             this.app.removeModuleInInterfaceDependencies(this.module);
         }
+
+        // 结束修改 ，批量操作
+        this.rootNode.emit('collect:end');
+    }
+
+    /* 删除接口引用的数据结构 */
+    deleteStructures() {
+        // 需要过滤被其他接口同时引用的数据结构
+
+        const structures = (this.parentNode as Module).structures;
+        // 递归找出 response/request 的 Body/Returns 引用的数据结构
+        const getStructures = (typeAnnotation: TypeAnnotation, result: Array<Structure> = []) => {
+            if (!typeAnnotation)
+                return;
+            if (typeAnnotation.typeKind === 'reference') {
+                const targetStructure = structures.find((s) => s.name === typeAnnotation.typeName);
+                if (targetStructure) {
+                    result.push(targetStructure);
+                    targetStructure?.properties.forEach((prop) => {
+                        getStructures(prop.typeAnnotation, result);
+                    });
+                }
+            } else if (typeAnnotation.typeKind === 'generic') {
+                typeAnnotation.typeArguments.forEach((arg) => {
+                    getStructures(arg, result);
+                });
+            }
+            return result;
+        };
+
+        const otherStructureMap: Record<string, number> = {};
+        // 找出其他接口引用的数据结构
+        (this.parentNode as Module).interfaces
+            .filter((itf) => itf !== this)
+            .forEach((itf) => {
+                const params = itf.params || [];
+                const returns = itf.returns || [];
+                [...params, ...returns].forEach((p) => {
+                    const strus = getStructures(p.typeAnnotation);
+                    strus.forEach((s) => {
+                        if (!(s.name in otherStructureMap)) {
+                            otherStructureMap[s.name] = 0;
+                        }
+                        otherStructureMap[s.name]++;
+                    });
+                });
+            });
+        const params = this.params || [];
+        const returns = this.returns || [];
+        [...params, ...returns].forEach((p) => {
+            const strus = getStructures(p.typeAnnotation);
+            strus.forEach((s) => {
+                if (!(s.name in otherStructureMap)) {
+                    (this.parentNode as Module).removeStructure(s);
+                }
+            });
+        });
     }
     /**
      * 设置逻辑名称

package/src/concepts/Logic__.ts

@@ -1629,7 +1629,7 @@ export class Logic extends BaseNode {
         this.virtualParams && Array.isArray(this.virtualParams) && this.virtualParams.forEach((param) => {
             code += indent((state?.tabSize || 0) + 1);
             code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
-            code += ';\n';
+            code += '\n';
         });
         this.variables.forEach((variable) => {
             code += indent((state?.tabSize || 0) + 1) + 'let ';
@@ -1680,7 +1680,7 @@ export class Logic extends BaseNode {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging'].includes(namespace) && !namespace.includes('.logics')) {
+            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;
@@ -1697,7 +1697,7 @@ export class Logic extends BaseNode {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process'].includes(namespace) && !namespace.includes('.logics')) {
+            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;

package/src/concepts/ProcessElement__.ts

@@ -257,7 +257,7 @@ export class ProcessElement extends BaseNode {
         });
     }
 
-        getBindEventExistingNames(excludedList: Array<BindEvent> = []) {
+    getBindEventExistingNames(excludedList: Array<BindEvent> = []) {
         const excludedSet = new Set(excludedList);
         return (this.bindEvents || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -1109,7 +1109,7 @@ export class ProcessElement extends BaseNode {
     }
 
 
-    
+
 
     /**
     * 删除元素绑定事件
@@ -1518,8 +1518,12 @@ export class ProcessElement extends BaseNode {
         return [...this.variables, ...this.returns, ...this.constants].filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
 
+    get isUserTask() {
+        return this.type === 'UserTask' || this.type === 'ApprovalTask' || this.type === 'InitiateTask';
+    }
+
     get logics() {
-        return [genUserTaskLogic(this)];
+        return [...genUserTaskLogic(this)];
         // const ns = entity2LogicNamespace(this);
         // ns.path = this.getNamespace() + '.' + ns.name;
         // return ns;
@@ -1547,20 +1551,23 @@ export class ProcessElement extends BaseNode {
         } else
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
-    cancelBindDelete() {
-        this.delete();
-        this.bindAttrs.forEach(({ destination }) => {
-            if (destination && destination.viewNode)
-                this.cancelBind(destination.viewNode);
-        });
-    }
-
-    async cancelBind(view: View) {
-        const name = this.uniqueTaskId(view);
-        const node = view.params.find((param) => param.name === name);
-        const UsageMap = await node.findUsage();
-        if (!UsageMap.size)
-            view.removeParam(name);
+    async cancelBindDelete(processDelete: boolean) {
+        if (!processDelete)
+            this.delete();
+        await Promise.all(this.bindAttrs.map(async ({ destination }) => {
+            if (destination && destination.viewNode) {
+                const view = destination.viewNode;
+                const name = this.uniqueTaskId(view);
+                const node = view.params.find((param: any) => param.name === name);
+                if (!node)
+                    return;
+                const UsageMap = await node.findUsage();
+                const usageNodes = UsageMap.get(this.process);
+                // console.log(UsageMap, usageNodes)
+                if (!UsageMap.size || (UsageMap.size === 1 && usageNodes && (!usageNodes.children || usageNodes.children.length === 1)))
+                    view.removeParam(name);
+            }
+        }));
     }
     //获取当前页面类型为String的taskId参数
     uniqueTaskId(view: View) {
@@ -1604,7 +1611,7 @@ export class ProcessElement extends BaseNode {
         });
         const afterLinks = getFlowAfterElements(this);
         const beforeLinks = getFlowBeforeElements(this);
-        if (this.type === 'UserTask'
+        if (this.isUserTask
             || this.type === 'ExclusiveGateway'
             || this.type === 'AutoTask') {
             const prevTasks = getPreviousTask(this);
@@ -1624,7 +1631,7 @@ export class ProcessElement extends BaseNode {
 
             // prevCode += `${tab4}}\n`
 
-            if (this.type === 'UserTask') {
+            if (this.isUserTask) {
                 //任务完成时可以拿到输出参数，prevCodeClose包含输出参数
                 let prevCodeClose = prevCode + `\n${tab5}${this.name}: { \n${this.constants.map((c) => `${tab6}${c.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},`).join('\n')}`;
                 prevCodeClose += ` \n${this.returns.map((c) => `${tab6}${c.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},`).join('\n')} \n${tab5}}\n`;
@@ -1653,12 +1660,15 @@ export class ProcessElement extends BaseNode {
                         code += `${tab3}},\n`;
                     }
                 });
-                const logic = genUserTaskLogic(this);
+                const logics = genUserTaskLogic(this);
                 // sourceMap 映射
-                logic.parentNode = this.process;
 
-                code += logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }));
-                code += ',\n';
+                logics.forEach((logic) => {
+                    logic.parentNode = this.process;
+
+                    code += logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }));
+                    code += ',\n';
+                });
                 code += `${tab1}},\n`;
             }
 
@@ -1669,7 +1679,7 @@ export class ProcessElement extends BaseNode {
                 code += `${this.logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }), prevCode, true)},\n`;
             }
         }
-        if (this.type === 'UserTask' || this.type === 'AutoTask' || this.type === 'StartNoneEvent') {
+        if (this.isUserTask || this.type === 'AutoTask' || this.type === 'StartNoneEvent') {
             code += '_constraints: function() {\n';
             code += `${tab1}nasl.process.oneOutcomeFlow(${afterLinks.map((l) => `'${l.name}'`).join(',')})\n`;
             code += '},\n';

package/src/concepts/Process__.ts

@@ -1212,7 +1212,7 @@ export class Process extends BaseNode {
             });
         });
         this.elements.forEach((item) => {
-            if (item.concept === 'ProcessElement' && item.type === 'UserTask') {
+            if (item.concept === 'ProcessElement' && item.isUserTask) {
                 utils.traverse((current) => {
                     current.node.bindEvents.forEach((bindEvent) => {
                         bindEvent.logics.forEach((logic) => {
@@ -1308,6 +1308,36 @@ export class Process extends BaseNode {
     }
 
     public static getDefaultOptions() {
+        const userTaskAttr = {
+            bindAttrs: [
+                {
+                    concept: 'BindAttribute',
+                    name: 'assignee',
+                    assignee: {
+                        concept: 'Assignee',
+                    },
+                },
+                {
+                    concept: 'BindAttribute',
+                    name: 'destination',
+                    destination: {
+                        concept: 'Destination',
+                    },
+                },
+            ],
+            constants: [
+                {
+                    concept: 'Constant',
+                    name: 'taskId',
+                    typeAnnotation: {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeNamespace: 'nasl.core',
+                        typeName: 'String',
+                    },
+                },
+            ],
+        };
         return {
             constants: [
                 {
@@ -1320,6 +1350,16 @@ export class Process extends BaseNode {
                         typeName: 'String',
                     },
                 },
+                {
+                    concept: 'Constant',
+                    name: 'startBy',
+                    typeAnnotation: {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeNamespace: 'nasl.core',
+                        typeName: 'String',
+                    },
+                },
             ],
             elements: [
                 {
@@ -1331,13 +1371,47 @@ export class Process extends BaseNode {
                         x: 0, y: 0,
                     },
                 },
+                {
+                    concept: 'ProcessElement',
+                    name: 'InitiateTask',
+                    type: 'InitiateTask',
+                    title: '发起任务',
+                    ...userTaskAttr,
+                    bounds: {
+                        concept: 'Rect',
+                        x: 0, y: 90,
+                    },
+                },
+                {
+                    concept: 'ProcessElement',
+                    name: 'ApprovalTask',
+                    type: 'ApprovalTask',
+                    title: '审批任务',
+                    returns: [
+                        {
+                            concept: 'Return',
+                            description: '审批意见',
+                            name: 'approvalComment',
+                        },
+                        {
+                            concept: 'Return',
+                            description: '审批结果',
+                            name: 'approvalResult',
+                        },
+                    ],
+                    ...userTaskAttr,
+                    bounds: {
+                        concept: 'Rect',
+                        x: 0, y: 250,
+                    },
+                },
                 {
                     concept: 'ProcessElement',
                     name: 'End',
                     type: 'EndNoneEvent',
                     bounds: {
                         concept: 'Rect',
-                        x: 0, y: 180,
+                        x: 0, y: 500,
                     },
                 },
                 {
@@ -1345,6 +1419,28 @@ export class Process extends BaseNode {
                     name: 'SequenceFlow',
                     type: 'SequenceFlow',
                     sourceRef: 'Start',
+                    targetRef: 'InitiateTask',
+                    waypoints: [
+                        { x: 0, y: 1 },
+                        { x: 0, y: -1 },
+                    ],
+                },
+                {
+                    concept: 'ProcessElement',
+                    name: 'SequenceFlow1',
+                    type: 'SequenceFlow',
+                    sourceRef: 'InitiateTask',
+                    targetRef: 'ApprovalTask',
+                    waypoints: [
+                        { x: 0, y: 1 },
+                        { x: 0, y: -1 },
+                    ],
+                },
+                {
+                    concept: 'ProcessElement',
+                    name: 'SequenceFlow2',
+                    type: 'SequenceFlow',
+                    sourceRef: 'ApprovalTask',
                     targetRef: 'End',
                     waypoints: [
                         { x: 0, y: 1 },