@lcap/nasl 1.0.0-alpha.8 → 1.0.1

package/src/server/getMemberIdentifier.ts

@@ -1,4 +1,4 @@
-import { BaseNode, CompletionProperty, App, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param, BindAttribute } from '..';
+import { BaseNode, CompletionProperty, App, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param, BindAttribute, LogicItem, TypeAnnotation } from '..';
 import naslServer from './naslServer';
 
 interface variableItem {
@@ -9,22 +9,116 @@ 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;
+}
 // 格式化变量数据
-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) => {
             // 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);
@@ -46,8 +140,14 @@ function formatVariableData(data: unknown | variableItem[], node: BaseNode, pare
 // 从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 +166,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,32 +198,117 @@ 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() {
-    return [];
+    const newList = [];
+    const globalVariable = {
+        name: 'userInfo',
+        value: 'userInfo',
+        children: [
+            { name: 'Status', value: 'userInfo.Status' },
+            { name: 'UserInfoExtend',
+                value: 'userInfo.UserInfoExtend',
+                children: [
+                    { 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.auth',
+    });
+    const userCompletionProperty = new CompletionProperty({
+        name: 'userInfo',
+        expression: userInfoIdentifier,
+        children: [],
+    });
+    userCompletionProperty.icon = 'variable';
+    newList.push(userCompletionProperty);
+    globalVariable.children.forEach((item) => {
+        const expression = new MemberExpression({
+            object: userInfoIdentifier,
+            property: new Identifier({ name: item.name }),
+        });
+        (item as any).expression = expression;
+        const completionProperty = new CompletionProperty(item as any);
+        completionProperty.icon = 'literal';
+        if (item.children) {
+            const children: LogicItem[] = [];
+            item.children.forEach((child) => {
+                const childExpression = new MemberExpression({
+                    object: expression,
+                    property: new Identifier({ name: child.name }),
+                });
+                (child as any).expression = childExpression;
+                const childProperty = new CompletionProperty(child as any);
+                childProperty.icon = 'literal';
+                children.push(childProperty as any);
+            });
+            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可以
@@ -134,41 +325,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);
@@ -176,9 +363,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();