@lcap/nasl 2.13.0 → 2.13.1

package/src/concepts/TypeAnnotation__.ts

@@ -42,7 +42,6 @@ import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 
-
 /**
  * 类型标注
  */
@@ -90,8 +89,6 @@ export class TypeAnnotation extends BaseNode {
     @property()
     ruleMap: Object = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -128,10 +125,6 @@ export class TypeAnnotation extends BaseNode {
         });
     }
 
-    
-
-    
-
     /**
     * 插入类型标注
     * @internal
@@ -164,8 +157,6 @@ export class TypeAnnotation extends BaseNode {
         return typeAnnotation;
     }
 
-    
-
     /**
      * 插入类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -188,8 +179,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加类型标注
      * @internal
@@ -209,8 +198,6 @@ export class TypeAnnotation extends BaseNode {
         return this._insertTypeAnnotationAt(options as any, index);
     }
 
-    
-
     /**
      * 添加类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -234,9 +221,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
      * 删除类型标注
      * @param typeAnnotation 已有的类型标注实例
@@ -244,7 +228,7 @@ export class TypeAnnotation extends BaseNode {
     removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
 
     removeTypeAnnotation(options: TypeAnnotation) {
-        let typeAnnotation: TypeAnnotation = options;
+        const typeAnnotation: TypeAnnotation = options;
         return typeAnnotation.delete();
     }
 
@@ -307,7 +291,7 @@ export class TypeAnnotation extends BaseNode {
             return typeTitle;
         } else if (this.typeKind === 'generic') {
             if (this.typeArguments && this.typeArguments.length)
-                return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.headTitle || 'T')}>`;
+                return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.headTitle || arg.name || 'T').join(', ')}>`;
             else
                 return this.typeName;
         } else {
@@ -324,18 +308,7 @@ export class TypeAnnotation extends BaseNode {
         } else if (this.typeKind === 'reference') {
             return this.typeName;
         } else if (this.typeKind === 'generic') {
-            let str = `${this.typeName}`;
-            const loop = (typeArguments: Array<TypeAnnotation>) => {
-                str += '<' + (typeArguments[0].typeTitle || 'T');
-                if (typeArguments[0].typeKind === 'generic') {
-                    if (this.typeArguments && this.typeArguments.length) {
-                        loop(typeArguments[0].typeArguments);
-                    }
-                }
-                str += '>';
-            };
-            loop(this.typeArguments);
-            return str;
+            return `${this.typeName}<${this.typeArguments.map((arg) => arg.typeTitle || arg.name || 'T').join(', ')}>`;
         } else {
             return this.typeName;
         }

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

@@ -68,6 +68,18 @@ export const collectionStructures = [
             }),
         ],
     }),
+    new Structure({
+        name: 'Map',
+        typeParams: [
+            new TypeParam({
+                name: 'K',
+            }),
+            new TypeParam({
+                name: 'V',
+            }),
+        ],
+        properties: [],
+    }),
 ];
 export const collectionTypeList: Array<TypeAnnotation> = reference2TypeAnnotationList(collectionStructures, 'nasl.collection');
 

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

@@ -221,7 +221,7 @@ export default new Namespace({
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
-                    name: 'seperator',
+                    name: 'separator',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -244,7 +244,7 @@ export default new Namespace({
                     }),
                 }),
                 new Param({
-                    name: 'seperator',
+                    name: 'separator',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -275,10 +275,10 @@ export default new Namespace({
         }),
         new Function({
             name: 'Length',
-            description: '返回字符串长度',
+            description: '获得String、Map、List的长度',
             params: [
                 new Param({
-                    name: 'str1',
+                    name: 'param',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -427,7 +427,7 @@ export default new Namespace({
                     }),
                 }),
                 new Param({
-                    name: 'addlist',
+                    name: 'addList',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
@@ -496,6 +496,188 @@ export default new Namespace({
                 }),
             ],
         }),
+        new Function({
+            name: 'MapGet',
+            description: '查询出Map中key为指定值的value值列表',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('V'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapPut',
+            description: '为Map中添加键值对',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+                new Param({
+                    name: 'value',
+                    typeAnnotation: TypeAnnotation.createTypeParam('V'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapRemove',
+            description: '删除Map中的键值对',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapContains',
+            description: '指定Map中是否存在参数key的键值对',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('Boolean'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapKeys',
+            description: '输出Map中key集合',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapValues',
+            description: '输出Map中value集合',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('V')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapFilter',
+            description: '在指定Map中过滤出符合条件参数的Map集合',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'byKey',
+                    defaultExpression: new Function({
+                        name: 'byKey',
+                        description: '',
+                        params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'byValue',
+                    defaultExpression: new Function({
+                        name: 'byValue',
+                        description: '',
+                        params: [
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K')],
+                    }),
+                }),
+            ],
+        }),
         new Function({
             name: 'CurrDate',
             description: '返回当前日期',

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

@@ -15,7 +15,7 @@ export function reference2TypeAnnotationList(list: Array<Entity | Structure | En
             return TypeAnnotation.createReference(item.name, {
                 typeKind: 'generic',
                 typeNamespace: namespace,
-                typeArguments: item.typeParams.map((typeParam) => new TypeAnnotation()),
+                typeArguments: item.typeParams.map((typeParam) => new TypeAnnotation({ name: typeParam.name })),
             });
         } else {
             return TypeAnnotation.createReference(item.name, {

package/src/enums/KEYWORDS.ts

@@ -1198,3 +1198,19 @@ export const ENTITY_PROPERTY_KEYWORDS = [
     'STATIC',
     'YIELD',
 ];
+
+export const USER_CUSTOM_KEYWORDS = [
+    'annotation',
+    'app',
+    'component',
+    'components',
+    'config',
+    'configuration',
+    'dataSource',
+    'element',
+    'elements',
+    'function',
+    'match',
+    'operator',
+    'system',
+];

package/src/generator/genBundleFiles.ts

@@ -132,6 +132,29 @@ export async function genBundleFiles(app: App,
         if (view.isIndex) {
             indexName = view.name;
         }
+        function getAuth(data: View) {
+            if (!data) return
+            let res:any = {};
+            if( data.children.length === 0) {
+                res.name = data.name;
+                res.auth = data.auth;
+                res.children = [];
+            } else {
+                res.name = data.name;
+                res.auth = data.auth;
+                res.children = [];
+                data.children.forEach(item => {
+                    res.children.push(getAuth(item));
+                })
+            }
+            return res;
+        }
+
+        let filterChildren: any[];
+        filterChildren = [];
+        view.children.forEach(item => {
+            filterChildren.push(getAuth(item));
+        });
         pages[view.name] = {
             title: view.title,
             name: view.name,
@@ -140,7 +163,7 @@ export async function genBundleFiles(app: App,
             hasAuth: app.hasAuth,
             domainName: app.name,
             auth: view.auth,
-            subPage: view.children,
+            subPage: filterChildren,
             documentTitle: app.documentTitle,
             router: {
                 notFound: '/',

package/src/server/getLogics.ts

@@ -74,13 +74,13 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             }
             nc.map((item) => {
                 item.logics = item.logics.filter((logic) => !logic.name.startsWith('import'));
-                item.expanded = true;
+                item.expanded = false;
                 item.originConcept = 'Entity';
                 return item;
             });
             const ps = app.processes.map((p) => {
                 const pItem = process2LogicNamespace(p);
-                pItem.expanded = true;
+                pItem.expanded = false;
                 pItem.originConcept = 'Process';
                 return pItem;
             });
@@ -92,7 +92,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 logics: app.logics,
                 children: [...nc, ...extensions, ...ps],
             });
-            tree.expanded = true;
+            tree.expanded = false;
             result.push(tree);
         }
 
@@ -114,7 +114,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                         path: `elements.${toHump(item.name)}.logics`,
                         originConcept: 'ViewElement',
                     });
-                    viewElement.expanded = true;
+                    viewElement.expanded = false;
                     viewElements.push(viewElement);
                 }
             });
@@ -126,7 +126,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 logics: node.view.logics,
                 children: viewElements,
             });
-            tree.expanded = true;
+            tree.expanded = false;
             result.push(tree);
             const systemTree = new Namespace({
                 name: 'category',
@@ -138,37 +138,37 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                         path: `process`,
                         title: '流程逻辑',
                         logics: stdlibNamespace.findChild('process').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                     new Namespace({
                         name: 'category',
                         path: `browser`,
                         title: '浏览器',
                         logics: stdlibNamespace.findChild('browser').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                     new Namespace({
                         name: 'category',
                         path: `auth`,
                         title: '认证与权限',
                         logics: stdlibNamespace.findChild('auth').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                     new Namespace({
                         name: 'category',
                         path: `configuration`,
                         title: '配置',
                         logics: stdlibNamespace.findChild('configuration').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                 ],
-                expanded: true,
+                expanded: false,
             });
             if (!app.processes.length)
                 systemTree.children.shift();
 
-            systemTree.expanded = true;
-            systemTree.children.forEach((child) => (child.expanded = true));
+            systemTree.expanded = false;
+            systemTree.children.forEach((child) => (child.expanded = false));
             result.push(systemTree);
         } else {
             // 增加全局逻辑中的系统逻辑
@@ -182,25 +182,26 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                         path: `process`,
                         title: '流程逻辑',
                         logics: stdlibNamespace.findChild('process').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                     new Namespace({
                         name: 'category',
                         path: `configuration`,
                         title: '配置',
                         logics: stdlibNamespace.findChild('configuration').logics,
-                        expanded: true,
+                        expanded: false,
                     })
                 ],
-                expanded: true,
+                expanded: false,
             });
             if (!app.processes.length)
                 systemTree.children.shift();
 
-            systemTree.expanded = true;
-            systemTree.children.forEach((child) => (child.expanded = true));
+            systemTree.expanded = false;
+            systemTree.children.forEach((child) => (child.expanded = false));
             result.push(systemTree);
         }
+        console.log(result)
         return result;
     }
 }