@lcap/nasl 1.0.0-alpha.9 → 1.0.2

package/src/server/getMemberIdentifier.ts

@@ -1,4 +1,4 @@
-import { BaseNode, CompletionProperty, App, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param, BindAttribute, LogicItem } from '..';
+import { BaseNode, CompletionProperty, App, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param, BindAttribute, LogicItem, TypeAnnotation } from '..';
 import naslServer from './naslServer';
 
 interface variableItem {
@@ -9,22 +9,155 @@ interface variableItem {
     value?: string;
     expression: MemberExpression | Identifier;
 }
+
+function getCompletionDetailType(displayParts: Array<{ text: string; kind: string }>): TypeAnnotation {
+    // 0: {text: 'let', kind: 'keyword'}
+    // 1: {text: ' ', kind: 'space'}
+    // 2: {text: 'bindRoles', kind: 'text'}
+    // 3: {text: ':', kind: 'punctuation'}
+    // 4: {text: ' ', kind: 'space'}
+    // 5: {text: 'roles', kind: 'moduleName'}
+    // 6: {text: '.', kind: 'punctuation'}
+    // 7: {text: 'DEV_AdminRole', kind: 'enumName'}
+    // 8: {text: '[', kind: 'punctuation'}
+    // 9: {text: ']', kind: 'punctuation'}
+    let str = '';
+    displayParts.forEach((item) => {
+        str += item.text;
+    });
+    const strTypes = str.split(': ');
+    const type = strTypes[1];
+    let typeAnnotation;
+    try {
+        if (type.includes('<') && type.includes('>')) {
+            // 泛型的处理
+            typeAnnotation = createGenericTypeAnnotation(type);
+        } else {
+            typeAnnotation = createType2Annotation(type);
+        }
+    } catch (err) {
+        console.log(err);
+    }
+    return typeAnnotation;
+}
+
+function createGenericTypeAnnotation(type: string) {
+    // 取出匹配的内容
+
+    const childType = type.substring(0, type.indexOf('<'));
+    const typeAnnotation = createType2Annotation(childType);
+    // 如果还有匹配到的多层泛型;
+    // 取出匹配到的内容
+    const types = /\<([^()]+)\>/g.exec(type);
+    const newtext = types[1];
+    // 把匹配的值，的内容在，检索一遍，看是不是泛型套泛型
+    const newTypes = /\<([^()]+)\>/g.exec(newtext);
+    // 如果是的话就去递归
+    if (newTypes) {
+        const argTypeAnnotation = createGenericTypeAnnotation(newtext);
+        typeAnnotation.typeArguments = [argTypeAnnotation];
+    } else {
+        // 如果不是就创造内部的真正类型
+        const argTypeAnnotation = createType2Annotation(newtext);
+        typeAnnotation.typeArguments = [argTypeAnnotation];
+    }
+    return typeAnnotation;
+}
+function createType2Annotation(type: string): TypeAnnotation {
+    let typeAnnotation;
+    // 没有泛型类型的
+    const types = type.split('.');
+    if (types.length === 1) {
+        typeAnnotation = TypeAnnotation.createPrimitive(types[0]);
+    } else {
+        if (type.startsWith('nasl.core')) {
+            typeAnnotation = TypeAnnotation.createPrimitive(types[types.length - 1]);
+        } else if (type.startsWith('nasl.ui')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'nasl.ui',
+            });
+        } else if (type.startsWith('nasl.collection')) {
+            typeAnnotation = TypeAnnotation.createGeneric(types[types.length - 1], {
+                typeNamespace: 'nasl.collection',
+            });
+        } else if (type.startsWith('entities.')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'app.entities',
+            });
+        } else if (type.startsWith('structures.')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'app.structures',
+            });
+        } else if (type.startsWith('enums.')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'app.enums',
+            });
+        }
+    }
+    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;
+}
 // 格式化变量数据
-function formatVariableData(data: unknown | variableItem[], node: BaseNode, parent?: any) {
+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;
+            // 当前结构的typeAnnotation
+            const typeAnnotation = item.completionDetail && getCompletionDetailType(item.completionDetail.displayParts as Array<{ text: string; kind: string }>);
             // 如果没有父节点就是Identifier
             if (!parent) {
                 const identifier = new Identifier({ name: item.name });
+                // 携带上当前的类型
+                identifier.typeAnnotation = typeAnnotation;
                 item.expression = identifier;
             } else {
-                item.expression = new MemberExpression({
+                const memberExpression = new MemberExpression({
                     object: parent.expression,
                     property: new Identifier({ name: item.name }),
                 });
+                // 携带上当前的类型
+                memberExpression.typeAnnotation = typeAnnotation;
+                item.expression = memberExpression;
             }
             if (item.children) {
                 item.children = formatVariableData(item.children, node, item);
@@ -40,14 +173,28 @@ function formatVariableData(data: unknown | variableItem[], node: BaseNode, pare
                 return completionProperty;
             }
         });
+
+        /**
+         * 排序result
+         * 如果没有父级就是第一集就排序一下当前result，用户体验优化
+        */
+        if (!parent) {
+            result = sortFirstVariableData(result, node);
+        }
         return result;
     }
 }
 // 从logic获取节点的icon
 function getNodeiconFromLogic(completionProperty: CompletionProperty, node: BaseNode): string {
     const logic = (node as Param).logic;
+    const view = (node as Param).view;
+    if (view) {
+        const { params } = view;
+        if (params.find((item) => item.name === completionProperty.name))
+            return 'param';
+    }
     if (logic) {
-        const { params, variables, returns } = logic;
+        const { params, returns } = logic;
         if (params.find((item) => item.name === completionProperty.name))
             return 'param';
 
@@ -66,22 +213,28 @@ function getNodeiconFromLogic(completionProperty: CompletionProperty, node: Base
 function formatEnums(enums: Array<Enum>) {
     const result = enums.map((item) => {
         const namespace = item.getNamespace();
-        item.expression = new Identifier({
+        const newItem: any = {
             name: item.name,
-            namespace,
-        });
-        item.children = item.enumItems.map((enumItem) => {
+            value: item.name,
+            expression: new Identifier({
+                name: item.name,
+                namespace,
+            }),
+            children: [],
+        };
+        newItem.children = item.enumItems.map((enumItem) => {
             const newEnumItem: any = { ...enumItem };
-            newEnumItem.name = newEnumItem.value;
             newEnumItem.expression = new MemberExpression({
-                object: item.expression,
+                object: newItem.expression,
                 property: new Identifier({ name: newEnumItem.value }),
             });
+            newEnumItem.name = newEnumItem.value;
+            newEnumItem.value = newItem.value + '.' + newEnumItem.value;
             const completionProperty = new CompletionProperty(newEnumItem);
             completionProperty.icon = 'enumItem';
             return completionProperty;
         });
-        const completionProperty = new CompletionProperty(item as any);
+        const completionProperty = new CompletionProperty(newItem);
         completionProperty.icon = 'enum';
         return completionProperty;
     });
@@ -92,50 +245,76 @@ type LiteralDefination = {
     value: string;
     expression?: Identifier;
 };
-// 先简单处理一下
 function formatLiterals() {
-    const list: Array<LiteralDefination> = [
-        { name: 'null', value: 'null' },
-        { name: 'true', value: 'true' },
-        { name: 'false', value: 'false' },
+    // const list: Array<LiteralDefination> = [
+    //     { name: 'null', value: 'null' },
+    //     { name: 'true', value: 'true' },
+    //     { name: 'false', value: 'false' },
+    // ];
+    // const newList = list.map((item) => {
+    //     item.expression = new Identifier({ name: item.name });
+    //     const completionProperty = new CompletionProperty(item);
+    //     completionProperty.icon = 'literal';
+    //     return completionProperty;
+    // });
+    // return newList;
+    const list = [
+        new CompletionProperty({
+            name: 'null',
+            value: 'null',
+            expression: new NullLiteral(),
+        }),
+        new CompletionProperty({
+            name: 'true',
+            value: 'true',
+            expression: new BooleanLiteral({ value: 'true' }),
+        }),
+        new CompletionProperty({
+            name: 'false',
+            value: 'false',
+            expression: new BooleanLiteral({ value: 'false' }),
+        }),
     ];
-    const newList = list.map((item) => {
-        item.expression = new Identifier({ name: item.name });
-        const completionProperty = new CompletionProperty(item);
-        completionProperty.icon = 'literal';
-        return completionProperty;
+    list.forEach((l) => {
+        l.icon = 'literal';
     });
-    return newList;
+    return list;
 }
 
 function formatGlobalVariable() {
     const newList = [];
     const globalVariable = {
         name: 'userInfo',
+        value: 'userInfo',
         children: [
-            { name: 'Status' },
+            { name: 'Status', value: 'userInfo.Status' },
             { name: 'UserInfoExtend',
+                value: 'userInfo.UserInfoExtend',
                 children: [
-                    { name: 'Company' },
-                    { name: 'JobLevel' },
-                    { name: 'JobNum' },
-                    { name: 'RealName' },
-                    { name: 'JobYear' },
-                ],
-            },
-            { name: 'UserName' },
-            { name: 'Email' },
-            { name: 'UserId' },
-            { name: 'Phone' },
-            { name: 'CreateTime' },
-            { name: 'UpdateTime' },
-            { name: 'LoginCount' },
-            { name: 'Source' },
+                    { name: 'Company', value: 'userInfo.UserInfoExtend.Company' },
+                    { name: 'JobLevel', value: 'userInfo.UserInfoExtend.JobLevel' },
+                    { name: 'JobNum', value: 'userInfo.UserInfoExtend.JobNum' },
+                    { name: 'JobYear', value: 'userInfo.UserInfoExtend.JobYear' },
+                    { name: 'RealName', value: 'userInfo.UserInfoExtend.RealName' },
+                    { name: 'NickName', value: 'userInfo.UserInfoExtend.NickName' },
+                    { name: 'NameAndEmail', value: 'userInfo.UserInfoExtend.NameAndEmail' },
+                    { name: 'Position', value: 'userInfo.UserInfoExtend.Position' },
+                    { name: 'Department', value: 'userInfo.UserInfoExtend.Department' },
+                    { name: 'EmployeeId', value: 'userInfo.UserInfoExtend.EmployeeId' },
+                ] },
+            { name: 'UserName', value: 'userInfo.UserName' },
+            { name: 'Email', value: 'userInfo.Email' },
+            { name: 'UserId', value: 'userInfo.UserId' },
+            { name: 'Phone', value: 'userInfo.Phone' },
+            { name: 'CreateTime', value: 'userInfo.CreateTime' },
+            { name: 'UpdateTime', value: 'userInfo.UpdateTime' },
+            { name: 'LoginCount', value: 'userInfo.LoginCount' },
+            { name: 'Source', value: 'userInfo.Source' },
         ],
     };
     const userInfoIdentifier = new Identifier({
         name: 'userInfo',
-        namespace: 'nasl.brower',
+        namespace: 'nasl.auth',
     });
     const userCompletionProperty = new CompletionProperty({
         name: 'userInfo',
@@ -164,23 +343,23 @@ function formatGlobalVariable() {
                 childProperty.icon = 'literal';
                 children.push(childProperty as any);
             });
-            completionProperty.children = children;
+            completionProperty.children = children as unknown as Array<CompletionProperty>;
         }
         userCompletionProperty.children.push(completionProperty as any);
     });
     return newList;
 }
 
-
 // 获取当前可选的逻辑
 function getCurrentLogic(node: BaseNode,
     result: {
         name: string;
         children: CompletionProperty[];
+        expanded: boolean;
         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) => {
@@ -193,41 +372,37 @@ function getCurrentLogic(node: BaseNode,
             completionProperty.icon = 'logic';
             return completionProperty;
         });
-        result.push({ name: '逻辑', children: logicVariable, icon: 'category' });
+        result.push({ name: '逻辑', children: logicVariable, expanded: true, icon: 'category' });
     }
 }
 
 export async function getMemberIdentifier(node: BaseNode) {
     if (node) {
+        // 获取字面量
+        const literals = getLiteralsIdentifier();
+        if (node.getAncestor('CallQueryComponent'))
+            literals.shift(); // 去除 null
         // 获取枚举
-        const app = node.rootNode as App;
-        const literals = formatLiterals();
-        const enums = app?.enums;
-        const newEnums = enums ? formatEnums(enums) : [];
+        const newEnums = getEnumsIdentifier(node);
 
-        //      extensionModules(state) {
-        // return state.app?.dependencies?.filter((module) => module.type === 'extension') || {};
+        // extensionModules(state) {
+        //   return state.app?.dependencies?.filter((module) => module.type === 'extension') || {};
         // },
 
         // 如果之前有选好的值就需要的把之前那一列的内容渲染出来
         // 先去获取
 
-        let completionData: CompletionProperty[] = [new CompletionProperty({})];
-        if (node instanceof Identifier || node instanceof MemberExpression) {
-            const value = (node as Identifier | MemberExpression).getValue();
-            if (value) {
-                const completion = (await naslServer.getValueSelectCompletion(node, value)) as variableItem[];
-                completionData = formatVariableData(completion, node);
-            }
-        }
-        const globalVariable = formatGlobalVariable();
+        // 获取变量
+        const completionData = await getVariableIdentifier(node);
+        // 获取公共变量
+        const globalVariable: CompletionProperty[] = await getGlobalVariableIdentifier(node);
+
         // 这个可能需要自己算一下
         const result = [
-            { name: '字面量', children: literals, icon: 'category' },
-            { name: '枚举', children: newEnums, icon: 'category' },
-            { name: '变量', children: completionData, icon: 'category' },
-            { name: '全局变量', children: globalVariable, icon: 'category' },
-
+            { name: '字面量', children: literals, expanded: true, icon: 'category' },
+            { name: '枚举', children: newEnums, expanded: true, icon: 'category' },
+            { name: '变量', children: completionData, expanded: true, icon: 'category' },
+            { name: '公共变量', children: globalVariable, expanded: true, icon: 'category' },
             // { name: '流程变量', children: [] },
         ];
         getCurrentLogic(node, result);
@@ -235,9 +410,51 @@ export async function getMemberIdentifier(node: BaseNode) {
     }
 }
 
+// 获取字面量
+export function getLiteralsIdentifier(): CompletionProperty[] {
+    return formatLiterals();
+}
+
+// 获取枚举
+export function getEnumsIdentifier(node: BaseNode): CompletionProperty[] {
+    const app = node.rootNode as App;
+    const enums = app?.enums;
+    const newEnums = enums ? formatEnums(enums) : [];
+    return newEnums;
+}
+
+// 获取变量
+export async function getVariableIdentifier(node: BaseNode): Promise<CompletionProperty[]> {
+    let completionData: CompletionProperty[] = [new CompletionProperty({})];
+    if (node instanceof Identifier || node instanceof MemberExpression) {
+        const value = (node as Identifier | MemberExpression).getValue();
+        if (value) {
+            const completion = (await naslServer.getValueSelectCompletion(node, value)) as variableItem[];
+            completionData = formatVariableData(completion, node);
+        } else {
+            const nextCompletion = await naslServer.getFieldKeySelectCompletion(node, '');
+            completionData = formatVariableData(nextCompletion, node);
+        }
+    } else {
+        const nextCompletion = await naslServer.getFieldKeySelectCompletion(node, '');
+        completionData = formatVariableData(nextCompletion, node);
+    }
+    return completionData;
+}
+
+// 获取公共变量
+export async function getGlobalVariableIdentifier(node: BaseNode):Promise<CompletionProperty[]> {
+    let globalVariable: CompletionProperty[] = [];
+    // 公共变量修改
+    if ((node as any).view) {
+        globalVariable = formatGlobalVariable();
+    }
+    return globalVariable;
+}
+
 export async function getSelectNextCompletionData(node: Identifier, completionProperty?: CompletionProperty) {
     if (node) {
-        let fieldKey: string = null;
+        let fieldKey: string = '';
         if (completionProperty) {
             const exp = BaseNode.from(completionProperty.expression);
             const value = (exp as Identifier).getValue();