@lcap/nasl 2.14.0 → 2.15.1

package/src/concepts/SqlQueryComponent__.ts

@@ -1,4 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
+import StructureProperty from './StructureProperty__';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -151,6 +154,142 @@ export class SqlQueryComponent extends LogicItem {
         });
     }
 
+    getVariableTs(state?: TranslatorState) {
+        const str = this.code;
+        const variables = [];
+        let code = '';
+        let temp: any;
+        const re = /(\#|\$)\{(.+?)\}/g;
+        while (temp = re.exec(str)) {
+            variables.push(temp[2]);
+        }
+        variables.forEach((variable: String) => {
+            const content = variable.replaceAll(' ', '');
+            code += indent((state?.tabSize || 0) + 2);
+            code += content + ';\n';
+        });
+        return code;
+    }
+
+    getTypeBanError() {
+        let sqlTypeBan = false;
+        if (this.typeAnnotation) {
+            const getSqlTypeBan = (typeAnnotation: TypeAnnotation) => {
+                const ref = this.getSelectRef(typeAnnotation);
+                if (ref?.length) {
+                    ref.forEach((item: StructureProperty) => {
+                        // 如果有类型但是类型不是基本类型，就需要打开开关，注入变量
+                        if (item?.typeAnnotation && item.typeAnnotation.typeNamespace !== 'nasl.core' && !(item.typeAnnotation.typeNamespace.endsWith('.enums'))) {
+                            sqlTypeBan = true;
+                        }
+                    });
+                }
+            };
+            if (this.typeAnnotation.typeArguments?.length) {
+                // list 就去校验一下内部的类型
+                if (this.typeAnnotation.typeName === 'List') {
+                    this.typeAnnotation.typeArguments.forEach((item) => {
+                        getSqlTypeBan(item);
+                    });
+                } else {
+                    // 别的都不放开
+                    sqlTypeBan = true;
+                }
+            } else {
+                getSqlTypeBan(this.typeAnnotation);
+            }
+        }
+        return sqlTypeBan;
+    }
+    getQueryComponentTsCode(state?: TranslatorState):string {
+        let tsCode = '';
+        // let sqlParser: null | any = null;
+        // let sqlParserErr: null | any = null;
+
+        if (!this.code)
+            return tsCode;
+        /**
+             * 处理变量，因为解析code，因为sql中不支持
+             * #{变量}这种写法
+             * 而且不支持a.b.c这种写法保留前两个，翻译的时候补上去
+             * 如果是多个.链接的变量就转换成nasl变量，让他可以翻译，等后面在把值换回来
+             */
+
+        /**
+        try {
+            const newCode = this.code.replace(/\#|\$\{(.+?)\}/g, (value, content) => {
+                console.log(content)
+                const len = content.split('.').length;
+                console.log(len, content, content.split('.'), content, content.split('.').length)
+                if (len > 2) {
+                    return '__NASL__SQL__' + content.replaceAll('.', '_');
+                }
+                return content;
+            });
+            console.log(newCode);
+            // 生成对应的sqlts 和 产生sourceMap对应
+            sqlParser = SQLParser(newCode || '', 0, this.dataSource);
+        } catch (err) {
+            sqlParserErr = err;
+        }
+        console.log(sqlParser, sqlParserErr);
+        if (sqlParserErr) {
+            tsCode += '__SQL_GRAMMAR_ERROR__';
+        } else if (sqlParser) {
+            // 解析内部变量，先看是不是未知变量
+            // 使用 tableList 和 columnList
+            tsCode += this.getContentVariable(sqlParser, state);
+        }
+         */
+
+        try {
+            tsCode += this.getVariableTs(state);
+        } catch (err) {
+            console.log(err);
+        }
+        return tsCode;
+    }
+
+    getSelectRef(newTypeAnnotation: TypeAnnotation) {
+        try {
+            const { typeName, typeKind, typeNamespace } = newTypeAnnotation || this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process') {
+                    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' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
+                // }
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = [...node.properties] || [];
+                for (let i = 0; i < properties.length; i++) {
+                    const item = properties[i];
+                    if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                        const newItem = StructureProperty.from(item.toJSON());
+                        newItem.typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                        newItem.parentNode = this;
+                        properties[i] = newItem;
+                    }
+                }
+                completionChildren = properties;
+            } else {
+                completionChildren = undefined;
+            }
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
+        }
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code;
@@ -164,11 +303,13 @@ export class SqlQueryComponent extends LogicItem {
         // app.dataSources.defaultDS;
         if (this.dataSource) {
             code += indent((state?.tabSize || 0) + 1);
-            code += `const dataSource = app.dataSources.${this.dataSource};`;
+            code += `const dataSource = app.dataSources.${this.dataSource};\n`;
         }
+        // 生成内部的ts内容
+        code += this.getQueryComponentTsCode(state);
         code += '\n';
         code += indent((state?.tabSize || 0) + 1) + 'return;\n';
-        code += indent((state?.tabSize || 0)) + '})();\n';
+        code += indent((state?.tabSize || 0)) + '})()';
         return code;
     }
 

package/src/concepts/Variable__.ts

@@ -238,7 +238,6 @@ export class Variable extends BaseNode {
             code += ': ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
-        code += ';';
         return code;
     }
 

package/src/concepts/ViewElement__.ts

@@ -301,8 +301,6 @@ export class ViewElement extends BaseNode {
         super.subConstructor(source);
     }
 
-
-
     /**
      * 从父级删除该节点
      * @internal
@@ -351,7 +349,7 @@ export class ViewElement extends BaseNode {
         });
     }
 
-        getBindAttributeExistingNames(excludedList: Array<BindAttribute> = []) {
+    getBindAttributeExistingNames(excludedList: Array<BindAttribute> = []) {
         const excludedSet = new Set(excludedList);
         return (this.bindAttrs || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -492,7 +490,6 @@ export class ViewElement extends BaseNode {
         return node;
     }
 
-
     getBindEventExistingNames(excludedList: Array<BindEvent> = []) {
         const excludedSet = new Set(excludedList);
         return (this.bindEvents || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -634,7 +631,6 @@ export class ViewElement extends BaseNode {
         return node;
     }
 
-
     getBindDirectiveExistingNames(excludedList: Array<BindDirective> = []) {
         const excludedSet = new Set(excludedList);
         return (this.bindDirectives || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -776,11 +772,6 @@ export class ViewElement extends BaseNode {
         return node;
     }
 
-
-
-
-
-
     /**
     * 插入页面元素
     * @internal
@@ -914,9 +905,6 @@ export class ViewElement extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
     * 删除元素绑定属性
     * @param name 元素绑定属性名称
@@ -965,8 +953,6 @@ export class ViewElement extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除元素绑定事件
     * @param name 元素绑定事件名称
@@ -1015,8 +1001,6 @@ export class ViewElement extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除元素指令
     * @param name 元素指令名称
@@ -1065,8 +1049,6 @@ export class ViewElement extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除页面元素
     * @param name 页面元素名称
@@ -1715,7 +1697,9 @@ export class ViewElement extends BaseNode {
                 const emptySlot = api && api.slots && api.slots.find((slot) => slot.name === 'default' && slot['empty-background']);
                 const hasSupport = api && api.slots && api.slots.some((slot) => slot.support);
                 if (emptySlot || hasSupport) {
-                    let childEmpty = !el.children.length;
+                    // 有些限制的组件如侧边栏分组有title插槽但要限制子元素放入
+                    const validChildren = el.children.filter((elem) => !(elem.tag === 'template' && elem.slotTarget !== 'default'));
+                    let childEmpty = !validChildren.length;
                     const defaultSlot = el.children.find((elem) => elem.tag === 'template' && elem.slotTarget === 'default');
                     if (defaultSlot) {
                         childEmpty = !defaultSlot.children.length;
@@ -1803,6 +1787,14 @@ export class ViewElement extends BaseNode {
         });
         newOptions.getExtraParts(this).forEach((part) => parts.push(part));
 
+        if (['u-modal', 'u-drawer'].includes(this.tag)) {
+            this.children.forEach((citem) => {
+                if (citem.tag === 'template' && !citem.children.length) {
+                    parts.push(`:is-${citem.slotTarget}-slot-empty=true`);
+                }
+            });
+        }
+
         let partsLength = 0;
         let partsString = '';
         parts.forEach((part) => {

package/src/concepts/View__.ts

@@ -1431,8 +1431,11 @@ export class View extends BaseNode {
         });
     }
 
+    // 获取当前页面的所有组件的名字
     getViewElementExistingNames(excludedList: Array<ViewElement> = []) {
-        const excludedSet = new Set(excludedList);
+        if (!this.existingViewElement.size) {
+            this.collectExistingViewElementName();
+        }
         return Array.from(this.existingViewElement);
     }
 

package/src/concepts/basics/stdlib/index.ts

@@ -13,11 +13,12 @@ import naslBrowser from './nasl.browser';
 import naslAuth from './nasl.auth';
 import naslConfiguration from './nasl.configuration';
 import naslLogging from './nasl.logging';
+import naslIo from './nasl.io';
 
 export { reference2TypeAnnotationList } from './reference2TypeAnnotationList';
 export const stdlibNamespace = new Namespace({
     name: 'nasl',
     path: 'nasl',
-    children: [naslCore, naslCollection, naslInterface, naslUi, naslUtil, naslProcess, naslValidation, naslBrowser, naslAuth, naslConfiguration, naslLogging],
+    children: [naslCore, naslCollection, naslInterface, naslUi, naslUtil, naslProcess, naslValidation, naslBrowser, naslAuth, naslConfiguration, naslLogging, naslIo],
 });
 export default stdlibNamespace;

package/src/concepts/basics/stdlib/nasl.auth.ts

@@ -42,5 +42,30 @@ export default new Namespace({
             ],
             returns: [],
         }),
+        new Logic({
+            name: 'getProcessStartBy',
+            params: [
+                new Param({
+                    name: 'userNameFilter',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'limit',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+                new Param({
+                    name: 'offset',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    name: 'result',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+        }),
     ],
 });

package/src/concepts/basics/stdlib/nasl.io.ts

@@ -0,0 +1,48 @@
+import Namespace from '../../Namespace__';
+import Param from '../../Param__';
+import Return from '../../Return__';
+import Logic from '../../Logic__';
+import TypeAnnotation from '../../TypeAnnotation__';
+import StringLiteral from '../../StringLiteral__';
+
+export default new Namespace({
+    name: 'io',
+    logics: [
+        new Logic({
+            name: 'downloadFile',
+            params: [
+                new Param({
+                    name: 'url',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    required: true,
+                }),
+                new Param({
+                    name: 'fileName',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultExpression: new StringLiteral({ value: '' }),
+                    required: false,
+                }),
+            ],
+            body: [],
+        }),
+        new Logic({
+            name: 'downloadFiles',
+            params: [
+                new Param({
+                    name: 'urlList',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                    required: true,
+                }),
+                new Param({
+                    name: 'fileName',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultExpression: new StringLiteral({ value: '' }),
+                    required: false,
+                }),
+            ],
+            body: [],
+        }),
+    ],
+});

package/src/concepts/basics/stdlib/nasl.process.ts

@@ -16,6 +16,7 @@ import { reference2TypeAnnotationList } from './reference2TypeAnnotationList';
 const logics = [
     new Logic({
         name: 'getProcessDefinitionList',
+        description: '获取流程定义列表',
         params: [],
         returns: [
             new Return({
@@ -27,6 +28,7 @@ const logics = [
     }),
     new Logic({
         name: 'getProcessDefinition',
+        description: '获取流程定义的详情，如流程标题',
         params: [
             new Param({
                 name: 'name',
@@ -42,6 +44,7 @@ const logics = [
     }),
     new Logic({
         name: 'getProcessInstance',
+        description: '获取流程详情，如发起人、时间',
         params: [
             new Param({
                 name: 'processId',
@@ -57,6 +60,7 @@ const logics = [
     }),
     new Logic({
         name: 'getProcessInstanceList',
+        description: '获取流程列表',
         params: [
             new Param({
                 name: 'processId',
@@ -118,6 +122,7 @@ const logics = [
     }),
     new Logic({
         name: 'getTaskDefinitionList',
+        description: '获取任务定义列表',
         params: [
             new Param({
                 name: 'processDefName',
@@ -135,6 +140,7 @@ const logics = [
     }),
     new Logic({
         name: 'getTaskDefinition',
+        description: '获取任务定义的详情，如任务标题',
         params: [
             new Param({
                 name: 'name',
@@ -154,6 +160,7 @@ const logics = [
     }),
     new Logic({
         name: 'getTaskInstance',
+        description: '获取任务详情，如状态、完成人',
         params: [
             new Param({
                 name: 'taskId',
@@ -169,6 +176,7 @@ const logics = [
     }),
     new Logic({
         name: 'getTaskInstanceList',
+        description: '获取流程任务列表',
         params: [
             new Param({
                 name: 'taskId',
@@ -243,6 +251,7 @@ const logics = [
     }),
     new Logic({
         name: 'claimTaskInstance',
+        description: '认领流程任务',
         params: [
             new Param({
                 name: 'taskId',
@@ -262,6 +271,7 @@ const logics = [
     }),
     new Logic({
         name: 'unclaimTaskInstance',
+        description: '取消认领流程任务',
         params: [
             new Param({
                 name: 'taskId',
@@ -277,6 +287,7 @@ const logics = [
     }),
     new Logic({
         name: 'getTaskDestinationUrl',
+        description: '获取任务审批页跳转链接',
         params: [
             new Param({
                 name: 'taskId',
@@ -290,6 +301,76 @@ const logics = [
             }),
         ],
     }),
+    new Logic({
+        name: 'transferTaskInstance',
+        description: '将任务审批人转交给其他人',
+        params: [
+            new Param({
+                name: 'taskId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'userName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createTypeParam('T'),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'withdrawProcessInstance',
+        description: '撤回流程，仅发起人可撤回',
+        params: [
+            new Param({
+                name: 'processId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createTypeParam('T'),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'endProcessInstance',
+        description: '结束流程，仅发起人可结束',
+        params: [
+            new Param({
+                name: 'processId',
+                typeAnnotation: TypeAnnotation.createTypeParam('T'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'getRejectableTaskDefinitionList',
+        description: '获取可驳回的任务定义列表',
+        params: [
+            new Param({
+                name: 'taskId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [TypeAnnotation.createTypeParam('T')],
+                }),
+            }),
+        ],
+    }),
 ];
 
 export const processStructures = [
@@ -413,6 +494,23 @@ export const processStructures = [
             }),
         ],
     }),
+    new Structure({
+        name: 'LCAPOperateProcessResult',
+        properties: [
+            new StructureProperty({
+                name: 'success',
+                typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+            }),
+            new StructureProperty({
+                name: 'failMessage',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'code',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+    }),
 ];
 
 export const processTypeList: Array<TypeAnnotation> = reference2TypeAnnotationList(processStructures, 'nasl.process');

package/src/concepts/basics/stdlib/nasl.ui.ts

@@ -821,6 +821,60 @@ export const uiStructures = [
             }),
         ],
     }),
+    new Structure({
+        name: 'SelectData',
+        typeParams: [
+            new TypeParam({
+                name: 'T',
+            }),
+        ],
+        properties: [
+            new StructureProperty({
+                name: 'parent',
+                typeAnnotation: TypeAnnotation.createTypeParam('T'),
+            }),
+            new StructureProperty({
+                name: 'item',
+                typeAnnotation: TypeAnnotation.createTypeParam('T'),
+            }),
+            new StructureProperty({
+                name: 'path',
+                typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+            }),
+        ],
+    }),
+    new Structure({
+        name: 'DragAndDropEvent',
+        typeParams: [
+            new TypeParam({
+                name: 'T',
+            }),
+        ],
+        properties: [
+            new StructureProperty({
+                name: 'source',
+                typeAnnotation: TypeAnnotation.createReference('SelectData', {
+                    typeNamespace: 'nasl.ui',
+                }),
+            }),
+            new StructureProperty({
+                name: 'target',
+                typeAnnotation: TypeAnnotation.createReference('SelectData', {
+                    typeNamespace: 'nasl.ui',
+                }),
+            }),
+            new StructureProperty({
+                name: 'position',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'list',
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [TypeAnnotation.createTypeParam('T')],
+                }),
+            }),
+        ],
+    }),
 ];
 
 export const uiTypeList: Array<TypeAnnotation> = reference2TypeAnnotationList(uiStructures, 'nasl.ui');

package/src/concepts/basics/stdlib/nasl.util.ts

@@ -104,7 +104,7 @@ export default new Namespace({
 
                 new Param({
                     name: 'ignoreCase',
-                    description: '计算类型。如选择天数，则计算前两个参数的天数差值。',
+                    description: '是否忽略大小写',
                     defaultExpression: new BooleanLiteral({ value: 'true' }),
                     options: [
                         { text: 'true', value: 'true' },
@@ -132,7 +132,7 @@ export default new Namespace({
                 }),
                 new Param({
                     name: 'ignoreCase',
-                    description: '计算类型。如选择天数，则计算前两个参数的天数差值。',
+                    description: '是否忽略大小写',
                     defaultExpression: new BooleanLiteral({ value: 'false' }),
                     options: [
                         { text: 'true', value: 'true' },

package/src/concepts/basics/stdlib/nasl.validation.ts

@@ -348,6 +348,10 @@ export default new Namespace({
         ...[
             'boolean',
             'array',
+            'function',
+            'object',
+            'plainObject',
+            '^az09-_$',
             'alpha',
             'alphaNum',
             'alphaDash',

package/src/enums/KEYWORDS.ts

@@ -23,6 +23,7 @@ export const KEYWORDS = [
     'catch',
     'char',
     'class',
+    'code',
     'collection',
     'com',
     'component',