@lcap/nasl 2.16.1 → 2.17.1

package/src/concepts/Match__.ts

@@ -0,0 +1,424 @@
+// @ts-nocheck
+import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
+import TypeAnnotation, { isUnion } from './TypeAnnotation__';
+import BooleanLiteral from './BooleanLiteral__';
+import { formatEnums } from '../server/getMemberIdentifier';
+import { ElementToVueOptions } from './ViewElement__';
+
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property } from '../decorators';
+
+import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
+import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
+import LogicItem from './LogicItem__';
+import MatchCase from './MatchCase__';
+
+/**
+ * 选择分支
+ */
+@concept('选择分支')
+export class Match extends LogicItem {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'Match' = 'Match';
+
+    /**
+     * 逻辑项
+     */
+    @property('LogicItem')
+    expression: LogicItem = undefined;
+
+    /**
+     * 是否表达式形态
+     */
+    @property()
+    isExpression: boolean = false;
+
+    /**
+     * 选择分支情况列表
+     */
+    @property('MatchCase')
+    cases: Array<MatchCase> = [];
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Match>) {
+        source = Object.assign({}, Match.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): Match {
+        return super.from(source, parentNode, parentKey) as Match;
+    }
+
+    /**
+    * 插入选择分支情况
+    * @internal
+    * @param matchCaseOptions 选择分支情况参数
+    */
+    _insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
+
+    /**
+    * 插入选择分支情况
+    * @internal
+    * @param matchCase 已有的选择分支情况实例
+    */
+    _insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
+
+    _insertMatchCaseAt(options: Partial<MatchCase> | MatchCase, index: number) {
+        const matchCaseOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'cases' };
+        let matchCase: MatchCase;
+        if (options instanceof MatchCase) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            matchCase = options;
+            Object.assign(matchCase, relationOptions);
+        } else {
+            matchCase = MatchCase.from({
+                ...matchCaseOptions,
+                ...options,
+            }, this, 'cases');
+        }
+        this.cases.splice(index, 0, matchCase);
+        return matchCase;
+    }
+
+    /**
+     * 插入选择分支情况
+     * @param matchCaseOptions 选择分支情况参数
+     */
+    insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
+
+    /**
+     * 插入选择分支情况
+     * @param matchCase 已有的选择分支情况实例
+     */
+    insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
+
+    insertMatchCaseAt(options: Partial<MatchCase> | MatchCase, index: number) {
+        const node = this._insertMatchCaseAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'cases',
+        });
+        return node;
+    }
+
+    /**
+     * 添加选择分支情况
+     * @internal
+     * @param matchCaseOptions 选择分支情况参数
+     */
+    _addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
+
+    /**
+     * 添加选择分支情况
+     * @internal
+     * @param matchCase 已有的选择分支情况实例
+     */
+    _addMatchCase(matchCase: MatchCase): MatchCase;
+
+    _addMatchCase(options?: Partial<MatchCase> | MatchCase) {
+        const index = this.cases.length;
+        return this._insertMatchCaseAt(options as any, index);
+    }
+
+    /**
+     * 添加选择分支情况
+     * @param matchCaseOptions 选择分支情况参数
+     */
+    addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
+
+    /**
+     * 添加选择分支情况
+     * @param matchCase 已有的选择分支情况实例
+     */
+    addMatchCase(matchCase: MatchCase): MatchCase;
+
+    addMatchCase(options?: Partial<MatchCase> | MatchCase) {
+        const node = this._addMatchCase(options as any);
+        const index = this.cases.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'cases',
+        });
+        return node;
+    }
+
+    /**
+    * 删除逻辑项
+    * @param name 逻辑项名称
+    */
+    removeExpression(name: string): void;
+
+    /**
+     * 删除逻辑项
+     * @param expression 已有的逻辑项实例
+     */
+    removeExpression(expression: LogicItem): void;
+
+    removeExpression(options: string | LogicItem) {
+        let expression: LogicItem;
+        if (typeof options === 'string') {
+            expression = this.expression;
+            if (!expression) {
+                throw new Error('找不到逻辑项 ' + options);
+            }
+        } else {
+            expression = options;
+        }
+        return expression.delete();
+    }
+
+    /**
+     * 删除选择分支情况
+     * @param matchCase 已有的选择分支情况实例
+     */
+    removeMatchCaseInCases(matchCase: MatchCase): void;
+
+    removeMatchCaseInCases(options: MatchCase) {
+        const matchCase: MatchCase = options;
+        return matchCase.delete();
+    }
+
+    __removeLogicItem(logicItem: LogicItem) {
+        const parentKey = logicItem.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: logicItem,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(logicItem);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === logicItem) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    async isEnumerable() {
+        const enumerableItems = await this.getEnumerableItems();
+        return !!enumerableItems?.length;
+    }
+
+    // 获取可枚举项
+    async getEnumerableItems(typeAnnotation?: TypeAnnotation) {
+        const expression = this.expression;
+        let currTypeAnnotation = typeAnnotation;
+        if (!currTypeAnnotation) {
+            currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
+        }
+        const { typeKind, typeNamespace, typeName, typeArguments } = currTypeAnnotation || {};
+        if (typeKind === 'union' && Array.isArray(typeArguments)) {
+            return typeArguments.map((typeArg) => {
+                let typeArgJson: any = typeArg;
+                if (typeArg instanceof TypeAnnotation) {
+                    typeArgJson = typeArg.toJSON();
+                }
+                return new TypeAnnotation(typeArgJson);
+            });
+        } else if (typeKind === 'reference') {
+            const nameArr = [typeName];
+            if (typeNamespace) {
+                nameArr.unshift(typeNamespace);
+            }
+            const typeNode = this.app.findNodeByCompleteName(nameArr.join('.')) || {};
+            if (typeNode.concept === 'Enum') {
+                const enums = formatEnums([typeNode]);
+                const { children } = enums?.[0] || {};
+                if (Array.isArray(children)) {
+                    return children.map((child) => child?.expression);
+                }
+            }
+        } else if (typeKind === 'primitive' && typeNamespace === 'nasl.core' && typeName === 'Boolean') {
+            return [
+                new BooleanLiteral({
+                    value: 'true',
+                }),
+                new BooleanLiteral({
+                    value: 'false',
+                }),
+            ];
+        }
+    }
+
+    /**
+     * 设置逻辑项
+     */
+    setExpression(expression: LogicItem) {
+        expression._delete();
+        const relationOptions = { parentNode: this, parentKey: 'expression' };
+        Object.assign(expression, relationOptions);
+        const object: any = {
+            expression,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    public static getDefaultOptions() {
+        return {
+            label: '选择分支',
+        };
+    }
+
+    async isTypeMatching() {
+        if (this.expression) {
+            const typeAnnotation = await this.expression.getCurrentTypeAnnotation();
+            const { typeKind, typeArguments } = typeAnnotation || {};
+            if (typeKind === 'union' && Array.isArray(typeArguments)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // 获取在页面中的名字
+    getInViewName() {
+        const nameList: string[] = [];
+        let node: BaseNode = this;
+        while (node) {
+            if (node === this) {
+                nameList.unshift('viewMatchExpression');
+            } else {
+                nameList.unshift(node.name);
+            }
+            if (node.concept === 'ViewElement') {
+                node = null;
+            } else {
+                nameList.unshift(node.parentKey);
+                node = node.parentNode;
+            }
+        }
+        return nameList.join('_');
+    }
+
+    getInViewMethod(state?: TranslatorState) {
+        let code = '';
+        code += `async ${this.getInViewName()} () {`;
+        code += this.toJS(state);
+        code += '}';
+        return code;
+    }
+
+    onChange($event?: EventPayload): void {
+        this.emit('change', $event);
+    }
+
+    toVue(options?: ElementToVueOptions): string {
+        if (options?.finalCode !== false) {
+            return `${this.getInViewName()}()`;
+        } else {
+            let code = '匹配 ';
+            if (this.expression) {
+                code += this.expression.toVue?.();
+            }
+            if (Array.isArray(this.cases)) {
+                code += ' { ';
+                this.cases.forEach((item, index) => {
+                    code += item?.toVue?.(options);
+                });
+                code += '}';
+            }
+            return code;
+        }
+    }
+
+    toUI(state?: TranslatorState): string {
+        let code = '匹配 ';
+        if (this.expression) {
+            code += this.expression.toUI?.();
+        }
+        if (Array.isArray(this.cases)) {
+            code += ' { ';
+            this.cases.forEach((item, index) => {
+                code += item?.toUI?.();
+            });
+            code += '}';
+        }
+        return code;
+    }
+
+    toJS(state?: TranslatorState): string {
+        let code = 'await (async () => {';
+        if (this.expression && Array.isArray(this.cases)) {
+            this.cases.forEach((item, index) => {
+                code += item?.toJS?.(this.expression, index, this.cases.length);
+            });
+        }
+        code += `})()`;
+        return code;
+    }
+
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        let code = '';
+
+        if (this.parentNode.concept === 'Logic') {
+            code += '\n';
+        }
+        code += indent((state?.tabSize || 0));
+        code += '(() => { \n';
+        let parentCode: string;
+        if (this.expression) {
+            code += indent((state?.tabSize || 0));
+            code += parentCode = this.expression.toEmbeddedTS(shiftState(state, code));
+            code += ';\n';
+        } else {
+            code += '__IDENTIFIER__;\n';
+        }
+        code += indent((state?.tabSize + 1 || 0));
+        code += ' function __MatchExpressionFuntion() {\n';
+
+        //  最后一项是else
+        this.cases.forEach((item, index) => {
+            // 如果是最后一项
+            code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) }), index, parentCode);
+        });
+        code += indent((state?.tabSize || 0));
+        code += '};\n';
+        code += indent((state?.tabSize || 0));
+        code += 'return __MatchExpressionFuntion();\n';
+        code += indent((state?.tabSize || 0));
+        code += '})();\n';
+        return code;
+    }
+
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap.Match = Match;
+export default Match;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================
+// @ts-check

package/src/concepts/MemberExpression__.ts

@@ -4,6 +4,7 @@ import { ElementToVueOptions } from './ViewElement__';
 import Identifier from './Identifier__';
 import BindAttribute from './BindAttribute__';
 import Assignment from './Assignment__';
+import BatchAssignment from './BatchAssignment__';
 
 const Identifier_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
@@ -43,7 +44,7 @@ export class MemberExpression extends LogicItem {
     @property('LogicItem')
     property: LogicItem = undefined;
 
-    
+
 
     /**
      * @param source 需要合并的部分参数
@@ -58,12 +59,12 @@ export class MemberExpression extends LogicItem {
         return super.from(source, parentNode, parentKey) as MemberExpression;
     }
 
-    
-    
 
-    
 
-    
+
+
+
+
 
     /**
     * 删除逻辑项
@@ -90,7 +91,7 @@ export class MemberExpression extends LogicItem {
         return object.delete();
     }
 
-    
+
 
     /**
     * 删除逻辑项
@@ -185,6 +186,7 @@ export class MemberExpression extends LogicItem {
         const property = this.property?.toJS();
         // 在赋值语句的左侧，不能有 &&
         const assignment: Assignment = this.getAncestor('Assignment') as Assignment;
+        const batchAssignment: BatchAssignment = this.getAncestor('BatchAssignment') as BatchAssignment;
         if (assignment) {
             const left = assignment.left;
             let node: any = this;
@@ -195,12 +197,22 @@ export class MemberExpression extends LogicItem {
             if (node) {
                 return Identifier_RE.test(property) ? `${object}.${property}` : `${object}['${property}']`;
             }
+        } else if (batchAssignment) {
+            const left = batchAssignment.left;
+            let node: any = this;
+            while (node && node.concept === 'MemberExpression' && left !== node) {
+                node = node.parentNode;
+            }
+            // 在赋值语句的左侧
+            if (node) {
+                return Identifier_RE.test(property) ? `${object}.${property}` : `${object}['${property}']`;
+            }
         }
         const lastPart = object.split(' && ').pop();
         return Identifier_RE.test(property) ? `${object} && ${lastPart}.${property}` : `${object} && ${lastPart}['${property}']`;
     }
 
-    toBrief(): string { 
+    toBrief(): string {
         return `${this.object.toBrief()}.${this.property.toBrief()}`
     }
 
@@ -224,7 +236,7 @@ export class MemberExpression extends LogicItem {
     }
 
     /**
-     * 设置数据结构字段名称
+     * 设置数据结构属性名称
      */
     setName(name: string) {
         // 需要单独处理下内容向上查找覆盖
@@ -284,13 +296,21 @@ export class MemberExpression extends LogicItem {
             }
             // 在赋值语句的左侧
             if (node) {
-                console.log(Identifier_RE.test(property) ? `${object}.${property}` : `${object}['${property}']`);
                 return Identifier_RE.test(property) ? `${object}.${property}` : `${object}['${property}']`;
             }
         }
         return Identifier_RE.test(property) ? `${object}.${property}` : `${object}['${property}']`;
     }
 
+    get rootName() {
+        const completeNameArr = this.completeName.split('.');
+        let name = completeNameArr[0];
+        // 公共变量， 全局变量情况下
+        if (completeNameArr[0] === 'app' || completeNameArr[0] === 'nasl')
+            name = `${completeNameArr[0]}.${completeNameArr[1]}.${completeNameArr[2]}`;
+        return name;
+    }
+
     /**
      * getValue的值就是想要的ts内容
      * @param state

package/src/concepts/Param__.ts

@@ -2,10 +2,11 @@ import { dataTypesMap } from './basics/types';
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import LogicItem from './LogicItem__';
 import EntityProperty from './EntityProperty__';
-import StructureProperty from './StructureProperty__';
 import Structure from './Structure__';
+import StructureProperty from './StructureProperty__';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 import Function from './Function__';
+import AnonymousFunction from './AnonymousFunction__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -177,10 +178,14 @@ export class Param extends BaseNode {
         });
     }
 
+
+
+
+
     /**
-     * 删除类型标注
-     * @param name 类型标注名称
-     */
+    * 删除类型标注
+    * @param name 类型标注名称
+    */
     removeTypeAnnotation(name: string): void;
 
     /**
@@ -232,7 +237,7 @@ export class Param extends BaseNode {
 
     @excludedInJSON()
     @property()
-    defaultExpression: LogicItem | Function = undefined;
+    defaultExpression: LogicItem | Function | AnonymousFunction = undefined;
     @excludedInJSON()
     @property()
     options: Array<{ text?: string; value: string }> = undefined;
@@ -244,7 +249,7 @@ export class Param extends BaseNode {
     } = undefined;
 
     /**
-     * 自动补全的字段列表
+     * 自动补全的属性列表
      */
     completionChildren: Array<EntityProperty | StructureProperty> = undefined;
 
@@ -368,24 +373,24 @@ export class Param extends BaseNode {
     getSelectRef(newTypeAnnotation: TypeAnnotation) {
         try {
             const { typeName, typeKind, typeNamespace } = newTypeAnnotation || this.typeAnnotation;
-            let completionChildren: StructureProperty[];
+            let completionChildren;
             if (typeKind === 'reference') {
                 if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process' || typeNamespace === 'nasl.auth') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName) as Structure;
-                    const properties = node?.properties || [];
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = (node as Structure)?.properties || [];
                     completionChildren = properties;
                 } else if (typeNamespace.endsWith('.enums')) {
                     completionChildren = [];
                 } else {
-                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName) as Structure;
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
                     const properties = node?.properties || [];
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
                 // if (typeNamespace === 'nasl.collection' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
                 // }
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName) as Structure;
-                const properties = (node?.properties && [...node?.properties]) || [];
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = ((node as Structure)?.properties && [...(node as Structure)?.properties]) || [];
                 for (let i = 0; i < properties.length; i++) {
                     const item = properties[i];
                     if (item?.typeAnnotation?.typeKind === 'typeParam') {

package/src/concepts/Process__.ts

@@ -1392,11 +1392,23 @@ export class Process extends BaseNode {
                             concept: 'Return',
                             description: '审批意见',
                             name: 'approvalComment',
+                            typeAnnotation: {
+                                concept: 'TypeAnnotation',
+                                typeKind: 'primitive',
+                                typeNamespace: 'nasl.core',
+                                typeName: 'String',
+                            },
                         },
                         {
                             concept: 'Return',
                             description: '审批结果',
                             name: 'approvalResult',
+                            typeAnnotation: {
+                                concept: 'TypeAnnotation',
+                                typeKind: 'primitive',
+                                typeNamespace: 'nasl.core',
+                                typeName: 'String',
+                            },
                         },
                     ],
                     ...userTaskAttr,

package/src/concepts/QueryAggregateExpression__.ts

@@ -42,7 +42,7 @@ export class QueryAggregateExpression extends LogicItem {
     @property('QueryFieldExpression')
     aggregateParam: QueryFieldExpression = undefined;
 
-    
+
 
     /**
      * @param source 需要合并的部分参数
@@ -57,22 +57,22 @@ export class QueryAggregateExpression extends LogicItem {
         return super.from(source, parentNode, parentKey) as QueryAggregateExpression;
     }
 
-    
-    
 
-    
 
-    
+
+
+
+
 
     /**
-    * 删除查询字段
-    * @param name 查询字段名称
+    * 删除查询属性
+    * @param name 查询属性名称
     */
     removeAggregateParam(name: string): void;
 
     /**
-     * 删除查询字段
-     * @param aggregateParam 已有的查询字段实例
+     * 删除查询属性
+     * @param aggregateParam 已有的查询属性实例
      */
     removeAggregateParam(aggregateParam: QueryFieldExpression): void;
 
@@ -81,7 +81,7 @@ export class QueryAggregateExpression extends LogicItem {
         if (typeof options === 'string') {
             aggregateParam = this.aggregateParam;
             if (!aggregateParam) {
-                throw new Error('找不到查询字段 ' + options);
+                throw new Error('找不到查询属性 ' + options);
             }
         } else {
             aggregateParam = options;