@lcap/nasl 3.7.3-beta.1 → 3.8.0-beta.2

package/src/server/naslServer.ts

@@ -99,6 +99,7 @@ import {
   FrontendType,
   InterfaceParam,
   ProcessBindV2,
+  SubLogic,
 } from '../concepts';
 
 import * as utils from '../utils';
@@ -398,8 +399,14 @@ class NaslServer {
     this.worker.terminate();
   }
 
-  async createUiTs(components: any, options: UiTsOptions) {
-    const { tsCode, baseComponents } = options;
+  async createUiTs(components: any, optinos: {
+    basicUITsCode: string,
+    withTypeLibraryTsCode: string,
+    standardUIComponents: Record<string, any>
+  }) {
+    const {
+      standardUIComponents, // 标准组件（带有ts类型定义文件的组件）
+    } = optinos;
 
     Object.assign(allComponent, components)
     const { code, elementsLogic } = await formatUiTs(allComponent);
@@ -437,17 +444,27 @@ class NaslServer {
     );
 
     // 添加基础组件的方法到elementsLogic
-    Object.assign(elementsLogic, createEleLogins(baseComponents));
+    Object.assign(elementsLogic, createEleLogins(standardUIComponents));
 
     // 基础组件
     await this.addFile(
       {
         file: 'nasl.ui.component.ts',
-        fileContent: tsCode,
+        fileContent: optinos.basicUITsCode,
+      },
+      { cache: true }
+    )
+
+    // 带有类型的依赖库组件
+    await this.addFile(
+      {
+        file: 'extension.component.ts',
+        fileContent: optinos.withTypeLibraryTsCode,
       },
       { cache: true }
     )
 
+    // 内置标准库类型
     Object.keys(naslStdlibMap).forEach(async (libFileName: string) => {
       await this.addFile(
         {
@@ -457,6 +474,7 @@ class NaslServer {
         { cache: true }
       );
     });
+
     this.elementsLogic = elementsLogic;
   }
 
@@ -481,7 +499,7 @@ class NaslServer {
         node.sourceMap = result.sourceMap;
         self.file2NodeMap.set(result.filePath, node);
       } catch (err) {
-        if (utils.isDebugMode) {
+        if (process.env.NODE_ENV === 'development') {
           self.logger.warn(node.nodePath ? node.nodePath : name, '代码转换失败', err);
         }
       }
@@ -747,9 +765,7 @@ class NaslServer {
       try {
         await Promise.all(openFiles.map(async (file) => fs.outputFile(path.join(__dirname, '../debug/apps', app.id, file.file), file.fileContent)));
       } catch (e) {
-        if (utils.isDebugMode) {
-          this.logger.error(e);
-        }
+        this.logger.error(e);
       }
     }
     /// #endif
@@ -861,8 +877,10 @@ class NaslServer {
     const quickInfo = await this._getTypeQuickinfo({
       file: (fileNode as FileNode).getEmbeddedFilePath(),
       line: lsp2tspNumber(currentSource.start.line),
+      // TODO 适配依赖库的extension.xxx
       offset: lsp2tspNumber(currentSource.start.character) + `new nasl.ui.`.length,
     });
+
     if (quickInfo.responseRequired) {
       const displayString = quickInfo?.response?.displayString || '';
 
@@ -1810,9 +1828,7 @@ class NaslServer {
                 try {
                   jsCode = nodeIn.toJS();
                 } catch (err) {
-                  if (utils.isDebugMode) {
-                    self.logger.error(err);
-                  }
+                  self.logger.error(err);
                 }
                 if (!jsCode.startsWith(`${node.name} = `)) return;
                 // 页面局部变量
@@ -1841,7 +1857,7 @@ class NaslServer {
                   const diagnostic = {
                     node: nodeIn,
                     severity: 'error',
-                    message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                    message: `${nodeIn.label || ''}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
                   };
                   nodeIn.tsErrorDetail = diagnostic;
                   diagnostics.push(diagnostic);
@@ -2350,7 +2366,7 @@ class NaslServer {
                     const diagnostic = {
                       node: nodeIn,
                       severity: 'error',
-                      message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                      message: `${nodeIn.label || ''}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
                     };
                     nodeIn.tsErrorDetail = diagnostic;
                     diagnostics.push(diagnostic);
@@ -2783,6 +2799,49 @@ class NaslServer {
         }
       }
     }
+    if (node instanceof CallLogic) {
+      // 处理依赖库高阶函数，函数签名和函数调用参数要完全一一对应
+      if (node.calleeNamespace?.startsWith('extensions.')) {
+        const logicNode = node.getCallNode();
+        const params = logicNode?.params?.slice();
+        const findFunction = params.find(param => param?.typeAnnotation?.typeKind === 'function');
+        if (findFunction) {
+          node.arguments?.forEach((argument, index) => {
+            const expression = argument?.expression;
+            const paramType = params[index]?.typeAnnotation;
+            if (!expression?.tsErrorDetail && paramType?.typeKind === 'function' && paramType?.typeArguments?.length) {
+              let hasLengthErrorDetail = {
+                flag: false,
+                message: '',
+              };
+              const isSubLogic = expression instanceof SubLogic;
+              const isCallLogic = expression instanceof Identifier && expression?.namespace?.endsWith('logics');
+              if (isSubLogic) {
+                if (expression?.params?.length !== paramType.typeArguments.length) {
+                  hasLengthErrorDetail.flag = true;
+                  hasLengthErrorDetail.message = `高阶函数: 参数个数不匹配，期望 ${paramType.typeArguments.length} 个, 实际传入 ${expression.params?.length || 0} 个!`;
+                }
+              } else if (isCallLogic) {
+                const getIdentCallLogic = expression.getFunctionCallNode();
+                if (getIdentCallLogic?.params?.length !== paramType.typeArguments.length) {
+                  hasLengthErrorDetail.flag = true;
+                  hasLengthErrorDetail.message = `高阶函数: 参数个数不匹配，期望 ${paramType.typeArguments.length} 个, 实际传入 ${getIdentCallLogic.params?.length || 0} 个!`;
+                }
+              }
+              if (hasLengthErrorDetail.flag) {
+                const diagnostic = {
+                  node: expression,
+                  severity: 'error',
+                  message: hasLengthErrorDetail.message,
+                };
+                expression.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+              }
+            }
+          })
+        }
+      }
+    }
 
     // if(node instanceof CallLogic) {
     //   const logic = node.getCallNode();
@@ -3189,9 +3248,7 @@ class NaslServer {
               }
             }
           } catch (e) {
-            if (utils.isDebugMode) {
-              this.logger.error('naslServer实体引用', e);
-            }
+            this.logger.error('naslServer实体引用', e);
           }
         }
       }
@@ -3618,9 +3675,7 @@ class NaslServer {
                   minRange.setTypeMethods = 'setValue';
                 }
               } catch (error) {
-                if (utils.isDebugMode) {
-                  this.logger.error(error);
-                }
+                console.error(error)
               }
             } else if (minRange.node instanceof Identifier) {
               minRange.newValue = utils.firstLowerCase(newValue);
@@ -3957,6 +4012,7 @@ class NaslServer {
       App.emit('collect:start', {
         actionMsg: '增加逻辑参数',
       });
+      console.log('-----增加逻辑参数-----')
       const index = node.getIndexOfParent();
       node.create({
         index,
@@ -3965,6 +4021,7 @@ class NaslServer {
       });
       this._addParamsEffect(refsList, node as Param);
       // 结束修改 ，批量操作
+      console.log('-----增加逻辑参数 结束-----')
       App.emit('collect:end');
       return node;
     }
@@ -4004,9 +4061,7 @@ class NaslServer {
         result = this.handleTreeMap(resMap);
       }
     } catch (err) {
-      if (utils.isDebugMode) {
-        this.logger.error(err);
-      }
+      this.logger.error(err);
     }
     return result;
   }
@@ -4032,9 +4087,7 @@ class NaslServer {
         result.add(minRange.node);
       });
     } catch (err) {
-      if (utils.isDebugMode) {
-        this.logger.error(err);
-      }
+      this.logger.error(err);
     }
     return [...result];
   }
@@ -4531,6 +4584,49 @@ class NaslServer {
         } else {
           // 清空原来已经赋值上去的类型，可能原来有现在没有了
           delete node.__TypeAnnotation;
+          // 给一些泛型标注的推导泛型
+          delete (node as any).__TypeArguments;
+          /**
+           * 特殊处理，calllogic 有泛型的情况，拿到的类型是错误的编译不出来的类型，所以要特殊处理一下
+           * 不想去查两次类型, 因为是从函数签名上拿类型，所以直接合并在一起，先这样
+           */
+          if (
+            node instanceof CallLogic &&
+            node.completeTypeParams?.length &&
+            (node as any)?.__nodeType
+          ) {
+            const logicNode = node.getCallNode();
+            const autoTypeArguments = (node as any).__nodeType?.typeArguments || [];
+            const newAutoTypeArguments = [...autoTypeArguments];
+            if (logicNode.returns?.length) {
+              let returnType = newAutoTypeArguments.shift();
+              if (node.handleError && returnType.typeName === 'Union') {
+                const returnTypeArguments =  returnType.typeArguments || [];
+                const typeArguments = [...returnTypeArguments];
+                const errorType = typeArguments.find((t: any) => t.typeName === 'Error');
+                if (errorType) {
+                  if (typeArguments.length === 2) {
+                    returnType = typeArguments.filter((t: any) => t !== errorType)[0];
+                  } else {
+                    returnType.typeArguments = typeArguments.filter((t: any) => t !== errorType);
+                  }
+                }
+              }
+              node.__TypeAnnotation = utils.runGeneratorSync(type2TypeAnnotation(returnType));
+            }
+
+            const typeArgs: any[] = [];
+            const typeArguments = node.typeArguments;
+            node.completeTypeParams.forEach((typeArg, typeIndex) => {
+              if (typeArg.needChoose) {
+                typeArgs.push(typeArguments?.[typeIndex])
+              } else {
+                const newType = utils.runGeneratorSync(type2TypeAnnotation(newAutoTypeArguments.shift()));
+                typeArgs.push(newType)
+              }
+            });
+            node.__TypeArguments = typeArgs;
+          }
         }
       } catch (err) {
         // if (globalThis.window) {
@@ -4574,8 +4670,8 @@ class NaslServer {
 
     this.logger.timeEnd('全量标注');
 
-    // 测试环境或者是调试模式打印数据
-    if (utils.isDebugMode || utils.isTestBrowser) {
+    // 测试环境打印数据
+    if (utils.isTestBrowser) {
       this.logger.info('全量标注数据', json);
     }
 
@@ -4745,6 +4841,15 @@ class NaslServer {
             node.arguments.pop();
           }
         }
+
+        /**
+        * 特殊处理，不想去查两次类型, 因为是从函数签名上拿类型，所以直接合并在一起，先这样
+        */
+        if (node instanceof CallLogic && node.__TypeArguments?.length) {
+          const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+          jsonNode.typeArguments = node.__TypeArguments;
+          jsonNode.typeAnnotation = node.__TypeAnnotation;
+        }
       }
 
       // 服务端需要默认值节点有类型来判断父节点是否是日期类型
@@ -4811,9 +4916,7 @@ class NaslServer {
     }
     return new Promise((resolve, reject) => {
       const myTimer = setTimeout(() => {
-        if (utils.isDebugMode) {
-          this.logger.warn(node, '没有获取到类型');
-        }
+        this.logger.warn(node, '没有获取到类型');
         clearTimeout(myTimer);
         clearInterval(mySetInterval);
         if (node.__isCorrectTypeAnnotation) {

package/src/server/translator.ts

@@ -456,6 +456,10 @@ const POST_RULES: Array<{
     re: /Boolean|"Boolean"/g,
     result: '布尔值',
   },
+  {
+    re: /unknown/g,
+    result: '未知类型',
+  },
   {
     re: /never/g,
     result: '未知类型',

package/src/service/storage/init.ts

@@ -4,16 +4,16 @@ import { addBreakpointNodesFromApp } from '../../breakpoint';
 import { getConceptConstructor } from '../../decorators';
 import { config } from '../../config';
 import storageService from './service';
-import { LsCache, BreakpointStatus, FullResponse, isDebugMode, BatchInstructResult } from '../../utils';
 import { v4 as uuidv4 } from 'uuid';
 import stepRecorder from '../../manager/stepRecorder';
 import * as jsoner from './jsoner';
 /// #if !process.env.NODE_ENV || process.env.BUILD_TARGET === 'node'
 import * as fs from 'fs-extra';
 import type { NaslServer } from 'src/server/naslServer';
-import { NaslCacheData, NaslData } from 'src/utils/language-cache';
 /// #endif
 
+
+
 export const batchQuery = storageService.batchQuery;
 export const batchAction = storageService.batchAction;
 export const batchInstruct = storageService.batchInstruct;
@@ -58,12 +58,12 @@ export function doOperationRecord(operation: Operation) {
       transaction.oncomplete = () => {
         db.close();
       };
-    } catch (err) {
+    } catch(err) {
       console.log(err);
     }
   };
 
-  request.onerror = function (event) {
+  request.onerror = function(event) {
     console.log('Failed to open database');
   };
 }
@@ -228,7 +228,7 @@ export async function operationRecordPlayback(app: any, operationRecordAction: '
         const pathArr = path?.split('.') || [];
         const lastPathItem = pathArr?.pop();
         if (lastPathItem) {
-          pathArr.push(lastPathItem.replace(/(name=)[^\]]+/, `$1${object?.name}`));
+            pathArr.push(lastPathItem.replace(/(name=)[^\]]+/, `$1${object?.name}`));
         }
         newPath = pathArr.join('.');
       }
@@ -254,7 +254,7 @@ export async function operationRecordPlayback(app: any, operationRecordAction: '
         case 'update':
           for (const key in oldObject) {
             if (node) {
-              (node as any)[key] = oldObject[key] ?? null;
+                (node as any)[key] = oldObject[key] ?? null;
             }
           }
           break;
@@ -427,7 +427,7 @@ async function doAction(app: any, actionItem: any) {
   let hasBackEnd = false;
   const actionList: any[] = [];
   const allRiskList: any[] = [];
-  const { list, actionMsg, action, extra } = actionItem || {};
+  const { list, actionMsg, action, extra} = actionItem || {};
   handleAIPoint(app, actionItem);
   const itemloop = (_i: LogicItem, app: any, diffArr: string[]) => {
     const _l = getStatement(_i, app, diffArr);
@@ -543,9 +543,9 @@ async function doAction(app: any, actionItem: any) {
             const isDelete = event?.originEvent?.action === 'delete';
             const isAuthView = (emitTarget as View).auth && event?.originEvent?.object?.name;
             const isUpdateAuth = event?.originEvent?.action === 'update' && "auth" in (event?.originEvent?.object || {});
-            const isUpdateAuthDes = event?.originEvent?.action === 'update' && "authDescription" in (event?.originEvent?.object || {});
+            const isUpdateAuthDes =  event?.originEvent?.action === 'update' &&  "authDescription" in (event?.originEvent?.object || {});
             const isUpdateBindRoles = event?.originEvent?.action === 'update' && event?.originEvent?.object && event?.originEvent?.object?.bindRoles;
-            if (isDelete || isUpdateAuth || isUpdateBindRoles || isAuthView || isUpdateAuthDes) {
+            if (isDelete || isUpdateAuth || isUpdateBindRoles || isAuthView||isUpdateAuthDes) {
               hasBackEnd = true;
               // const app = emitTarget.app;
               // const diffArr: string[] = [];
@@ -566,7 +566,7 @@ async function doAction(app: any, actionItem: any) {
             hasFrontEnd = true;
           }
           if (emitTarget.concept === 'ViewElement') {
-            if (event?.originEvent?.action === 'update' || event?.originEvent?.action === 'delete') {
+            if(event?.originEvent?.action === 'update' || event?.originEvent?.action === 'delete'){
               if ('authDescription' in (event?.originEvent?.object ?? {})) {
                 hasBackEnd = true;
               }
@@ -597,7 +597,7 @@ async function doAction(app: any, actionItem: any) {
           }
           if (emitTarget.concept === 'BindAttribute' && emitTarget.name === 'url') {
             const needUpdateBackEnd =
-              (emitTarget as BindAttribute)?.value?.endsWith('/import') || (emitTarget as BindAttribute)?.value?.includes('/upload/')
+            (emitTarget as BindAttribute)?.value?.endsWith('/import') || (emitTarget as BindAttribute)?.value?.includes('/upload/')
             if (!(emitTarget as BindAttribute).view.parentAuth && needUpdateBackEnd) {
               hasBackEnd = true
             }
@@ -888,7 +888,7 @@ function ensureSafe(instructList: any[]) {
     instruct?.actions?.forEach((actionItem: any) => {
       const { path, action, object } = actionItem || {};
       if (path === 'app') {
-        switch (action) {
+        switch(action) {
           case 'create':
             riskList.push('重复创建App');
             break;
@@ -918,8 +918,7 @@ async function _saveNasl(options: TaskOption) {
   } else if (hasBackEnd) {
     ChangedNASLType = 'backend';
   }
-
-  let res: BatchInstructResult;
+  let res: any;
   let err: any;
 
   if (config.storage.protocol === 'http') {
@@ -997,13 +996,6 @@ async function _saveNasl(options: TaskOption) {
     });
   }
   app.emit?.('saved', err);
-
-  // 更新缓存
-  await LsCache.updateNaslCache(app.id, {
-    ...res,
-    getData: () => cloneDeep(app.toJSON()),
-  });
-
   return err;
 }
 
@@ -1019,6 +1011,7 @@ export interface ProxyApp extends App {
   _action: string;
   _extra?: any;
   naslServer: NaslServer;
+  _historyName?: string,
 }
 
 export function handleApp(app: ProxyApp) {
@@ -1026,6 +1019,7 @@ export function handleApp(app: ProxyApp) {
   app._collectingList = [];
   app._historyList = [];
   app._historyIndex = 0;
+  app._historyName = 'IDE';
   app._historying = false;
   app._timer = null;
 
@@ -1146,104 +1140,65 @@ export function handleApp(app: ProxyApp) {
   });
 }
 
-async function getBatchAdditionalData(appId: string) {
-  const { data: { result: [globalChangedTime] }, headers }: FullResponse<number> = await storageService.batchQuery({
-    body: [
-      {
-        path: 'app.globalChangedTime',
-      },
-    ],
-    headers: {
-      appId,
-      checkTabOpenTime: 'true',
-    },
-    config: {
-      shortResponse: false
-    },
-  });
-
-  return {
-    globalChangedTime,
-    tabTimestamp: headers['tabtimestamp'],
-  };
-}
-
-async function getNaslFromServer(appId: string, globalChangedTime: number | null) {
-  const [naslData] = await storageService.batchQuery({
-    body: [
-      {
-        path: 'app',
-      },
-    ],
-    headers: {
-      appId,
-    },
-  });
-
-  // 后端没有此值时，表示为存量应用，不可缓存
-  if (!globalChangedTime) {
-    return naslData;
-  }
-
-  await LsCache.updateNaslCache(appId, {
-    getData: () => naslData,
-    // 初次缓存时此值无用，故赋值为 0
-    preGlobalChangedTime: 0,
-    globalChangedTime: globalChangedTime,
-  });
-
-  return naslData as NaslData;
-}
-
-async function getNaslFromCache(appId: string) {
-  return LsCache.getNaslCacheWithoutCheck(appId).then((data) => data.data);
-}
+type BreakpointItem =
+  | any
+  | {
+      path: string
+      breakpointStatus: null | 'ENABLED' | 'DISABLED'
+    }
 
 /**
  * 加载 app
  * @param appId 如果是从文件读，就不需要传
  * @returns app 对象
  */
-export async function loadApp(appId: string) {
+export async function loadApp(appId?: string) {
   try {
     // 删除失效数据
     deleteExpiredRecords();
-  } catch (err) { }
+  } catch(err) { }
   let app: App;
   if (config.storage.protocol === 'http') {
     console.time('batchQuery');
-    const additionalData = await getBatchAdditionalData(appId);
-    const useCache = await LsCache.canUseNaslCache(appId, additionalData.globalChangedTime);
     const promises = [
-      useCache
-        ? getNaslFromCache(appId)
-        : getNaslFromServer(appId, additionalData.globalChangedTime),
+      storageService.batchQuery({
+        body: [
+          {
+            path: 'app'
+            // excludes: ['views'],
+          }
+        ],
+        headers: {
+          appId,
+          checkTabOpenTime: 'true'
+          // 其他封装在 storageService 里了
+        },
+        config: {
+          shortResponse: false
+        }
+      }),
       storageService.breakpoint({
         body: { appId }
-      }),
-      useCache ? Promise.resolve() : LsCache.clearCache(appId),
-    ] as [Promise<LsCache.NaslCacheData>, Promise<BreakpointStatus[]>, Promise<void>];
-
-    if (isDebugMode) {
-      if (useCache) {
-        console.log('命中 Nasl 前端缓存');
-      }
-      else {
-        console.log('未命中 Nasl 前端缓存');
-      }
-    }
+      })
+    ]
 
     const [batchQueryRes, breakpointRes] = await Promise.all(promises)
 
     // 请求
     console.timeEnd('batchQuery');
-    tabTimestamp = additionalData.tabTimestamp;
 
-    console.time('new App');
-    app = new App(Object.assign(batchQueryRes, { id: appId }));
+    tabTimestamp = batchQueryRes?.headers?.tabtimestamp;
+    const data = batchQueryRes?.data?.result;
 
-    breakpointRes?.forEach?.((item) => {
-      const { path, breakpointStatus } = item ?? {};
+    console.time('new App');
+    app = new App(Object.assign(data?.[0] || {}, { id: appId }));
+    app.frontendTypes.forEach(ft => {
+      if(!ft.frameworkKind) {
+        ft.frameworkKind = 'vue2';
+      }
+    })
+    breakpointRes?.forEach?.((item: BreakpointItem = {}) => {
+      const { path, breakpointStatus } = item
 
       if (breakpointStatus) {
         const node = app.findNodeByPath(path)

package/src/templator/genCreateBlock.ts

@@ -430,7 +430,12 @@ function genProcessV2LaunchLogic(module: any, entity: Entity, process: ProcessV2
  * 生成创建页区块
  * @param resolver 实体创建 Action
  */
-export function genCreateBlock(entity: Entity, oldNode: ViewElement, appointKeys: string[] = [],frontendType: string, process: ProcessV2, extra: IBlockExtra = {}) {
+export function genCreateBlock(entity: Entity, oldNode: ViewElement, appointKeys: string[] = [],frontendType: string, process: ProcessV2, extra: IBlockExtra = {}, useViewVriable = true,
+  localTemplate: {
+    genCreateTemplate: (entity: Entity, nameGroup: NameGroup, selectNameGroupMap: Map<string, NameGroup>, appointKeys: string[], process: ProcessV2, extra: IBlockExtra) => string,
+    genSubmitLogicLocal: (createLogic: Logic, nameGroup: NameGroup, extendConsequents: any[]) => any,
+    genCreatedHandler: (entity: Entity, nameGroup: NameGroup) =>  string
+  }) {
   const likeComponent = oldNode?.likeComponent;
   const dataSource = entity.parentNode as DataSource;
   const module = dataSource.app;
@@ -490,35 +495,51 @@ export function genCreateBlock(entity: Entity, oldNode: ViewElement, appointKeys
       })
     );
   }
+  let viewBindEvents = '';
+  let viewLoadLogic;
+  if(localTemplate.genCreatedHandler) {
+    nameGroup.viewLogicCreated = likeComponent.getLogicUniqueName('load');
+    viewLoadLogic = localTemplate.genCreatedHandler(entity, nameGroup)
+    viewBindEvents = `
+    ,"viewBindEvents": [
+      {
+          "concept": "BindEvent",
+          "arguments": [],
+          "name": "created",
+          "calleeNamespace": "",
+          "calleeName": "${nameGroup.viewLogicCreated}"
+      }
+    ]`
+  }
 
-  const submitLogic = genSubmitLogic(createLogic, nameGroup, extendConsequent);
-
+  const submitLogic = (localTemplate.genSubmitLogicLocal || genSubmitLogic)(createLogic, nameGroup, extendConsequent);
+  const genTemplate = localTemplate.genCreateTemplate || ((frontendType || config.scope) === 'h5' ? genH5CreateFormTemplate : genCreateFormTemplate);
   return `<template>
-    ${(frontendType || config.scope) === 'h5'
-      ? genH5CreateFormTemplate(entity, nameGroup, selectNameGroupMap, appointKeys, process, extra)
-      : genCreateFormTemplate(entity, nameGroup, selectNameGroupMap, appointKeys, process, extra)
-    }
+    ${genTemplate(entity, nameGroup, selectNameGroupMap, appointKeys, process, extra)}
 </template>
 
 <definition>
 {
     "viewVariables": [
-        {
+      ${useViewVriable ?  `{
             "concept": "Variable",
             "name": "${nameGroup.viewVariableEntity}",
             "typeAnnotation": ${JSON.stringify(
-      NaslTypeAnnotation.Reference({
-        typeNamespace: entity.getNamespace(),
-        typeName: entity.name,
-      })
-    )}
-        }
+            NaslTypeAnnotation.Reference({
+              typeNamespace: entity.getNamespace(),
+              typeName: entity.name,
+            })
+          )}}` : ''
+      }
+        
     ]
     ${appointKeys.length ? '' : `,"viewLogics": [
       ${JSON.stringify(submitLogic)}
       ${newLoadSelectLogics.map((logic) => `,${JSON.stringify(logic)}`).join('\n')}
+      ${viewLoadLogic ? ',' + JSON.stringify(viewLoadLogic) : ''}
   ],
   "logics": ${JSON.stringify(newLogics)}`}
+  ${viewBindEvents}
 }
 </definition>
 `;