@lcap/nasl 0.3.10-beta.oom4 → 0.3.12-beta

package/src/types/data/genBlock/genEditTableBlock.ts

@@ -0,0 +1,470 @@
+import {
+    dataTypesMap, vertexsMap, Entity, EntityProperty, View,
+    LEVEL_ENUM, utils,
+    Enum,
+} from '../..';
+import {
+    getExpression, filterProperty, NameGroup, genUniqueQueryNameGroup,
+    getFirstDisplayedProperty, getParamFromResolver,
+    genGenericTypeSchema, genVariable, genInterParam, genCallComponentLogic,
+    genCallInterface, genQueryInterface,
+    genCallInterfaceFromTempInterface,
+    genMemberExpression,
+    genEditQueryStructure,
+} from '.';
+
+/**
+ * 根据实体属性生成表格列模板
+ * @param property 实体属性
+ */
+export function genEditTableColumnTemplate(entity: Entity, property: EntityProperty, nameGroup: NameGroup, selectNameGroupMap?: Map<string, NameGroup>) {
+    const lowerEntityName = utils.firstLowerCase(property.root.name);
+    const valueExpression = `scope.item.${lowerEntityName}.${property.name}`;
+    const title = property.label || property.name;
+
+    const expression = getExpression(property, `scope.item.${lowerEntityName}.${property.name}`);
+
+    const canEditable = (property: EntityProperty) => property.editable;
+
+    const getText = (property: EntityProperty) => {
+        if (property.typeKey === '#/basicTypes/Boolean') {
+            return `
+            <u-text v-if="${expression}" text="是"></u-text>
+            <u-text v-if="!${expression}" text="否"></u-text>
+            `;
+        } else {
+            return `<u-text :text="${expression}"></u-text>`;
+        }
+    };
+
+    const genEditComponent = (property: EntityProperty) => {
+        if (!property.editable)
+            return '';
+        const label = property.label || property.name;
+        let formItem = '';
+        if (property.$relationEntity && selectNameGroupMap) { // 有外键关联
+            const relationEntity = vertexsMap.get(property.$relationEntity) as Entity;
+            if (relationEntity) {
+                const relationProperty = vertexsMap.get(property.$relationProperty) as EntityProperty;
+                const displayedProperty = getFirstDisplayedProperty(relationEntity, 'inForm');
+                if (displayedProperty) {
+                    const lowerEntityName = utils.firstLowerCase(relationEntity.name);
+                    formItem += `
+                        <u-select clearable placeholder="请选择${label}" :data-source="${selectNameGroupMap.get(relationEntity.id).load}"
+                            :autofocus="true" :opened="true" append-to="body" @blur="${nameGroup.blurUpdate}" @select="${nameGroup.blurUpdate}"
+                            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 (property.typeKey === '#/basicTypes/Boolean') {
+            formItem += `<u-select clearable :value.sync="${valueExpression}" placeholder="请输入${label}"
+            :autofocus="true" :opened="true" append-to="body" @blur="${nameGroup.blurUpdate}" @select="${nameGroup.blurUpdate}">
+                <u-select-item :value="true">是</u-select-item>
+                <u-select-item :value="false">否</u-select-item>
+            </u-select>`;
+        } else if (property.typeKey === '#/basicTypes/Integer' || property.typeKey === '#/basicTypes/Long') {
+            formItem = `<u-number-input :value.sync="${valueExpression}" placeholder="请输入${label}" :autofocus="true" @blur="${nameGroup.blurUpdate}"></u-number-input>`;
+        } else if (property.typeKey === '#/basicTypes/Decimal') {
+            formItem = `<u-number-input :value.sync="${valueExpression}" :precision="0" :step="0" placeholder="请输入${label}" :autofocus="true" @blur="${nameGroup.blurUpdate}"></u-number-input>`;
+        } else if (property.typeKey === '#/basicTypes/Text') {
+            formItem = `<u-validator placement="bottom" display="appear" @blur-valid="${nameGroup.blurUpdate}" style="width:100%">
+            <u-textarea :value.sync="${valueExpression}" placeholder="请输入${label}" :autofocus="true" size="full"></u-textarea>
+            </u-validator>`;
+        } else if (property.typeKey === '#/basicTypes/Date') {
+            formItem = `<u-date-picker clearable :date.sync="${valueExpression}" placeholder="请输入${label}" append-to="body" :autofocus="true" :opened="true" @blur="${nameGroup.blurUpdate}"></u-date-picker>`;
+        } else if (property.typeKey === '#/basicTypes/Time') {
+            formItem = `<u-time-picker :time.sync="${valueExpression}" placeholder="请输入${label}" append-to="body" :autofocus="true" @blur="${nameGroup.blurUpdate}"></u-time-picker>`;
+        } else if (property.typeKey === '#/basicTypes/DateTime') {
+            formItem = `<u-date-time-picker clearable :date.sync="${valueExpression}" placeholder="请输入${label}" append-to="body" :autofocus="true" :opened="true" @blur="${nameGroup.blurUpdate}"></u-date-time-picker>`;
+        } else if (dataTypesMap[property.typeKey].type === 'enum') {
+            formItem = `<u-select clearable :value.sync="${valueExpression}" placeholder="请选择${label}"
+            :autofocus="true" :opened="true" append-to="body" :data-source="ID_ENUM_LIST_${dataTypesMap[property.typeKey].id}"
+            @blur="${nameGroup.blurUpdate}" @select="${nameGroup.blurUpdate}">
+            </u-select>`;
+        } else {
+            formItem = `<u-validator placement="bottom" display="appear" @blur-valid="${nameGroup.blurUpdate}" style="width:100%" append-to="body">
+                <u-input :value.sync="${valueExpression}" placeholder="请输入${label}" :autofocus="true" size="full"></u-input>
+            </u-validator>`;
+        }
+        return `<template #editcell="scope">
+            <u-linear-layout gap="small">
+                ${formItem}
+            </u-linear-layout>
+        </template>`;
+    };
+
+    return `<u-table-view-column title="${title}" field="${utils.firstLowerCase(entity.name)}.${property.name}" ${canEditable(property) ? 'type="editable"' : ''}>
+    <template #cell="scope">
+        <u-linear-layout gap="small">
+            ${getText(property)}
+        </u-linear-layout>
+    </template>
+    ${genEditComponent(property)}
+</u-table-view-column>`;
+}
+
+/**
+ * 生成表格模板
+ * @param entity 实体
+ * @param nameGroup 命名组
+ */
+export function genEditTableTemplate(entity: Entity, nameGroup: NameGroup, selectNameGroupMap?: Map<string, NameGroup>) {
+    const propertyList = entity.propertyList
+        .filter(filterProperty('inTable'));
+
+    return `<u-table-view ref="tableView" :data-source="${nameGroup.load}" data-schema="${nameGroup.structure}"
+        value-field="${nameGroup.lowerEntity}.id"
+        :pageable="true" :remote-paging="true" :show-sizer="true" :default-column-width="300" editable>
+    <u-table-view-column type="index" width="60" title="序号"></u-table-view-column>
+
+    ${propertyList.map((property) => genEditTableColumnTemplate(entity, property, nameGroup, selectNameGroupMap) + '\n').join('')}
+
+    <u-table-view-column title="操作">
+        <template #cell="scope">
+            <u-linear-layout gap="small">
+                <u-link @click="${nameGroup.remove}($event, scope)">删除</u-link>
+            </u-linear-layout>
+        </template>
+    </u-table-view-column>
+</u-table-view>
+`;
+}
+
+/**
+ * 生成表格 load 逻辑
+ * @param entity 实体
+ */
+export function genEditTableLoadLogic(entity: Entity, nameGroup: NameGroup,
+    newStructures: Array<any>, newInterfaces: Array<any>, supportFilter: boolean) {
+    const paramsSchema = {
+        $ref: '#/systemTypes/DataSourceParams',
+    };
+    const resultSchema = genGenericTypeSchema('PageOf', { T: { $ref: nameGroup.structure } });
+    const params = [
+        genInterParam(
+            `${newInterfaces[0].name}.${newInterfaces[0].logic.params[0].name}`,
+            'params.page',
+            [undefined, undefined],
+        ),
+        genInterParam(
+            `${newInterfaces[0].name}.${newInterfaces[0].logic.params[1].name}`,
+            'params.size',
+            [undefined, undefined],
+        ),
+        genInterParam(
+            `${newInterfaces[0].name}.${newInterfaces[0].logic.params[2].name}`,
+            'params.sort',
+            [undefined, undefined],
+        ),
+        genInterParam(
+            `${newInterfaces[0].name}.${newInterfaces[0].logic.params[3].name}`,
+            'params.order',
+            [undefined, undefined],
+        ),
+    ];
+
+    if (supportFilter)
+        params.push(
+            genInterParam(
+                `${newInterfaces[0].name}.${newInterfaces[0].logic.params[4].name}`,
+                'filter',
+                [undefined],
+            ),
+        );
+
+    return {
+        level: 'logic',
+        name: nameGroup.load,
+        params: [{
+            level: 'param',
+            type: 'Identifier',
+            name: 'params',
+            schema: paramsSchema,
+        }],
+        returns: [
+            genVariable('result', resultSchema, LEVEL_ENUM.return),
+        ],
+        variables: [] as Array<any>,
+        body: [{
+            level: 'logicNode',
+            type: 'Start',
+            label: '开始',
+        }, {
+            level: 'logicNode',
+            type: 'AssignmentExpression',
+            label: '赋值',
+            operator: '=',
+            left: {
+                level: 'expressionNode',
+                type: 'Identifier',
+                name: 'result',
+            },
+            right: genCallInterfaceFromTempInterface(newInterfaces[0], params),
+        }, {
+            level: 'logicNode',
+            type: 'End',
+            label: '结束',
+        }],
+    };
+}
+
+/**
+ * 生成表格 remove 逻辑
+ * @param entity 实体
+ */
+export function genEditTableRemoveLogic(entity: Entity, nameGroup: NameGroup) {
+    const scopeStructureSchema = genGenericTypeSchema('ScopeOf', { T: { $ref: nameGroup.structure } });
+    const deleteResolver = entity.resolvers.find((resolver) => resolver.name === 'delete');
+    const deleteInterface = deleteResolver.interface;
+    const idParam = getParamFromResolver(deleteResolver, 'id');
+    const idProperty = entity.propertyList.find((property) => property.primaryKey || property.name === 'id');
+
+    return {
+        level: 'logic',
+        name: nameGroup.remove,
+        params: [{
+            level: 'param',
+            type: 'Identifier',
+            name: 'event',
+            schema: { $ref: '#/basicTypes/String' },
+        }, {
+            level: 'param',
+            name: 'scope',
+            schema: scopeStructureSchema,
+        }],
+        returns: [] as Array<any>,
+        variables: [] as Array<any>,
+        body: [{
+            level: 'logicNode',
+            type: 'Start',
+            label: '开始',
+        },
+        genCallInterface(deleteInterface, [
+            genInterParam(
+                idParam.id,
+                `scope.item.${nameGroup.lowerEntity}.id`,
+                ['', '', `${nameGroup.structure}.${nameGroup.lowerEntity}`, idProperty.id],
+            ),
+        ]),
+        genCallComponentLogic('tableView', 'reload'),
+        {
+            level: 'logicNode',
+            label: '结束',
+            type: 'End',
+        }],
+    };
+}
+
+/**
+ * 生成表格 双击编辑 逻辑
+ * @param entity 实体
+ */
+export function genEditTableDblclickLogic(property: EntityProperty, nameGroup: NameGroup, existingNameSets: {
+    viewLogic: Set<string>,
+    interface: Set<string>,
+    structure: Set<string>,
+}) {
+    const scopeStructureSchema = genGenericTypeSchema('ScopeOf', { T: { $ref: nameGroup.structure } });
+    const logicName = utils.unique(`set${utils.firstUpperCase(property.name)}Edit`, existingNameSets.viewLogic);
+    return {
+        level: 'logic',
+        name: logicName,
+        params: [{
+            level: 'param',
+            type: 'Identifier',
+            name: 'event',
+            schema: { $ref: '#/basicTypes/String' },
+        }, {
+            level: 'param',
+            name: 'scope',
+            schema: scopeStructureSchema,
+        }],
+        returns: [] as Array<any>,
+        variables: [] as Array<any>,
+        body: [{
+            level: 'logicNode',
+            type: 'Start',
+            label: '开始',
+        },
+        {
+            level: 'logicNode',
+            type: 'AssignmentExpression',
+            label: '赋值',
+            operator: '=',
+            left: genMemberExpression(`scope.item.editing`, ['', '', `${nameGroup.structure}.editing`]),
+            right: {
+                level: 'expressionNode',
+                type: 'StringLiteral',
+                value: `${property.name}`,
+            },
+        },
+        {
+            level: 'logicNode',
+            label: '结束',
+            type: 'End',
+        }],
+    };
+}
+
+/**
+ * 生成表格区块
+ * @param entity 实体
+ * @param view 所插入的页面，用于生成逻辑名字，去重等
+ * @notice 目前 logic 名去重做成前置处理了，与 mergeBlock 的后置处理不冲突
+ *        (页面 load 名) -产生-> (interface 名) -产生-> (structure 名)
+ *        load -> load_someView_tableView
+ *        load_select_student -> load_someView_select_student
+ */
+export function genEditTableBlock(entity: Entity, view: View) {
+    const existingNameSets = {
+        viewLogic: new Set(view.$def.logics.map((logic) => logic.name)),
+        interface: new Set(entity.dataNode.service.interfaces.map((itface) => itface.name)),
+        structure: new Set(entity.dataNode.structures.map((structure) => structure.name)),
+    };
+
+    const nameGroup = genUniqueQueryNameGroup(existingNameSets, view.name, 'tableView');
+    nameGroup.remove = utils.unique('remove', existingNameSets.viewLogic);
+    nameGroup.blurUpdate = utils.unique('blurUpdate', existingNameSets.viewLogic);
+    nameGroup.lowerEntity = utils.firstLowerCase(entity.name);
+
+    // 收集所有和本实体关联的实体
+    const allEntities = [entity];
+    entity.propertyList.forEach((property) => {
+        if (property.$relationEntity) { // 有外键关联
+            const relationEntity = vertexsMap.get(property.$relationEntity) as Entity;
+            if (relationEntity) {
+                const displayedProperty = getFirstDisplayedProperty(relationEntity);
+                if (displayedProperty)
+                    allEntities.push(relationEntity);
+            }
+        }
+    });
+
+    const newStructures: Array<any> = [genEditQueryStructure(allEntities, nameGroup)];
+    const newInterfaces: Array<any> = [genQueryInterface(allEntities, nameGroup, false, true)];
+
+    return `
+<template>
+    ${genEditTableTemplate(entity, nameGroup)}
+</template>
+<definition>
+{
+    "logics": [
+        ${JSON.stringify(genEditTableLoadLogic(entity, nameGroup, newStructures, newInterfaces, false))},
+        ${JSON.stringify(genEditTableRemoveLogic(entity, nameGroup))}
+    ],
+    "interfaces": ${JSON.stringify(newInterfaces)},
+    "structures": ${JSON.stringify(newStructures)}
+}
+</definition>
+`;
+}
+
+export function genBlurUpdateLogic(entity: Entity, nameGroup: NameGroup) {
+    const scopeStructureSchema = genGenericTypeSchema('ScopeOf', { T: { $ref: nameGroup.structure } });
+    const updateResolver = entity.resolvers.find((item) => item.name === 'update');
+    const updateBodyParam = getParamFromResolver(updateResolver, 'body');
+
+    return {
+        level: 'logic',
+        name: nameGroup.blurUpdate,
+        params: [{
+            level: 'param',
+            type: 'Identifier',
+            name: 'event',
+            schema: { $ref: '#/basicTypes/String' },
+        }, {
+            level: 'param',
+            name: 'scope',
+            schema: scopeStructureSchema,
+        }],
+        returns: [] as Array<any>,
+        body: [
+            {
+                level: 'logicNode',
+                type: 'Start',
+                label: '开始',
+            },
+            {
+                level: 'logicNode',
+                type: 'AssignmentExpression',
+                label: '赋值',
+                operator: '=',
+                left: genMemberExpression(`scope.item.editing`, ['', '', `${nameGroup.structure}.editing`]),
+                right: {
+                    level: 'expressionNode',
+                    type: 'StringLiteral',
+                    value: '',
+                },
+            },
+            genCallInterface(updateResolver.interface, [
+                genInterParam(
+                    updateBodyParam.id,
+                    `scope.item.${nameGroup.lowerEntity}`,
+                    ['', '', `${nameGroup.structure}.${nameGroup.lowerEntity}`],
+                ),
+            ]),
+            {
+                level: 'logicNode',
+                type: 'End',
+                label: '结束',
+            },
+        ],
+        playground: [] as Array<any>,
+        expanded: false,
+    };
+}
+
+export function genEditTableColumnBlock(property: EntityProperty, view: View) {
+    const entity = property.root;
+
+    const existingNameSets = {
+        viewLogic: new Set(view.$def.logics.map((logic) => logic.name)),
+        interface: new Set(entity.dataNode.service.interfaces.map((itface) => itface.name)),
+        structure: new Set(entity.dataNode.structures.map((structure) => structure.name)),
+    };
+
+    const nameGroup = genUniqueQueryNameGroup(existingNameSets, view.name, 'tableView');
+    nameGroup.remove = utils.unique('remove', existingNameSets.viewLogic);
+    nameGroup.lowerEntity = utils.firstLowerCase(entity.name);
+
+    // 收集所有和本实体关联的实体
+    const allEntities = [entity];
+    const propertyList = [property];
+    propertyList.forEach((property) => {
+        if (property.$relationEntity) { // 有外键关联
+            const relationEntity = vertexsMap.get(property.$relationEntity) as Entity;
+            if (relationEntity) {
+                const displayedProperty = getFirstDisplayedProperty(relationEntity);
+                if (displayedProperty)
+                    allEntities.push(relationEntity);
+            }
+        }
+    });
+
+    const newStructures: Array<any> = [genEditQueryStructure(allEntities, nameGroup)];
+    const newInterfaces: Array<any> = [genQueryInterface(allEntities, nameGroup, false, true)];
+
+    return `
+<template>
+    <u-table-view ref="tableView" :data-source="${nameGroup.load}" :pageable="true" :remote-paging="true" :show-sizer="true" data-schema="${nameGroup.structure}">
+        ${propertyList.map((property) => genEditTableColumnTemplate(entity, property, nameGroup) + '\n').join('')}
+    </u-table-view>
+</template>
+<definition>
+{
+    "logics": [
+        ${JSON.stringify(genEditTableLoadLogic(entity, nameGroup, newStructures, newInterfaces, false))},
+        ${JSON.stringify(genBlurUpdateLogic(entity, nameGroup))}
+    ],
+    "interfaces": ${JSON.stringify(newInterfaces)},
+    "structures": ${JSON.stringify(newStructures)}
+}
+</definition>
+`;
+}
+
+export default genEditTableBlock;

package/src/types/data/genBlock/genQueryComponent.ts

@@ -490,3 +490,59 @@ export async function joinEntity(callQueryComponent: LogicItem, entity: Entity,
 
 export default genQueryAssignment;
 
+export function genEditQueryStructure(allEntities: Array<Entity>, nameGroup: NameGroup) {
+    allEntities = Array.from(new Set(allEntities));
+    const propertyList = allEntities.map((entity, index) => ({
+        level: 'property',
+        ideVersion: '2.0',
+        editable: true,
+        name: utils.firstLowerCase(entity.name),
+        $ref: entity.schemaRef,
+        _posIndex: index,
+        typeKey: entity.schemaRef,
+        type: '',
+        format: '',
+    }));
+    // const tempPropertyList = propertyList.map((property) => {
+    //     const tempProperty = Object.assign({}, property);
+    //     tempProperty.name = `temp${utils.firstUpperCase(property.name)}`;
+    //     return tempProperty;
+    // });
+    // tempPropertyList.push({
+    //     level: 'property',
+    //     ideVersion: '2.0',
+    //     editable: true,
+    //     name: 'editing',
+    //     _posIndex: 0,
+    //     $ref: '',
+    //     type: 'string',
+    //     format: '',
+    //     typeKey: '#/basicTypes/String',
+    // });
+    // propertyList = propertyList.concat(tempPropertyList);
+    propertyList.push({
+        level: 'property',
+        ideVersion: '2.0',
+        editable: true,
+        name: 'editing',
+        _posIndex: 0,
+        $ref: '',
+        type: 'string',
+        format: '',
+        typeKey: '#/basicTypes/String',
+    });
+    propertyList.forEach((property, index) => {
+        property._posIndex = index;
+    });
+    return {
+        level: 'structure',
+        ideVersion: '2.0',
+        editable: true,
+        name: nameGroup.structure,
+        type: 'object',
+        propertyList,
+        serviceId: allEntities[0].serviceId,
+        serviceType: 'entity',
+    };
+}
+

package/src/types/data/genBlock/genTableBlock.ts

@@ -168,9 +168,7 @@ export function genTableRemoveLogic(entity: Entity, nameGroup: NameGroup) {
     const scopeStructureSchema = genGenericTypeSchema('ScopeOf', { T: { $ref: nameGroup.structure } });
     const deleteResolver = entity.resolvers.find((resolver) => resolver.name === 'delete');
     const deleteInterface = deleteResolver.interface;
-    const idParam = getParamFromResolver(deleteResolver, 'id');
-    const idProperty = entity.propertyList.find((property) => property.primaryKey || property.name === 'id');
-
+    const idPropertys = entity.propertyList.filter((property) => property.primaryKey);
     return {
         level: 'logic',
         name: nameGroup.remove,
@@ -191,13 +189,19 @@ export function genTableRemoveLogic(entity: Entity, nameGroup: NameGroup) {
             type: 'Start',
             label: '开始',
         },
-        genCallInterface(deleteInterface, [
-            genInterParam(
-                idParam.id,
-                `scope.item.${nameGroup.lowerEntity}.id`,
-                ['', '', `${nameGroup.structure}.${nameGroup.lowerEntity}`, idProperty.id],
-            ),
-        ]),
+        genCallInterface(deleteInterface,
+            idPropertys.map((idProperty) => {
+                let paramFromResolver = getParamFromResolver(deleteResolver, idProperty.name);
+                // 如果旧逻辑，但是新导入表中，id的name 不是id 的话，就直接使用名称叫id的
+                if (!paramFromResolver) {
+                    paramFromResolver = getParamFromResolver(deleteResolver, 'id');
+                }
+                return genInterParam(paramFromResolver.id,
+                    `scope.item.${nameGroup.lowerEntity}.id`,
+                    ['', '', `${nameGroup.structure}.${nameGroup.lowerEntity}`, idProperty.id],
+                )
+            }),
+        ),
         genCallComponentLogic('tableView', 'reload'),
         {
             level: 'logicNode',

package/src/types/data/genBlock/index.ts

@@ -13,6 +13,8 @@ export * from './genSelectBlock';
 export * from './genCurdBlock';
 export * from './genListViewBlock';
 export * from './genGridViewBlock';
+export * from './genEditTableBlock';
+export * from './genCurdEditTableBlock';
 
 // eslint-disable-next-line prefer-const
 export let dragSource: Entity | EntityProperty = null;

package/src/types/data/genBlock/utils.ts

@@ -169,6 +169,44 @@ export function genInterParam(paramIdOrName: string, expression: string, schemaR
     };
 }
 
+/**
+ * 生成接口 Param
+ * @param paramIdOrName 参数 id 或引用名称
+ * @param expression 表达式
+ * @param schemaChildren 数据结构
+ */
+export function genMemberExpression(expression: string, schemaRefs: Array<string> = []) {
+    const arr = expression.split('.');
+
+    let expressionNode: any;
+    arr.forEach((name, index) => {
+        const currentNode = {
+            level: LEVEL_ENUM.expressionNode,
+            type: 'Identifier',
+            name,
+            schemaRef: schemaRefs[index],
+        };
+        if (expressionNode) {
+            expressionNode = {
+                level: LEVEL_ENUM.expressionNode,
+                type: 'MemberExpression',
+                object: expressionNode,
+                property: {
+                    level: LEVEL_ENUM.expressionNode,
+                    type: 'Identifier',
+                    name,
+                    schemaRef: schemaRefs[index],
+                    code: schemaRefs[index] === '' ? '' : undefined,
+                },
+            };
+        } else {
+            expressionNode = currentNode;
+        }
+    });
+
+    return expressionNode;
+}
+
 /**
  * 命名组，主要承载一次 mergeBlock 中的逻辑名称
  */