@lcap/nasl 3.2.0-beta.3 → 3.3.0-alpha

package/src/server/getProcesses.ts

@@ -1,632 +1,646 @@
 import Constant from '../concepts/Constant__';
-import { CompletionProperty, Process, ProcessElement, Namespace, Logic, TypeAnnotation, Return, Variable, StructureProperty, Param, Identifier, MemberExpression, LogicItem, App, BaseNode, Structure, Entity, EntityProperty } 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';
 import { isNoChildType, nextFindTypeChild } from './formatTsUtils';
+
 function alphaUpper(name: string) {
-    if (!name) {
-        return '';
-    }
-    return `${name[0].toUpperCase()}${name.substring(1)}`;
+  if (!name) {
+    return '';
+  }
+  return `${name[0].toUpperCase()}${name.substring(1)}`;
 }
 
 export function genLaunchProcess(process: Process) {
-    const l: Logic = new Logic({
-        name: 'launch',
-        params: process.params,
-        body: [],
-        returns: [
-            new Return({
-                name: 'processId',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-        ],
-    });
-    const path = `app.processes.${process.name}.logics`;
-    l.getNamespace = function () {
-        return path;
-    };
-    l.fake = true;
-    return l;
+  const l: Logic = new Logic({
+    name: 'launch',
+    params: process.params,
+    body: [],
+    returns: [
+      new Return({
+        name: 'processId',
+        typeAnnotation: TypeAnnotation.createPrimitive('String'),
+      }),
+    ],
+  });
+  const path = `app.processes.${process.name}.logics`;
+  l.getNamespace = function () {
+    return path;
+  };
+  l.fake = true;
+  return l;
 }
 
 export function process2LogicNamespace(process: Process) {
-    const ns = new Namespace({
-        name: process.name,
-        logics: [genLaunchProcess(process)],
-    });
+  const ns = new Namespace({
+    name: process.name,
+    logics: [genLaunchProcess(process)],
+  });
 
-    return ns;
+  return ns;
 }
 
 export function returnToParam(r: Return) {
-    const obj = r.toJSON() as { concept: string };
-    delete obj.concept;
-    return Param.from(obj);
+  const obj = r.toJSON() as { concept: string };
+  delete obj.concept;
+  return Param.from(obj);
 }
 
 function variableToParam(v: Variable) {
-    const obj = v.toJSON() as { concept: string };
-    delete obj.concept;
-    return Param.from(obj);
+  const obj = v.toJSON() as { concept: string };
+  delete obj.concept;
+  return Param.from(obj);
 }
 
 export function constantToParam(v: Constant) {
-    const obj = v.toJSON() as { concept: string };
-    delete obj.concept;
-    // console.log(Param.from(obj));
-    return Param.from(obj);
+  const obj = v.toJSON() as { concept: string };
+  delete obj.concept;
+  // console.log(Param.from(obj));
+  return Param.from(obj);
 }
 
 export function genUserTaskLogic(userTask: ProcessElement) {
-    const taskId = userTask.constants.find((p) => p.name === 'taskId');
-    const process = userTask.process;
-    const l = [
-        new Logic({
-            name: `complete`,
-            fake: true,
-            params: [constantToParam(taskId), ...userTask.returns.map(returnToParam)],
-            body: [],
-            returns: [],
+  const taskId = userTask.constants.find((p) => p.name === 'taskId');
+  const { process } = userTask;
+  const l = [
+    new Logic({
+      name: `complete`,
+      fake: true,
+      params: [constantToParam(taskId), ...userTask.returns.map(returnToParam)],
+      body: [],
+      returns: [],
+    }),
+    new Logic({
+      name: `reject`,
+      fake: true,
+      params: [
+        new Param({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
         }),
-        new Logic({
-            name: `reject`,
-            fake: true,
-            params: [
-                new Param({
-                    name: 'taskId',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                }),
-                new Param({
-                    name: 'targetTaskDefinitionId',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                }),
-                ...userTask.returns.map(returnToParam),
-            ],
-            body: [],
-            returns: [],
+        new Param({
+          name: 'targetTaskDefinitionId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
         }),
-    ];
-    if (userTask.type === 'InitiateTask')
-        l.pop();
-    const path = `app.processes.${process.name}.elements.${userTask.name}.logics`;
-    l.forEach((item) => {
-        item.getNamespace = function () {
-            return path;
-        };
-        item.fake = true;
-    });
-    return l;
+        ...userTask.returns.map(returnToParam),
+      ],
+      body: [],
+      returns: [],
+    }),
+  ];
+  if (userTask.type === 'InitiateTask') l.pop();
+  const path = `app.processes.${process.name}.elements.${userTask.name}.logics`;
+  l.forEach((item) => {
+    item.getNamespace = function () {
+      return path;
+    };
+    item.fake = true;
+  });
+  return l;
 }
 
 export function userTask2LogicNamespace(userTask: ProcessElement) {
-    const ns = new Namespace({
-        name: userTask.name,
-        logics: [...genUserTaskLogic(userTask)],
-    });
+  const ns = new Namespace({
+    name: userTask.name,
+    logics: [...genUserTaskLogic(userTask)],
+  });
 
-    return ns;
+  return ns;
 }
 
 type CompletionData = {
-    name: string;
-    concept: string;
-    value: string;
-    selectable?: boolean;
-    children: Array<CompletionData>;
+  name: string;
+  concept: string;
+  value: string;
+  selectable?: boolean;
+  children: Array<CompletionData>;
 };
 type Suggestion = {
-    name: string;
-    children: Array<CompletionProperty | CompletionData>;
+  name: string;
+  children: Array<CompletionProperty | CompletionData>;
 };
 type VariableSuggestion = Array<Suggestion>;
 
 type CompletionPropertyEnhance = CompletionProperty & {
-    children?: Array<CompletionProperty>;
+  children?: Array<CompletionProperty>;
 };
 const excludeKey = [
-    'app',
-    'module',
-    'structure',
-    'enumeration',
-    'entity',
-    'view',
-    'viewElement',
-    'processElement',
-    'element',
-    'viewComponent',
-    'logic',
-    'process',
-    'interface',
-    'nodePath',
-    'upperNode',
-    'rootNode',
-    'parentNode',
+  'app',
+  'module',
+  'structure',
+  'enumeration',
+  'entity',
+  'view',
+  'viewElement',
+  'processElement',
+  'element',
+  'viewComponent',
+  'logic',
+  'process',
+  'interface',
+  'nodePath',
+  'upperNode',
+  'rootNode',
+  'parentNode',
 ];
 export function travelDown(node: any, callback: (node: any) => void) {
-    const stack = [node];
-    const checked = new WeakSet();
-    while (stack.length) {
-        const n = stack.pop();
-        if (!n) {
-            continue;
-        }
-        checked.add(n);
-        callback(n);
-        for (const k in n) {
-            if (!excludeKey.includes(k) && n.hasOwnProperty(k)) {
-                const t = n[k];
-                if (t && typeof t === 'object' && !checked.has(t)) {
-                    if (Array.isArray(t)) {
-                        for (const q in t) {
-                            const w = t[q];
-                            if (typeof w === 'object') {
-                                stack.push(w);
-                            }
-                        }
-                    } else {
-                        stack.push(t);
-                    }
-                }
+  const stack = [node];
+  const checked = new WeakSet();
+  while (stack.length) {
+    const n = stack.pop();
+    if (!n) {
+      continue;
+    }
+    checked.add(n);
+    callback(n);
+    for (const k in n) {
+      if (!excludeKey.includes(k) && n.hasOwnProperty(k)) {
+        const t = n[k];
+        if (t && typeof t === 'object' && !checked.has(t)) {
+          if (Array.isArray(t)) {
+            for (const q in t) {
+              const w = t[q];
+              if (typeof w === 'object') {
+                stack.push(w);
+              }
             }
+          } else {
+            stack.push(t);
+          }
         }
+      }
     }
+  }
 }
 
 export function syncMemberExpression(elem: ProcessElement | Process, callback: (node: MemberExpression) => void) {
-    const process = elem instanceof Process ? elem : elem.process;
-    process.elements.forEach((el) => {
-        if (el.isUserTask) {
-            el.bindAttrs.forEach((attr) => {
-                if (attr.name === 'destination') {
-                    attr.destination.arguments.forEach((arg) => {
-                        travelDown(arg.expression, (node) => {
-                            if (node instanceof MemberExpression) {
-                                // 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);
-                            }
-                        });
-                    });
-                }
+  const process = elem instanceof Process ? elem : elem.process;
+  process.elements.forEach((el) => {
+    if (el.isUserTask) {
+      el.bindAttrs.forEach((attr) => {
+        if (attr.name === 'destination') {
+          attr.destination.arguments.forEach((arg) => {
+            travelDown(arg.expression, (node) => {
+              if (node instanceof MemberExpression) {
+                // console.log('UserTask destination', node.getValue());
+                callback(node);
+              }
             });
+          });
         }
-        if (el.type === 'ExclusiveGateway' || el.type === 'AutoTask') {
-            travelDown(el.logic, (node) => {
-                if (node instanceof MemberExpression) {
-                    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 (el.type === 'ExclusiveGateway' || el.type === 'AutoTask') {
+      travelDown(el.logic, (node) => {
+        if (node instanceof MemberExpression) {
+          callback(node);
+        }
+      });
+    }
+  });
 }
 // 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.parentKey = 'object';
-            cv.parentNode = m;
-        } else {
-            m.property = cv;
-            cv.parentKey = 'property';
-            cv.parentNode = m;
-            if (arr.length) {
-                const tm = new MemberExpression({
-                    object: m,
-                });
-                m.parentKey = 'object';
-                m.parentNode = tm;
-                m = tm;
-            }
-        }
+  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.parentKey = 'object';
+      cv.parentNode = m;
+    } else {
+      m.property = cv;
+      cv.parentKey = 'property';
+      cv.parentNode = m;
+      if (arr.length) {
+        const tm = new MemberExpression({
+          object: m,
+        });
+        m.parentKey = 'object';
+        m.parentNode = tm;
+        m = tm;
+      }
     }
+  }
 
-    return m;
+  return m;
 }
 
 // ['a','b','c'] => a.b.c
-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 });
-        const t = prefix.slice();
-        const q = prefix.slice();
-        while (q.length) {
-            const ns = q.shift();
-            let cv;
-            if (v?.parentNode?.parentNode?.concept === 'BackendVariable') {
-                cv = new Identifier({ name: ns, namespace: 'app.backend.variables' });
-            } else {
-                cv = new Identifier({ name: ns });
-            }
-            if (!m) {
-                m = new MemberExpression({
-                    object: cv,
-                });
-                cv.parentNode = m;
-            } else {
-                m.property = cv;
-                const tm = new MemberExpression({
-                    object: m,
-                });
-                m.parentKey = 'object';
-                m.parentNode = tm;
-                cv.parentKey = 'property';
-                cv.parentNode = tm;
-                m = tm;
-            }
-        }
-        if (m) {
-            m.property = p;
-            p.parentNode = m;
-            p.parentKey = 'property';
-        }
-        let prevalue = '';
-        if (t.length) {
-            prevalue = `${t.join('.')}.`;
-        }
-        const noChildType = v.typeAnnotation ? isNoChildType(v.typeAnnotation.typeKey) : true;
-        const item = {
-            expression: m || p,
-            name: v.name,
-            value: prevalue + v.name,
-        };
-
-        if (!noChildType) {
-            nextFindTypeChild(v.typeAnnotation.typeKey, item, v);
-        }
-
-        const cp = new CompletionProperty(item);
-        console.log(cp.value, v);
-        cp.icon = v.concept;
-        return cp;
+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 });
+    const t = prefix.slice();
+    const q = prefix.slice();
+    while (q.length) {
+      const ns = q.shift();
+      let cv;
+      if (v?.parentNode?.parentNode?.concept === 'BackendVariable') {
+        cv = new Identifier({ name: ns, namespace: 'app.backend.variables' });
+      } else {
+        cv = new Identifier({ name: ns });
+      }
+      if (!m) {
+        m = new MemberExpression({
+          object: cv,
+        });
+        cv.parentNode = m;
+      } else {
+        m.property = cv;
+        const tm = new MemberExpression({
+          object: m,
+        });
+        m.parentKey = 'object';
+        m.parentNode = tm;
+        cv.parentKey = 'property';
+        cv.parentNode = tm;
+        m = tm;
+      }
+    }
+    if (m) {
+      m.property = p;
+      p.parentNode = m;
+      p.parentKey = 'property';
+    }
+    let prevalue = '';
+    if (t.length) {
+      prevalue = `${t.join('.')}.`;
+    }
+    const noChildType = v.typeAnnotation ? isNoChildType(v.typeAnnotation.typeKey) : true;
+    const item = {
+      expression: m || p,
+      name: v.name,
+      value: prevalue + v.name,
     };
+
+    if (!noChildType) {
+      nextFindTypeChild(v.typeAnnotation.typeKey, item, v);
+    }
+
+    const cp = new CompletionProperty(item);
+    console.log(cp.value, v);
+    cp.icon = v.concept;
+    return cp;
+  };
 }
 
 export function getPreviousTask(node: ProcessElement, nodePorcess?: Process) {
-    const process = node.process || nodePorcess;
-    const elems = process.elements;
-    const elements: ProcessElement[] = [];
-    const visitedMap = new WeakMap();
-    function iterator(processElem: ProcessElement) {
-        if (visitedMap.has(processElem)) {
-            return;
-        }
-        if (processElem !== node && (processElem.isUserTask || processElem.type === 'AutoTask')) {
-            elements.push(processElem);
-        }
-        visitedMap.set(processElem, true);
-        let links = [];
-        if (processElem.parentNode?.concept === 'BindEvent' || processElem.parentNode?.concept === 'Assignee') {
-            const elemParentNode = processElem.getAncestor('ProcessElement') || processElem.getAncestor('Process');
-            links = elems.filter((e) => e.type === 'SequenceFlow' && e.targetRef === elemParentNode.name); //流程事件api逻辑名字与任务名字不同，需要重新适配
-        } else
-            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) {
-                iterator(t);
-            }
-        });
+  const process = node.process || nodePorcess;
+  const elems = process.elements;
+  const elements: ProcessElement[] = [];
+  const visitedMap = new WeakMap();
+  function iterator(processElem: ProcessElement) {
+    if (visitedMap.has(processElem)) {
+      return;
+    }
+    if (processElem !== node && (processElem.isUserTask || processElem.type === 'AutoTask')) {
+      elements.push(processElem);
     }
+    visitedMap.set(processElem, true);
+    let links = [];
+    if (processElem.parentNode?.concept === 'BindEvent' || processElem.parentNode?.concept === 'Assignee') {
+      const elemParentNode = processElem.getAncestor('ProcessElement') || processElem.getAncestor('Process');
+      links = elems.filter((e) => e.type === 'SequenceFlow' && e.targetRef === elemParentNode.name); // 流程事件api逻辑名字与任务名字不同，需要重新适配
+    } else 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) {
+        iterator(t);
+      }
+    });
+  }
 
-    iterator(node);
-    return elements;
+  iterator(node);
+  return elements;
 }
 
 export function getProcessVariableSuggestions(node: LogicItem, abandonConstant: boolean = false): CompletionProperty {
-    // if (!node.processElement) {
-    //     return;
-    // }
-    //流程下的callback没有processElement
-    const tempPorcessEle = new ProcessElement({});
-    const processElem = node.processElement || tempPorcessEle;
-    const process = node.process;
-
-    const elements: ProcessElement[] = getPreviousTask(processElem, process);
-    const prevtasks = elements.map((us) => {
-        const cp = new CompletionProperty({
-            name: us.name,
-            value: us.name,
-            children: [
-                ...us.returns.map(genCompletionProperty([process.name, us.name])),
-                ...(abandonConstant ? [] : us.constants.map(genCompletionProperty([process.name, us.name]))),
-            ],
-        });
-        cp.icon = us.type;
-        cp.isProcess = true;
-        return cp;
+  // if (!node.processElement) {
+  //     return;
+  // }
+  // 流程下的callback没有processElement
+  const tempPorcessEle = new ProcessElement({});
+  const processElem = node.processElement || tempPorcessEle;
+  const { process } = node;
+
+  const elements: ProcessElement[] = getPreviousTask(processElem, process);
+  const prevtasks = elements.map((us) => {
+    const cp = new CompletionProperty({
+      name: us.name,
+      value: us.name,
+      children: [
+        ...us.returns.map(genCompletionProperty([process.name, us.name])),
+        ...(abandonConstant ? [] : us.constants.map(genCompletionProperty([process.name, us.name]))),
+      ],
     });
-
-    const processVariables = new CompletionProperty({
-        name: process.name,
-        value: process.name,
-        children: [
-            ...process.params.map(genCompletionProperty([process.name])),
-            ...process.returns.map(genCompletionProperty([process.name])),
-            ...process.constants.map(genCompletionProperty([process.name])),
-            ...prevtasks,
-        ],
+    cp.icon = us.type;
+    cp.isProcess = true;
+    return cp;
+  });
+
+  const processVariables = new CompletionProperty({
+    name: process.name,
+    value: process.name,
+    children: [
+      ...process.params.map(genCompletionProperty([process.name])),
+      ...process.returns.map(genCompletionProperty([process.name])),
+      ...process.constants.map(genCompletionProperty([process.name])),
+      ...prevtasks,
+    ],
+  });
+  processVariables.icon = 'Process';
+  if (processElem.type === 'ExclusiveGateway') {
+    const scopeVariable = new CompletionProperty({
+      name: processElem.name,
+      value: processElem.name,
+      icon: processElem.type,
+      children: processElem.variables.map(genCompletionProperty([process.name, processElem.name])),
     });
-    processVariables.icon = 'Process';
-    if (processElem.type === 'ExclusiveGateway') {
-        const scopeVariable = new CompletionProperty({
-            name: processElem.name,
-            value: processElem.name,
-            icon: processElem.type,
-            children: processElem.variables.map(genCompletionProperty([process.name, processElem.name])),
-        });
-        scopeVariable.isProcess = true;
-        scopeVariable.icon = processElem.type;
-        processVariables.children.push(scopeVariable);
-    }
-
-    if (processElem.isUserTask) {
-        // 任务完成时可以拿到该任务的输出参数
-        let returns: CompletionProperty[] = [];
-        if (node.logic && node.logic.parentNode.name === 'OnClose') {
-            returns = processElem.returns.map(genCompletionProperty([process.name, processElem.name]));
-        }
-        const scopeVariable = new CompletionProperty({
-            name: processElem.name,
-            value: processElem.name,
-            icon: processElem.type,
-            children: [
-                ...returns,
-                ...processElem.constants.map(genCompletionProperty([process.name, processElem.name])),
-            ],
-        });
-        scopeVariable.isProcess = true;
-        scopeVariable.icon = processElem.type;
-        processVariables.children.push(scopeVariable);
+    scopeVariable.isProcess = true;
+    scopeVariable.icon = processElem.type;
+    processVariables.children.push(scopeVariable);
+  }
+
+  if (processElem.isUserTask) {
+    // 任务完成时可以拿到该任务的输出参数
+    let returns: CompletionProperty[] = [];
+    if (node.logic && node.logic.parentNode.name === 'OnClose') {
+      returns = processElem.returns.map(genCompletionProperty([process.name, processElem.name]));
     }
-    if (processElem.type === 'AutoTask') {
-        const scopeVariable = new CompletionProperty({
-            name: processElem.name,
-            value: processElem.name,
-            icon: processElem.type,
-            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;
+    const scopeVariable = new CompletionProperty({
+      name: processElem.name,
+      value: processElem.name,
+      icon: processElem.type,
+      children: [...returns, ...processElem.constants.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,
+      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;
 }
 
 export function getProcessVaraibleSelections(node: Logic, list: VariableSuggestion) {
-    const process = node.process;
-    const processElem = node.processElement;
-    const exsitNames = processElem.getVarExistingNames();
-
-    const data: Suggestion = {
-        name: '流程变量',
-        children: [],
-    };
-    const processData: CompletionData = {
-        name: process.name,
-        concept: 'Process',
-        value: process.name,
-        selectable: false,
-        children: [],
+  const { process } = node;
+  const processElem = node.processElement;
+  const exsitNames = processElem.getVarExistingNames();
+
+  const data: Suggestion = {
+    name: '流程变量',
+    children: [],
+  };
+  const processData: CompletionData = {
+    name: process.name,
+    concept: 'Process',
+    value: process.name,
+    selectable: false,
+    children: [],
+  };
+  data.children.push(processData);
+  const vars = list.find((i) => i.name === '变量');
+  const varidx = list.findIndex((i) => i.name === '变量');
+  const processVars = vars.children.find((v) => v.children && v.name === process.name) as CompletionPropertyEnhance;
+  const elementVars = vars.children.filter((v) => exsitNames.includes(v.name));
+  // console.log(list);
+  if (processVars) {
+    processVars.children.forEach((p: CompletionProperty) => {
+      processData.children.push(p as any as CompletionData);
+    });
+  }
+
+  if (elementVars) {
+    const processElementData: CompletionData = {
+      name: processElem.name,
+      concept: 'ProcessElement',
+      value: processElem.name,
+      selectable: false,
+      children: [],
     };
-    data.children.push(processData);
-    const vars = list.find((i) => i.name === '变量');
-    const varidx = list.findIndex((i) => i.name === '变量');
-    const processVars = vars.children.find((v) => v.children && v.name === process.name) as CompletionPropertyEnhance;
-    const elementVars = vars.children.filter((v) => exsitNames.includes(v.name));
-    // console.log(list);
-    if (processVars) {
-        processVars.children.forEach((p: CompletionProperty) => {
-            processData.children.push(p as any as CompletionData);
-        });
-    }
-
-    if (elementVars) {
-        const processElementData: CompletionData = {
-            name: processElem.name,
-            concept: 'ProcessElement',
-            value: processElem.name,
-            selectable: false,
-            children: [],
-        };
-        processData.children.push(processElementData);
-        elementVars.forEach((p) => {
-            processElementData.children.push(p as CompletionData);
-        });
-    }
+    processData.children.push(processElementData);
+    elementVars.forEach((p) => {
+      processElementData.children.push(p as CompletionData);
+    });
+  }
 
-    list.splice(varidx, 1, data);
+  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) => deduceTypeAnnotation(app, p, p.typeAnnotation, prefix.concat([node.name]), records.slice())).filter((q: CompletionProperty | null) => !!q);
-        completion.children = children;
-        completion.expanded = true;
-        return completion;
-    }
+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) => 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, exitConstantId?: Boolean) {
-    const processElem = node;
-    const process = node.process;
-    const app = node.app;
-    const elements: ProcessElement[] = getPreviousTask(processElem);
-    const prevtasks = elements.map((us) => {
-        const returns = us.returns.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], []));
-        let constants = us.constants.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], []));
-        exitConstantId && (constants = constants.filter((constant) => constant.name !== 'taskId'));
-        const cp = new CompletionProperty({
-            name: us.name,
-            value: us.name,
-            children: [
-                ...returns,
-                ...constants,
-            ],
-        });
-        cp.expanded = true;
-        cp.icon = us.type;
-        cp.isProcess = true;
-        return cp;
+  const processElem = node;
+  const { process } = node;
+  const { app } = node;
+  const elements: ProcessElement[] = getPreviousTask(processElem);
+  const prevtasks = elements.map((us) => {
+    const returns = us.returns.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], []));
+    let constants = us.constants.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], []));
+    exitConstantId && (constants = constants.filter((constant) => constant.name !== 'taskId'));
+    const cp = new CompletionProperty({
+      name: us.name,
+      value: us.name,
+      children: [...returns, ...constants],
     });
-
-    let processContants = process.constants.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], []));
-    exitConstantId && (processContants = processContants.filter((constant) => constant.name !== 'processId'));
-    const processVariables = new CompletionProperty({
-        name: process.name,
-        value: process.name,
-        children: [
-            ...process.params.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
-            ...process.returns.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
-            ...processContants,
-            ...prevtasks,
-        ],
+    cp.expanded = true;
+    cp.icon = us.type;
+    cp.isProcess = true;
+    return cp;
+  });
+
+  let processContants = process.constants.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], []));
+  exitConstantId && (processContants = processContants.filter((constant) => constant.name !== 'processId'));
+  const processVariables = new CompletionProperty({
+    name: process.name,
+    value: process.name,
+    children: [
+      ...process.params.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
+      ...process.returns.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
+      ...processContants,
+      ...prevtasks,
+    ],
+  });
+  processVariables.expanded = true;
+  processVariables.icon = 'Process';
+  if (processElem.type === 'ExclusiveGateway') {
+    const scopeVariable = new CompletionProperty({
+      name: processElem.name,
+      value: processElem.name,
+      icon: processElem.type,
+      children: processElem.variables.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
     });
-    processVariables.expanded = true;
-    processVariables.icon = 'Process';
-    if (processElem.type === 'ExclusiveGateway') {
-        const scopeVariable = new CompletionProperty({
-            name: processElem.name,
-            value: processElem.name,
-            icon: processElem.type,
-            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.isUserTask) && !exitConstantId) {
-        const scopeVariable = new CompletionProperty({
-            name: processElem.name,
-            value: processElem.name,
-            icon: processElem.type,
-            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,
-            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;
+    scopeVariable.expanded = true;
+    scopeVariable.isProcess = true;
+    scopeVariable.icon = processElem.type;
+    processVariables.children.push(scopeVariable);
+  }
+
+  if (processElem.isUserTask && !exitConstantId) {
+    const scopeVariable = new CompletionProperty({
+      name: processElem.name,
+      value: processElem.name,
+      icon: processElem.type,
+      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,
+      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;
+  const { process } = el;
+  const processname = el.name;
+  const elems = process.elements;
+  const links = elems.filter((e) => e.type === 'SequenceFlow' && e.sourceRef === processname);
+  return links;
 }
 export function getFlowBeforeElements(el: ProcessElement) {
-    const process = el.process;
-    const processname = el.name;
-    const elems = process.elements;
-    const links = elems.filter((e) => e.type === 'SequenceFlow' && e.targetRef === processname);
-    return links;
+  const { process } = el;
+  const processname = el.name;
+  const elems = process.elements;
+  const links = elems.filter((e) => e.type === 'SequenceFlow' && e.targetRef === 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) {
-        const t = stack.shift();
-        const 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);
-            }
-        });
+  const { process } = el;
+  // const processname = el.name;
+  const elems = process.elements;
+  const set = new WeakSet();
+  const stack = [el];
+  while (stack.length) {
+    const t = stack.shift();
+    const { name } = t;
+    if (t.type === 'StartNoneEvent') {
+      return true;
     }
-    return false;
+    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) {
-        const 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);
-            }
-        });
+  const { process } = el;
+  const elems = process.elements;
+  const set = new WeakSet();
+  const nodeSet = new Set();
+  const stack = [el];
+  while (stack.length) {
+    const t = stack.shift();
+    if (el !== t) {
+      nodeSet.add(t);
     }
-    return Array.from(nodeSet);
+    const { name } = t;
+    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);
 }