@lcap/nasl/out/templator/utils.js

NetEase Application Specific Language

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.transEntityMetadataTypes = exports.getDecimalInfo = exports.NaslNode = exports.NaslQueryExpression = exports.NaslLogicItem = exports.NaslCollectionTypeAnnotation = exports.NaslTypeAnnotation = exports.NaslIOTypeAnnotation = exports.NaslUITypeAnnotation = exports.NaslCoreTypeAnnotation = exports.genUniqueQueryNameGroup = exports.genMemberExpression = exports.genLogicParam = exports.getFirstDisplayedProperty = exports.getParamFromLogic = exports.getExpression = exports.filterProperty = void 0;
const __1 = require("..");
const filterProperty = (key) => (property) => {
    if (property.display) {
        return property.display[key];
    }
    return !['id', 'createdTime', 'updatedTime'].includes(property.name);
};
exports.filterProperty = filterProperty;
/**
 * 生成表达式的代码
 * @param property 实体属性
 * @param expression 表达式
 */
function getExpression(property, expression) {
    const { typeAnnotation } = property || {};
    const { typeName: propertyTypeName, typeNamespace: propertyTypeNamespace } = typeAnnotation || {};
    if (propertyTypeName === 'DateTime')
        return `$utils['FormatDateTime'](${expression}, 'YYYY-MM-DD HH:mm:ss')`;
    if (propertyTypeName === 'Date')
        return `$utils['FormatDate'](${expression}, 'YYYY-MM-DD')`;
    const namespaceArr = propertyTypeNamespace?.split?.('.') || [];
    const type = namespaceArr.pop();
    if (type === 'enums') {
        return `$utils['EnumItemToText'](${expression}, '__enumTypeAnnotation_${propertyTypeNamespace}.${propertyTypeName}')`;
    }
    return `${expression || "''"}`;
}
exports.getExpression = getExpression;
/**
 * 从 Logic 中获取变量
 * @param resolver
 * @param paramName
 */
function getParamFromLogic(logic, paramName) {
    const { params } = logic;
    return params.find((item) => item.name === paramName);
}
exports.getParamFromLogic = getParamFromLogic;
function getFirstDisplayedProperty(entity) {
    let property = entity.properties.find((property) => !property.readonly);
    if (!property)
        property = entity.properties[0];
    return property;
}
exports.getFirstDisplayedProperty = getFirstDisplayedProperty;
function genArgumentMemberExpression(arr) {
    let expressionNode;
    const 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 = []) {
    const arr = expression.split('.');
    let expressionNode;
    arr.forEach((name, index) => {
        const currentNode = exports.NaslLogicItem.Identifier({
            name,
        });
        if (expressionNode) {
            expressionNode = exports.NaslLogicItem.MemberExpression({
                object: expressionNode,
                property: exports.NaslLogicItem.Identifier({
                    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 = true, suffix = '') {
    const result = {};
    componentName = componentName?.replace(/_/g, '');
    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 = '') {
    return {
        concept: 'TypeAnnotation',
        name: '',
        typeKind: 'primitive',
        typeNamespace: 'nasl.core',
        typeName,
        text,
    };
}
function genNaslUITypeAnnotation(typeName) {
    return {
        concept: 'TypeAnnotation',
        name: '',
        typeKind: 'reference',
        typeNamespace: 'nasl.ui',
        typeName,
    };
}
function genNaslCollectionTypeAnnotation(typeName) {
    return (typeArguments) => ({
        concept: 'TypeAnnotation',
        name: '',
        typeKind: 'generic',
        typeNamespace: 'nasl.collection',
        typeName,
        typeArguments,
    });
}
function genNaslUIGenericTypeAnnotation(typeName) {
    return (typeArguments) => ({
        concept: 'TypeAnnotation',
        name: '',
        typeKind: 'generic',
        typeNamespace: 'nasl.ui',
        typeName,
        typeArguments,
    });
}
function genNaslIOTypeAnnotation(typeName) {
    return {
        concept: 'TypeAnnotation',
        name: '',
        typeKind: 'reference',
        typeNamespace: 'nasl.io',
        typeName,
    };
}
exports.NaslCoreTypeAnnotation = {
    Boolean: genNaslCoreTypeAnnotation('Boolean'),
    // Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
    // Double: genNaslCoreTypeAnnotation('Double'),
    Decimal: genNaslCoreTypeAnnotation('Decimal'),
    Long: genNaslCoreTypeAnnotation('Long', ' Integer 整数'),
    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'),
    ValidateResult: genNaslUITypeAnnotation('ValidateResult'),
    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'),
    KeyboardEvent: genNaslUITypeAnnotation('KeyboardEvent'),
    Current: genNaslUIGenericTypeAnnotation('Current'),
    DragAndDropEvent: genNaslUIGenericTypeAnnotation('DragAndDropEvent'),
    ExpandEvent: genNaslUIGenericTypeAnnotation('ExpandEvent'),
    ScrollEvent: genNaslUIGenericTypeAnnotation('ScrollEvent'),
};
exports.NaslIOTypeAnnotation = {
    File: genNaslIOTypeAnnotation('File'),
    FileInfo: genNaslIOTypeAnnotation('FileInfo'),
};
exports.NaslTypeAnnotation = {
    Reference: ({ typeNamespace, typeName }) => ({
        concept: 'TypeAnnotation',
        name: '',
        typeKind: 'reference',
        typeNamespace,
        typeName,
    }),
    AnonymousStructure: (properties) => ({
        concept: 'TypeAnnotation',
        typeKind: 'generic',
        typeName: 'List',
        typeNamespace: 'nasl.collection',
        typeArguments: [
            {
                concept: 'TypeAnnotation',
                typeKind: 'anonymousStructure',
                properties,
            },
        ],
    }),
};
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: ({ calleeNamespace, calleeName, label = '调用逻辑', shortcut = false, arguments: args, }) => ({
        concept: 'CallLogic',
        name: '',
        label,
        kind: 'Statement',
        shortcut,
        calleeNamespace,
        calleeName,
        arguments: args,
    }),
    // 内置函数
    CallFunction: ({ calleeNamespace = 'nasl.util', calleeName, label = '内置函数', shortcut = false, arguments: args = [], typeArguments: typeArgs = [], }) => ({
        concept: 'CallFunction',
        name: '',
        label: '调用逻辑',
        kind: 'Expression',
        calleeNamespace,
        calleeName,
        arguments: args,
        typeArguments: typeArgs,
    }),
    // 参数
    Argument: ({ keyword, expression }) => ({
        concept: 'Argument',
        name: '',
        kind: 'Statement',
        keyword,
        expression,
    }),
    // 成员表达式
    MemberExpression: ({ object, property }) => ({
        concept: 'MemberExpression',
        name: '',
        kind: 'Expression',
        object,
        property,
    }),
    // 变量
    Identifier: ({ name }) => ({
        concept: 'Identifier',
        kind: 'Expression',
        name,
    }),
    // 布尔常量
    BooleanLiteral: ({ value }) => ({
        concept: 'BooleanLiteral',
        value,
        folded: false,
    }),
    // 字面量
    StringLiteral: ({ value }) => ({
        concept: 'StringLiteral',
        name: '',
        kind: 'Expression',
        value,
    }),
    Assignment: ({ left, right }) => ({
        concept: 'Assignment',
        name: '',
        label: '赋值',
        kind: 'Statement',
        left,
        right,
    }),
    IfStatement: ({ test, consequent, alternate }) => ({
        concept: 'IfStatement',
        name: '',
        kind: 'Statement',
        test,
        consequent,
        alternate,
    }),
    // 二元
    BinaryExpression: ({ operator, left, label = '算术运算', right }) => ({
        concept: 'BinaryExpression',
        name: '',
        kind: 'Expression',
        label,
        operator,
        left,
        right,
    }),
    // 分页
    Paginate: ({ list, page, size }) => ({
        concept: 'Paginate',
        name: '',
        kind: 'Expression',
        label: '分页',
        list,
        page,
        size,
    }),
};
exports.NaslQueryExpression = {
    QueryFieldExpression: ({ label, isDotStar, entityAsName, propertyName, }) => ({
        concept: 'QueryFieldExpression',
        name: '',
        label,
        kind: 'Expression',
        isDotStar,
        entityAsName,
        propertyName,
    }),
    QueryFromExpression: ({ entityNamespace, entityName, joinParts }) => ({
        concept: 'QueryFromExpression',
        name: '',
        kind: 'Expression',
        entityNamespace,
        entityName,
        joinParts,
    }),
    QueryJoinExpression: ({ label, entityNamespace, entityName, joinType, onExpressions, joinParts, }) => ({
        concept: 'QueryJoinExpression',
        label,
        name: '',
        kind: 'Expression',
        entityNamespace,
        entityName,
        joinType,
        onExpressions,
        joinParts,
    }),
    QuerySelectExpression: ({ label, distinct, star, selectElements, }) => ({
        concept: 'QuerySelectExpression',
        name: '',
        kind: 'Expression',
        label,
        distinct,
        star,
        selectElements,
    }),
    QueryOrderByExpression: ({ label, order, orderElement }) => ({
        concept: 'QueryOrderByExpression',
        label,
        order,
        orderElement,
    }),
    QueryLimitExpression: ({ label, pageElement, pageSizeElement }) => ({
        concept: 'QueryLimitExpression',
        name: '',
        kind: 'Expression',
        label,
        pageElement,
        pageSizeElement,
    }),
    CallQueryComponent: ({ label, typeAnnotation, select, from, where, limit, groupBy, having, orderBy, logicName, structureName, ideVersion, }) => ({
        concept: 'CallQueryComponent',
        name: '',
        label,
        kind: 'Statement',
        typeAnnotation,
        select,
        from,
        where,
        limit,
        groupBy,
        having,
        orderBy,
        logicName,
        structureName,
        ideVersion,
    }),
};
exports.NaslNode = {
    Logic: ({ name, params, returns, variables, body, description, playground, }) => ({
        concept: 'Logic',
        name,
        params,
        returns,
        variables,
        body,
        description,
        playground,
    }),
    Structure: ({ name, properties, origin }) => ({
        concept: 'Structure',
        name,
        properties,
        origin,
    }),
    StructureProperty: ({ name, typeAnnotation }) => ({
        concept: 'StructureProperty',
        name,
        typeAnnotation,
    }),
    Variable: ({ name, typeAnnotation }) => ({
        concept: 'Variable',
        name,
        typeAnnotation,
    }),
    Param: ({ name, typeAnnotation }) => ({
        concept: 'Param',
        name,
        typeAnnotation,
    }),
    Return: ({ name, typeAnnotation }) => ({
        concept: 'Return',
        name,
        typeAnnotation,
    }),
};
const getDecimalInfo = (property) => {
    let step;
    let typeAnnotation = property?.typeAnnotation;
    let decimalLength = typeAnnotation ? typeAnnotation.ruleMap?.scale : 0;
    if (decimalLength > 0) {
        step = +`${'0.'.padEnd(decimalLength + 1, '0')}1`;
    }
    else {
        step = 1;
    }
    return { step, decimalLength };
};
exports.getDecimalInfo = getDecimalInfo;
function transEntityMetadataTypes(typeAnnotation, app) {
    let { typeName: propertyTypeName } = typeAnnotation || {};
    if (typeAnnotation?.typeNamespace?.endsWith('.metadataTypes')) {
        const referenceNode = app.findNodeByCompleteName(typeAnnotation.typeNamespace + '.' + typeAnnotation.typeName) || {};
        const { typeName } = referenceNode.typeAnnotation || {};
        propertyTypeName = typeName;
    }
    return propertyTypeName;
}
exports.transEntityMetadataTypes = transEntityMetadataTypes;
//# sourceMappingURL=utils.js.map