@lcap/nasl 1.0.1 → 1.0.2

package/out/server/naslServer.js

@@ -17,6 +17,7 @@ const common_1 = require("../common");
 const diagnostic_1 = __importDefault(require("../manager/diagnostic"));
 const createUiTs_1 = __importDefault(require("./createUiTs"));
 const coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
+const utils_1 = require("../utils");
 const EmbeddedTSFileLineMap = {
     Entity: 3,
 };
@@ -322,31 +323,38 @@ const naslServer = {
              * fileNode
              */
             const { currentSource, fileNode } = naslServer.getCurrentSource(callFunction);
-            const quickInfo = await naslServer._getTypeQuickinfo({
-                file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character) + `nasl.util.C`.length,
-            });
-            if (quickInfo.responseRequired) {
-                const displayString = quickInfo?.response?.displayString || '';
-                const typeList = naslServer.getDisplayString2Type(displayString);
-                let res = [];
-                typeList.forEach((type) => {
-                    const typeAnnotation = coreTypeList_1.primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
-                    if (typeAnnotation) {
-                        res.push(typeAnnotation);
+            try {
+                const quickInfo = await naslServer._getTypeQuickinfo({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character) + `nasl.util.C`.length,
+                });
+                if (quickInfo.responseRequired) {
+                    const displayString = quickInfo?.response?.displayString || '';
+                    const typeList = naslServer.getDisplayString2Type(displayString);
+                    const res = [];
+                    typeList.forEach((type) => {
+                        const typeAnnotation = coreTypeList_1.primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
+                        if (typeAnnotation) {
+                            res.push(typeAnnotation);
+                        }
+                        else if (type === 'unknown' || type === 'never') {
+                            return null;
+                        }
+                    });
+                    if (!res.length) {
+                        return [];
                     }
-                    else if (type === 'unknown' || type === 'never') {
-                        return null;
+                    else {
+                        return [{ title: '基础类型', children: res }];
                     }
-                });
-                if (!res.length) {
-                    return [];
-                }
-                else {
-                    return [{ title: '基础类型', children: res }];
                 }
             }
+            catch (err) {
+                console.log(err);
+                // 如果有异常就先放开全部可选，兜底逻辑
+                return [];
+            }
         }
         else {
             // 字符串 和 inter
@@ -424,6 +432,7 @@ const naslServer = {
             record.semanticDiagnostics = record.semanticDiagnostics
                 .map((diag) => this._resolveDiagnostic(diag, node))
                 .filter((diag) => !!diag);
+            record.semanticDiagnostics.push(...this._attachDiagnostics(node));
             // 建议诊断
             // 实体下的建议不用展示，因为都是平台自己写的逻辑
             // if (node instanceof Entity) {
@@ -445,6 +454,28 @@ const naslServer = {
         });
         return records;
     },
+    _attachDiagnostics(fileNode) {
+        const diagnostics = [];
+        if (fileNode instanceof concepts_1.View) {
+            (0, utils_1.traverse)((current) => {
+                if (current.node.tag) {
+                    current.node.bindAttrs.forEach((bindAttr) => {
+                        if ((bindAttr.model || bindAttr.sync)
+                            && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
+                            const diagnostic = {
+                                node: bindAttr,
+                                severity: 'error',
+                                message: '页面元素双向绑定：只允许绑定可赋值的变量和字段。',
+                            };
+                            bindAttr.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
+            }, { node: { children: fileNode.elements } });
+        }
+        return diagnostics;
+    },
     _resolveDiagnostic(diagnostic, fileNode) {
         const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
@@ -893,12 +924,18 @@ const naslServer = {
                 if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.Entity) {
                     minRange.setTypeMethods = 'setEntityAsName';
                 }
+                if (minRange.node instanceof concepts_1.QueryGroupByExpression && node instanceof concepts_1.Entity) {
+                    minRange.setTypeMethods = 'setEntityAsName';
+                }
                 if ((minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression) && node instanceof concepts_1.Entity) {
                     minRange.setTypeMethods = 'setEntityName';
                 }
                 if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.EntityProperty) {
                     minRange.setTypeMethods = 'setPropertyName';
                 }
+                if (minRange.node instanceof concepts_1.QueryGroupByExpression && node instanceof concepts_1.EntityProperty) {
+                    minRange.setTypeMethods = 'setPropertyName';
+                }
                 // 如果跳转链接或者页面变量同一个param和TypeAnnotation 有两个过滤掉一个
                 if ((minRange.node instanceof concepts_1.Param || minRange.node instanceof concepts_1.Variable || minRange.node instanceof concepts_1.Return) && (node instanceof concepts_1.Entity || node instanceof concepts_1.Enum || node instanceof concepts_1.Structure)) {
                     return null;
@@ -906,6 +943,9 @@ const naslServer = {
                 if (minRange.node instanceof concepts_1.Destination && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
                     return null;
                 }
+                if (minRange.node instanceof concepts_1.Assignee && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
+                    return null;
+                }
                 // 枚举修改枚举名，比较特殊
                 if (minRange.node instanceof concepts_1.EnumItem && node instanceof concepts_1.Enum) {
                     // 什么都不做，用来跳过修改
@@ -967,18 +1007,9 @@ const naslServer = {
         console.log(result);
         return result;
     },
-    _addParamsPrepare(node, refsList) {
-        const App = node.rootNode;
-        const parantNode = node.parentNode;
-        // 收集修改
-        App.emit('collect:start', {
-            actionMsg: '增加逻辑参数',
-        });
-        node.create({
-            index: 0,
-            parentNode: parantNode,
-            parentKey: node.parentKey,
-        });
+    // 增加参数的副作用，用于更新logic和view
+    _addParamsEffect(refsList, node) {
+        const parantNode = node?.parentNode;
         refsList.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.file);
             if (!fileNode)
@@ -995,19 +1026,37 @@ const naslServer = {
                 }
             }
         });
-        // 结束修改 ，批量操作
-        App.emit('collect:end');
+    },
+    _addParamsPrepare(node, refsList, needAdd) {
+        if (needAdd) {
+            const App = node?.rootNode;
+            const parantNode = node?.parentNode;
+            // 收集修改
+            App.emit('collect:start', {
+                actionMsg: '增加逻辑参数',
+            });
+            node.create({
+                index: 0,
+                parentNode: parantNode,
+                parentKey: node.parentKey,
+            });
+            naslServer._addParamsEffect(refsList, (node));
+            // 结束修改 ，批量操作
+            App.emit('collect:end');
+            return node;
+        }
+        naslServer._addParamsEffect(refsList, (node));
+        return node;
     },
     // 查找引用
     async findReferences(node) {
         let refsList = await naslServer._isHaveRef(node);
         // 如果查找引用查到自己里面的引用不展示
-        refsList = refsList.filter((item) => {
-            // 自己引用自己的过滤掉
-            // 删除的时候过滤一把组件删除提示
-            // 展示组件自己屏蔽掉
-            return !item.isDefinition && !(item.lineText.includes(' = new nasl.ui.'));
-        });
+        refsList = refsList.filter((item) => 
+        // 自己引用自己的过滤掉
+        // 删除的时候过滤一把组件删除提示
+        // 展示组件自己屏蔽掉
+        !item.isDefinition && !(item.lineText.includes(' = new nasl.ui.')));
         // 最后返回的结果
         let result = new Map();
         // 树的构造，key： 一个file的node， 值是 [[logic, params],[logic, returns]]
@@ -1040,14 +1089,15 @@ const naslServer = {
     // 获取节点的上层渲染
     _getTreeMap(minRange, fileNode, resMap, nodeMap) {
         const minRangeNode = minRange.node;
-        let parantNode = minRangeNode;
+        let currentNode = minRangeNode;
+        let parantNode = currentNode.parentNode;
         // 顺序队列
         const queue = [];
         // 先插入自己,如果没有在往上找,
         // 一直到file节点的父级
         while (!(parantNode instanceof concepts_1.App)) {
             // 找到上一级 在map对象中构造出他的子集
-            const currentNode = parantNode;
+            currentNode = parantNode;
             parantNode = parantNode.parentNode;
             // 如果第一次就塞入子集和父节点，以后就只用父节点了
             // 因为部分节点没有name，先过滤掉
@@ -1094,12 +1144,12 @@ const naslServer = {
             }
         }
         // 一个logic 或者 view可能会有多个顺序队列
-        if (resMap.get(fileNode)) {
+        if (resMap.get(currentNode)) {
             // 是否展示两个内容全等，但是两个queue的node可能不一样，但是只需要展示一个
-            resMap.get(fileNode).push(queue);
+            resMap.get(currentNode).push(queue);
         }
         else {
-            resMap.set(fileNode, [queue]);
+            resMap.set(currentNode, [queue]);
         }
     },
     handleTreeMap(resMap) {
@@ -1240,320 +1290,6 @@ async function handleDelete(fileNode, targetNode, result) {
     await naslServer.updateFiles({ outputFiles });
     newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
 }
-concepts_1.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];
-            if (this.concept === 'Logic') {
-                if (logic instanceof concepts_1.Logic)
-                    if (logic.calleewholeKey === this.calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            }
-            else {
-                if (logic instanceof concepts_1.Logic)
-                    if (logic.calleewholeKey === this.parentNode.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];
-            if (logic.getNamespace && logic.getNamespace() === this.getNamespace()) {
-                targetNode = logic;
-                break;
-            }
-        }
-    }
-    try {
-        return naslServer.findReferences(targetNode);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-// 查找引用
-concepts_1.BaseNode.prototype.findUsage = function findUsage() {
-    try {
-        return naslServer.findReferences(this);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-concepts_1.BaseNode.prototype.changeName = async function changeName(newValue, updateAll = 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.setName(newValue);
-        }
-        else {
-            const callback = (value) => {
-                if (value) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '重命名并更新引用',
-                    });
-                    res.forEach((item) => {
-                        const itemNode = item.node;
-                        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.setName(newValue);
-                }
-            };
-            const confirmParms = {
-                actionType: 'rename',
-                node: this,
-                newValue,
-            };
-            /**
-             * nasl和vue的通信，回退，要触发vue的watch。
-             * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
-             * 先修改之
-             */
-            const closeCallBack = () => {
-                if (this.concept === 'EnumItem') {
-                    const oldValue = this.value;
-                    this.value = oldValue + ' ';
-                    setTimeout(() => {
-                        this.value = oldValue;
-                    }, 0);
-                }
-                else {
-                    const oldValue = this.name;
-                    this.name = oldValue + ' ';
-                    setTimeout(() => {
-                        this.name = oldValue;
-                    }, 0);
-                }
-            };
-            updateAll ? callback(true) : (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback, closeCallBack);
-            return;
-        }
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-/**
- * 准备删除
- */
-concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete() {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const node = this;
-        let refsList = await naslServer._isHaveRef(node);
-        // 删除的时候过滤一把组件删除提示
-        refsList = refsList.filter((item) => {
-            // 因为ui组件本身会多渲染一次,就先过滤一个 
-            return !(item.lineText.includes(': nasl.ui.'));
-        });
-        // 删除参数单独处理
-        if (node instanceof concepts_1.Param) {
-            const methodRefs = [];
-            refsList.forEach((item) => {
-                // 入参查找引用,查到logic 和自己,内容完全一样,就保留一个
-                const find = methodRefs.find((findItem) => item.lineText === findItem.lineText);
-                if (!find) {
-                    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 concepts_1.ViewElement) {
-                this.delete();
-                return;
-            }
-            callback = () => {
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
-                    this.deleteLogincAndModule();
-                }
-                else {
-                    this.delete();
-                }
-            };
-        }
-        else {
-            // 如果有依赖就有一个查找引用提示
-            confirmParms.tipFlag = true;
-            const node = this;
-            // 删除页面或者流程
-            if (node instanceof concepts_1.View || node instanceof concepts_1.Process) {
-                /**
-                 * 查找这个页面是不是有依赖
-                 */
-                let viewPath = this.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 concepts_1.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 = naslServer._findMinRange(record, fileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof concepts_1.CallLogic) {
-                                minRange.node.setCalleeArgName(parentNode);
-                            }
-                            if (minRange.node instanceof concepts_1.Destination) {
-                                minRange.node.setViewArgument(parentNode);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除logic节点，如果有对应的interface要一起删除
-                if (node instanceof concepts_1.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 = naslServer._findMinRange(record, fileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof concepts_1.Interface) {
-                                minRange.node.delete();
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除权限节点
-                if (node instanceof concepts_1.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 = naslServer._findMinRange(record, fileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof concepts_1.View || minRange.node instanceof concepts_1.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 concepts_1.View || node instanceof concepts_1.Process) {
-                    this.delete();
-                }
-                // 其余的都直接调用删除
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
-                    this.deleteLogincAndModule();
-                }
-                else {
-                    this.delete();
-                }
-            };
-        }
-        (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-/**
- * 如果添加需要触发查找引用并且在之后，对内容产生影响
- */
-concepts_1.BaseNode.prototype.addParamsPrepare = async function addParamsPrepare() {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const refsList = await naslServer._isHaveRef(this);
-        return naslServer._addParamsPrepare(this, refsList);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
 /**
  * 除去rename场景下的更新
  * @param fileNode 文件级别的节点
@@ -1692,7 +1428,6 @@ async function incidentalAction(action, fileNode, targetNode, oldpath) {
                     await incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
                 }
             }
-            ;
         }
         // 删除或新增模块
         // 需要把下面的哦内容全部都更新一遍
@@ -1710,7 +1445,6 @@ async function incidentalAction(action, fileNode, targetNode, oldpath) {
                     await handleDelete(node, node, result);
                 }
             }
-            ;
             // 删除模块通知更新列表
             if (action === 'delete') {
                 try {