@lcap/nasl 2.20.1-beta.2 → 2.21.0-beta.2

package/src/templator/dist/utils.js

@@ -0,0 +1,527 @@
+"use strict";
+exports.__esModule = true;
+exports.NaslNode = exports.NaslQueryExpression = exports.NaslLogicItem = exports.NaslCollectionTypeAnnotation = exports.NaslTypeAnnotation = exports.NaslUITypeAnnotation = exports.NaslCoreTypeAnnotation = exports.genUniqueQueryNameGroup = exports.genMemberExpression = exports.genLogicParam = exports.getFirstDisplayedProperty = exports.getParamFromLogic = exports.getExpression = exports.filterProperty = void 0;
+var __1 = require("..");
+exports.filterProperty = function (key) { return function (property) {
+    if (property.display) {
+        return property.display[key];
+    }
+    else {
+        return !['id', 'createdTime', 'updatedTime'].includes(property.name);
+    }
+}; };
+/**
+ * 生成表达式的代码
+ * @param property 实体属性
+ * @param expression 表达式
+ */
+function getExpression(property, expression) {
+    var typeAnnotation = (property || {}).typeAnnotation;
+    var _a = typeAnnotation || {}, propertyTypeName = _a.typeName, propertyTypeNamespace = _a.typeNamespace;
+    if (propertyTypeName === 'DateTime')
+        return "$utils['FormatDateTime'](" + expression + ", 'YYYY-MM-DD HH:mm:ss')";
+    else if (propertyTypeName === 'Date')
+        return "$utils['FormatDate'](" + expression + ", 'YYYY-MM-DD')";
+    else {
+        var namespaceArr = propertyTypeNamespace.split('.');
+        var type = namespaceArr.pop();
+        if (type === 'enums') {
+            return "$utils['EnumValueToText'](" + expression + ", '__enumTypeAnnotation_" + propertyTypeNamespace + "." + propertyTypeName + "')";
+        }
+        else {
+            return "" + (expression || "''");
+        }
+    }
+}
+exports.getExpression = getExpression;
+/**
+ * 从 Logic 中获取变量
+ * @param resolver
+ * @param paramName
+ */
+function getParamFromLogic(logic, paramName) {
+    var params = logic.params;
+    return params.find(function (item) { return item.name === paramName; });
+}
+exports.getParamFromLogic = getParamFromLogic;
+function getFirstDisplayedProperty(entity) {
+    var property = entity.properties.find(function (property) { return !property.readonly; });
+    if (!property)
+        property = entity.properties[0];
+    return property;
+}
+exports.getFirstDisplayedProperty = getFirstDisplayedProperty;
+function genArgumentMemberExpression(arr) {
+    var expressionNode;
+    var propertyName = arr.pop();
+    if (arr.length >= 1) {
+        expressionNode = exports.NaslLogicItem.MemberExpression({
+            object: genArgumentMemberExpression(arr),
+            property: exports.NaslLogicItem.Identifier({
+                name: propertyName
+            })
+        });
+    }
+    else {
+        return exports.NaslLogicItem.Identifier({
+            name: propertyName
+        });
+    }
+    return expressionNode;
+}
+/**
+ * 生成逻辑 Param
+ * @param paramIdOrName 参数 id 或引用名称
+ * @param expression 表达式
+ * @param schemaChildren 数据结构
+ */
+function genLogicParam(paramIdOrName, expression) {
+    return exports.NaslLogicItem.Argument({
+        keyword: paramIdOrName,
+        expression: genArgumentMemberExpression(expression.split('.'))
+    });
+}
+exports.genLogicParam = genLogicParam;
+/**
+ * 生成接口 Param
+ * @param paramIdOrName 参数 id 或引用名称
+ * @param expression 表达式
+ * @param schemaChildren 数据结构
+ */
+function genMemberExpression(expression, schemaRefs) {
+    if (schemaRefs === void 0) { schemaRefs = []; }
+    var arr = expression.split('.');
+    var expressionNode;
+    arr.forEach(function (name, index) {
+        var currentNode = exports.NaslLogicItem.Identifier({
+            name: name
+        });
+        if (expressionNode) {
+            expressionNode = exports.NaslLogicItem.MemberExpression({
+                object: expressionNode,
+                property: exports.NaslLogicItem.Identifier({
+                    name: name
+                })
+            });
+        }
+        else {
+            expressionNode = currentNode;
+        }
+    });
+    return expressionNode;
+}
+exports.genMemberExpression = genMemberExpression;
+function capFirstLetter(word) {
+    if (!word)
+        return word;
+    return word[0].toUpperCase() + word.slice(1);
+}
+/**
+ * 生成数据查询唯一的命名组
+ * @param viewName 页面名称
+ * @param componentName 组件名称
+ * @param suffix 其它后缀，比如实体名等等
+ * @param defaultInView 是否在页面逻辑中用 load 简写
+ */
+function genUniqueQueryNameGroup(scope, view, componentName, defaultInView, suffix) {
+    if (componentName === void 0) { componentName = ''; }
+    if (defaultInView === void 0) { defaultInView = true; }
+    if (suffix === void 0) { suffix = ''; }
+    var result = {};
+    result.viewLogicLoad = view.getLogicUniqueName("load" + (defaultInView ? '' : capFirstLetter(componentName)) + (suffix ? capFirstLetter(suffix) : ''));
+    result.logic = scope.getLogicUniqueName("load" + capFirstLetter(view.name) + (componentName ? capFirstLetter(componentName) : '') + (suffix ? capFirstLetter(suffix) : ''));
+    result.structure = scope.getStructureUniqueName(__1.utils.firstUpperCase(result.logic + 'Structure'));
+    return result;
+}
+exports.genUniqueQueryNameGroup = genUniqueQueryNameGroup;
+function genNaslCoreTypeAnnotation(typeName, text) {
+    if (text === void 0) { text = ''; }
+    return {
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'primitive',
+        typeNamespace: 'nasl.core',
+        typeName: typeName,
+        text: text
+    };
+}
+function genNaslUITypeAnnotation(typeName) {
+    return {
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'reference',
+        typeNamespace: 'nasl.ui',
+        typeName: typeName
+    };
+}
+function genNaslCollectionTypeAnnotation(typeName) {
+    return function (typeArguments) { return ({
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'generic',
+        typeNamespace: 'nasl.collection',
+        typeName: typeName,
+        typeArguments: typeArguments
+    }); };
+}
+function genNaslUIGenericTypeAnnotation(typeName) {
+    return function (typeArguments) { return ({
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'generic',
+        typeNamespace: 'nasl.ui',
+        typeName: typeName,
+        typeArguments: typeArguments
+    }); };
+}
+exports.NaslCoreTypeAnnotation = {
+    Boolean: genNaslCoreTypeAnnotation('Boolean'),
+    Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
+    Double: genNaslCoreTypeAnnotation('Double'),
+    Decimal: genNaslCoreTypeAnnotation('Decimal'),
+    Long: genNaslCoreTypeAnnotation('Long', 'Long 长整数'),
+    String: genNaslCoreTypeAnnotation('String', 'String 字符串'),
+    Text: genNaslCoreTypeAnnotation('Text'),
+    Binary: genNaslCoreTypeAnnotation('Binary'),
+    Date: genNaslCoreTypeAnnotation('Date'),
+    Time: genNaslCoreTypeAnnotation('Time'),
+    DateTime: genNaslCoreTypeAnnotation('DateTime'),
+    Email: genNaslCoreTypeAnnotation('Email')
+};
+exports.NaslUITypeAnnotation = {
+    DataSourceParams: genNaslUITypeAnnotation('DataSourceParams'),
+    EventTarget: genNaslUITypeAnnotation('EventTarget'),
+    MouseEvent: genNaslUITypeAnnotation('MouseEvent'),
+    FocusEvent: genNaslUITypeAnnotation('FocusEvent'),
+    ChangeEvent: genNaslUITypeAnnotation('ChangeEvent'),
+    NavigateEvent: genNaslUITypeAnnotation('NavigateEvent'),
+    ChangeItemEvent: genNaslUITypeAnnotation('ChangeItemEvent'),
+    ChangeItemsEvent: genNaslUITypeAnnotation('ChangeItemsEvent'),
+    CascadeCapsulesEvent: genNaslUITypeAnnotation('CascadeCapsulesEvent'),
+    CollapseEvent: genNaslUITypeAnnotation('CollapseEvent'),
+    SliderEvent: genNaslUITypeAnnotation('SliderEvent'),
+    DateEvent: genNaslUITypeAnnotation('DateEvent'),
+    OperatorItemEvent: genNaslUITypeAnnotation('OperatorItemEvent'),
+    ValidateEvent: genNaslUITypeAnnotation('ValidateEvent'),
+    PaginationEvent: genNaslUITypeAnnotation('PaginationEvent'),
+    DurationEvent: genNaslUITypeAnnotation('DurationEvent'),
+    TransferEvent: genNaslUITypeAnnotation('TransferEvent'),
+    TreeChangeEvent: genNaslUITypeAnnotation('TreeChangeEvent'),
+    CheckedEvent: genNaslUITypeAnnotation('CheckedEvent'),
+    UploadEvent: genNaslUITypeAnnotation('UploadEvent'),
+    UploadErrorEvent: genNaslUITypeAnnotation('UploadErrorEvent'),
+    SortEvent: genNaslUITypeAnnotation('SortEvent'),
+    PoiInfo: genNaslUITypeAnnotation('PoiInfo'),
+    File: genNaslUITypeAnnotation('File'),
+    Current: genNaslUIGenericTypeAnnotation('Current')
+};
+exports.NaslTypeAnnotation = {
+    Reference: function (_a) {
+        var typeNamespace = _a.typeNamespace, typeName = _a.typeName;
+        return ({
+            concept: 'TypeAnnotation',
+            name: '',
+            typeKind: 'reference',
+            typeNamespace: typeNamespace,
+            typeName: typeName
+        });
+    },
+    AnonymousStructure: function (properties) { return ({
+        concept: 'TypeAnnotation',
+        typeKind: 'anonymousStructure',
+        properties: [{
+                concept: 'StructureProperty',
+                name: 'list',
+                typeAnnotation: {
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'List',
+                    typeNamespace: 'nasl.collection',
+                    typeArguments: [{
+                            concept: 'TypeAnnotation',
+                            typeKind: 'anonymousStructure',
+                            properties: properties
+                        }]
+                }
+            }, {
+                concept: 'StructureProperty',
+                name: 'total',
+                typeAnnotation: {
+                    concept: 'TypeAnnotation',
+                    typeKind: 'primitive',
+                    typeNamespace: 'nasl.core',
+                    typeName: 'Integer'
+                }
+            }]
+    }); }
+};
+exports.NaslCollectionTypeAnnotation = {
+    List: genNaslCollectionTypeAnnotation('List'),
+    PageOf: genNaslCollectionTypeAnnotation('PageOf')
+};
+exports.NaslLogicItem = {
+    // 开始
+    Start: {
+        concept: 'Start',
+        name: '',
+        label: '开始',
+        kind: 'Statement'
+    },
+    // 结束
+    End: {
+        concept: 'End',
+        name: '',
+        label: '结束',
+        kind: 'Statement'
+    },
+    // 调用逻辑
+    CallLogic: function (_a) {
+        var calleeNamespace = _a.calleeNamespace, calleeName = _a.calleeName, _b = _a.label, label = _b === void 0 ? '调用逻辑' : _b, _c = _a.shortcut, shortcut = _c === void 0 ? false : _c, args = _a.arguments;
+        return ({
+            concept: 'CallLogic',
+            name: '',
+            label: label,
+            kind: 'Statement',
+            shortcut: shortcut,
+            calleeNamespace: calleeNamespace,
+            calleeName: calleeName,
+            arguments: args
+        });
+    },
+    // 内置函数
+    CallFunction: function (_a) {
+        var _b = _a.calleeNamespace, calleeNamespace = _b === void 0 ? 'nasl.util' : _b, calleeName = _a.calleeName, _c = _a.label, label = _c === void 0 ? '内置函数' : _c, _d = _a.shortcut, shortcut = _d === void 0 ? false : _d, _e = _a.arguments, args = _e === void 0 ? [] : _e;
+        return ({
+            concept: 'CallFunction',
+            name: '',
+            label: '调用逻辑',
+            kind: 'Expression',
+            calleeNamespace: calleeNamespace,
+            calleeName: calleeName,
+            arguments: args
+        });
+    },
+    // 参数
+    Argument: function (_a) {
+        var keyword = _a.keyword, expression = _a.expression;
+        return ({
+            concept: 'Argument',
+            name: '',
+            kind: 'Statement',
+            keyword: keyword,
+            expression: expression
+        });
+    },
+    // 成员表达式
+    MemberExpression: function (_a) {
+        var object = _a.object, property = _a.property;
+        return ({
+            concept: 'MemberExpression',
+            name: '',
+            kind: 'Expression',
+            object: object,
+            property: property
+        });
+    },
+    // 变量
+    Identifier: function (_a) {
+        var name = _a.name;
+        return ({
+            concept: 'Identifier',
+            kind: 'Expression',
+            name: name
+        });
+    },
+    // 字面量
+    StringLiteral: function (_a) {
+        var value = _a.value;
+        return ({
+            concept: 'StringLiteral',
+            name: '',
+            kind: 'Expression',
+            value: value
+        });
+    },
+    Assignment: function (_a) {
+        var left = _a.left, right = _a.right;
+        return ({
+            concept: 'Assignment',
+            name: '',
+            label: '赋值',
+            kind: 'Statement',
+            left: left,
+            right: right
+        });
+    },
+    IfStatement: function (_a) {
+        var test = _a.test, consequent = _a.consequent, alternate = _a.alternate;
+        return ({
+            concept: 'IfStatement',
+            name: '',
+            kind: 'Statement',
+            test: test,
+            consequent: consequent,
+            alternate: alternate
+        });
+    },
+    // 二元
+    BinaryExpression: function (_a) {
+        var operator = _a.operator, left = _a.left, _b = _a.label, label = _b === void 0 ? '算术运算' : _b, right = _a.right;
+        return ({
+            concept: 'BinaryExpression',
+            name: '',
+            kind: 'Expression',
+            label: label,
+            operator: operator,
+            left: left,
+            right: right
+        });
+    }
+};
+exports.NaslQueryExpression = {
+    QueryFieldExpression: function (_a) {
+        var label = _a.label, isDotStar = _a.isDotStar, entityAsName = _a.entityAsName, propertyName = _a.propertyName;
+        return ({
+            concept: 'QueryFieldExpression',
+            name: '',
+            label: label,
+            kind: 'Expression',
+            isDotStar: isDotStar,
+            entityAsName: entityAsName,
+            propertyName: propertyName
+        });
+    },
+    QueryFromExpression: function (_a) {
+        var entityNamespace = _a.entityNamespace, entityName = _a.entityName, joinParts = _a.joinParts;
+        return ({
+            concept: 'QueryFromExpression',
+            name: '',
+            kind: 'Expression',
+            entityNamespace: entityNamespace,
+            entityName: entityName,
+            joinParts: joinParts
+        });
+    },
+    QueryJoinExpression: function (_a) {
+        var label = _a.label, entityNamespace = _a.entityNamespace, entityName = _a.entityName, joinType = _a.joinType, onExpressions = _a.onExpressions, joinParts = _a.joinParts;
+        return ({
+            concept: 'QueryJoinExpression',
+            label: label,
+            name: '',
+            kind: 'Expression',
+            entityNamespace: entityNamespace,
+            entityName: entityName,
+            joinType: joinType,
+            onExpressions: onExpressions,
+            joinParts: joinParts
+        });
+    },
+    QuerySelectExpression: function (_a) {
+        var label = _a.label, distinct = _a.distinct, star = _a.star, selectElements = _a.selectElements;
+        return ({
+            concept: 'QuerySelectExpression',
+            name: '',
+            kind: 'Expression',
+            label: label,
+            distinct: distinct,
+            star: star,
+            selectElements: selectElements
+        });
+    },
+    QueryOrderByExpression: function (_a) {
+        var label = _a.label, order = _a.order, orderElement = _a.orderElement;
+        return ({
+            concept: 'QueryOrderByExpression',
+            label: label,
+            order: order,
+            orderElement: orderElement
+        });
+    },
+    QueryLimitExpression: function (_a) {
+        var label = _a.label, pageElement = _a.pageElement, pageSizeElement = _a.pageSizeElement;
+        return ({
+            concept: 'QueryLimitExpression',
+            name: '',
+            kind: 'Expression',
+            label: label,
+            pageElement: pageElement,
+            pageSizeElement: pageSizeElement
+        });
+    },
+    CallQueryComponent: function (_a) {
+        var label = _a.label, typeAnnotation = _a.typeAnnotation, select = _a.select, from = _a.from, where = _a.where, limit = _a.limit, groupBy = _a.groupBy, having = _a.having, orderBy = _a.orderBy, logicName = _a.logicName, structureName = _a.structureName, ideVersion = _a.ideVersion;
+        return ({
+            concept: 'CallQueryComponent',
+            name: '',
+            label: label,
+            kind: 'Statement',
+            typeAnnotation: typeAnnotation,
+            select: select,
+            from: from,
+            where: where,
+            limit: limit,
+            groupBy: groupBy,
+            having: having,
+            orderBy: orderBy,
+            logicName: logicName,
+            structureName: structureName,
+            ideVersion: ideVersion
+        });
+    }
+};
+exports.NaslNode = {
+    Logic: function (_a) {
+        var name = _a.name, params = _a.params, returns = _a.returns, variables = _a.variables, body = _a.body, description = _a.description, playground = _a.playground;
+        return ({
+            concept: 'Logic',
+            name: name,
+            params: params,
+            returns: returns,
+            variables: variables,
+            body: body,
+            description: description,
+            playground: playground
+        });
+    },
+    Structure: function (_a) {
+        var name = _a.name, properties = _a.properties, origin = _a.origin;
+        return ({
+            concept: 'Structure',
+            name: name,
+            properties: properties,
+            origin: origin
+        });
+    },
+    StructureProperty: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'StructureProperty',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    },
+    Variable: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'Variable',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    },
+    Param: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'Param',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    },
+    Return: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'Return',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    }
+};

package/src/templator/genCallComponentLogic.ts

@@ -6,7 +6,7 @@ import { NaslLogicItem } from './utils';
  * @param componentMethod 组件方法
  * @param params 输入的参数
  */
-export function genCallComponentLogic(componentName: string, componentMethod: string, params: Array<string> = []) {
+export function genCallComponentLogic(componentName: string, componentMethod: string, params: Array<string | any> = []) {
     return NaslLogicItem.CallLogic({
         calleeNamespace: `elements.${componentName}.logics`,
         calleeName: componentMethod,

package/src/templator/genCurdEditMultipleKeyBlock.ts

@@ -4,7 +4,7 @@
  * 3. 先简单做后续在看如何优化
  */
 import * as utils from '../utils';
-import { App, Module, Namespace, Entity, View, Enum, DataSource, ViewElement } from '../concepts';
+import { App, Module, Namespace, Entity, View, Enum, DataSource, ViewElement, EntityProperty } from '../concepts';
 import { NaslCoreTypeAnnotation, NaslUITypeAnnotation, NaslTypeAnnotation, NaslLogicItem, NaslNode } from './utils';
 import {
     filterProperty,
@@ -374,3 +374,112 @@ export function genCurdEditMultipleKeyBlock(entity: Entity, oldNode: ViewElement
 </definition>
 `;
 }
+
+/**
+ * 根据实体属性生成表格列模板
+ * @param property 实体属性
+ */
+export function genEditTableColumnComponent(app:App, entity: Entity, property: EntityProperty, view: View, nameGroup: NameGroup) {
+    const dataSource = entity.parentNode as DataSource;
+    const valueExpression = `${nameGroup.valuePrefixExpression}.${property.name}`;
+    const module = app;
+
+    const newLogics: any[] = [];
+    const newLoadSelectLogics: any[] = [];
+
+    const genEditComponent = (property: EntityProperty) => {
+        const label = property.label || property.name;
+        let formItem = '';
+
+        const propertyTypeName = property.typeAnnotation.typeName;
+        const propertyTypeNamespace = property.typeAnnotation.typeNamespace;
+        if (property.relationEntity) {
+            // 有外键关联
+            const relationEntity = dataSource?.findEntityByName(property.relationEntity);
+            if (relationEntity) {
+                const relationProperty = relationEntity.properties.find((prop) => prop.name === property.relationProperty);
+                const displayedProperty = getFirstDisplayedProperty(relationEntity);
+                if (displayedProperty) {
+                    const lowerEntityName = utils.firstLowerCase(relationEntity.name);
+                    const selectNameGroup = {
+                        viewLogicLoad: nameGroup.viewElementSelectLogic,
+                        viewElementSelect: '',
+                    };
+                    if (!nameGroup.viewElementSelectLogic) {
+                        const viewElementSelect = view.getViewElementUniqueName('select');
+                        const selectNameGroup = genUniqueQueryNameGroup(module, view, viewElementSelect, false, relationEntity.name);
+                        selectNameGroup.viewElementSelect = viewElementSelect;
+                        const newLogic = genQueryLogic([relationEntity], selectNameGroup, false, false, module);
+                        newLogics.push(newLogic);
+                        newLoadSelectLogics.push(genLoadSelectLogic(relationEntity, selectNameGroup, newLogic));
+                    }
+                    formItem += `
+                        <u-select clearable placeholder="请选择${label}" :data-source="${selectNameGroup.viewLogicLoad}"
+                            :autofocus="true" :opened="true" append-to="body" @blur="${nameGroup.viewLogicBlurUpdate}" @select="${nameGroup.viewLogicBlurUpdate}"
+                            text-field="${lowerEntityName}.${displayedProperty.name}" value-field="${lowerEntityName}.${relationProperty.name}" :pageable="true" :remote-paging="true" :value.sync="${valueExpression}">
+                        </u-select>
+                    `;
+                } else
+                    return '';
+            } else
+                return '';
+        } else if (propertyTypeName === 'Boolean') {
+            formItem += `<u-select clearable :value.sync="${valueExpression}" placeholder="请输入${label}"
+            :autofocus="true" :opened="true" append-to="body" @blur="${nameGroup.viewLogicBlurUpdate}" @select="${nameGroup.viewLogicBlurUpdate}">
+                <u-select-item :value="true" text="是">是</u-select-item>
+                <u-select-item :value="false" text="否">否</u-select-item>
+            </u-select>`;
+        } else if (propertyTypeName === 'Integer' || propertyTypeName === 'Long') {
+            formItem = `<u-number-input :value.sync="${valueExpression}" placeholder="请输入${label}" :autofocus="true" @blur="${nameGroup.viewLogicBlurUpdate}"></u-number-input>`;
+        } else if (propertyTypeName === 'Double') {
+            formItem = `<u-number-input :value.sync="${valueExpression}" :precision="0" :step="0" placeholder="请输入${label}" :autofocus="true" @blur="${nameGroup.viewLogicBlurUpdate}"></u-number-input>`;
+        } else if (propertyTypeName === 'Decimal') {
+            formItem = `<u-number-input :value.sync="${valueExpression}" :precision="0" :step="0" placeholder="请输入${label}" :autofocus="true" @blur="${nameGroup.viewLogicBlurUpdate}"></u-number-input>`;
+        } else if (propertyTypeName === 'Text') {
+            formItem = `<u-validator placement="bottom" display="appear" @blur-valid="${nameGroup.viewLogicBlurUpdate}" style="width:100%">
+            <u-textarea :value.sync="${valueExpression}" placeholder="请输入${label}" :autofocus="true" size="full"></u-textarea>
+            </u-validator>`;
+        } else if (propertyTypeName === 'Date') {
+            formItem = `<u-date-picker clearable :date.sync="${valueExpression}" placeholder="请输入${label}" append-to="body" :autofocus="true" :opened="true" @blur="${nameGroup.viewLogicBlurUpdate}"></u-date-picker>`;
+        } else if (propertyTypeName === 'Time') {
+            formItem = `<u-time-picker :time.sync="${valueExpression}" placeholder="请输入${label}" append-to="body" :autofocus="true" @blur="${nameGroup.viewLogicBlurUpdate}"></u-time-picker>`;
+        } else if (propertyTypeName === 'DateTime') {
+            formItem = `<u-date-time-picker clearable :date.sync="${valueExpression}" placeholder="请输入${label}" append-to="body" :autofocus="true" :opened="true" @blur="${nameGroup.viewLogicBlurUpdate}"></u-date-time-picker>`;
+        } else {
+            const namespaceArr = propertyTypeNamespace && propertyTypeNamespace.split('.') || [];
+            const type = namespaceArr.pop();
+            if (type === 'enums') {
+                const enumeration = app.findNodeByCompleteName(propertyTypeNamespace + '.' + propertyTypeName) as Enum;
+                const namespace = enumeration?.getNamespace() || '';
+                const name = enumeration?.name || '';
+                const enumTypeAnnotationStr = `__enumTypeAnnotation_${namespace}.${name}`;
+                formItem += `<u-select clearable 
+                :data-source="$utils.EnumToList('${enumTypeAnnotationStr}')"
+                :value.sync="${valueExpression}" placeholder="请输入${label}"
+                :autofocus="true" :opened="true" append-to="body" @blur="${nameGroup.viewLogicBlurUpdate}" @select="${nameGroup.viewLogicBlurUpdate}">
+                </u-select>`;
+            } else {
+                formItem = `<u-validator placement="bottom" display="appear" @blur-valid="${nameGroup.viewLogicBlurUpdate}" style="width:100%" append-to="body">
+                    <u-input :value.sync="${valueExpression}" placeholder="请输入${label}" :autofocus="true" size="full"></u-input>
+                </u-validator>`;
+            }
+        }
+        return `<template #editcell="current">
+            <u-linear-layout gap="small">
+                ${formItem}
+            </u-linear-layout>
+        </template>`;
+    };
+
+    return `<template>${genEditComponent(property)}</template>
+<definition>
+{
+    "viewLogics": [
+        ${JSON.stringify(genBlurUpdateLogic(entity, nameGroup))}
+        ${newLoadSelectLogics.map((logic) => ',' + JSON.stringify(logic)).join('\n')}
+    ],
+    "logics": ${JSON.stringify(newLogics)}
+}
+</definition>`;
+}
+