@lcap/nasl 3.8.2-beta.8 → 3.8.3-beta.1

package/src/concepts/OqlQueryComponent__.ts

@@ -16,7 +16,8 @@ import type Identifier from './Identifier__';
 import type MemberExpression from './MemberExpression__';
 import type { Entity } from './Entity__';
 import type { EntityProperty } from './EntityProperty__';
-import logicService from '../service/logic';
+import { naslOQLCacheStore } from '../utils/language-cache/nasl';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -303,8 +304,8 @@ export class OqlQueryComponent extends LogicItem {
         };
       }
 
-      return http
-        .post('/api/v1/querydebug/generate/typescript', {
+      const query = async () => {
+        const params = {
           appId: 'myAppId',
           oqlIdentifier: 'myoqlIdentifier',
           dataSourceName: this.dataSource,
@@ -313,8 +314,31 @@ export class OqlQueryComponent extends LogicItem {
           dataSourceNasl,
           typeScriptStartLine: 1,
           typeScriptStartLineColumn: 1,
-        })
-        .then(({ data }: any) => {
+        };
+        const key = JSON.stringify(params);
+        let res = null;
+        let canUseCache = false;
+        try {
+          res = await naslOQLCacheStore.getItem(key);
+          canUseCache = true;
+        } catch (error) {}
+        if (res !== null) {
+          return res;
+        }
+        return http
+          .post('/api/v1/querydebug/generate/typescript', params)
+          .then(async ({ data }) => {
+            if (canUseCache) {
+              try {
+                await naslOQLCacheStore.setItem(key, data);
+              } catch (error) {}
+            }
+            return data;
+          });
+      };
+
+      return query()
+        .then((data: any) => {
           this.codeSourceMap = data.result ?? { typescript: '', lexicalErrorCode: 1001 };
         })
         .catch((err) => {

package/src/concepts/OverriddenLogic__.ts

@@ -1769,22 +1769,39 @@ export class OverriddenLogic extends BaseNode {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
               returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },

package/src/concepts/Param__.ts

@@ -329,12 +329,13 @@ export class Param extends BaseNode {
     if (asserts.isFunction(this.defaultExpression) || asserts.isAnonymousFunction(this.defaultExpression)) {
       code += this.defaultValue?.expression || this.defaultExpression ? '?: ' : ': ';
       code += runSync(this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code)));
-    } else if (!dontType && this.typeAnnotation) {
+    } else if (!dontType && (this.typeAnnotation || this.__TypeAnnotation)) {
+      const typeAnnotation = this?.typeAnnotation || this?.__TypeAnnotation;
       code += ': ';
-      code += this.typeAnnotation.toNaturalTS(shiftState(state, code));
-      if (this.typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
+      code += typeAnnotation?.toNaturalTS(shiftState(state, code));
+      if (typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
         if (this.isEnum()) {
-          code += `= ${this.typeAnnotation.typeKey}['${this.defaultValue}']`;
+          code += `= ${typeAnnotation.typeKey}['${this.defaultValue}']`;
         }
       }
     }

package/src/concepts/QueryOrderByExpression__.ts

@@ -114,7 +114,6 @@ export class QueryOrderByExpression extends LogicItem {
   public static getDefaultOptions() {
     return {
       concept: 'QueryOrderByExpression',
-      label: '查询组件OrderBy元素',
       orderElement: {
         concept: 'QueryFieldExpression',
       },

package/src/concepts/Structure__.ts

@@ -573,16 +573,14 @@ export class Structure extends BaseNode {
         .join(', ')}>`;
     }
 
-    code += ` {`;
-    if (state.descriptionComment && this.description)
-      code += `/* ${this.description} */`;
-    code += '\n';
+    code += ` {\n`;
+    // if (state.descriptionComment && this.description)
+    //   code += `/* ${this.description} */`;
+    // code += '\n';
 
     // code += `${indent(state.tabSize + 1)}__name: '${this.getNamespace()}.${this.name}';\n`;
     this.properties.forEach((property) => {
-      code += indent(state.tabSize + 1);
-      code += property.toNaturalTS(shiftState(state, code, { tabSize: 0 }));
-      code += ';\n';
+      code += `${property.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }))};\n`;
     });
     code += `${indent(state.tabSize)}}\n`;
     return code;

package/src/concepts/Variable__.ts

@@ -24,7 +24,7 @@ function tryJSONParse(str: string) {
 
   try {
     result = JSON.parse(str);
-  } catch (e) {}
+  } catch (e) { }
 
   return result;
 }
@@ -208,7 +208,7 @@ export class Variable extends BaseNode {
   get __isVirtual() {
     const processV2 = this.getAncestor('ProcessV2') as ProcessV2;
     const process = this.getAncestor('Process') as Process;
-    const isDisabled = !!this.getAncestor('HistoryProcessV2') || ['enabled', 'history'].includes(processV2?.status)
+    const isDisabled = !!this.getAncestor('HistoryProcessV2') || ['enabled', 'history'].includes(processV2?.status);
     return isDisabled || process?.__isVirtual || false;
   }
 
@@ -305,6 +305,11 @@ export class Variable extends BaseNode {
   @withSourceMap()
   toNaturalTS(state = createCompilerState()): string {
     let code = this.name;
+    if (state.needNamespace) {
+      const namespace = this.getNamespace();
+      const prefix = ['Frontend', 'Backend']?.includes(this?.parentNode?.concept) ? `${namespace}.` : '';
+      code = `${prefix}${code}`;
+    }
     if (this.typeAnnotation) {
       code += ': ';
       code += this.typeAnnotation.toNaturalTS(shiftState(state, code));
@@ -363,9 +368,8 @@ export class Variable extends BaseNode {
    * @param name 一般不用传，用于 rename
    */
   getEmbeddedFilePath(name = this.name) {
-    return `/embedded/${this.getAncestor('App')?.name}/frontendTypes/${
-      this.getAncestor('FrontendType')?.name
-    }/frontends/${this.getAncestor('Frontend')?.name}/variables/${name}.ts`;
+    return `/embedded/${this.getAncestor('App')?.name}/frontendTypes/${this.getAncestor('FrontendType')?.name
+      }/frontends/${this.getAncestor('Frontend')?.name}/variables/${name}.ts`;
   }
 
   *toEmbeddedTSFile(): EmbeddedTSFileGenerator {

package/src/concepts/ViewElement__.ts

@@ -27,7 +27,6 @@ import type Identifier from './Identifier__';
 import { PAGE_COMPONENT_INCLUDE_TAG_MAP } from './View__';
 import type BusinessComponent from './BusinessComponent__';
 import type FrontendType from './FrontendType__';
-import { ComponentCompletionPropertyMap } from './View__';
 
 import { kebab2Camel } from '../utils';
 export interface ParseContext {
@@ -1493,6 +1492,10 @@ export class ViewElement extends Annotatable {
     return this.bindStyles.find((bindStyle) => bindStyle.name === name);
   }
 
+  getBindEvent(name: string) {
+    return this.bindEvents.find((bindEvent) => bindEvent.name === name);
+  }
+
   toHump(name: string): string {
     return name.replace(/-(\w)/g, (all, letter) => letter.toUpperCase());
   }
@@ -1637,7 +1640,7 @@ export class ViewElement extends Annotatable {
     code += `${self.name}: () => {\n`;
 
     const getPropInitialValue = (name: string) => {
-      let v = 'new nasl.core.BooleanFalse()';
+      let v = 'new nasl.core.Boolean()';
       const attr = self.bindAttrs?.find((attr) => attr.name === name);
       if (['static', 'string'].includes(attr?.type)) {
         v = attr.value ? 'new nasl.core.BooleanTrue()' : 'new nasl.core.BooleanFalse()';
@@ -1777,7 +1780,7 @@ export class ViewElement extends Annotatable {
     if (hasDataSource && V && !T1) {
       const valueFieldAttr = self.bindAttrs?.find((attr) => attr.name === 'valueField');
       if (dataSourceSetted && ['static', 'string'].includes(valueFieldAttr?.type)) {
-        valueType = `nasl.util._formatEnum<typeof __item.${valueFieldAttr.value}>`;
+        valueType = `nasl.util._formatEnum<typeof __item.${valueFieldAttr.value || 'value'}>`;
       } else {
         valueType = `nasl.util._formatEnum<typeof __staticItem>`;
       }
@@ -2262,6 +2265,15 @@ export class ViewElement extends Annotatable {
 
     code += `$refs.${this.name} = new ${kebab2Camel(this.tag)}({\n`;
 
+    this?.bindDirectives?.forEach((directive) => {
+      code += directive.toNaturalTS(
+        shiftState(state, code, {
+          tabSize: state.tabSize + 1,
+        }),
+      );
+      code += ',\n';
+    });
+
     this.bindAttrs.forEach((attr) => {
       code += attr.toNaturalTS(
         shiftState(state, code, {
@@ -2271,6 +2283,15 @@ export class ViewElement extends Annotatable {
       code += ',\n';
     });
 
+    this.bindStyles.forEach((style) => {
+      code += style.toNaturalTS(
+        shiftState(state, code, {
+          tabSize: state.tabSize + 1,
+        }),
+      );
+      code += ',\n';
+    });
+
     this.bindEvents.forEach((event) => {
       code += event.toNaturalTS(
         shiftState(state, code, {
@@ -2438,12 +2459,7 @@ export class ViewElement extends Annotatable {
 
     if (['u-button', 'u-form', 'u-modal', 'u-table-view', 'u-select', 'u-input', 'u-number-input'].includes(this.tag)) {
       code += indent(state.tabSize + 1);
-      // 登录组件不翻译
-      // if (this.toHump(this.tag) === 'lcapLogin' || this.staticClass === 'login-form') {
-      //     code += `${this.name}: nasl.ui.div;\n`;
-      // } else {
-      code += `${this.name}: nasl.ui.${kebab2Camel(this.tag.replace(/^\w-/, ''))},\n`;
-      // }
+        code += `${this.name}: nasl.ui.${kebab2Camel(this.tag.replace(/^\w-/, ''))},\n`;
     }
 
     if (Array.isArray(this.children)) {

package/src/concepts/View__.ts

@@ -46,6 +46,8 @@ const removedViewElementCache: {
   [key: string]: number | bigint;
 } = {};
 
+import { config } from '../config';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1583,8 +1585,8 @@ export class View extends Annotatable {
     const BindEvent = getConceptConstructor('BindEvent');
     const definitionStr = utils.sliceTagContent(code, 'definition') || '{}';
     const definition: any = JSON.parse(definitionStr);
-     // 服务端逻辑
-     if (Array.isArray(definition.logics)) {
+    // 服务端逻辑
+    if (Array.isArray(definition.logics)) {
       definition.logics.forEach((logicOption: any) => {
         const logic = Logic.from(
           {
@@ -1671,8 +1673,8 @@ export class View extends Annotatable {
     const BindEvent = getConceptConstructor('BindEvent');
     const definitionStr = utils.sliceTagContent(code, 'definition') || '{}';
     const definition: any = JSON.parse(definitionStr);
-     // 服务端逻辑
-     if (Array.isArray(definition.logics)) {
+    // 服务端逻辑
+    if (Array.isArray(definition.logics)) {
       definition.logics.forEach((logicOption: any) => {
         const logic = Logic.from(
           {
@@ -1834,7 +1836,7 @@ export class View extends Annotatable {
    */
   genScript() {
     const componentList: Array<ViewElement> = [];
-    const allComponentList: Array<ViewElement & { currentIndex: number }> = [];
+    const allComponentList: Array<ViewElement & { currentIndex: number; }> = [];
     this.elementsAttrs(this.elements, componentList, allComponentList, -1);
 
     const routeMeta = this.getRouteMeta();
@@ -1857,22 +1859,22 @@ export class View extends Annotatable {
                 document.addEventListener('keydown', this.onKeyDown);
                 document.addEventListener('keyup', this.onKeyUp);
             },
-            beforeDestory() {
+            beforeDestroy() {
                 document.removeEventListener('keydown', this.onKeyDown);
                 document.removeEventListener('keyup', this.onKeyUp);
             },
             methods: {
                 async onKeyDown(e) {
                     ${this.bindEvents
-                      .filter((event) => ['keydown'].includes(event.name))
-                      .map((event) => `await this.${event.view.name}_${event.name}(e);`)
-                      .join('\n')}
+        .filter((event) => ['keydown'].includes(event.name))
+        .map((event) => `await this.${event.view.name}_${event.name}(e);`)
+        .join('\n')}
                 },
                 async onKeyUp(e) {
                     ${this.bindEvents
-                      .filter((event) => ['keyup'].includes(event.name))
-                      .map((event) => `await this.${event.view.name}_${event.name}(e);`)
-                      .join('\n')}
+        .filter((event) => ['keyup'].includes(event.name))
+        .map((event) => `await this.${event.view.name}_${event.name}(e);`)
+        .join('\n')}
                 }
             }
         };\n`;
@@ -2066,9 +2068,8 @@ export class View extends Annotatable {
         parent = parent.parentNode;
       }
     }
-    return `/embedded/${this.getAncestor('App')?.name}/frontendTypes/${
-      this.getAncestor('FrontendType')?.name
-    }/frontends/${this.getAncestor('Frontend')?.name}/views/${pathName}.ts`;
+    return `/embedded/${this.getAncestor('App')?.name}/frontendTypes/${this.getAncestor('FrontendType')?.name
+      }/frontends/${this.getAncestor('Frontend')?.name}/views/${pathName}.ts`;
   }
 
   getNamespace(): string {
@@ -2117,16 +2118,16 @@ export class View extends Annotatable {
   elementsAttrs(
     elements: Array<ViewElement>,
     componentList: Array<ViewElement>,
-    allComponentList: Array<ViewElement & { currentIndex: number }>,
+    allComponentList: Array<ViewElement & { currentIndex: number; }>,
     currentIndex: number,
   ) {
     if (elements) {
-      elements.forEach((item: ViewElement & { currentIndex: number }) => {
+      elements.forEach((item: ViewElement & { currentIndex: number; }) => {
         let index = currentIndex ?? -1;
         if (item.tag === 'template' && item.haveScope()) {
           index += 1;
         }
-        if (ComponentCompletionPropertyMap[item.tag]) {
+        if (config?.allNodesAPI && config?.allNodesAPI[item.tag]?.readablePropsMap) {
           componentList.push(item);
         }
         item.currentIndex = index;
@@ -2246,9 +2247,9 @@ export class View extends Annotatable {
             const leftCode =
               leftIndex.length === 1
                 ? yield* el.left?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('')
+                returnOrigin('')
                 : yield* el.left?.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
+                returnOrigin('');
             const advanceVar = self.variables?.find(
               (variable) => !variable.typeAnnotation && leftCode === variable.name,
             );
@@ -2303,7 +2304,7 @@ export class View extends Annotatable {
             leftIndex.length === 1
               ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
               : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                  returnOrigin('');
+              returnOrigin('');
           if (leftCode === variable.name) {
             const rightNode =
               rightIndex.length === 1
@@ -2360,22 +2361,39 @@ export class View extends Annotatable {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
-              returnOrigin('');
+                returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },
@@ -2541,10 +2559,16 @@ export class View extends Annotatable {
       code += `export function ${viewName}_view`;
       // 有参数长度
       code += '(';
+      if (this.params?.length > 0) {
+        code += '{';
+      }
       this.params.forEach((param, index) => {
         code += param.toNaturalTS(shiftState(state, code, { tabSize: 0 }));
         if (index !== this.params.length - 1) code += ', ';
       });
+      if (this.params?.length > 0) {
+        code += '}';
+      }
       code += ') {';
       if (state.convertChildren && this.children?.length) {
         code += '\n';
@@ -2559,10 +2583,16 @@ export class View extends Annotatable {
 
       // 有参数长度
       code += '(';
+      if (this.params?.length > 0) {
+        code += '{';
+      }
       this.params.forEach((param, index) => {
         code += param.toNaturalTS(shiftState(state, code, { inline: true }));
         if (index !== this.params.length - 1) code += ', ';
       });
+      if (this.params?.length > 0) {
+        code += '}';
+      }
       code += ')';
 
       code += ' {\n';
@@ -2573,7 +2603,35 @@ export class View extends Annotatable {
         code += ';\n';
       });
       if (this.variables.length) code += '\n';
+      if (!callback) {
+        this.bindEvents.forEach((bindEvent) => {
+          bindEvent.logics.forEach((logic) => {
+            const logicCode = logic.toNaturalTS(
+              shiftState(state, code, {
+                tabSize: state.tabSize + 1,
+                // declaration: true,
+                autoPrefixName: true,
+              })
+            );
+            code += logicCode.replace('function ', 'private function ');
+            code += '\n';
+          });
+          if (bindEvent.logics.length) code += '\n';
+        });
 
+        this.logics.forEach((logic) => {
+          const logicCode = logic.toNaturalTS(
+            shiftState(state, code, {
+              tabSize: state.tabSize + 1,
+              declaration: true,
+              autoPrefixName: true,
+            })
+          );
+          code += logicCode.replace('declare function', 'function');
+          code += '\n';
+        });
+        if (this.logics.length) code += '\n';
+      }
       if (callback) {
         code += callback.call(this, state);
       } else {
@@ -3129,15 +3187,17 @@ export class View extends Annotatable {
 
   getSubLogics() {
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
-      if (asserts.isSubLogic(node)) {
-        // 仅仅是为了处理数据源中的子逻辑，Logic 下面的，交由Logic 自己处理
-        if (node?.getAncestor('Logic')) {
-          return false;
-        }
+      // 仅仅是为了处理数据源中的子逻辑，Logic 下面的，交由Logic 自己处理
+      if (node?.concept === 'Logic') {
+        return true;
+      }
+      if (node?.concept === 'SubLogic') {
         return true;
       }
     });
-    this.subLogics = subLogics as Array<SubLogic>;
+    this.subLogics = subLogics?.filter(node => {
+      return asserts.isSubLogic(node);
+    }) as Array<SubLogic>;
   }
 
   existingSubLogic: Set<string> = new Set<string>();
@@ -3697,9 +3757,9 @@ export const ComponentCompletionPropertyMap: Record<string, any> = {
       prop: 'sorting',
       label: '排序方式',
     },
-    filter:{
-      prop:'filter',
-      label:'筛选条件'
+    filter: {
+      prop: 'filter',
+      label: '筛选条件'
     },
   },
   List: {

package/src/concepts/basics/stdlib/nasl.processV2.ts

@@ -378,6 +378,51 @@ export function initialize() {
         }),
       ],
     }),
+    new Structure({
+      name: 'TaskInst',
+      properties: [
+        new StructureProperty({
+          name: 'processDefUniqueKey',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'processDefinitionId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'processInstanceId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'taskDefName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'taskTitle',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'completeBy',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'finished',
+          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+        }),
+        new StructureProperty({
+          name: 'createTime',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'completeTime',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+    }),
   );
 
   processV2TypeList.push(
@@ -820,6 +865,24 @@ export function initialize() {
       ],
       returns: [],
     }),
+    new Logic({
+      name: 'getUsersForAddSign',
+      description: '查询可加签用户列表',
+      params: [
+        new Param({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createGeneric('List', {
+            typeArguments: [TypeAnnotation.createReference('LCAPUser', { typeNamespace: 'nasl.processV2' })],
+          }),
+        }),
+      ],
+    }),
     new Logic({
       name: 'terminateProcess',
       description: '终止',
@@ -919,6 +982,22 @@ export function initialize() {
         }),
       ],
     }),
+    new Logic({
+      name: 'getTaskInfo',
+      description: '查询流程任务信息',
+      params: [
+        new Param({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createReference('TaskInst', { typeNamespace: 'nasl.processV2' }),
+        }),
+      ],
+    }),
   ];
 
   const processComponents = [