@lcap/nasl 1.0.0-alpha.8 → 1.0.1

package/src/server/entity2LogicNamespace.ts

@@ -1,17 +1,40 @@
-import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return } from '..';
+import { CallLogic, EntityProperty, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return } from '..';
+
 export function entity2LogicNamespace(entity: Entity) {
+    const properties = entity.properties;
+    const keys = properties.filter((item) => item.primaryKey);
+    const params = keys.map((item: EntityProperty) => new Param({ name: item.name, typeAnnotation: TypeAnnotation.createPrimitive(item.typeAnnotation.typeName), required: true }));
+    const batchDeleteParams
+        = keys.length > 1 ? [
+            new Param({
+                name: 'body',
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [
+                        TypeAnnotation.from({
+                            typeKind: 'reference',
+                            typeNamespace: entity.getNamespace(),
+                            typeName: entity.name,
+                        }),
+                    ],
+                }),
+                required: true,
+            }),
+        ] : [
+            new Param({
+                name: 'body',
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [TypeAnnotation.createPrimitive(keys[0].typeAnnotation.typeName)],
+                }),
+                required: true,
+            }),
+        ];
     const ns = new Namespace({
         name: entity.name,
         logics: [
             new Logic({
                 name: 'get',
-                params: [
-                    new Param({
-                        name: 'id',
-                        typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-                        required: true,
-                    }),
-                ],
+                description: 'get',
+                params,
                 returns: [
                     new Return({
                         name: 'result',
@@ -26,6 +49,7 @@ export function entity2LogicNamespace(entity: Entity) {
             }),
             new Logic({
                 name: 'create',
+                description: 'create',
                 params: [
                     new Param({
                         name: 'body',
@@ -51,6 +75,7 @@ export function entity2LogicNamespace(entity: Entity) {
             }),
             new Logic({
                 name: 'update',
+                description: 'update',
                 params: [
                     new Param({
                         name: 'body',
@@ -76,17 +101,13 @@ export function entity2LogicNamespace(entity: Entity) {
             }),
             new Logic({
                 name: 'delete',
-                params: [
-                    new Param({
-                        name: 'id',
-                        typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-                        required: true,
-                    }),
-                ],
+                description: 'delete',
+                params,
                 body: [],
             }),
             new Logic({
                 name: 'batchCreate',
+                description: 'batchCreate',
                 params: [
                     new Param({
                         name: 'body',
@@ -120,6 +141,7 @@ export function entity2LogicNamespace(entity: Entity) {
             }),
             new Logic({
                 name: 'batchUpdate',
+                description: 'batchUpdate',
                 params: [
                     new Param({
                         name: 'body',
@@ -153,19 +175,13 @@ export function entity2LogicNamespace(entity: Entity) {
             }),
             new Logic({
                 name: 'batchDelete',
-                params: [
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: TypeAnnotation.createGeneric('List', {
-                            typeArguments: [TypeAnnotation.createPrimitive('Long')],
-                        }),
-                        required: true,
-                    }),
-                ],
+                description: 'batchDelete',
+                params: batchDeleteParams,
                 body: [],
             }),
             new Logic({
                 name: 'import',
+                description: 'import',
                 params: [
                     new Param({
                         name: 'body',
@@ -183,7 +199,7 @@ export function entity2LogicNamespace(entity: Entity) {
             }),
         ],
     });
-
+    ns.parentNode = entity;
     return ns;
 }
 

package/src/server/getExtensionModules.ts

@@ -9,5 +9,7 @@ export function moduleToLogicNamesapce(m: Module) {
         logics: m.logics,
     });
     ns.path = `app.${m.name}.logics`;
+    ns.expanded = true
+    ns.originConcept = 'import-interface-category'
     return ns;
 }

package/src/server/getFunctions.ts

@@ -8,3 +8,9 @@ export function getBuildInFunction(name: string) {
     const utilFunctions = getFunctions().functions;
     return utilFunctions.find((f) => f.name === name);
 }
+
+export function getValidationInFunction(name: string) {
+    const validation = stdlibNamespace.findChild('validation');
+    const validationFunctions = validation.functions;
+    return validationFunctions.find((f) => f.name === name);
+}

package/src/server/getLogics.ts

@@ -1,4 +1,4 @@
-import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process, ViewElement } from '..';
+import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process, ViewElement, stdlibNamespace } from '..';
 import { process2LogicNamespace } from './process2LogicNamespace';
 import { moduleToLogicNamesapce } from './getExtensionModules';
 import naslServer from './naslServer';
@@ -20,32 +20,34 @@ function iterator(tree: FakeNode | FakeProcessNode, searchContent: string, fakeN
     if (searchContent) {
         fakeNode.children = [];
         fakeNode.logics = [];
-        fakeNode.processes = [];
+        // fakeNode.processes = [];
         if (tree.children) {
             tree.children.forEach((c) => {
                 const childFakeNode = {};
-                if (iterator(c, searchContent, childFakeNode)) {
+                if(c.title?.toLowerCase().includes(searchContent) || c.name?.toLowerCase().includes(searchContent))
+                    fakeNode.children.push({...c});
+                else if (iterator(c, searchContent, childFakeNode)) {
                     fakeNode.children.push(childFakeNode);
                 }
             });
         }
         if (tree.logics) {
             tree.logics.forEach((l) => {
-                const exist = l.name.includes(searchContent);
+                const exist = l.name.toLowerCase().includes(searchContent);
                 if (exist) {
                     fakeNode.logics.push(l);
                 }
             });
         }
-        if (tree.processes) {
-            tree.processes.forEach((c) => {
-                const childFakeNode = {};
-                if (iterator(c, searchContent, childFakeNode)) {
-                    fakeNode.processes.push(childFakeNode);
-                }
-            });
-        }
-        if (fakeNode.logics.length > 0) {
+        // if (tree.processes) {
+        //     tree.processes.forEach((c) => {
+        //         const childFakeNode = {};
+        //         if (iterator(c, searchContent, childFakeNode)) {
+        //             fakeNode.processes.push(childFakeNode);
+        //         }
+        //     });
+        // }
+        if (fakeNode.logics.length > 0 || fakeNode.children.length > 0) {
             return true;
         }
         return false;
@@ -64,17 +66,25 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             const nc = app.entities.map((entity) => entity.ns);
             nc.map((item) => {
                 item.logics = item.logics.filter((logic) => !logic.name.startsWith('import'));
+                item.expanded = true;
+                item.originConcept = 'Entity';
                 return item;
             });
-            const ps = app.processes.map((p) => process2LogicNamespace(p));
+            const ps = app.processes.map((p) => {
+                const pItem = process2LogicNamespace(p);
+                pItem.expanded = true;
+                pItem.originConcept = 'Process';
+                return pItem;
+            });
             const extensions = app.dependencies.map(moduleToLogicNamesapce);
             const tree = new Namespace({
-                name: 'logics',
+                name: 'category',
                 path: `${app.getNamespace()}.logics`,
                 title: '全局逻辑',
                 logics: app.logics,
                 children: [...nc, ...extensions, ...ps],
             });
+            tree.expanded = true;
             result.push(tree);
         }
 
@@ -92,29 +102,66 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 if (Array.isArray(eleLogis) && eleLogis.length) {
                     const viewElement = new Namespace({
                         title: toHump(item.name),
-                        name: 'methods',
-                        logics: elementsLogic[elementsLogicName],
+                        logics: eleLogis.map((item: Logic) => Logic.from(item)),
                         path: `elements.${toHump(item.name)}.logics`,
+                        originConcept: 'ViewElement',
                     });
+                    viewElement.expanded = true;
                     viewElements.push(viewElement);
                 }
             });
             // 增加页面逻辑
             const tree = new Namespace({
-                name: 'logics',
+                name: 'category',
                 path: `${node.view.getNamespace()}.${node.view.name}.logics`,
                 title: '页面逻辑',
                 logics: node.view.logics,
                 children: viewElements,
             });
+            tree.expanded = true;
             result.push(tree);
+
+            const systemTree = new Namespace({
+                name: 'category',
+                path: `nasl`,
+                title: '系统逻辑',
+                children: [
+                    new Namespace({
+                        name: 'category',
+                        path: `browser`,
+                        title: '浏览器',
+                        logics: stdlibNamespace.findChild('browser').logics,
+                        expanded: true,
+                    }),
+                    new Namespace({
+                        name: 'category',
+                        path: `auth`,
+                        title: '认证与权限',
+                        logics: stdlibNamespace.findChild('auth').logics,
+                        expanded: true,
+                    }),
+                    new Namespace({
+                        name: 'category',
+                        path: `configuration`,
+                        title: '配置',
+                        logics: stdlibNamespace.findChild('configuration').logics,
+                        expanded: true,
+                    }),
+                ],
+                expanded: true,
+            });
+
+            systemTree.expanded = true;
+            systemTree.children.forEach((child) => (child.expanded = true));
+            result.push(systemTree);
         }
         return result;
     }
 }
 
-export function iteratorTree(treeList: {}[], filterText?: string) {
+export function iteratorTree(treeList: {}[], filterText: string = '') {
     const result: {}[] = [];
+    filterText = filterText.toLowerCase();
     treeList.forEach((item) => {
         const fakeNode = {};
         iterator(item, filterText, fakeNode);