@lcap/nasl 2.18.0-beta.7 → 2.19.0-beta.1

package/src/concepts/BatchAssignment__.ts

@@ -731,7 +731,7 @@ export class BatchAssignment extends LogicItem {
     }
 
     deleteAssignmentLine(assignmentLine: AssignmentLine) {
-        const newLine = this.assignmentLines.filter((line) => line === assignmentLine);
+        const newLine = this.assignmentLines.filter((line) => line !== assignmentLine);
         this.update({
             assignmentLines: newLine,
         });
@@ -769,6 +769,50 @@ export class BatchAssignment extends LogicItem {
         }
     }
 
+    changeMembers(oldNode:any, members: MemberExpression[], keepMembers: any, expression: LogicItem) {
+        this.app.emit('collect:start', {
+            actionMsg: '批量赋值修改变量',
+        });
+        const selectMember = oldNode.parentNode;
+        const autoConnectionIndex = this.rights.findIndex((right) => right === selectMember);
+        const newSelectMember = Object.assign({}, selectMember, { expression, members });
+        let newLines: any = [];
+        // 修改连线
+        if (selectMember.parentKey === 'left') {
+            members.forEach((item: any, index: any) => {
+                if (keepMembers.has(item.completeName)) {
+                    const lines = this.findlines(item, selectMember);
+                    lines.forEach((line) => {
+                        const newLine = Object.assign({}, line, { leftIndex: [line.leftIndex[0], index] });
+                        newLines.push(newLine);
+                    });
+                }
+            });
+            this.update({
+                assignmentLines: newLines,
+                left: newSelectMember,
+            });
+        } else {
+            const splitIndex = this.rights.findIndex((right) => selectMember === right);
+            newLines = this.assignmentLines.filter(({ rightIndex }) => rightIndex[0] !== splitIndex);
+            members.forEach((item, index) => {
+                if (keepMembers.has(item.completeName)) {
+                    const lines = this.findlines(item, selectMember);
+                    lines.forEach((line) => {
+                        const newLine = Object.assign({}, line, { rightIndex: [line.rightIndex[0], index] });
+                        newLines.push(newLine);
+                    });
+                }
+            });
+            this.update({
+                assignmentLines: newLines,
+                rights: [...this.rights.slice(0, splitIndex), newSelectMember, ...this.rights.slice(splitIndex + 1, this.rights.length)],
+            });
+        }
+        this.autoConnection && this.batchAutoConnection(autoConnectionIndex);
+        this.app.emit('collect:end');
+    }
+
     findMember(arrIndex: Array<number>, place: string) {
         const [firstIndex, secondIndex] = [arrIndex[0], arrIndex[1]];
         if (place === 'left') {

package/src/concepts/BindAttribute__.ts

@@ -723,13 +723,20 @@ export class BindAttribute extends BaseNode {
                     str += 'download="true" ';
                     name = 'href';
                 }
+                // 文本默认要经过toString转换
+                if (options.finalCode !== false && name === 'text' && !this.sync && this.type === 'dynamic') {
+                    const expTypeAnnotation = (this.expression as any)?.typeAnnotation || this.expression?.__TypeAnnotation;
+                    value = `$utils['ToString'](${value}, '${expTypeAnnotation?.sortedTypeKey}')`;
+                }
                 if (this.type === 'string') {
                     str += `${name}="${value}"`;
                 } else {
                     str += `:${name}${this.sync ? '.sync' : ''}="${value}"`;
                 }
-            } else if(this.type === 'string' && this.value === '')
-                str = `${name}="${this.value}"`;
+            } else if (this.type === 'string' && this.value === '')
+                if (!['destination', 'externalDestination'].includes(this.name)) {
+                    str = `${name}="${this.value}"`;
+                }
 
             return str;
         }

package/src/concepts/CallFunction__.ts

@@ -66,7 +66,7 @@ export class CallFunction extends LogicItem {
     @property('Argument')
     arguments: Array<Argument> = [];
 
-    
+
 
     /**
      * @param source 需要合并的部分参数
@@ -81,12 +81,12 @@ export class CallFunction extends LogicItem {
         return super.from(source, parentNode, parentKey) as CallFunction;
     }
 
-    
-    
 
-    
 
-    
+
+
+
+
 
     /**
     * 插入类型标注
@@ -120,7 +120,7 @@ export class CallFunction extends LogicItem {
         return typeAnnotation;
     }
 
-    
+
 
     /**
      * 插入类型标注
@@ -144,7 +144,7 @@ export class CallFunction extends LogicItem {
         return node;
     }
 
-    
+
 
     /**
      * 添加类型标注
@@ -165,7 +165,7 @@ export class CallFunction extends LogicItem {
         return this._insertTypeAnnotationAt(options as any, index);
     }
 
-    
+
 
     /**
      * 添加类型标注
@@ -193,7 +193,7 @@ export class CallFunction extends LogicItem {
 
 
 
-    
+
 
     /**
     * 插入实际参数
@@ -227,7 +227,7 @@ export class CallFunction extends LogicItem {
         return argument;
     }
 
-    
+
 
     /**
      * 插入实际参数
@@ -251,7 +251,7 @@ export class CallFunction extends LogicItem {
         return node;
     }
 
-    
+
 
     /**
      * 添加实际参数
@@ -272,7 +272,7 @@ export class CallFunction extends LogicItem {
         return this._insertArgumentAt(options as any, index);
     }
 
-    
+
 
     /**
      * 添加实际参数
@@ -298,7 +298,7 @@ export class CallFunction extends LogicItem {
     }
 
 
-    
+
 
     /**
      * 删除类型标注
@@ -380,11 +380,19 @@ export class CallFunction extends LogicItem {
         } else {
             let code = `$utils['${this.calleeName}']`;
             code += '(';
-            this.arguments?.forEach((arg, index) => {
-                code += arg?.toVue(options);
-                if (index !== this.arguments?.length - 1)
-                    code += ', ';
-            });
+            if (Array.isArray(this.arguments) && this.arguments.length) {
+                const needToString = ['Concat'].includes(this.calleeName);
+                this.arguments?.forEach((arg: any, index) => {
+                    let argStr = arg?.toVue(options);
+                    if (needToString) {
+                        const argTypeAnnotation = arg.typeAnnotation || arg.__TypeAnnotation;
+                        argStr = `$utils['ToString'](${argStr}, '${argTypeAnnotation?.sortedTypeKey}')`;
+                    }
+                    code += argStr;
+                    if (index !== this.arguments?.length - 1)
+                        code += ', ';
+                });
+            }
             if (this.typeArguments && this.typeArguments.length) {
                 if (this.arguments?.length)
                     code += ', ';
@@ -423,23 +431,49 @@ export class CallFunction extends LogicItem {
     toJS(state?: TranslatorState): string {
         let code = `this.$utils['${this.calleeName}']`;
         code += '(';
-        this.arguments?.forEach((arg, index) => {
-            code += arg?.toJS(shiftState(state, code));
-            if (index !== this.arguments?.length - 1)
-                code += ', ';
-        });
-        if (this.typeArguments && this.typeArguments.length) {
-            if (this.arguments?.length)
-                code += ', ';
-            this.typeArguments?.forEach((arg, index) => {
-                code += arg?.toJS(shiftState(state, code));
-                if (index !== this.typeArguments?.length - 1)
+        if (Array.isArray(this.arguments) && this.arguments.length) {
+            const needToString = ['Concat'].includes(this.calleeName);
+            this.arguments.forEach((arg: any, index) => {
+                let argStr = arg?.toJS(shiftState(state, code));
+                if (needToString) {
+                    const argTypeAnnotation = arg.typeAnnotation || arg.__TypeAnnotation;
+                    argStr = `this.$utils['ToString'](${argStr}, '${argTypeAnnotation?.sortedTypeKey}')`;
+                }
+                code += argStr;
+                if (index !== this.arguments?.length - 1)
                     code += ', ';
             });
         }
+        const isStringConvert = ['ToString', 'FromString'].includes(this.calleeName);
+        let argTypeAnnotation;
+        if (isStringConvert) {
+            if (this.calleeName === 'ToString') {
+                const arg = this.arguments[0];
+                argTypeAnnotation = (arg as any).typeAnnotation || arg.__TypeAnnotation;
+            } else if (this.calleeName === 'FromString') {
+                argTypeAnnotation = this.typeArguments?.[0];
+            }
+        }
+        if (argTypeAnnotation) {
+            code += `, '${argTypeAnnotation?.sortedTypeKey}'`;
+        } else {
+            if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+                if (this.arguments?.length)
+                    code += ', ';
+                this.typeArguments?.forEach((arg, index) => {
+                    code += arg?.toJS(shiftState(state, code));
+                    if (index !== this.typeArguments?.length - 1)
+                        code += ', ';
+                });
+            }
+        }
+
         code += ')';
         const typeAnnotation = (this as any).typeAnnotation || this.__TypeAnnotation;
-        const needGenInitFromSchema = typeAnnotation && !['primitive', 'union'].includes(typeAnnotation.typeKind);
+        const needGenInitFromSchema = typeAnnotation && (
+            !['primitive', 'union'].includes(typeAnnotation.typeKind)
+            || typeAnnotation.typeName === 'DateTime'
+        );
         if (needGenInitFromSchema) {
             code = `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', ${code})`;
         }
@@ -550,7 +584,7 @@ export class CallFunction extends LogicItem {
     toEmbeddedTS(state?: TranslatorState): string {
         let code = '';
         const calleeKey = this.calleeKey;
-        if (calleeKey === 'nasl.util.Convert') {
+        if (['nasl.util.Convert', 'nasl.util.FromString'].includes(calleeKey)) {
             // nasl.util.Convert(variable1)<nasl.core.String>();
             // 单独处理
 

package/src/concepts/CallInterface__.ts

@@ -61,8 +61,6 @@ export class CallInterface extends LogicItem {
     @property('Argument')
     arguments: Array<Argument> = [];
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -76,13 +74,6 @@ export class CallInterface extends LogicItem {
         return super.from(source, parentNode, parentKey) as CallInterface;
     }
 
-    
-    
-
-    
-
-    
-
     /**
     * 插入实际参数
     * @internal
@@ -115,8 +106,6 @@ export class CallInterface extends LogicItem {
         return argument;
     }
 
-    
-
     /**
      * 插入实际参数
      * @param argumentOptions 实际参数参数
@@ -139,8 +128,6 @@ export class CallInterface extends LogicItem {
         return node;
     }
 
-    
-
     /**
      * 添加实际参数
      * @internal
@@ -160,8 +147,6 @@ export class CallInterface extends LogicItem {
         return this._insertArgumentAt(options as any, index);
     }
 
-    
-
     /**
      * 添加实际参数
      * @param argumentOptions 实际参数参数
@@ -185,9 +170,6 @@ export class CallInterface extends LogicItem {
         return node;
     }
 
-
-    
-
     /**
      * 删除实际参数
      * @param argument 已有的实际参数实例
@@ -195,7 +177,7 @@ export class CallInterface extends LogicItem {
     removeArgument(argument: Argument): void;
 
     removeArgument(options: Argument) {
-        let argument: Argument = options;
+        const argument: Argument = options;
         return argument.delete();
     }
 
@@ -368,7 +350,8 @@ export class CallInterface extends LogicItem {
             && this.parentNode.concept !== 'SelectMembers'
             && this.parentNode.concept !== 'BinaryExpression'
             && this.parentNode.concept !== 'MemberExpression'
-            && this.parentNode.concept !== 'StringInterpolation') {
+            && this.parentNode.concept !== 'StringInterpolation'
+            && !['NewMap', 'NewList'].includes(this.parentNode.concept)) {
             code += ';';
         }
         code += '\n';
@@ -553,8 +536,9 @@ export class CallInterface extends LogicItem {
             logicParam = node.params;
         }
         if (this.arguments?.length) {
-            this.arguments.forEach((arg, index) => {
-                const param = logicParam[index];
+            this.arguments.forEach((arg) => {
+                const idx = logicParam.findIndex((params) => arg.keyword === params.name);
+                const param = logicParam[idx];
 
                 arg.paramRequired = param?.required;
                 arg.paramTypeAnnotation = undefined;

package/src/concepts/CallLogic__.ts

@@ -5,6 +5,8 @@ import View from './View__';
 import { ElementToVueOptions } from './ViewElement__';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 import { findConceptKeyWordIndexFromNamespace } from '../utils';
+import * as JSON5 from 'json5';
+import Identifier from './Identifier__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -448,10 +450,14 @@ export class CallLogic extends LogicItem {
         }
         this.calleeName = logic.name;
         this.arguments = [];
-        logic.params.forEach((param) => {
-            this._addArgument({
+        logic.params.forEach((param: any) => {
+            const argument = this._addArgument({
                 keyword: param.name,
             });
+            if (param.defaultExpression) {
+                const exp: any = BaseNode.from({ ...param.defaultExpression.toJSON() });
+                argument.setExpression(exp);
+            }
         });
         if (logic.typeParams) {
             this.typeArguments = [];
@@ -471,7 +477,7 @@ export class CallLogic extends LogicItem {
             const relationOptions = { parentNode: this, parentKey: 'arguments' };
             const argument = Argument.from({
                 keyword: param.name,
-                expression: param.defaultExpression,
+                expression: param.isFunction ? new Identifier() : param.defaultExpression,
             }, this);
             Object.assign(argument, relationOptions);
             return argument;
@@ -692,7 +698,6 @@ var __parseType = __parseType || ((root, prop) => {
 
         // 全局逻辑
         if (!isViewLogic) {
-            const namespaceArr = calleeNamespace?.split('.');
             const logic = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: string, tempPoint: any) => {
                 // 处理 NASL 中未定义的假的节点
                 if (key === tempPoint.name) {
@@ -754,12 +759,31 @@ var __parseType = __parseType || ((root, prop) => {
                         code += `},\n`;
                         break;
                     }
+                    case 'update':
+                    case 'createOrUpdate':
+                    case 'batchUpdate': {
+                        code += `body: {\n`;
+                        const argsStr = logicArgs
+                            .filter((arg: any) => arg.expression)
+                            .map((arg: any) => {
+                                const name = arg.keyword === 'body' ? 
+                                    (this.calleeName === 'batchUpdate' ? 'entities' : 'entity') : 
+                                    arg.keyword;
+                                return `${name}: ${arg.expression.toJS(shiftState(state, code))}`;
+                            })
+                            .join(',\n');
+                        code += argsStr;
+                        code += `},\n`;
+                        logicArgs = [];
+                        breakBody = true;
+                        break;
+                    }
                     case 'updateBy': {
                         code += `body: {`;
                         const argsStr = logicArgs
                             .filter((arg: any) => arg.expression)
                             .map((arg: any) => {
-                                const name = arg.expression.returnExpression ? arg.expression.name : 'entity';
+                                const name = arg.keyword === 'body' ? 'entity' : arg.keyword;
                                 // filter回调函数
                                 if (arg.expression.returnExpression) {
                                     const argsStr = JSON.stringify(handleMember(arg.expression.returnExpression));
@@ -816,6 +840,9 @@ var __parseType = __parseType || ((root, prop) => {
                         .map((obj: any) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`)
                         .join(', ');
                     code += argsStr;
+                    if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+                        code += `,\n__typeArguments: ${JSON5.stringify(this.typeArguments)}`;
+                    }
                 }
                 code += '\n}';
             }
@@ -854,12 +881,27 @@ var __parseType = __parseType || ((root, prop) => {
                 code += '})';
             } else {
                 code += '(';
-                completeArguments
-                    .forEach((arg, index) => {
+                const needToString = ['showMessage', 'consoleLog'].includes(this.calleeName);
+                if (needToString) {
+                    code += `this.$utils['ToString'](`;
+                }
+                if (Array.isArray(completeArguments) && completeArguments.length) {
+                    completeArguments.forEach((arg, index) => {
                         code += arg?.toJS(shiftState(state, code));
                         if (index !== completeArguments?.length - 1)
                             code += ', ';
                     });
+                    if (needToString) {
+                        const arg = this.arguments[0];
+                        const argTypeAnnotation = (arg as any).typeAnnotation || arg.__TypeAnnotation;
+                        if (argTypeAnnotation) {
+                            code += `, '${argTypeAnnotation?.sortedTypeKey}'`;
+                        }
+                    }
+                }
+                if (needToString) {
+                    code += `)`;
+                }
                 code += ')';
             }
         }
@@ -914,7 +956,10 @@ var __parseType = __parseType || ((root, prop) => {
             };
         }
         const typeAnnotation = (this as any).typeAnnotation || this.__TypeAnnotation;
-        const needGenInitFromSchema = typeAnnotation && !['primitive', 'union'].includes(typeAnnotation.typeKind);
+        const needGenInitFromSchema = typeAnnotation && (
+            !['primitive', 'union'].includes(typeAnnotation.typeKind)
+            || typeAnnotation.typeName === 'DateTime'
+        );
         if (needGenInitFromSchema) {
             code = `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', ${code})`;
         }
@@ -934,13 +979,14 @@ var __parseType = __parseType || ((root, prop) => {
             code += `<`;
             code += `${typeAnnotation.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }))}>`;
         }
-
+        // 参数必填
+        const paramRequired = ['showMessage', 'consoleLog'].includes(this.calleeName);
         const tsCalleeNamespace = this.tsCalleeNamespace;
         if ((tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) || tsCalleeNamespace.startsWith('nasl.')) {
             code += '(';
             this.arguments.forEach((arg, index) => {
                 // 页面逻辑先都非必填
-                code += arg.toEmbeddedTS(shiftState(state, code), false);
+                code += arg.toEmbeddedTS(shiftState(state, code), paramRequired);
                 if (index !== this.arguments.length - 1)
                     code += ', ';
             });
@@ -953,7 +999,8 @@ var __parseType = __parseType || ((root, prop) => {
                 && this.parentNode.concept !== 'SelectMembers'
                 && this.parentNode.concept !== 'BinaryExpression'
                 && this.parentNode.concept !== 'StringInterpolation'
-                && this.parentNode.concept !== 'MemberExpression') {
+                && this.parentNode.concept !== 'MemberExpression'
+                && !['NewMap', 'NewList'].includes(this.parentNode.concept)) {
                 code += ';';
             }
         } else {
@@ -975,7 +1022,8 @@ var __parseType = __parseType || ((root, prop) => {
                     && this.parentNode.concept !== 'SelectMembers'
                     && this.parentNode.concept !== 'BinaryExpression'
                     && this.parentNode.concept !== 'StringInterpolation'
-                    && this.parentNode.concept !== 'MemberExpression') {
+                    && this.parentNode.concept !== 'MemberExpression'
+                    && !['NewMap', 'NewList'].includes(this.parentNode.concept)) {
                     code += ';';
                 }
             } else {
@@ -988,7 +1036,8 @@ var __parseType = __parseType || ((root, prop) => {
                     && this.parentNode.concept !== 'SelectMembers'
                     && this.parentNode.concept !== 'BinaryExpression'
                     && this.parentNode.concept !== 'StringInterpolation'
-                    && this.parentNode.concept !== 'MemberExpression') {
+                    && this.parentNode.concept !== 'MemberExpression'
+                    && !['NewMap', 'NewList'].includes(this.parentNode.concept)) {
                     code += ';';
                 }
             }

package/src/concepts/CallQueryComponent__.ts

@@ -1087,7 +1087,8 @@ export class CallQueryComponent extends LogicItem {
             && this.parentNode.concept !== 'SelectMembers'
             && this.parentNode.concept !== 'BinaryExpression'
             && this.parentNode.concept !== 'StringInterpolation'
-            && this.parentNode.concept !== 'MemberExpression') {
+            && this.parentNode.concept !== 'MemberExpression'
+            && ['NewMap', 'NewList'].includes(this.parentNode.concept)) {
             code += ';';
         }
         code += '\n';
@@ -1486,6 +1487,8 @@ export class CallQueryComponent extends LogicItem {
                                 expression,
                             });
                             completionProperty.icon = 'property';
+                            // 标记实体属性是否是符合类型
+                            Object.assign(completionProperty, { isComplexType: property.typeAnnotation.isComplexType() });
                             return completionProperty;
                         }),
                     }));

package/src/concepts/DataSource__.ts

@@ -1,4 +1,5 @@
 import { TranslatorState, withSourceMap, createCompilerState } from '../translator';
+import datasourceService from '../service/datasource';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -402,7 +403,7 @@ export class DataSource extends BaseNode {
             code += this.toEmbeddedTS(state);
         } catch (err) {
             code += '';
-            console.log(err);
+            console.error(err);
         }
         code += '}\n';
 
@@ -413,6 +414,60 @@ export class DataSource extends BaseNode {
         };
     }
 
+    // 测试数据源连通性
+    async pingDatabase(recordEnvConnectError: Function) {
+        const configProperty = this.app.configuration.getGroup('dataSource').getProperty(this.name);
+        configProperty && configProperty.values.forEach((prop) => {
+            // 未配置数据源时，不进行连接测试
+            if (!prop.value) {
+                return;
+            }
+            const dataSource = configProperty.name;
+            const env = prop.env;
+            return datasourceService.pingDatabase({
+                body: {
+                    category: 'sql',
+                    appId: this.app.id,
+                    dataSource,
+                    env,
+                },
+            }).then(() => {
+                Object.assign(this, { [`__${env}ConnectError`]: false });
+            }).catch(() => {
+                Object.assign(this, { [`__${env}ConnectError`]: true });
+            }).then(() => {
+                recordEnvConnectError(env);
+            });
+        });
+    }
+    recordEnvConnectError(records: any[], env: string) {
+        const target = records?.find((item: any) => item.id === this.id);
+        // 诊断还未生成，在诊断时生成问题
+        if (!target) {
+            return;
+        }
+        // 诊断已生成，手动插入问题
+        const errorKey = `__${env}ConnectError`;
+        const errorText = `DataSource ${env} env connect error`;
+        target.semanticDiagnostics = target.semanticDiagnostics.filter((item: any) => item.code !== errorText);
+        if ((this as any)[errorKey]) {
+            const envText = env === 'online' ? '生产' : '开发';
+            target.semanticDiagnostics.push({
+                text: errorText,
+                node: this,
+                severity: 'error',
+                message: `数据源配置：数据源 ${this.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
+                originalDiagnostic: {
+                    fileName: '',
+                    start: null,
+                    end: null,
+                    category: 'error',
+                    text: `DataSource connection error`,
+                },
+            });
+        }
+    }
+
     // 获取datasource对应的数据源配置
     get dataSourceConfig() {
         let devProperty = null;

package/src/concepts/ForEachStatement__.ts

@@ -531,6 +531,8 @@ export class ForEachStatement extends LogicItem {
         code += this.each ? this.each.toEmbeddedTS(shiftState(state, code, {
             tabSize: 0,
         })) : '__IDENTIFIER__';
+        if (['NewList', 'NewMap'].includes(this.each.concept))
+            code += '\n';
         code += '.__slice(';
         code += this.start ? this.start.toEmbeddedTS(shiftState(state, code)) : '__IDENTIFIER__';
         code += ', ';