@lcap/nasl 1.0.2 → 2.12.0

package/src/concepts/View__.ts

@@ -234,7 +234,7 @@ export class View extends BaseNode {
         });
     }
 
-    
+
 
     /**
     * 插入页面元素
@@ -370,12 +370,8 @@ export class View extends BaseNode {
     }
 
 
-    getParamExistingNames(excludedList: Array<Param> = []) {
-        const excludedSet = new Set(excludedList);
-        return (this.params || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
     getParamUniqueName(name = 'param1') {
-        return utils.unique(name, this.getParamExistingNames(), undefined, false);
+        return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
 
     /**
@@ -512,12 +508,8 @@ export class View extends BaseNode {
     }
 
 
-    getVariableExistingNames(excludedList: Array<Variable> = []) {
-        const excludedSet = new Set(excludedList);
-        return (this.variables || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
     getVariableUniqueName(name = 'variable1') {
-        return utils.unique(name, this.getVariableExistingNames(), undefined, false);
+        return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
 
     /**
@@ -1078,7 +1070,7 @@ export class View extends BaseNode {
     }
 
 
-    
+
 
     /**
     * 删除页面元素
@@ -1599,6 +1591,7 @@ export class View extends BaseNode {
             title: this.title,
             crumb: this.crumb,
             first: this.children.find((child) => child.isIndex)?.name,
+            auth: this.auth ? 'loginAuth' : undefined,
         };
         return `${componentOptions}
             ${translator(definition)}
@@ -1659,12 +1652,14 @@ export class View extends BaseNode {
     }
 
     getNamespace(): string {
-        if (this.parentNode) {
-            let parentNodeNamespace = (this.parentNode as Namespace).getNamespace();
-            if (this.parentNode.concept === 'View') {
-                parentNodeNamespace = `${(this.parentNode as View).getNamespace()}.${this.parentNode.name}`;
+        if (this.parentNode && (this.parentNode as Namespace).getNamespace) {
+            const parentNamespace = (this.parentNode as Namespace).getNamespace();
+            const parentName = this.parentNode.name;
+            const arr = [parentNamespace];
+            if (this.parentNode.concept !== 'App' && parentName) {
+                arr.push(parentName);
             }
-            return `${parentNodeNamespace}.views`;
+            return `${arr.join('.')}.views`;
         } else
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
@@ -1700,27 +1695,27 @@ export class View extends BaseNode {
         let code = `export namespace ${this.tsName} {\n`;
         // 角色
         if (Array.isArray(this.bindRoles) && this.bindRoles.length) {
-            code += indent(state.tabSize + 1);
+            code += indent((state?.tabSize || 0) + 1);
             code += 'export let __bindRoles = [\n';
             this.bindRoles.forEach((role) => {
-                code += indent(state.tabSize + 1);
+                code += indent((state?.tabSize || 0) + 1);
                 code += `${this.app.getNamespace()}.roles.${chineseTsName(role)}.${chineseTsName(role)},`;
                 code += '\n';
             });
             code += '\n';
-            code += indent(state.tabSize + 1);
+            code += indent((state?.tabSize || 0) + 1);
             code += '];\n';
         }
         if (Array.isArray(this.params)) {
             this.params.forEach((param) => {
-                code += indent(state.tabSize + 1) + 'let ';
+                code += indent((state?.tabSize || 0) + 1) + 'let ';
                 code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
                 code += ';\n';
             });
         }
         if (Array.isArray(this.variables)) {
             this.variables.forEach((variable) => {
-                code += indent(state.tabSize + 1) + 'let ';
+                code += indent((state?.tabSize || 0) + 1) + 'let ';
                 code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
                 code += ';\n';
             });
@@ -1731,53 +1726,53 @@ export class View extends BaseNode {
         // 生成所有的name和类型定义
         this.elements.forEach((element) => {
             code += element.toEmbeddedTSDefinition(shiftState(state, code, {
-                tabSize: state.tabSize + 1,
+                tabSize: (state?.tabSize || 0) + 1,
             }));
         });
-        code += indent(state.tabSize + 1) + '}\n';
+        code += indent((state?.tabSize || 0) + 1) + '}\n';
         code += `let __elements: __elements;\n`;
         // 逻辑
         if (Array.isArray(this.logics) && this.logics.length) {
-            code += indent(state.tabSize + 1);
+            code += indent((state?.tabSize || 0) + 1);
             this.logics.forEach((logic) => {
                 code += logic.toEmbeddedTS(shiftState(state, code, {
-                    tabSize: state.tabSize + 2,
+                    tabSize: (state?.tabSize || 0) + 2,
                 }), 'noExport');
                 code += '\n';
             });
-            code += indent(state.tabSize + 1);
+            code += indent((state?.tabSize || 0) + 1);
         }
         // 事件
         if (Array.isArray(this.bindEvents)) {
             this.bindEvents.forEach((event) => {
                 code += event.toEmbeddedTS(shiftState(state, code, {
-                    tabSize: state.tabSize,
+                    tabSize: (state?.tabSize || 0),
                 }), true);
                 code += '\n';
             });
         }
 
         // render函数
-        code += '\n' + indent(state.tabSize + 1);
+        code += '\n' + indent((state?.tabSize || 0) + 1);
         code += `export function __render(`;
         code += `){\n`;
-        code += indent(state.tabSize);
+        code += indent((state?.tabSize || 0));
 
         // elements 元素
         if (Array.isArray(this.elements)) {
             // 生成嵌套式的内容
             this.elements.forEach((element) => {
                 code += element.toEmbeddedTS(shiftState(state, code, {
-                    tabSize: state.tabSize + 3,
+                    tabSize: (state?.tabSize || 0) + 3,
                 }));
                 code += '\n';
             });
         }
 
-        code += '\n' + indent(state.tabSize + 1) + '}\n';
+        code += '\n' + indent((state?.tabSize || 0) + 1) + '}\n';
 
         if (Array.isArray(this.params)) {
-            code += indent(state.tabSize + 1) + `export function $destination(options: {`;
+            code += indent((state?.tabSize || 0) + 1) + `export function $destination(options: {`;
             this.params.forEach((param, index) => {
                 code += param.name + '?: ';
                 code += param.typeAnnotation.toEmbeddedTS(shiftState(state, code));
@@ -1786,7 +1781,7 @@ export class View extends BaseNode {
             });
             code += '}){}\n';
         }
-        code += indent(state.tabSize) + '}\n';
+        code += indent((state?.tabSize || 0)) + '}\n';
         return code;
     }
 

package/src/concepts/WhileStatement__.ts

@@ -257,12 +257,12 @@ export class WhileStatement extends LogicItem {
             this.body.forEach((logicItem) => {
                 code
                     += logicItem.toJS(shiftState(state, code, {
-                        tabSize: state.tabSize + 1,
+                        tabSize: (state?.tabSize || 0) + 1,
                     })) + '\n';
             });
         }
 
-        code += indent(state.tabSize) + '}\n';
+        code += indent((state?.tabSize || 0)) + '}\n';
         return code;
     }
 
@@ -279,12 +279,12 @@ export class WhileStatement extends LogicItem {
             this.body.forEach((logicItem) => {
                 code
                     += logicItem.toEmbeddedTS(shiftState(state, code, {
-                        tabSize: state.tabSize + 1,
+                        tabSize: (state?.tabSize || 0) + 1,
                     })) + '\n';
             });
         }
 
-        code += indent(state.tabSize) + '}\n';
+        code += indent((state?.tabSize || 0)) + '}\n';
         return code;
     }
     //================================================================================

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

@@ -22,5 +22,25 @@ export default new Namespace({
             params: [],
             returns: [],
         }),
+        new Logic({
+            name: 'encryptByAES',
+            params: [
+                new Param({
+                    name: 'string',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [],
+        }),
+        new Logic({
+            name: 'decryptByAES',
+            params: [
+                new Param({
+                    name: 'string',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [],
+        }),
     ],
 });

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

@@ -13,8 +13,414 @@ import Attribute from '../../Attribute__';
 import { primitiveTypeList } from '../types/coreTypeList';
 import { reference2TypeAnnotationList } from './reference2TypeAnnotationList';
 
+const logics = [
+    new Logic({
+        name: 'getProcessDefinitionList',
+        params: [],
+        returns: [
+            new Return({
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [TypeAnnotation.createTypeParam('T')],
+                }),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'getProcessDefinition',
+        params: [
+            new Param({
+                name: 'name',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createTypeParam('T'),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'getProcessInstance',
+        params: [
+            new Param({
+                name: 'processId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createTypeParam('T'),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'getProcessInstanceList',
+        params: [
+            new Param({
+                name: 'processId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'startBy',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'finished',
+                typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+            }),
+            new Param({
+                name: 'processDefName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'startTimeBefore',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new Param({
+                name: 'startTimeAfter',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new Param({
+                name: 'endTimeBefore',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new Param({
+                name: 'endTimeAfter',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new Param({
+                name: 'page',
+                typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+            }),
+            new Param({
+                name: 'size',
+                typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+            }),
+            new Param({
+                name: 'sort',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'order',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
+                    typeArguments: [TypeAnnotation.createTypeParam('T')],
+                }),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'getTaskDefinitionList',
+        params: [
+            new Param({
+                name: 'processDefName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [TypeAnnotation.createTypeParam('T')],
+                }),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'getTaskDefinition',
+        params: [
+            new Param({
+                name: 'name',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'processDefName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createTypeParam('T'),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'getTaskInstance',
+        params: [
+            new Param({
+                name: 'taskId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createTypeParam('T'),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'getTaskInstanceList',
+        params: [
+            new Param({
+                name: 'taskId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'user',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'finished',
+                typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+            }),
+            new Param({
+                name: 'processId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'processIdIn',
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [TypeAnnotation.createTypeParam('String')],
+                }),
+            }),
+            new Param({
+                name: 'processDefName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'taskDefName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'createTimeBefore',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new Param({
+                name: 'createTimeAfter',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new Param({
+                name: 'completeTimeBefore',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new Param({
+                name: 'completeTimeAfter',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new Param({
+                name: 'page',
+                typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+            }),
+            new Param({
+                name: 'size',
+                typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+            }),
+            new Param({
+                name: 'sort',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'order',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
+                    typeArguments: [TypeAnnotation.createTypeParam('T')],
+                }),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'claimTaskInstance',
+        params: [
+            new Param({
+                name: 'taskId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new Param({
+                name: 'user',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'unclaimTaskInstance',
+        params: [
+            new Param({
+                name: 'taskId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+            }),
+        ],
+    }),
+    new Logic({
+        name: 'getTaskDestinationUrl',
+        params: [
+            new Param({
+                name: 'taskId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+        returns: [
+            new Return({
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+    }),
+];
+
+export const processStructures = [
+    new Structure({
+        name: 'LCAPProcessDefinition',
+        properties: [
+            new StructureProperty({
+                name: 'name',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'title',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'description',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+    }),
+    new Structure({
+        name: 'LCAPProcessInstance',
+        properties: [
+            new StructureProperty({
+                name: 'processId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'title',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'description',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'startBy',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'startTime',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new StructureProperty({
+                name: 'endTime',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new StructureProperty({
+                name: 'finished',
+                typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+            }),
+            new StructureProperty({
+                name: 'processDefName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+    }),
+    new Structure({
+        name: 'LCAPTaskDefinition',
+        properties: [
+            new StructureProperty({
+                name: 'name',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'title',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'description',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'processDefName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+    }),
+    new Structure({
+        name: 'LCAPTaskInstance',
+        properties: [
+            new StructureProperty({
+                name: 'taskId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'title',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'description',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'finished',
+                typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+            }),
+            new StructureProperty({
+                name: 'completeBy',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'createTime',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new StructureProperty({
+                name: 'completeTime',
+                typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+            }),
+            new StructureProperty({
+                name: 'taskDefName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'processId',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+            new StructureProperty({
+                name: 'processDefName',
+                typeAnnotation: TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+    }),
+];
+
+export const processTypeList: Array<TypeAnnotation> = reference2TypeAnnotationList(processStructures, 'nasl.process');
+
 export default new Namespace({
     name: 'process',
+    logics,
+    structures: processStructures,
     processComponents: [
         new ProcessComponent({
             name: 'UserTask',

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

@@ -599,16 +599,6 @@ export const uiStructures = [
     new Structure({
         name: 'TreeChangeEvent',
         properties: [
-            new StructureProperty({
-                name: 'param1',
-                description: '参数1',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'param2',
-                description: '参数2',
-                typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-            }),
             new StructureProperty({
                 name: 'value',
                 description: '改变后的值',
@@ -653,7 +643,7 @@ export const uiStructures = [
             }),
             new StructureProperty({
                 name: 'oldValues',
-                description: '改变后每项值的数组',
+                description: '旧的每项值的数组',
                 typeAnnotation: TypeAnnotation.createGeneric('List', {
                     typeArguments: [TypeAnnotation.createTypeParam('T')],
                 }),