@lcap/nasl 1.0.1 → 1.0.2

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

@@ -102,7 +102,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 if (Array.isArray(eleLogis) && eleLogis.length) {
                     const viewElement = new Namespace({
                         title: toHump(item.name),
-                        logics: eleLogis.map((item: Logic) => Logic.from(item)),
+                        logics: eleLogis.map((item: Logic) => Logic.from(item.toJSON())),
                         path: `elements.${toHump(item.name)}.logics`,
                         originConcept: 'ViewElement',
                     });
@@ -151,6 +151,27 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 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);

package/src/server/getMemberIdentifier.ts

@@ -96,10 +96,49 @@ function createType2Annotation(type: string): TypeAnnotation {
     }
     return typeAnnotation;
 }
+
+/**
+ * 把要返回去的数据做一下排序
+ * @param result 要返回数据
+ * @param node 当前内容的上下级
+ * @returns 返回排序后的数组
+ * 因为ts会按照 a-z的顺序进行排序
+ * 但是影响用户体验，需要先按照页面排序，其次按照logic进行排序
+ * 流程的韬哥自己解决了，所以先解决这两部分
+ */
+function sortFirstVariableData(result: CompletionProperty[], node: BaseNode) {
+    const newResult: CompletionProperty[] = [];
+    const logic = (node as Param).logic;
+    const view = (node as Param).view;
+    if (view) {
+        const { params, variables } = view;
+        const list = [...params, ...variables];
+        list.forEach((item) => {
+            const findIndex = result.findIndex((findItem) => findItem.name === item.name);
+            if (findIndex === 0 || findIndex) {
+                newResult.push(result[findIndex]);
+                result.splice(findIndex, 1);
+            }
+        });
+    }
+    if (logic) {
+        const { params, returns, variables } = logic;
+        const list = [...params, ...returns, ...variables];
+        list.forEach((item) => {
+            const findIndex = result.findIndex((findItem) => findItem.name === item.name);
+            if (findIndex === 0 || findIndex) {
+                newResult.push(result[findIndex]);
+                result.splice(findIndex, 1);
+            }
+        });
+    }
+    newResult.push(...result);
+    return newResult;
+}
 // 格式化变量数据
 export function formatVariableData(data: unknown | variableItem[], node: BaseNode, parent?: any) {
     if (Array.isArray(data)) {
-        const result = data.map((item) => {
+        let result = data.map((item) => {
             // value需要拼接生成
             item.value = parent ? `${parent.value}.${item.text}` : item.text;
             item.name = item.text;
@@ -134,6 +173,14 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
                 return completionProperty;
             }
         });
+
+        /**
+         * 排序result
+         * 如果没有父级就是第一集就排序一下当前result，用户体验优化
+        */
+        if (!parent) {
+            result = sortFirstVariableData(result, node);
+        }
         return result;
     }
 }
@@ -312,7 +359,7 @@ function getCurrentLogic(node: BaseNode,
         icon: string;
     }[]) {
     // 只有data-source可以
-    if (node instanceof Identifier && node.parentNode instanceof BindAttribute && node.parentNode.name === 'data-source') {
+    if (node instanceof Identifier && node.parentNode instanceof BindAttribute && (node.parentNode.name === 'data-source' || node.parentNode.name === 'check-file')) {
         const view = node.view;
         const viewLogics = view.logics;
         const logicVariable = viewLogics.map((item) => {

package/src/server/getProcesses.ts

@@ -1,5 +1,5 @@
 import Constant from '@nasl/concepts/Constant__';
-import { CompletionProperty, Process, ProcessElement, Namespace, Logic, TypeAnnotation, Return, Variable, StructureProperty, Param, Identifier, MemberExpression, LogicItem } from '..';
+import { CompletionProperty, Process, ProcessElement, Namespace, Logic, TypeAnnotation, Return, Variable, StructureProperty, Param, Identifier, MemberExpression, LogicItem, App, BaseNode, Structure, Entity, EntityProperty } from '..';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
 function alphaUpper(name: string) {
     if (!name) {
@@ -156,16 +156,25 @@ export function syncMemberExpression(elem: ProcessElement | Process, callback: (
                     attr.destination.arguments.forEach((arg) => {
                         travelDown(arg.expression, (node) => {
                             if (node instanceof MemberExpression) {
-                                console.log('UserTask', node.getValue());
+                                // console.log('UserTask destination', node.getValue());
+                                callback(node);
+                            }
+                        });
+                    });
+                }
+                if (attr.name === 'assignee') {
+                    attr.assignee.dynamicUsers.forEach((dy) => {
+                        travelDown(dy, (node) => {
+                            if (node instanceof MemberExpression) {
+                                // console.log('UserTask assignee', node.getValue());
                                 callback(node);
-                                // if(node.property.name === oldName) {}
                             }
                         });
                     });
                 }
             });
         }
-        if (el.type === 'ExclusiveGateway') {
+        if (el.type === 'ExclusiveGateway' || el.type === 'AutoTask') {
             travelDown(el.logic, (node) => {
                 if (node instanceof MemberExpression) {
                     console.log('ExclusiveGateway', node.getValue());
@@ -175,8 +184,38 @@ export function syncMemberExpression(elem: ProcessElement | Process, callback: (
         }
     });
 }
+// a.b.c => MemberExpression
+export function genMemberExpression(path: string) {
+    const arr = path.split('.');
+    let m: MemberExpression;
+    while(arr.length) {
+        const ns = arr.shift();
+        const cv = new Identifier({ name: ns });
+        if (!m) {
+            m = new MemberExpression({
+                object: cv,
+            });
+            cv.parentNode = m;
+        } else {
+            m.property = cv;
+            if(arr.length) {
+                const tm = new MemberExpression({
+                    object: m,
+                });
+                m.parentKey = 'object';
+                m.parentNode = tm;
+                cv.parentKey = 'property';
+                cv.parentNode = tm;
+                m = tm;
+            }
+        }
+    }
+
+    return m;
+}
+
 // ['a','b','c'] => a.b.c
-export function genCompletionProperty(prefix: string[] = []):(v: Variable | Param | Return | Constant) => CompletionProperty {
+export function genCompletionProperty(prefix: string[] = []):(v: Variable | Param | Return | Constant | EntityProperty| StructureProperty) => CompletionProperty {
     return (v) => {
         let m: MemberExpression;
         const p = new Identifier({ name: v.name });
@@ -238,7 +277,7 @@ export function getPreviousTask(node: ProcessElement) {
         if (visitedMap.has(processElem)) {
             return;
         }
-        if (processElem !== node && (processElem.type === 'UserTask')) {
+        if (processElem !== node && (processElem.type === 'UserTask' || processElem.type === 'AutoTask')) {
             elements.push(processElem);
         }
         visitedMap.set(processElem, true);
@@ -316,21 +355,21 @@ export function getProcessVariableSuggestions(node: Logic, abandonConstant: bool
         scopeVariable.icon = processElem.type;
         processVariables.children.push(scopeVariable);
     }
-    // if(processElem.type === 'AutoTask') {
-    //     const scopeVariable = new CompletionProperty({
-    //         name: processElem.name,
-    //         value: processElem.name,
-    //         icon: processElem.type,
-    //         noFurther: true,
-    //         children: [
-    //             ...processElem.variables.map(genCompletionProperty([process.name, processElem.name])),
-    //             ...processElem.returns.map(genCompletionProperty([process.name, processElem.name])),
-    //         ]
-    //     });
-    //     scopeVariable.isProcess = true;
-    //     scopeVariable.icon = processElem.type;
-    //     processVariables.children.push(scopeVariable);
-    // }
+    if(processElem.type === 'AutoTask') {
+        const scopeVariable = new CompletionProperty({
+            name: processElem.name,
+            value: processElem.name,
+            icon: processElem.type,
+            noFurther: true,
+            children: [
+                ...processElem.variables.map(genCompletionProperty([process.name, processElem.name])),
+                ...processElem.returns.map(genCompletionProperty([process.name, processElem.name])),
+            ]
+        });
+        scopeVariable.isProcess = true;
+        scopeVariable.icon = processElem.type;
+        processVariables.children.push(scopeVariable);
+    }
     return processVariables;
 }
 
@@ -378,3 +417,113 @@ export function getProcessVaraibleSelections(node: Logic, list: VariableSuggesti
 
     list.splice(varidx, 1, data);
 }
+
+function deduceTypeAnnotation(
+    app: App, 
+    node: Variable | Param | Return | Constant | EntityProperty| StructureProperty,
+    typeA: TypeAnnotation,
+    prefix: string[],
+    records: BaseNode[],
+) {
+    const ns = typeA.typeNamespace;
+    const name = typeA.typeName;
+    const completion = genCompletionProperty(prefix)(node)
+    if(ns.startsWith('nasl')) {
+        return completion;
+    }
+    const nsPath = `${ns}.${name}`;
+
+    const typeNode = getNodeByNodeCallee(app, nsPath);
+    if(records.includes(typeNode)){
+        return null;
+    }
+    if(typeNode) {
+        records.push(typeNode)
+        const children = typeNode.properties.map((p: EntityProperty| StructureProperty) => {
+            return deduceTypeAnnotation(app, p, p.typeAnnotation, prefix.concat([node.name]), records.slice())     
+        }).filter((q: CompletionProperty | null) => !!q);
+        completion.children = children;
+        completion.expanded = true;
+        return completion;
+    }
+}
+
+export function getProcessVariableSuggestionsAll(node: ProcessElement) {
+    const processElem = node;
+    const process = node.process;
+    const app = node.app;
+    const elements: ProcessElement[] = getPreviousTask(processElem);
+    const prevtasks = elements.map((us) => {
+        const cp = new CompletionProperty({
+            name: us.name,
+            value: us.name,
+            noFurther: true,
+            children: [
+                ...us.returns.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], [])),
+               ...us.constants.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], [])),
+            ],
+        });
+        cp.expanded = true;
+        cp.icon = us.type;
+        cp.isProcess = true;
+        return cp;
+    });
+
+    const processVariables = new CompletionProperty({
+        name: process.name,
+        value: process.name,
+        noFurther: true,
+        children: [
+            ...process.params.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
+            ...process.returns.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
+            ...process.constants.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
+            ...prevtasks,
+        ],
+    });
+    processVariables.expanded = true;
+    processVariables.icon = 'Process';
+    if (processElem.type === 'ExclusiveGateway') {
+        const scopeVariable = new CompletionProperty({
+            name: processElem.name,
+            value: processElem.name,
+            icon: processElem.type,
+            noFurther: true,
+            children: processElem.variables.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
+        });
+        scopeVariable.expanded = true;
+        scopeVariable.isProcess = true;
+        scopeVariable.icon = processElem.type;
+        processVariables.children.push(scopeVariable);
+    }
+
+    if (processElem.type === 'UserTask') {
+        const scopeVariable = new CompletionProperty({
+            name: processElem.name,
+            value: processElem.name,
+            icon: processElem.type,
+            noFurther: true,
+            children: processElem.constants.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
+        });
+        scopeVariable.expanded = true;
+        scopeVariable.isProcess = true;
+        scopeVariable.icon = processElem.type;
+        processVariables.children.push(scopeVariable);
+    }
+    if(processElem.type === 'AutoTask') {
+        const scopeVariable = new CompletionProperty({
+            name: processElem.name,
+            value: processElem.name,
+            icon: processElem.type,
+            noFurther: true,
+            children: [
+                ...processElem.variables.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
+                ...processElem.returns.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
+            ]
+        });
+        scopeVariable.expanded = true;
+        scopeVariable.isProcess = true;
+        scopeVariable.icon = processElem.type;
+        processVariables.children.push(scopeVariable);
+    }
+    return processVariables;
+}