@lcap/nasl 1.0.0 → 2.12.0-beta

package/src/server/getProcesses.ts

@@ -1,5 +1,5 @@
 import Constant from '@nasl/concepts/Constant__';
-import { CompletionProperty, Process, ProcessElement, Namespace, Logic, TypeAnnotation, Return, Variable, StructureProperty, Param, Identifier, MemberExpression, LogicItem } from '..';
+import { CompletionProperty, Process, ProcessElement, Namespace, Logic, TypeAnnotation, Return, Variable, StructureProperty, Param, Identifier, MemberExpression, LogicItem, App, BaseNode, Structure, Entity, EntityProperty } from '..';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
 function alphaUpper(name: string) {
     if (!name) {
@@ -156,16 +156,25 @@ export function syncMemberExpression(elem: ProcessElement | Process, callback: (
                     attr.destination.arguments.forEach((arg) => {
                         travelDown(arg.expression, (node) => {
                             if (node instanceof MemberExpression) {
-                                console.log('UserTask', node.getValue());
+                                // console.log('UserTask destination', node.getValue());
+                                callback(node);
+                            }
+                        });
+                    });
+                }
+                if (attr.name === 'assignee') {
+                    attr.assignee.dynamicUsers.forEach((dy) => {
+                        travelDown(dy, (node) => {
+                            if (node instanceof MemberExpression) {
+                                // console.log('UserTask assignee', node.getValue());
                                 callback(node);
-                                // if(node.property.name === oldName) {}
                             }
                         });
                     });
                 }
             });
         }
-        if (el.type === 'ExclusiveGateway') {
+        if (el.type === 'ExclusiveGateway' || el.type === 'AutoTask') {
             travelDown(el.logic, (node) => {
                 if (node instanceof MemberExpression) {
                     console.log('ExclusiveGateway', node.getValue());
@@ -175,8 +184,38 @@ export function syncMemberExpression(elem: ProcessElement | Process, callback: (
         }
     });
 }
+// a.b.c => MemberExpression
+export function genMemberExpression(path: string) {
+    const arr = path.split('.');
+    let m: MemberExpression;
+    while(arr.length) {
+        const ns = arr.shift();
+        const cv = new Identifier({ name: ns });
+        if (!m) {
+            m = new MemberExpression({
+                object: cv,
+            });
+            cv.parentNode = m;
+        } else {
+            m.property = cv;
+            if(arr.length) {
+                const tm = new MemberExpression({
+                    object: m,
+                });
+                m.parentKey = 'object';
+                m.parentNode = tm;
+                cv.parentKey = 'property';
+                cv.parentNode = tm;
+                m = tm;
+            }
+        }
+    }
+
+    return m;
+}
+
 // ['a','b','c'] => a.b.c
-export function genCompletionProperty(prefix: string[] = []):(v: Variable | Param | Return | Constant) => CompletionProperty {
+export function genCompletionProperty(prefix: string[] = []):(v: Variable | Param | Return | Constant | EntityProperty| StructureProperty) => CompletionProperty {
     return (v) => {
         let m: MemberExpression;
         const p = new Identifier({ name: v.name });
@@ -238,7 +277,7 @@ export function getPreviousTask(node: ProcessElement) {
         if (visitedMap.has(processElem)) {
             return;
         }
-        if (processElem !== node && (processElem.type === 'UserTask')) {
+        if (processElem !== node && (processElem.type === 'UserTask' || processElem.type === 'AutoTask')) {
             elements.push(processElem);
         }
         visitedMap.set(processElem, true);
@@ -316,21 +355,21 @@ export function getProcessVariableSuggestions(node: Logic, abandonConstant: bool
         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);
-    // }
+    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;
 }
 
@@ -378,3 +417,174 @@ export function getProcessVaraibleSelections(node: Logic, list: VariableSuggesti
 
     list.splice(varidx, 1, data);
 }
+
+function deduceTypeAnnotation(
+    app: App, 
+    node: Variable | Param | Return | Constant | EntityProperty| StructureProperty,
+    typeA: TypeAnnotation,
+    prefix: string[],
+    records: BaseNode[],
+) {
+    const ns = typeA.typeNamespace;
+    const name = typeA.typeName;
+    const completion = genCompletionProperty(prefix)(node)
+    if(ns.startsWith('nasl')) {
+        return completion;
+    }
+    const nsPath = `${ns}.${name}`;
+
+    const typeNode = getNodeByNodeCallee(app, nsPath);
+    if(records.includes(typeNode)){
+        return null;
+    }
+    if(typeNode) {
+        records.push(typeNode)
+        const children = typeNode.properties.map((p: EntityProperty| StructureProperty) => {
+            return deduceTypeAnnotation(app, p, p.typeAnnotation, prefix.concat([node.name]), records.slice())     
+        }).filter((q: CompletionProperty | null) => !!q);
+        completion.children = children;
+        completion.expanded = true;
+        return completion;
+    }
+}
+
+export function getProcessVariableSuggestionsAll(node: ProcessElement) {
+    const processElem = node;
+    const process = node.process;
+    const app = node.app;
+    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(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], [])),
+               ...us.constants.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], [])),
+            ],
+        });
+        cp.expanded = true;
+        cp.icon = us.type;
+        cp.isProcess = true;
+        return cp;
+    });
+
+    const processVariables = new CompletionProperty({
+        name: process.name,
+        value: process.name,
+        noFurther: true,
+        children: [
+            ...process.params.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
+            ...process.returns.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
+            ...process.constants.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
+            ...prevtasks,
+        ],
+    });
+    processVariables.expanded = true;
+    processVariables.icon = 'Process';
+    if (processElem.type === 'ExclusiveGateway') {
+        const scopeVariable = new CompletionProperty({
+            name: processElem.name,
+            value: processElem.name,
+            icon: processElem.type,
+            noFurther: true,
+            children: processElem.variables.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
+        });
+        scopeVariable.expanded = true;
+        scopeVariable.isProcess = true;
+        scopeVariable.icon = processElem.type;
+        processVariables.children.push(scopeVariable);
+    }
+
+    if (processElem.type === 'UserTask') {
+        const scopeVariable = new CompletionProperty({
+            name: processElem.name,
+            value: processElem.name,
+            icon: processElem.type,
+            noFurther: true,
+            children: processElem.constants.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
+        });
+        scopeVariable.expanded = true;
+        scopeVariable.isProcess = true;
+        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(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
+                ...processElem.returns.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
+            ]
+        });
+        scopeVariable.expanded = true;
+        scopeVariable.isProcess = true;
+        scopeVariable.icon = processElem.type;
+        processVariables.children.push(scopeVariable);
+    }
+    return processVariables;
+}
+
+
+export function getFlowAfterElements(el: ProcessElement) {
+    const process = el.process;
+    const processname = el.name;
+    const elems = process.elements;
+    const links = elems.filter(e => e.type === 'SequenceFlow' && e.sourceRef === processname);
+    return links;
+}
+
+export function isFromStartNode(el: ProcessElement) {
+    const process = el.process;
+    // const processname = el.name;
+    const elems = process.elements;
+    const set = new WeakSet();
+    const stack = [el];
+    while(stack.length){
+        let t = stack.shift();
+        let name = t.name;
+        if(t.type === 'StartNoneEvent') {
+            return true;
+        }
+        elems.forEach(e => {
+            if(e.type === 'SequenceFlow' 
+                && e.targetRef === name 
+                && !set.has(e)) {
+                set.add(e);
+                const sourcename = e.sourceRef;
+                const source = elems.find(e => e.name === sourcename);
+                stack.push(source);
+            }
+        });
+    }
+    return false;
+}
+
+export function findNodeAfterNodeInFlow(el: ProcessElement) {
+    const process = el.process;
+    const elems = process.elements;
+    const set = new WeakSet();
+    const nodeSet = new Set();
+    const stack = [el];
+    while(stack.length){
+        let t = stack.shift();
+        if(el !== t) {
+            nodeSet.add(t);
+        }
+        const name = t.name;
+        elems.forEach(e => {
+            if(e.type === 'SequenceFlow' 
+                && e.sourceRef === name 
+                && !set.has(e)) {
+                set.add(e);
+                const targetname = e.targetRef;
+                const source = elems.find(e => e.name === targetname);
+                stack.push(source);
+            }
+        });
+    }
+    return Array.from(nodeSet);
+}

package/src/server/getScope.ts

@@ -1,50 +1,67 @@
-import { Logic, View, Process } from "..";
+import { Logic, View, Process } from '..';
 
 type wordScope = {
     Param?: string[]
     Return?: string[]
     Variable?: string[]
     Constant?: string[]
+    Logic?: string[]
 }
 
-export function getLogicScopeWords(logic: Logic): wordScope{
+export function getLogicScopeWords(logic: Logic): wordScope {
     const scope: wordScope = {
-        Param: logic.params.map(p => p.name),
-        Return: logic.returns.map(p => p.name),
-        Variable: logic.variables.map(p => p.name),
-    }
+        Param: logic.params.map((p) => p.name),
+        Return: logic.returns.map((p) => p.name),
+        Variable: logic.variables.map((p) => p.name),
+        Constant: [],
+        Logic: []
+    };
     return scope;
 }
 
-export function getViewScopeWords(view: View): wordScope{
+export function getViewScopeWords(view: View): wordScope {
     const scope: wordScope = {
-        Param: view.params.map(p => p.name),
-        // returns: View.returns.map(p => p.name),
-        Variable: view.variables.map(p => p.name),
-    }
+        Param: view.params.map((p) => p.name),
+        Variable: view.variables.map((p) => p.name),
+        Return: [],
+        Constant: [],
+        Logic: view.logics.map(l => l.name),
+    };
     return scope;
 }
 
-export function getProcessScopeWords(process: Process): wordScope{
+export function getProcessScopeWords(process: Process): wordScope {
     const processName = process.name;
     const scope: wordScope = {
-        Param: process.params.map(p => `${processName}.${p.name}`),
-        Return: process.returns.map(p => `${processName}.${p.name}`),
-        Constant: process.constants.map(p => `${processName}.${p.name}`),
+        Param: process.params.map((p) => `${processName}.${p.name}`),
+        Return: process.returns.map((p) => `${processName}.${p.name}`),
+        Constant: process.constants.map((p) => `${processName}.${p.name}`),
         Variable: [],
-    }
+        Logic: []
+    };
 
-    process.elements.forEach(el => {
+    process.elements.forEach((el) => {
         const elname = el.name;
-        el.variables.forEach(v => {
-            scope.Variable.push(`${processName}.${elname}.${v.name}`)
+        el.variables.forEach((v) => {
+            scope.Variable.push(`${processName}.${elname}.${v.name}`);
         });
-        el.returns.forEach(v => {
-            scope.Return.push(`${processName}.${elname}.${v.name}`)
+        el.returns.forEach((v) => {
+            scope.Return.push(`${processName}.${elname}.${v.name}`);
         });
-        el.constants.forEach(v => {
-            scope.Constant.push(`${processName}.${elname}.${v.name}`)
+        el.constants.forEach((v) => {
+            scope.Constant.push(`${processName}.${elname}.${v.name}`);
         });
-    })
+    });
+    return scope;
+}
+
+export function combineScope(a: wordScope, b: wordScope) : wordScope {
+    const scope: wordScope = {
+        Param: [...a.Param, ...b.Param],
+        Return: [...a.Return, ...b.Return],
+        Constant: [...a.Constant, ...b.Constant],
+        Variable: [...a.Variable, ...b.Variable],
+        Logic: [...a.Logic, ...b.Logic],
+    };
     return scope;
 }

package/src/server/index.ts

@@ -12,6 +12,7 @@ import {
     getSelectNextCompletionData,
 } from './getMemberIdentifier';
 import naslServer from './naslServer';
+import './extendBaseNode';
 
 const server: any = {
     ...naslServer,