@lcap/asl/src/types/data/genBlock/genGetBlock.ts

NetEase Application Specific Language

import { Resolver } from '../Entity';
import { config, dataTypesMap, Entity, Enum, View, LEVEL_ENUM, utils } from '../..';
import { NameGroup, filterProperty, getExpression, getParamFromResolver, genEnumSelectBlock, genCallComponentLogic, genCallInterface } from '.';

export function genGetTemplate(entity: Entity, nameGroup: NameGroup) {
    const propertyList = entity.propertyList
        .filter(filterProperty('inDetail'));

    return `<u-info-list>
    <u-info-list-group title="基本信息">
    ${propertyList.map((property) => {
        let formItem = `            <u-info-list-item label="${property.label || property.name}">`;

        if (dataTypesMap[property.typeKey].type === 'enum')
            formItem += '<u-text :text="' + getExpression(property, `${nameGroup.model}.${property.name}`) + '"></u-text>';
        else
            formItem += '<u-text :text="' + getExpression(property, `${nameGroup.model}.${property.name}`) + '"></u-text>';

        formItem += `            </u-info-list-item>\n`;
        return formItem;
    }).join('')}
    </u-info-list-group>
</u-info-list>`;
}

function genLoadLogic(resolver: Resolver, nameGroup: NameGroup) {
    const resSchema = {
        $ref: `#/${resolver.entity.dataNode.service.id}/${resolver.entity.id}`,
    };
    const idParam = getParamFromResolver(resolver, 'id');

    return {
        level: 'logic',
        expanded: false,
        name: nameGroup.load,
        description: '',
        params: [] as any,
        returns: [] as any,
        body: [
            {
                level: 'logicNode',
                type: 'Start',
                label: '开始',
            }, {
                level: 'logicNode',
                type: 'AssignmentExpression',
                label: '赋值',
                operator: '=',
                left: {
                    level: 'expressionNode',
                    type: 'Identifier',
                    name: nameGroup.model,
                },
                right: genCallInterface(resolver.interface, [
                    {
                        parentAttr: 'params',
                        level: LEVEL_ENUM.param,
                        type: 'CallInterParam',
                        name: '',
                        callInterParam: `#/${idParam.id}`,
                        callInterParamValue: {
                            parentAttr: 'callInterParamValue',
                            level: 'expressionNode',
                            type: 'Identifier',
                            name: 'id',
                        },
                    },
                ]),
            },
            {
                level: 'logicNode',
                type: 'End',
                label: '结束',
            },
        ],
        playground: [] as any,
        serviceType: 'web',
    };
}

export function genH5GetTemplate(entity: Entity, nameGroup: NameGroup) {
    const propertyList = entity.propertyList
        .filter(filterProperty('inDetail'));

    return `<van-cell-group>
    ${propertyList.map((property) => {
        let formItem = `            <van-cell isLink title="${property.label || property.name}"`;

        if (dataTypesMap[property.typeKey].type === 'enum')
            formItem += ' :value="' + getExpression(property, `${nameGroup.model}.${property.name}`) + '">';
        else
            formItem += ' :value="' + getExpression(property, `${nameGroup.model}.${property.name}`) + '">';

        formItem += `            </van-cell>\n`;
        return formItem;
    }).join('')}
</van-cell-group>`;
}

export function genGetBlock(entity: Entity, view: View) {
    const resolver = entity.resolvers.find((item) => item.name.startsWith('get') && !item.name.startsWith('getAll'));

    const modelSchema = {
        $ref: resolver.entity.schemaRef,
    };

    const existingNameSets = {
        viewLogic: new Set(view.$def.logics.map((logic) => logic.name)),
    };
    const nameGroup: NameGroup = {
        model: utils.firstLowerCase(resolver.entity.name),
    };
    nameGroup.load = utils.unique('load', existingNameSets.viewLogic);

    return `<template>
    ${config.scope === 'h5' ? genH5GetTemplate(entity, nameGroup) : genGetTemplate(entity, nameGroup)}
</template>

<definition>
{
"params": [
    {
        "level": "param",
        "type": "Identifier",
        "name": "id",
        "description": "",
        "schema": {
            "type": "integer",
            "format": "long",
            "isLeaf": true
        },
        "isLeaf": true,
        "init": {
            "type": "Identifier",
            "name": "undefined"
        }
    }
],
"variables": [{
    "level": "variable",
    "type": "Identifier",
    "name": "${nameGroup.model}",
    "schema": ${JSON.stringify(modelSchema)}
}],
"lifecycles": [
    {
        "level": "lifecycle",
        "name": "created",
        "logicId": "${nameGroup.load}"
    }
],
"logics": [
    ${JSON.stringify(genLoadLogic(resolver, nameGroup))}
]
}
</definition>
`;
}

export default genGetBlock;