@lcap/nasl 1.0.0-alpha.2 → 1.0.0-alpha.3

package/src/server/naslServer.ts

@@ -34,12 +34,16 @@ import {
     BindAttribute,
     Assignment,
     CallQueryComponent,
+    Role,
+    Configuration,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem, embeddedTSEmitter } from '../translator';
 import axios from '../service/storage';
 import { transformType, translateDiagnosticMessage } from './translator';
 import { EventPayload, invokeCommand, registerCommand } from '../common';
 import { DiagnosticRecord, Diagnostic, default as diagnosticManager } from '../manager/diagnostic';
+import formatUiTs from './createUiTs';
+import { primitiveTypeList } from '../concepts/basics/types/coreTypeList';
 
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
     Entity: 3,
@@ -108,9 +112,21 @@ const naslServer = {
      * 先用挂在点上面，简单的方法实现，后期再考虑解耦
      */
     file2NodeMap: new Map<string, BaseNode>(),
+    elementsLogic: <{ [elementLogicName: string]: Array<Logic> }>{},
     start() {
         return this.messager.requestCommand('start');
     },
+    async createUiTs(allComponent: any) {
+        const { code, elementsLogic } = await formatUiTs(allComponent);
+        // 放入生產的uits文件
+        await naslServer.addFile({
+            file: 'nasl.ui.definition.ts',
+            fileContent: code,
+        });
+        naslServer.elementsLogic = elementsLogic;
+        // 全部文件加载完毕开始初始化
+        await naslServer.getDiagnosticRecordsAndPushAll();
+    },
     contentToFile(module: Module | App, results: Array<ReturnType<Structure['toEmbeddedTSFile']>>) {
         module.structures.forEach((structure) => {
             const result = structure.toEmbeddedTSFile();
@@ -141,18 +157,17 @@ const naslServer = {
             this.file2NodeMap.set(result.filePath, _enum);
         });
         module.logics.forEach((logic) => {
+            if (!(logic instanceof Logic))
+                return;
             const result = logic.toEmbeddedTSFile();
             results.push(result);
             logic.sourceMap = result.sourceMap;
             this.file2NodeMap.set(result.filePath, logic);
         });
 
-        module.views.forEach((view) => {
-            const result = view.toEmbeddedTSFile();
-            results.push(result);
-            view.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, view);
-        });
+        // view的生成
+        naslServer.view2TSFile(module.views, results);
+
         module.processes.forEach((process) => {
             const result = process.toEmbeddedTSFile();
             results.push(result);
@@ -170,6 +185,18 @@ const naslServer = {
             });
         }
     },
+    view2TSFile(viewsChildren: View[], results: Array<ReturnType<Structure['toEmbeddedTSFile']>>) {
+        // 子页面
+        viewsChildren.forEach((view) => {
+            const result = view.toEmbeddedTSFile();
+            results.push(result);
+            view.sourceMap = result.sourceMap;
+            this.file2NodeMap.set(result.filePath, view);
+            if (view.children.length) {
+                naslServer.view2TSFile(view.children, results);
+            }
+        });
+    },
     async openApp(app: App) {
         const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
         try {
@@ -210,7 +237,13 @@ const naslServer = {
             fileContent: result.code,
         }));
         await this.writeFiles(files);
-        this._debugInFileStorage((module.parentNode) as App, files);
+        this._debugInFileStorage(module.parentNode as App, files);
+    },
+    /**
+     * 初始化之前添加文件
+     */
+    addFile(file: tsProtocol.OpenRequestArgs) {
+        return this.messager.requestCommand('addFile', file);
     },
     /**
      * 只新增文件
@@ -235,11 +268,15 @@ const naslServer = {
     updateFiles(args: { outputFiles: Array<tsProtocol.OpenRequestArgs> }) {
         return this.messager.requestCommand('updateFiles', args);
     },
-    _debugInFileStorage(app: App, openFiles: Array<tsProtocol.OpenRequestArgs>) {
-        return Promise.all(openFiles.map(async (file) => {
-            const res = await axios.post('/api/App/debugEmbedded?id=' + app.id, file);
-            return res.data;
-        }));
+    _debugInFileStorage(node: BaseNode, openFiles: Array<tsProtocol.OpenRequestArgs>) {
+        // let app = node;
+        // if (node.concept !== 'App') {
+        //     app = (node as any).rootNode || (node as any).app;
+        // }
+        // return Promise.all(openFiles.map(async (file) => {
+        //     const res = await axios.post('/api/App/debugEmbedded?id=' + app.id, file);
+        //     return res.data;
+        // }));
     },
     open() {
         return this.messager.requestCommand('open');
@@ -253,23 +290,87 @@ const naslServer = {
     async references(args: tsProtocol.FileLocationRequestArgs) {
         return ((await this.messager.requestCommand('references', args)) as any)?.response as tsProtocol.ReferencesResponseBody;
     },
-    getSelectCompletion(node: BaseNode) {
+    getValueSelectCompletion(node: BaseNode, value: string) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
         // console.log(currentSource, fileNode);
         if (currentSource && fileNode) {
-            return naslServer._getSelectCompletion({
+            return naslServer._getValueSelectCompletion({
                 file: (fileNode as FileNode).getEmbeddedFilePath(),
                 range: {
                     line: lsp2tspNumber(currentSource.range.start.line),
                     offset: lsp2tspNumber(currentSource.range.start.character),
                 },
+                value,
             });
         } else {
             console.log('没找到节点', node, currentSource, fileNode);
         }
     },
-    _getSelectCompletion(args: any) {
-        return this.messager.requestCommand('getSelectCompletion', args);
+    _getValueSelectCompletion(args: any) {
+        return this.messager.requestCommand('getValueSelectCompletion', args);
+    },
+    // 联合类型切割取出类型
+    getDisplayString2Type(displayString: string) {
+        // 取出匹配的内容
+        const reg = /\<([^()]+)\>/g;
+        const types = reg.exec(displayString);
+        // 取出提示的类型，组成是数组
+        const typeList: string[] = types[1].split(' | ').map((item: string) => {
+            if (item.includes(' ')) {
+                const strs = item.split(' ');
+                const type = strs[strs.length - 1];
+                return type;
+            } else if (item.includes('.')) {
+                const strs = item.split('.');
+                const type = strs[strs.length - 1];
+                return type;
+            } else {
+                return item;
+            }
+        });
+        return typeList;
+    },
+    async getTypeQuickinfo(node: BaseNode) {
+        console.log(node);
+        if (node instanceof Identifier) {
+            const callFunction = node.parentNode.parentNode;
+            /**
+             * currentSource callFunction 的节点，要去到当前节点的位置
+             * nasl.util.Convert(xxx),所以取到的位置要 + `nasl.util.C` 的长度
+             * fileNode
+             */
+            const { currentSource, fileNode } = naslServer.getCurrentSource(callFunction);
+            const quickInfo = await naslServer._getTypeQuickinfo({
+                file: (fileNode as FileNode).getEmbeddedFilePath(),
+                line: lsp2tspNumber(currentSource.range.start.line),
+                offset: lsp2tspNumber(currentSource.range.start.character) + `nasl.util.C`.length,
+            });
+            if (quickInfo.responseRequired) {
+                const displayString = quickInfo?.response?.displayString || '';
+                const typeList = naslServer.getDisplayString2Type(displayString);
+                let res: Array<TypeAnnotation> = [];
+                typeList.forEach((type) => {
+                    const typeAnnotation = primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
+                    if (typeAnnotation) {
+                        res.push(typeAnnotation);
+                    } else if (type === 'unknown') {
+                        return null;
+                    }
+                });
+                if (!res.length) {
+                    res = primitiveTypeList;
+                }
+                // 调整结构
+                const dataTypeList: Array<{
+                    title: string;
+                    children: Array<TypeAnnotation>;
+                }> = [{ title: '基础类型', children: res }];
+                return dataTypeList;
+            }
+        }
+    },
+    _getTypeQuickinfo(args: any) {
+        return this.messager.requestCommand('quickInfo', args) as unknown as { responseRequired: boolean; response: tsProtocol.QuickInfoResponseBody };
     },
     getSelectNextCompletion(node: BaseNode) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
@@ -320,10 +421,15 @@ const naslServer = {
             // 实体下的建议不用展示，因为都是平台自己写的逻辑
             if (node instanceof Entity) {
                 record.suggestionDiagnostics = [];
-            } else if (node instanceof View) {
+            }
+            if (node instanceof View) {
                 // event在view中不展示建议使用,提示关闭掉
                 record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`'event'`));
             }
+            if (node instanceof Logic) {
+                // logic在for循环中，不展示any提示
+                record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
+            }
             record.suggestionDiagnostics = record.suggestionDiagnostics
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node.sourceMap))
                 .filter((diag) => !!diag);
@@ -361,7 +467,7 @@ const naslServer = {
     _diagnosticSpecialTreatment(minRange: MinRange, tsErrorDetail: Diagnostic) {
         // 因为缺少参数时候有可能有特殊情况,因为原本少的多了就会找到 callLogic上,
         // 但是只少一个的时候就会找到准确的Argument上 需要特殊处理, ui层就可以统一处理
-        if (minRange.node instanceof Argument && /Expected (.+?) arguments, but got (.+?)./.exec(tsErrorDetail.text)) {
+        if (minRange.node instanceof Argument && /Expected (.+?) arguments, but got (.+?)./.exec(tsErrorDetail.originalDiagnostic.text)) {
             minRange.node = minRange.node.parentNode;
         }
         minRange.node.tsErrorDetail = tsErrorDetail;
@@ -515,6 +621,31 @@ const naslServer = {
             });
             refsList = [...viewRefs.refs];
         }
+        /**
+         * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
+         */
+        if (node instanceof ViewElement) {
+            const code = currentSource.code;
+            const prefix = '__elements.';
+            const prefixIndex = code.indexOf(prefix) !== -1 ? code.indexOf(prefix) : 0;
+            const methodsNameIndex = prefixIndex + prefix.length;
+            const methods = await naslServer.references({
+                file: (fileNode as FileNode).getEmbeddedFilePath(),
+                line: lsp2tspNumber(currentSource.range.start.line),
+                offset: lsp2tspNumber(currentSource.range.start.character + methodsNameIndex),
+            });
+
+            const methodRefs = methods.refs.filter((item) => {
+                if (item.lineText.includes('__elements.') && item.lineText.includes('new nasl.ui.')) {
+                    return false;
+                }
+                if (item.lineText.includes(': <nasl.ui.')) {
+                    return false;
+                }
+                return true;
+            });
+            refsList = [...methodRefs];
+        }
         return refsList;
     },
     /**
@@ -545,6 +676,10 @@ const naslServer = {
                     if (minRange.node instanceof CallLogic && node instanceof Logic) {
                         minRange.setTypeMethods = 'setCalleeName';
                     }
+                    if (minRange.node instanceof CallLogic && node instanceof ViewElement) {
+                        minRange.setTypeMethods = 'setCalleeName';
+                        minRange.newValue = 'elements.' + newValue + '.logics';
+                    }
                     // 如果节点是实体修改引发calllogic修改
                     if (minRange.node instanceof CallLogic && (node instanceof Entity || node instanceof View)) {
                         // 匹配到的内容，当前这一行的内容；
@@ -609,6 +744,11 @@ const naslServer = {
                             minRange.newValue = newTextValue;
                         }
                     }
+                    // 如果修改逻辑，改到了Identifier表达式，只能说明是在属性里有使用了
+                    if (minRange.node instanceof Identifier && node instanceof Logic) {
+                        minRange.newValue = newValue;
+                        minRange.setTypeMethods = 'setName';
+                    }
                     // 如果节点是MemberExpression表达式
                     if (minRange.node instanceof MemberExpression) {
                         // 匹配到的内容，当前这一行的内容；
@@ -711,6 +851,19 @@ const naslServer = {
                             minRange.newValue = newTsNameSpace;
                         }
                     }
+                    if (minRange.node instanceof Interface && node instanceof Logic) {
+                        minRange.setTypeMethods = 'setOriginLogicName';
+                    }
+                    // 如果是role改名,就需要查到变更后的数组
+                    if ((minRange.node instanceof View || minRange.node instanceof ViewElement) && node instanceof Role) {
+                        // oldName旧的节点存的值
+                        // newValue用户输入值
+                        // node.bindRoles 存的
+                        minRange.setTypeMethods = 'setBindRoles';
+                        const str = minRange.node.bindRoles.toString().replace(oldName, newValue);
+                        const newBindRoles = str.split(',');
+                        minRange.newValue = newBindRoles;
+                    }
                     // 枚举修改枚举名，比较特殊
                     if (minRange.node instanceof EnumItem && node instanceof Enum) {
                         // 什么都不做，用来跳过修改
@@ -725,6 +878,10 @@ const naslServer = {
                     if (minRange.node instanceof View && node instanceof View && minRange.node !== node) {
                         return null;
                     }
+                    // 逻辑改名，触发了在定义里面的，element定义，的值，直接掠过
+                    if (minRange.node instanceof View && node instanceof Logic) {
+                        return null;
+                    }
                 } else {
                     console.log('没找到节点需要排查');
                     console.log(record, fileNode.sourceMap);
@@ -920,7 +1077,7 @@ const naslServer = {
         }
     },
     // 获取element方法的可选值
-    getElementsMethod(node: CallLogic | BindEvent, getFieldKey: string) {
+    getFieldKeySelectCompletion(node: BaseNode, fieldKey?: string) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
         console.log(currentSource);
         if (currentSource && fileNode) {
@@ -930,7 +1087,7 @@ const naslServer = {
                     line: lsp2tspNumber(currentSource.range.start.line),
                     offset: lsp2tspNumber(currentSource.range.start.character),
                 },
-                getFieldKey,
+                getFieldKey: fieldKey,
             });
         } else {
             console.log('没找到节点', currentSource, fileNode);
@@ -984,6 +1141,8 @@ BaseNode.prototype.findUsage = function findUsage() {
     }
 };
 BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = false) {
+    console.log(newValue);
+    console.log(this);
     try {
         /**
          * 查找这个节点是不是有依赖
@@ -1068,10 +1227,11 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
         } else {
             // 如果有依赖就有一个查找引用提示
             confirmParms.tipFlag = true;
+            const node = this;
             callback = () => {
                 // removeParam
                 // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
-                if (this instanceof Param) {
+                if (node instanceof Param) {
                     const App = this.rootNode;
                     const logicNode = this.parentNode;
                     // 收集修改
@@ -1092,6 +1252,26 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                     App.emit('collect:end');
                     return;
                 }
+                // 删除logic节点，如果有对应的interface要一起删除
+                if (node instanceof Logic) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start');
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode.sourceMap);
+                        if (minRange) {
+                            if (minRange.node instanceof Interface) {
+                                minRange.node.delete();
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                }
                 // 其余的都直接调用删除
                 this.delete();
             };
@@ -1235,8 +1415,8 @@ async function receiveHandleChange($event: EventPayload) {
     const targetNode = $event.target;
     // 当前操作的文件节点
     const { fileNode } = naslServer.getCurrentSource(targetNode);
-    // 如果是导入模块就，就引入对应模块,先不处理module，下面的内容会自动创建
-    if (fileNode instanceof Module) {
+    // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
+    if (fileNode instanceof Module || fileNode instanceof Configuration) {
         return;
     }
 
@@ -1273,7 +1453,7 @@ embeddedTSEmitter.on('change', ($event: EventPayload) => {
     // 收集到一个行为集合
     const eventValue = $event.value;
     eventValue.forEach((item: EventPayload) => {
-        receiveHandleChange(item);
+        receiveHandleChange(item.originEvent);
     });
 });
 

package/src/server/process2LogicNamespace.ts

@@ -1,4 +1,4 @@
-import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process } from '..';
+import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process, ProcessElement } from '..';
 import { genLaunchProcess, genUserTaskLogic } from './getProcesses';
 
 export function process2LogicNamespace(process: Process) {
@@ -10,11 +10,12 @@ export function process2LogicNamespace(process: Process) {
                 name: e.name,
                 logics: [l],
             });
+            const path = `app.processes.${process.name}.elements.${e.name}.logic`;
             l.getNamespace = function() {
-                return (this.parentNode as Namespace).getNamespace()
+                return path;
             }
             children.push(ns);
-            ns.path = `app.processes.${process.name}.elements.${e.name}.logic`;
+            ns.path = `app.processes.${process.name}.elements.${e.name}`
         }
     });
     const launchLogic = genLaunchProcess(process);
@@ -26,3 +27,43 @@ export function process2LogicNamespace(process: Process) {
     ns.path = `app.processes.${process.name}.logics`;
     return ns;
 }
+
+interface processTreeFragment {
+    level: 'processTreeFragment';
+    name: string,
+    id: string,
+    logics: Array<Logic>,
+    elements: Array<{
+        level: 'processTreeElementFragment',
+        name: string,
+        id: string,
+        logics: Array<Logic>,
+    }>
+}
+
+export function processToTreeFragment(process: Process) {
+    const fragment: processTreeFragment = {
+        level: 'processTreeFragment',
+        name: process.name,
+        id: process.id,
+        logics: [],
+        elements: [],
+    }
+    process.elements.forEach((e) => {
+        if (e.type === 'UserTask') {
+            const l = genUserTaskLogic(e);
+            l.parentKey = 'readonly'
+            fragment.elements.push({
+                level: 'processTreeElementFragment',
+                id: e.id,
+                name: e.name,
+                logics: [l],
+            })
+        }
+    });
+
+    const launchLogic = genLaunchProcess(process);
+    fragment.logics.push(launchLogic);
+    launchLogic.parentKey = 'readonly'
+    return fragment;
+}