@lcap/nasl 3.8.0-beta.3 → 3.8.0-beta.5

package/src/server/naslServer.ts

@@ -36,6 +36,7 @@ import {
   EnumItem,
   Param,
   Process,
+  ProcessV2,
   Interface,
   Argument,
   ViewElement,
@@ -99,6 +100,7 @@ import {
   FrontendType,
   InterfaceParam,
   ProcessBindV2,
+  ValidationRule,
   SubLogic,
 } from '../concepts';
 
@@ -119,7 +121,7 @@ import { EventEmitter } from '../common/EventEmitter';
 import { traverse, FileNode } from '../utils';
 import { withQueueExecute } from '../decorators';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
-import { isConnection, isConnector, isMsgTriggerEvent } from '../concepts/utils/asserts';
+import { isConnection, isConnector, isMsgTriggerEvent, isProcess, isProcessV2, isStrictLogic } from '../concepts/utils/asserts';
 
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
   Entity: 3,
@@ -411,6 +413,24 @@ class NaslServer {
     Object.assign(allComponent, components)
     const { code, elementsLogic } = await formatUiTs(allComponent);
 
+    // 处理一堆api.ts的类型
+    const convertTsCode = (code: string) => {
+      code = code.replace(/nasl.core.Integer/g, 'nasl.core.Long')
+      // 匹配union类型的正则
+      const unionReg = /\s*['"].*['"](\s*\|\s*['"].*['"])+/g;
+      code = code.replace(unionReg, 'nasl.core.String');
+
+      const extendsBooleanReg = /extends\s+(true|false)/g;
+      code = code.replace(extendsBooleanReg, ($0, $1) => {
+        return $1 === 'true' ? 'extends nasl.core.BooleanTrue' : 'extends nasl.core.BooleanFalse';
+      })
+
+      const extendsStringReg = /extends\s+(['"](.*)['"])/g;
+      code = code.replace(extendsStringReg, ($0, $1, $2) => `extends nasl.core.StringLiteral<\`${$2}\`>`)
+
+      return code;
+    }
+
     ///  process.env.BUILD_TARGET !== 'node'
     if (!utils.isNode) {
       await this.addFile(
@@ -425,10 +445,11 @@ class NaslServer {
     /// #endif
 
     if (utils.isNode) {
+      let content = await fs.readFile(path.join(__dirname, '../../sandbox/stdlib/nasl.ui.definition.ts'), 'utf-8');
       await this.addFile(
         {
           file: 'nasl.ui.definition.ts',
-          fileContent: await fs.readFile(path.join(__dirname, '../../sandbox/stdlib/nasl.ui.definition.ts'), 'utf-8'),
+          fileContent: content,
         },
         { cache: true }
       );
@@ -450,7 +471,8 @@ class NaslServer {
     await this.addFile(
       {
         file: 'nasl.ui.component.ts',
-        fileContent: optinos.basicUITsCode,
+        // FIXME 临时解决方式将union类型转换为string类型
+        fileContent: convertTsCode(optinos.basicUITsCode),
       },
       { cache: true }
     )
@@ -459,7 +481,7 @@ class NaslServer {
     await this.addFile(
       {
         file: 'extension.component.ts',
-        fileContent: optinos.withTypeLibraryTsCode,
+        fileContent: convertTsCode(optinos.withTypeLibraryTsCode),
       },
       { cache: true }
     )
@@ -499,7 +521,7 @@ class NaslServer {
         node.sourceMap = result.sourceMap;
         self.file2NodeMap.set(result.filePath, node);
       } catch (err) {
-        if (process.env.NODE_ENV === 'development') {
+        if (utils.isDebugMode) {
           self.logger.warn(node.nodePath ? node.nodePath : name, '代码转换失败', err);
         }
       }
@@ -765,7 +787,9 @@ 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) {
-        this.logger.error(e);
+        if (utils.isDebugMode) {
+          this.logger.error(e);
+        }
       }
     }
     /// #endif
@@ -890,6 +914,9 @@ class NaslServer {
       // 从 {entity1:Entity1(defaultDS);},unknown,unknown,unknown 取出{entity1:Entity1(defaultDS);}
       typeStr = typeStr?.split(',')[0];
 
+      // 将Long转换为Integer
+      typeStr = typeStr?.replace('Long', 'Integer');
+
       if (flag) {
         // 自定义结构的展示
         if (typeStr.includes('__name: "AStructure_')) {
@@ -1163,7 +1190,8 @@ class NaslServer {
             if (diagnostic.severity === 'warning') {
               record.suggestionDiagnostics.push(diagnostic);
               return null;
-            } if (asserts.isStrictOqlQueryComponent(currentNode)) {
+            }
+            if (asserts.isStrictOqlQueryComponent(currentNode)) {
               // OQL别名错误降级为警告
               if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
                 // 重置 图标和错误等级
@@ -1176,6 +1204,26 @@ class NaslServer {
                 return null;
               }
             }
+            // 组件部分属性错误降级
+            if (asserts.isBindAttribute(currentNode) && asserts.isViewElement(currentNode.parentNode)) {
+              const element = currentNode.parentNode as ViewElement;
+              const tags: Record<string, string[]> = {
+                'u-number-input': ['value', 'min', 'max'],
+                'u-input': ['value'],
+                'van-fieldinput': ['value'],
+                'van-stepper-new': ['value', 'min', 'max'],
+              }
+              if (tags[element.tag] && tags[element.tag].includes(currentNode.name)) {
+                diagnostic.severity = 'warning';
+                if (diagnostic.node?.tsErrorDetail) {
+                  // 重置组件节点上的错误信息
+                  diagnostic.node.tsErrorDetail.severity = 'warning';
+                }
+                record.suggestionDiagnostics.push(diagnostic);
+                return null;
+              }
+            }
+
             while (currentNode && currentNode?.parentNode?.concept !== 'App') {
               if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
                 // 草稿区降级
@@ -1828,7 +1876,9 @@ class NaslServer {
                 try {
                   jsCode = nodeIn.toJS();
                 } catch (err) {
-                  self.logger.error(err);
+                  if (utils.isDebugMode) {
+                    self.logger.error(err);
+                  }
                 }
                 if (!jsCode.startsWith(`${node.name} = `)) return;
                 // 页面局部变量
@@ -2187,6 +2237,20 @@ class NaslServer {
                         typeAnnotationErrorDetail.errorPos.scale = errorMsg;
                       }
                     }
+                    if(property.defaultValue?.expression?.concept === 'NumericLiteral') {
+                      const numeric = property.defaultValue.expression as NumericLiteral;
+                      const value = numeric.value;
+                      const decimalPlaces = value?.split('.')[1]?.length || 0;
+                      if(decimalPlaces > +scale) {
+                        const diag: any = {
+                          node: property,
+                          severity: 'error',
+                          message: `实体字段${property.name}默认值的小数位数不能大于设置的小数位数${scale}`,
+                        };
+                        diagnostics.push(diag);
+                      }
+                    }
+
                     break;
                   }
                 }
@@ -2363,6 +2427,13 @@ class NaslServer {
                 if (jsCode.startsWith(`${node.name} = `)) {
                   used = true;
                   if (!nodeIn.tsErrorDetail) {
+                    // 如果要加报错的时候，当前赋值或者批量复制，属于子逻辑的
+                    // 但是没有类型的参数 或者返回值，不是 属于他的
+                    // 就不加了，只有是子逻辑，而且是自己的参数没类型才加
+                    const isSubLogic = nodeIn?.getAncestor('SubLogic');
+                    if (isSubLogic && isSubLogic !== node.parentNode) {
+                      return;
+                    }
                     const diagnostic = {
                       node: nodeIn,
                       severity: 'error',
@@ -2423,6 +2494,47 @@ class NaslServer {
       yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), ([node, value]) => {
         this.checkNodeError(node, diagnostics);
       });
+    } else if (fileNode instanceof ProcessV2) {
+      yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), function* wrapIterator([node, value]) {
+        if (node instanceof Return || node instanceof Variable) {
+          const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
+          if (!node.typeAnnotation && !node.__TypeAnnotation) {
+            let used = false;
+            fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
+              if (!used && nodeIn && (nodeIn instanceof BatchAssignment || (nodeIn instanceof Assignment && nodeIn.left?.name))) {
+                let jsCode = '';
+                try {
+                  jsCode = nodeIn.toJS();
+                } catch (err) {
+                  self.logger.error(err);
+                }
+                if (jsCode.startsWith(`${node.name} = `)) {
+                  used = true;
+                  if (!nodeIn.tsErrorDetail) {
+                    const diagnostic = {
+                      node: nodeIn,
+                      severity: 'error',
+                      message: `${nodeIn.label || ''}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                    };
+                    nodeIn.tsErrorDetail = diagnostic;
+                    diagnostics.push(diagnostic);
+                  }
+                }
+              }
+            });
+            const msg = used ? '必须赋值有返回值的内容。' : '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
+            const diagnostic = {
+              node,
+              severity: 'error',
+              message: `${nodeTypeName} ${node.name} ${msg}`,
+            };
+            node.__aStructureError = diagnostic;
+            diagnostics.push(diagnostic);
+          } else {
+            node.__aStructureError = null;
+          }
+        }
+      });
     } else if (fileNode instanceof Connection) {
       const connectorPropertyNames = NaslServer.getPropertyNames(fileNode);
       const connectionPropertyNames = NaslServer.getPropertyNames(fileNode?.connector);
@@ -2502,6 +2614,74 @@ class NaslServer {
       })
     }
 
+    // TODO need reset when process support hoc & spread param & type annotation
+    const isInProcess = fileNode instanceof Process ||
+      fileNode instanceof ProcessV2 ||
+      !!fileNode?.getAncestor('Process') ||
+      !!fileNode?.getAncestor('ProcessV2');
+    if (isInProcess) {
+      // 查找计算过 subLogic 的节点。（目前只有 Logic、ProcessElement、ProcessElementV2）
+      let targetNode: Process | ProcessV2 = fileNode as | Process | ProcessV2;
+      if (
+        isProcess(fileNode) ||
+        isProcessV2(fileNode)
+      ) {
+        targetNode = fileNode;
+      } else {
+        targetNode = fileNode.getAncestor('Process') as Process || fileNode.getAncestor('ProcessV2') as ProcessV2;
+      }
+      if (targetNode?.subLogics?.length) {
+        const diagnostic = {
+          node: fileNode,
+          severity: 'error',
+          message: `流程暂不支持子逻辑`,
+          // 保留原来的内容方便查询一些问题
+          originalDiagnostic: {
+            fileName: '',
+            start: <any>null,
+            end: <any>null,
+            category: 'error',
+            text: `process not support subLogic`,
+          },
+        };
+        diagnostics.push(diagnostic);
+      }
+
+      if (targetNode.includeSpreadCallLogic) {
+        const diagnostic = {
+          node: fileNode,
+          severity: 'error',
+          message: `流程暂不支持可变参数`,
+          // 保留原来的内容方便查询一些问题
+          originalDiagnostic: {
+            fileName: '',
+            start: <any>null,
+            end: <any>null,
+            category: 'error',
+            text: `process not support spread call`,
+          },
+        };
+        diagnostics.push(diagnostic);
+      }
+
+      if (targetNode.includeTypeArgs) {
+        const diagnostic = {
+          node: fileNode,
+          severity: 'error',
+          message: `流程暂不支持范型参数`,
+          // 保留原来的内容方便查询一些问题
+          originalDiagnostic: {
+            fileName: '',
+            start: <any>null,
+            end: <any>null,
+            category: 'error',
+            text: `process not support type args`,
+          },
+        };
+        diagnostics.push(diagnostic);
+      }
+    }
+
     return diagnostics;
   }
 
@@ -2799,11 +2979,27 @@ class NaslServer {
         }
       }
     }
+
+    // 加上信用卡验证规则的静态检查
+    if (node instanceof ValidationRule && node.calleeName === 'creditCard') {
+      const typesArg = node.arguments?.find((arg) => {
+        return arg?.keyword === 'types';
+      });
+      if (typesArg?.expression?.concept !== 'NewList' || !((typesArg?.expression as NewList)?.items?.length)) {
+        const diagnostic = {
+          node: typesArg?.expression,
+          severity: 'error',
+          message: '至少选择1项验证信用卡',
+        };
+        typesArg.expression.tsErrorDetail = diagnostic;
+        diagnostics.push(diagnostic);
+      }
+    }
     if (node instanceof CallLogic) {
       // 处理依赖库高阶函数，函数签名和函数调用参数要完全一一对应
       if (node.calleeNamespace?.startsWith('extensions.')) {
         const logicNode = node.getCallNode();
-        const params = logicNode?.params?.slice();
+        const params = logicNode?.params?.slice() || [];
         const findFunction = params.find(param => param?.typeAnnotation?.typeKind === 'function');
         if (findFunction) {
           node.arguments?.forEach((argument, index) => {
@@ -3248,7 +3444,9 @@ class NaslServer {
               }
             }
           } catch (e) {
-            this.logger.error('naslServer实体引用', e);
+            if (utils.isDebugMode) {
+              this.logger.error('naslServer实体引用', e);
+            }
           }
         }
       }
@@ -3571,8 +3769,12 @@ class NaslServer {
             //     return null;
             // }
           }
-          // 如果节点是Identifier表达式
+          // 如果匹配到的节点是Identifier表达式
           if (minRange.node instanceof Identifier) {
+            // 如果参数修改影响了Identifier, 就说明是上一级逻辑的引用，所以就直接过滤掉就好了
+            if (node instanceof Param && minRange.node?.namespace?.endsWith('logics')) {
+              return null;
+            }
             // 匹配到的内容，当前这一行的内容；
             // 因为要用下面的点位信息
             const {name} = minRange.node;
@@ -3675,7 +3877,9 @@ class NaslServer {
                   minRange.setTypeMethods = 'setValue';
                 }
               } catch (error) {
-                console.error(error)
+                if (utils.isDebugMode) {
+                  this.logger.error(error);
+                }
               }
             } else if (minRange.node instanceof Identifier) {
               minRange.newValue = utils.firstLowerCase(newValue);
@@ -4061,7 +4265,9 @@ class NaslServer {
         result = this.handleTreeMap(resMap);
       }
     } catch (err) {
-      this.logger.error(err);
+      if (utils.isDebugMode) {
+        this.logger.error(err);
+      }
     }
     return result;
   }
@@ -4087,7 +4293,9 @@ class NaslServer {
         result.add(minRange.node);
       });
     } catch (err) {
-      this.logger.error(err);
+      if (utils.isDebugMode) {
+        this.logger.error(err);
+      }
     }
     return [...result];
   }
@@ -4595,25 +4803,22 @@ class NaslServer {
             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);
-                  }
+            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));
             }
+            node.__TypeAnnotation = utils.runGeneratorSync(type2TypeAnnotation(returnType));
 
             const typeArgs: any[] = [];
             const typeArguments = node.typeArguments;
@@ -4670,8 +4875,8 @@ class NaslServer {
 
     this.logger.timeEnd('全量标注');
 
-    // 测试环境打印数据
-    if (utils.isTestBrowser) {
+    // 测试环境或者是调试模式打印数据
+    if (utils.isDebugMode || utils.isTestBrowser) {
       this.logger.info('全量标注数据', json);
     }
 
@@ -4847,8 +5052,70 @@ class NaslServer {
         */
         if (node instanceof CallLogic && node.__TypeArguments?.length) {
           const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
-          jsonNode.typeArguments = node.__TypeArguments;
-          jsonNode.typeAnnotation = node.__TypeAnnotation;
+          jsonNode.typeArguments = node.__TypeArguments.map((type) => type?.toJSON());
+          jsonNode.typeAnnotation = node.__TypeAnnotation?.toJSON();
+        }
+
+        // 根据 https://projectmanage.netease-official.lcap.163yun.com/dashboard/FeatureDetail?id=2737356895760128&id1=null&iterationId=null&versionid=null&tab=info
+        // 对CallFunction节点，若其callee为部分List/Map内置函数，则修改其argument类型标注以让服务端据此插入显式的类型转换。规则如下：
+        // - 对argument.expression.typeAnnotation 无需做修改，保持为其实际类型
+        // - 对argument.typeAnnotation，为根据对应Collection的泛型参数的类型填写其类型
+        if (node instanceof CallFunction) {
+          if (node.calleeNamespace === 'nasl.util') {
+            const calleeName = node.calleeName;
+            const listFunctionParamIndexMaps = new Map(
+              Object.entries({
+                Add: { collection: 0, item: 1 },
+                Insert: { collection: 0, item: 2 },
+                Remove: { collection: 0, item: 1 },
+                Contains: { collection: 0, item: 1 },
+              })
+            );
+            const mapFunctionParamIndexMaps = new Map(
+              Object.entries({
+                MapPut: { collection: 0, key: 1, value: 2 },
+                MapGet: { collection: 0, key: 1, },
+                MapRemove: { collection: 0, key: 1 },
+                MapContains: { collection: 0, key: 1 },
+              })
+            );
+            const listParamIndex = listFunctionParamIndexMaps.get(calleeName);
+            if (listParamIndex) {
+              const list = node.arguments[listParamIndex.collection];
+              const item = node.arguments[listParamIndex.item];
+              const itemExpression = item?.expression;
+              if (itemExpression) {
+                const listTypeArgument = list.__TypeAnnotation?.typeArguments?.[0]?.toJSON();
+                if (listTypeArgument) {
+                  const jsonNode = jsoner.queryNodeByPath(json, item.getNodePath(false));
+                  jsonNode.typeAnnotation = listTypeArgument;
+                }
+              }
+            } else {
+              const mapParamIndex = mapFunctionParamIndexMaps.get(calleeName);
+              if(mapParamIndex){
+                const map = node.arguments[mapParamIndex.collection];
+                const key = node.arguments[mapParamIndex.key];
+                const value = node.arguments[mapParamIndex.value];
+                const keyExpression = key?.expression;
+                const valueExpression = value?.expression;
+                if (keyExpression) {
+                  const mapKeyTypeArgument = map.__TypeAnnotation?.typeArguments?.[0]?.toJSON();
+                  if (mapKeyTypeArgument) {
+                    const jsonNode = jsoner.queryNodeByPath(json, key.getNodePath(false));
+                    jsonNode.typeAnnotation = mapKeyTypeArgument;
+                  }
+                }
+                if (valueExpression) {
+                  const mapValueTypeArgument = map.__TypeAnnotation?.typeArguments?.[1]?.toJSON();
+                  if (mapValueTypeArgument) {
+                    const jsonNode = jsoner.queryNodeByPath(json, value.getNodePath(false));
+                    jsonNode.typeAnnotation = mapValueTypeArgument;
+                  }
+                }
+              }
+            }
+          }
         }
       }
 
@@ -4916,7 +5183,9 @@ class NaslServer {
     }
     return new Promise((resolve, reject) => {
       const myTimer = setTimeout(() => {
-        this.logger.warn(node, '没有获取到类型');
+        if (utils.isDebugMode) {
+          this.logger.warn(node, '没有获取到类型');
+        }
         clearTimeout(myTimer);
         clearInterval(mySetInterval);
         if (node.__isCorrectTypeAnnotation) {

package/src/server/translator.ts

@@ -73,7 +73,7 @@ export interface MinRange {
 const mapAstString = new Map();
 
 function transformType(tsType: string): string {
-  if (tsType === 'string' || tsType === 'String') return '字符串';
+  if (tsType === 'string' || tsType === 'String' || /StringLiteral<['"].*['"]>/.test(tsType)) return '字符串';
   else if (tsType === 'number') return '数字';
   else if (tsType === 'Integer') return '整数';
   else if (tsType === 'Double') return '小数';
@@ -324,6 +324,10 @@ const TS_RULES: Array<{
     re: /Cannot find name '__ValidationRule__'./,
     result: '校验规则不能为空',
   },
+  {
+    re: /Cannot find name '__UNCERTAIN__INTERMEDIATE__FIELDS__'./,
+    result: '来自不确定结构或实体的字段',
+  },
   {
     re: /No value exists in scope for the shorthand property '__(?:IDENTIFIER|LEFT|RIGHT)__'. Either declare one or provide an initializer./,
     result: '用户任务未关联页面',

package/src/templator/genCreateBlock.ts

@@ -246,25 +246,12 @@ function genSubmitLogic(createLogic: Logic, nameGroup: NameGroup, extendConseque
     name: nameGroup.viewLogicSubmit,
     params: [],
     returns: [],
-    variables: [
-      NaslNode.Variable({
-        name: 'validateResult',
-        typeAnnotation: NaslUITypeAnnotation.ValidateEvent,
-      }),
-    ],
+    variables: [],
     body: [
       NaslLogicItem.Start,
-      NaslLogicItem.Assignment({
-        left: NaslLogicItem.Identifier({
-          name: 'validateResult',
-        }),
-        right: genCallComponentLogic(nameGroup.viewElementMainView, 'validate'),
-      }),
       NaslLogicItem.IfStatement({
         test: NaslLogicItem.MemberExpression({
-          object: NaslLogicItem.Identifier({
-            name: 'validateResult',
-          }),
+          object: genCallComponentLogic(nameGroup.viewElementMainView, 'validate'),
           property: NaslLogicItem.Identifier({
             name: 'valid',
           }),
@@ -497,7 +484,7 @@ export function genCreateBlock(entity: Entity, oldNode: ViewElement, appointKeys
   }
   let viewBindEvents = '';
   let viewLoadLogic;
-  if(localTemplate.genCreatedHandler) {
+  if(localTemplate?.genCreatedHandler) {
     nameGroup.viewLogicCreated = likeComponent.getLogicUniqueName('load');
     viewLoadLogic = localTemplate.genCreatedHandler(entity, nameGroup)
     viewBindEvents = `
@@ -512,8 +499,8 @@ export function genCreateBlock(entity: Entity, oldNode: ViewElement, appointKeys
     ]`
   }
 
-  const submitLogic = (localTemplate.genSubmitLogicLocal || genSubmitLogic)(createLogic, nameGroup, extendConsequent);
-  const genTemplate = localTemplate.genCreateTemplate || ((frontendType || config.scope) === 'h5' ? genH5CreateFormTemplate : genCreateFormTemplate);
+  const submitLogic = (localTemplate?.genSubmitLogicLocal || genSubmitLogic)(createLogic, nameGroup, extendConsequent);
+  const genTemplate = localTemplate?.genCreateTemplate || ((frontendType || config.scope) === 'h5' ? genH5CreateFormTemplate : genCreateFormTemplate);
   return `<template>
     ${genTemplate(entity, nameGroup, selectNameGroupMap, appointKeys, process, extra)}
 </template>

package/src/templator/genCurdMultipleKeyBlock.ts

@@ -324,25 +324,12 @@ export function genSubmitLogic(entity: Entity, nameGroup: NameGroup) {
     name: nameGroup.viewLogicSubmit,
     params: [] as any[],
     returns: [] as any[],
-    variables: [
-      NaslNode.Variable({
-        name: 'validateResult',
-        typeAnnotation: NaslUITypeAnnotation.ValidateEvent,
-      }),
-    ],
+    variables: [],
     body: [
       NaslLogicItem.Start,
-      NaslLogicItem.Assignment({
-        left: NaslLogicItem.Identifier({
-          name: 'validateResult',
-        }),
-        right: genCallComponentLogic(nameGroup.viewElementSaveModalForm, 'validate'),
-      }),
       NaslLogicItem.IfStatement({
         test: NaslLogicItem.MemberExpression({
-          object: NaslLogicItem.Identifier({
-            name: 'validateResult',
-          }),
+          object: genCallComponentLogic(nameGroup.viewElementSaveModalForm, 'validate'),
           property: NaslLogicItem.Identifier({
             name: 'valid',
           }),
@@ -372,25 +359,12 @@ export function genUpdateSubmitLogic(entity: Entity, nameGroup: NameGroup) {
     name: nameGroup.viewLogicUpdateSubmit,
     params: [] as any[],
     returns: [] as any[],
-    variables: [
-      NaslNode.Variable({
-        name: 'validateResult',
-        typeAnnotation: NaslUITypeAnnotation.ValidateEvent,
-      }),
-    ],
+    variables: [],
     body: [
       NaslLogicItem.Start,
-      NaslLogicItem.Assignment({
-        left: NaslLogicItem.Identifier({
-          name: 'validateResult',
-        }),
-        right: genCallComponentLogic(nameGroup.viewElementSaveModalForm, 'validate'),
-      }),
       NaslLogicItem.IfStatement({
         test: NaslLogicItem.MemberExpression({
-          object: NaslLogicItem.Identifier({
-            name: 'validateResult',
-          }),
+          object: genCallComponentLogic(nameGroup.viewElementSaveModalForm, 'validate'),
           property: NaslLogicItem.Identifier({
             name: 'valid',
           }),
@@ -994,10 +968,10 @@ function genDelModalSubmitLogic(entity: Entity, nameGroup: NameGroup) {
 export function genFilterTemplateTableDesigner(entity: Entity, nameGroup: NameGroup, selectNameGroupMap: Map<string, NameGroup>, optionsMap?: any, dataSourcesMap?: any) {
   const dataSource = entity.parentNode as DataSource;
   const properties = entity.properties.filter(filterProperty('inFilter')).filter((it) => it?.typeAnnotation?.typeName !== 'List');
-  const getCol = (code: string) => `<u-grid-layout-column span="6" style="padding: 10px 0;">${code}</u-grid-layout-column>`;
+  const getCol = (code: string) => `<u-grid-layout-column :span="6" style="padding: 10px 0;">${code}</u-grid-layout-column>`;
   return `<u-form style="margin-bottom: 6px;padding: 15px 15px 5px 15px;background: #fff;">
       <u-grid-layout>
-        <u-grid-layout-row repeat="24">
+        <u-grid-layout-row :repeat="24">
           ${properties
             .map((property) => {
               const vModel = `${nameGroup.viewVariableFilter}.${property.name}`;
@@ -1209,6 +1183,14 @@ function genSaveModalTemplateDesigner(
       '<u-form',
       `<u-form ref="${nameGroup.viewElementSaveModalForm}" :preview="${nameGroup.viewVariablePreview}" `
     );
+    const hasUploader = SaveModalFormTemplate && SaveModalFormTemplate.indexOf('u-uploader') > -1;
+    if (hasUploader) {
+      // 文件上传组件绑定预览属性, todo: 表单中各类组件的预览属性绑定
+      SaveModalFormTemplate = SaveModalFormTemplate.replaceAll(
+        '<u-uploader',
+        '<u-uploader :preview="preview"'
+      );
+    }
   }
 
   return `