@lcap/nasl 1.0.0-alpha.9 → 1.0.2

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/extendBaseNode.ts

@@ -0,0 +1,318 @@
+import naslServer, { FileNode } from './naslServer';
+import * as tsProtocol from 'typescript/lib/protocol';
+import { MinRange } from './translator';
+import { BaseNode, CallLogic, Destination, EnumItem, Interface, Logic, Param, Process, Role, Structure, View, ViewElement } from '../concepts';
+import { EventPayload, invokeCommand, registerCommand } from '../common';
+
+interface SetNameNode extends BaseNode {
+    setName(name: string): any;
+    [propname: string]: any;
+}
+
+BaseNode.prototype.findReadOnlyLogicUsage = function () {
+    let targetNode;
+
+    if (this.parentNode.concept === 'Namespace' || this.parentNode.parentNode.concept === 'Namespace') {
+        const sourceMap = this.parentNode.concept === 'Namespace' ? this.parentNode.parentNode.sourceMap : this.parentNode.parentNode.parentNode.sourceMap;
+        for (const item of sourceMap) {
+            const logic = item[0] as Logic;
+            if (this.concept === 'Logic') {
+                if (logic instanceof Logic)
+                    if (logic.calleewholeKey === (this as Logic).calleewholeKey) {
+                        targetNode = logic;
+                        break;
+                    }
+            } else {
+                if (logic instanceof Logic)
+                    if (logic.calleewholeKey === (this.parentNode as Logic).calleewholeKey) {
+                        targetNode = logic;
+                        break;
+                    }
+            }
+        }
+    } else if (this.parentNode.concept === 'Module') {
+        // 父级是模块的还是用它本身去查找引用
+        targetNode = this;
+    } else {
+        const sourceMap = this.parentNode.sourceMap;
+        for (const item of sourceMap) {
+            const logic = item[0] as Logic;
+            if (logic.getNamespace && logic.getNamespace() === (this as Logic).getNamespace()) {
+                targetNode = logic;
+                break;
+            }
+        }
+    }
+
+    try {
+        return naslServer.findReferences(targetNode);
+    } catch (err) {
+        console.log(err);
+    }
+};
+// 查找引用
+BaseNode.prototype.findUsage = function findUsage() {
+    try {
+        return naslServer.findReferences(this);
+    } catch (err) {
+        console.log(err);
+    }
+};
+BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = false) {
+    console.log(newValue);
+    console.log(this);
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const refsList = await naslServer._isHaveRef(this);
+        // 是不是有引用有的话，就返回
+        /**
+         * @param this 当前重命名的节点
+         * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+         * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+         * @returns 找到的引用
+         */
+        const res = naslServer._renamePrepare(this, refsList, newValue);
+        if (res.length <= 1) {
+            (this as SetNameNode).setName(newValue);
+        } else {
+            const callback = (value: boolean) => {
+                if (value) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '重命名并更新引用',
+                    });
+                    res.forEach((item) => {
+                        const itemNode = item.node as SetNameNode;
+                        if (item.newValue) {
+                            // 如果有指定的修改方法，就用那个，没有就修改名字
+                            item.setTypeMethods ? itemNode[item.setTypeMethods](item.newValue) : itemNode.setName?.(item.newValue);
+                        } else {
+                            item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                } else {
+                    (this as SetNameNode).setName(newValue);
+                }
+            };
+            const confirmParms = {
+                actionType: 'rename',
+                node: this,
+                newValue,
+            };
+            /**
+             * nasl和vue的通信，回退，要触发vue的watch。
+             * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
+             * 先修改之
+             */
+            const closeCallBack = () => {
+                if (this.concept === 'EnumItem') {
+                    const oldValue = (this as EnumItem).value;
+                    (this as EnumItem).value = oldValue + ' ';
+                    setTimeout(() => {
+                        (this as EnumItem).value = oldValue;
+                    }, 0);
+                } else {
+                    const oldValue = this.name;
+                    this.name = oldValue + ' ';
+                    setTimeout(() => {
+                        this.name = oldValue;
+                    }, 0);
+                }
+            };
+            updateAll ? callback(true) : invokeCommand('tsConfirm.open', confirmParms, callback, closeCallBack);
+
+            return;
+        }
+    } catch (err) {
+        console.log(err);
+    }
+};
+
+/**
+ * 准备删除
+ */
+BaseNode.prototype.prepareDelete = async function prepareDelete() {
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const node = this;
+        let refsList = await naslServer._isHaveRef(node);
+        // 删除的时候过滤一把组件删除提示
+        refsList = refsList.filter((item) =>
+            // 因为ui组件本身会多渲染一次,就先过滤一个
+            !(item.lineText.includes(': nasl.ui.')));
+        // 删除参数单独处理
+        if (node instanceof Param) {
+            const methodRefs: tsProtocol.ReferencesResponseItem[] = [];
+            refsList.forEach((item) => {
+                // 入参查找引用,查到logic 和自己,内容完全一样,就保留一个
+                const find = methodRefs.find((findItem) => item.lineText === findItem.lineText);
+                // 而且内容不是跳转链接，跳转链接多个可能会完全一样
+                if (!find || find?.lineText?.includes('.$destination')) {
+                    methodRefs.push(item);
+                }
+            });
+            refsList = methodRefs;
+        }
+
+        // delete的弹框展示
+        const confirmParms = {
+            actionType: 'delete',
+            tipFlag: false,
+            node,
+            icon: 'warning',
+        };
+        let callback = null;
+        if (refsList.length <= 1) {
+            // 页面组件直接删除然后return
+            if (node instanceof ViewElement) {
+                this.delete();
+                return;
+            }
+            callback = () => {
+                // Structure 和 Interface是内部有delete方法
+                if (node instanceof Structure || node instanceof Interface) {
+                    (this as any).deleteLogincAndModule();
+                } else {
+                    this.delete();
+                }
+            };
+        } else {
+            // 如果有依赖就有一个查找引用提示
+            confirmParms.tipFlag = true;
+            const node = this;
+
+            // 删除页面或者流程
+            if (node instanceof View || node instanceof Process) {
+                /**
+                 * 查找这个页面是不是有依赖
+                 */
+                let viewPath = (this as FileNode).getEmbeddedFilePath();
+                viewPath = viewPath.slice(0, viewPath.length - 3);
+                const find = refsList.find((record) => !record.file.includes(viewPath));
+                // 如果没有别的文件的依赖，就直接delete
+                if (!find) {
+                    this.delete();
+                    return;
+                }
+            }
+            callback = () => {
+                // removeParam
+                // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
+                if (node instanceof Param) {
+                    const App = this.rootNode;
+                    const parentNode = this.parentNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '删除参数',
+                    });
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
+                        if (minRange) {
+                            if (minRange.node instanceof CallLogic) {
+                                minRange.node.setCalleeArgName(parentNode as Logic);
+                            }
+                            if (minRange.node instanceof Destination) {
+                                minRange.node.setViewArgument(parentNode as View);
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                    return;
+                }
+                // 删除logic节点，如果有对应的interface要一起删除
+                if (node instanceof Logic) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '删除逻辑并删除导出的接口',
+                    });
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
+                        if (minRange) {
+                            if (minRange.node instanceof Interface) {
+                                minRange.node.delete();
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                    return;
+                }
+                // 删除权限节点
+                if (node instanceof Role) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '删除权限',
+                    });
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
+                        if (minRange) {
+                            if (minRange.node instanceof View || minRange.node instanceof ViewElement) {
+                                // oldName旧的节点存的值
+                                // newValue用户输入值
+                                // node.bindRoles 存的
+                                const str = minRange.node.bindRoles.toString().replace(this.name, '');
+                                const newBindRoles = str.split(',').filter((item) => !!item);
+                                minRange.node.setBindRoles(newBindRoles);
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                    return;
+                }
+
+                // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
+                if (node instanceof View || node instanceof Process) {
+                    this.delete();
+                }
+                // 其余的都直接调用删除
+                // Structure 和 Interface是内部有delete方法
+                if (node instanceof Structure || node instanceof Interface) {
+                    (this as any).deleteLogincAndModule();
+                } else {
+                    this.delete();
+                }
+            };
+        }
+        invokeCommand('tsConfirm.open', confirmParms, callback);
+    } catch (err) {
+        console.log(err);
+    }
+};
+
+/**
+ * 如果添加需要触发查找引用并且在之后，对内容产生影响
+ */
+BaseNode.prototype.addParamsPrepare = async function addParamsPrepare(needAdd = true) {
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const refsList = await naslServer._isHaveRef(this);
+        return naslServer._addParamsPrepare(this, refsList, needAdd);
+    } catch (err) {
+        console.log(err);
+    }
+};

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,87 @@ 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.toJSON())),
                         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);
+        } else {
+            // 增加全局逻辑中的系统逻辑
+            const systemTree = new Namespace({
+                name: 'category',
+                path: `nasl`,
+                title: '系统逻辑',
+                children: [
+                    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);