@lcap/nasl 1.0.0-alpha.13 → 1.0.0-alpha.16

package/src/server/getMemberIdentifier.ts

@@ -27,7 +27,6 @@ function getCompletionDetailType(displayParts: Array<{ text: string; kind: strin
     });
     const strTypes = str.split(': ');
     const type = strTypes[1];
-    console.log(type);
     let typeAnnotation;
     try {
         if (type.includes('<') && type.includes('>')) {
@@ -167,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;
     });
@@ -233,22 +238,31 @@ function formatGlobalVariable() {
     const newList = [];
     const globalVariable = {
         name: 'userInfo',
+        value: 'userInfo',
         children: [
-            { name: 'Status' },
-            { name: '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: '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: 'RealName', value: 'userInfo.UserInfoExtend.RealName' },
+                    { name: 'JobYear', value: 'userInfo.UserInfoExtend.JobYear' },
+                ] },
+            { 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.browser',
+        namespace: 'nasl.auth',
     });
     const userCompletionProperty = new CompletionProperty({
         name: 'userInfo',
@@ -312,45 +326,31 @@ function getCurrentLogic(node: BaseNode,
 
 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);
-            } else {
-                const nextCompletion = await naslServer.getFieldKeySelectCompletion(node, '');
-                completionData = formatVariableData(nextCompletion, node);
-            }
-        } else {
-            const nextCompletion = await naslServer.getFieldKeySelectCompletion(node, '');
-            completionData = formatVariableData(nextCompletion, node);
-        }
-        let globalVariable: CompletionProperty[] = [];
-        // 全局变量修改
-        if ((node as any).view) {
-            globalVariable = formatGlobalVariable();
-        }
+        // 获取变量
+        const completionData = await getVariableIdentifier(node);
+        // 获取公共变量
+        const globalVariable: CompletionProperty[] = await getGlobalVariableIdentifier(node);
+
         // 这个可能需要自己算一下
         const result = [
             { 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: globalVariable, expanded: true, icon: 'category' },
             // { name: '流程变量', children: [] },
         ];
         getCurrentLogic(node, result);
@@ -358,6 +358,48 @@ 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 = '';

package/src/server/getProcesses.ts

@@ -20,6 +20,10 @@ export function genLaunchProcess(process: Process) {
             }),
         ],
     });
+    const path = `process.${process.name}.logics`;
+    l.getNamespace = function() {
+        return path;
+    }
     l.fake = true;
     return l;
 }
@@ -61,6 +65,10 @@ export function genUserTaskLogic(userTask: ProcessElement) {
         body: [],
         returns: [],
     });
+    const path = `elements.${userTask.name}.logics`;
+    l.getNamespace = function() {
+        return path;
+    }
     l.fake = true;
     return l;
 }
@@ -221,7 +229,7 @@ export function genCompletionProperty(prefix: string[] = []):(v: Variable | Para
     };
 }
 
-export function getPreviousUserTask(node: ProcessElement) {
+export function getPreviousTask(node: ProcessElement) {
     const process = node.process;
     const elems = process.elements;
     const elements: ProcessElement[] = [];
@@ -230,15 +238,15 @@ export function getPreviousUserTask(node: ProcessElement) {
         if (visitedMap.has(processElem)) {
             return;
         }
+        if (processElem !== node && (processElem.type === 'UserTask')) {
+            elements.push(processElem);
+        }
         visitedMap.set(processElem, true);
         const links = elems.filter((e) => e.type === 'SequenceFlow' && e.targetRef === processElem.name);
         links.forEach((l) => {
             const s = l.sourceRef;
             const t = elems.find((el) => el.name === s);
             if (t) {
-                if (t.type === 'UserTask') {
-                    elements.push(t);
-                }
                 iterator(t);
             }
         });
@@ -248,22 +256,22 @@ export function getPreviousUserTask(node: ProcessElement) {
     return elements;
 }
 
-export function getProcessVariableSuggestions(node: Logic): CompletionProperty {
+export function getProcessVariableSuggestions(node: Logic, abandonConstant: boolean = false): CompletionProperty {
     if (!node.processElement) {
         return;
     }
     const processElem = node.processElement;
     const process = node.process;
 
-    const elements: ProcessElement[] = getPreviousUserTask(processElem);
-    const usertasks = elements.map((us) => {
+    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(genCompletionProperty([process.name, us.name])),
-                ...us.constants.map(genCompletionProperty([process.name, us.name])),
+                ...(abandonConstant ? [] : us.constants.map(genCompletionProperty([process.name, us.name]))),
             ],
         });
         cp.icon = us.type;
@@ -279,7 +287,7 @@ export function getProcessVariableSuggestions(node: Logic): CompletionProperty {
             ...process.params.map(genCompletionProperty([process.name])),
             ...process.returns.map(genCompletionProperty([process.name])),
             ...process.constants.map(genCompletionProperty([process.name])),
-            ...usertasks,
+            ...prevtasks,
         ],
     });
     processVariables.icon = 'Process';
@@ -308,6 +316,21 @@ export function getProcessVariableSuggestions(node: Logic): CompletionProperty {
         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;
 }
 

package/src/server/index.ts

@@ -3,7 +3,14 @@ import { getInterfaces } from './getInterfaces';
 import { getFunctions, getBuildInFunction } from './getFunctions';
 import { getValidates, getValidateFunction } from './getValidates';
 import { getProcessComponents, getProcessComponent } from './getProcessComponents';
-import { getMemberIdentifier, getSelectNextCompletionData } from './getMemberIdentifier';
+import {
+    getMemberIdentifier,
+    getVariableIdentifier,
+    getEnumsIdentifier,
+    getGlobalVariableIdentifier,
+    getLiteralsIdentifier,
+    getSelectNextCompletionData,
+} from './getMemberIdentifier';
 import naslServer from './naslServer';
 
 const server: any = {
@@ -19,5 +26,9 @@ const server: any = {
     getValidates,
     getValidateFunction,
     getSelectNextCompletionData,
+    getVariableIdentifier,
+    getEnumsIdentifier,
+    getGlobalVariableIdentifier,
+    getLiteralsIdentifier,
 };
 export default server;