@lcap/nasl/out/automate/engine/operators.js

NetEase Application Specific Language

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ComponentOps = exports.ops = void 0;
const nasl_concepts_1 = require("@lcap/nasl-concepts");
const nasl_utils_1 = require("@lcap/nasl-utils");
const viewCache_1 = require("./viewCache");
function instanceOfBaseNode(item) {
    return (item instanceof nasl_concepts_1.BaseNode);
}
function getDefaultValue(typeAnnotation, oldValue) {
    const typeKey = `${typeAnnotation?.typeNamespace}.${typeAnnotation?.typeName}`;
    const value = String(oldValue);
    let expression = null;
    let defaultValue = null;
    if (!typeAnnotation) {
        defaultValue = null;
    }
    else if (typeKey.startsWith('nasl.core')
        && typeAnnotation.typeName !== 'Binary'
        && typeAnnotation.typeKind !== 'union') {
        switch (typeKey) {
            case 'nasl.core.String':
                expression = {
                    concept: 'StringLiteral',
                    name: '',
                    folded: false,
                    value,
                };
                break;
            case 'nasl.core.Long':
            case 'nasl.core.Decimal':
                expression = value === '' ? null : {
                    concept: 'NumericLiteral',
                    name: '',
                    folded: false,
                    value,
                    typeAnnotation: {
                        concept: "TypeAnnotation",
                        name: "",
                        typeKind: "primitive",
                        typeNamespace: "nasl.core",
                        typeName: "Long",
                        typeArguments: null,
                        returnType: null,
                        properties: null
                    }
                };
                break;
            case 'nasl.core.Boolean':
                expression = value === '' ? null : {
                    concept: 'BooleanLiteral',
                    name: '',
                    folded: false,
                    value,
                };
                break;
            case 'nasl.core.DateTime':
            case 'nasl.core.Date':
            case 'nasl.core.Time':
                expression = value === '' ? null : {
                    concept: 'StringLiteral',
                    name: '',
                    folded: false,
                    value,
                };
                break;
            default:
                expression = null;
        }
        if (expression !== null) {
            defaultValue = {
                concept: "DefaultValue",
                name: "",
                expression,
                playground: []
            };
        }
    }
    else if (typeAnnotation.typeNamespace?.endsWith('.enums') && value !== '') {
        const object = {
            concept: 'Identifier',
            name: typeAnnotation.typeName,
            namespace: typeAnnotation.typeNamespace,
            folded: false,
        };
        const property = {
            concept: 'Identifier',
            name: value,
            folded: false,
        };
        expression = {
            concept: 'MemberExpression',
            name: '',
            folded: false,
            object,
            property,
        };
        defaultValue = {
            concept: "DefaultValue",
            name: "",
            expression,
            playground: []
        };
    }
    return defaultValue;
}
exports.ops = {
    upgraders: [],
    _set(item, propertyName, value, callback) {
        if (instanceOfBaseNode(value)) {
            value.parentNode = item;
            value.parentKey = propertyName;
        }
        if (!exports.ops.templateVersion) {
            // 兼容 2.13.0 版本前的操作
            if (['View', 'ViewElement'].includes(item.concept)) {
                if (!viewCache_1.viewCache.has(item)) {
                    viewCache_1.viewCache.set(item, {
                        bindEvents: [],
                    });
                    viewCache_1.views.push(item);
                }
            }
        }
        if (item[propertyName] !== value) {
            item.update({
                [propertyName]: value,
            });
            if (instanceOfBaseNode(value) && callback) {
                callback(item[propertyName]);
            }
        }
        if (!item.parentNode && propertyName === 'concept' && value === 'DataSource')
            viewCache_1.virtualApp.dataSources.push(item);
        if (!item.parentNode && propertyName === 'concept' && value === 'Structure')
            viewCache_1.virtualApp.structures.push(item);
        if (!item.parentNode && propertyName === 'concept' && value === 'Enum')
            viewCache_1.virtualApp.enums.push(item);
        if (!item.parentNode && propertyName === 'concept' && value === 'Logic')
            viewCache_1.virtualApp.logics.push(item);
        if (!item.parentNode && propertyName === 'concept' && value === 'Interface')
            viewCache_1.virtualApp.interfaces.push(item);
        if (!item.parentNode && propertyName === 'concept' && value === 'View')
            viewCache_1.virtualApp.views.push(item);
        if (!item.parentNode && propertyName === 'concept' && value === 'Variable')
            viewCache_1.virtualApp.frontendVariables.push(item);
        if (!item.parentNode && propertyName === 'concept' && value === 'Process')
            viewCache_1.virtualApp.processes.push(item);
        if (!item.parentNode && propertyName === 'concept' && value === 'Role')
            viewCache_1.virtualApp.roles.push(item);
        if (!item.parentNode && propertyName === 'concept' && value === 'Module')
            viewCache_1.virtualApp.dependencies.push(item);
    },
    _push(item, propertyName, value) {
        if (!exports.ops.templateVersion) {
            // 兼容 2.13.0 版本前的操作
            if (['View', 'ViewElement'].includes(item.concept) && propertyName === 'bindEvents') {
                const meta = viewCache_1.viewCache.get(item);
                meta.bindEvents.push(value);
                value.parentNode = item;
                return;
            }
        }
        if (propertyName === 'dataSources' && value.concept === 'DataSource') {
            // 合并策略
            const exsitDataSource = item.dataSources.find((d) => d.name === value.name);
            if (exsitDataSource) {
                const nameSet = new Set(exsitDataSource.getEntityExistingNames());
                value.entities.forEach((e) => {
                    const n = (0, nasl_utils_1.unique)(e.name, nameSet, 1, true);
                    nameSet.add(n);
                    e.update({
                        name: n,
                    });
                    e.parentNode = exsitDataSource;
                    exsitDataSource.entities.push(e);
                    const index = exsitDataSource.entities.length;
                    e.create({
                        index,
                        parentNode: exsitDataSource,
                        parentKey: 'entities',
                    });
                });
                return;
            }
            else {
                const dataSourceGroup = item.configuration?.getGroup('dataSource');
                dataSourceGroup.addConfigProperty({
                    name: value.name,
                    description: '',
                    values: [
                        { env: 'dev', value: '', concept: 'ConfigPropertyValue' },
                        { env: 'online', value: '', concept: 'ConfigPropertyValue' },
                    ],
                });
            }
        }
        if (item.concept === 'App' && propertyName === 'entities' && value.concept === 'Entity') {
            // 兼容 2.11之前无 datasource 模板
            const defaultDS = item.dataSources.find((d) => d.name === 'defaultDS');
            // defaultDS.addEntity(value);
            value.parentNode = defaultDS;
            value.parentKey = 'entities';
            defaultDS.entities.push(value);
            const index = defaultDS.entities.length;
            value.create({
                index,
                parentNode: defaultDS,
                parentKey: 'entities',
            });
            return;
        }
        let returnFlag;
        exports.ops.upgraders.forEach((upgrader) => {
            if (upgrader.push) {
                const result = upgrader.push(item, propertyName, value, viewCache_1.virtualApp);
                if (result === false)
                    returnFlag = true;
            }
        });
        if (returnFlag) // 如果 upgrader 有一个返回 false，表示不添加了
            return;
        if (item.concept === 'App' && propertyName === 'logics') {
            // virtualApp[propertyName].push(value);
            value.parentNode = viewCache_1.virtualApp;
            value.parentKey = propertyName;
            return;
        }
        if (!item[propertyName]) {
            item[propertyName] = [];
        }
        value.parentNode = item;
        value.parentKey = propertyName;
        item[propertyName].push(value);
        const index = item[propertyName].length;
        value.create({
            index,
            parentNode: item,
            parentKey: propertyName,
        });
    },
    _create(concept) {
        const _ctor = (0, nasl_concepts_1.getConceptConstructor)(concept);
        const item = new _ctor();
        const { propertyMap } = (0, nasl_concepts_1.getConceptMeta)(concept);
        for (const p of propertyMap) {
            const [propertyName] = p;
            const t = item[propertyName];
            if (Array.isArray(t)) {
                exports.ops._set(item, propertyName, []);
            }
        }
        return item;
    },
    _addModule(app, frontend, name, belongs, data) {
        // const ms = app[belongs];
        // const exist = ms.find((m) => m.name === name);
        // if (!exist) {
        //     app['addModuleIn' + firstUpperCase(belongs)](data);
        // }
        const method = 'addModuleIn' + (0, nasl_utils_1.firstUpperCase)(belongs) + 'WithDataSource';
        if (app[method])
            app[method](data);
        else {
            if (frontend && belongs === 'componentDependencies') {
                const ms = frontend[belongs];
                const exist = ms.find((m) => m.name === name);
                if (!exist) {
                    frontend.addModule(data);
                }
            }
            else {
                const ms = app[belongs];
                const exist = ms.find((m) => m.name === name);
                if (!exist) {
                    app['addModuleIn' + (0, nasl_utils_1.firstUpperCase)(belongs)](data);
                }
            }
        }
    },
    _bindRoles() {
        return Array.prototype.map.call(arguments, (r) => r.name);
    },
};
//组件模板的导入有些不同
let handleDatas = [];
let dynamicNames = {};
let defaultValues = [];
exports.ComponentOps = {
    ...exports.ops,
    _set(item, propertyName, value, callback) {
        if (instanceOfBaseNode(value)) {
            value.parentNode = item;
            value.parentKey = propertyName;
        }
        if (item[propertyName] !== value) {
            //指view的全局逻辑或全局变量名称修改
            if (propertyName === 'name' && dynamicNames[item.name]) {
                dynamicNames[item.name] = value;
            }
            if (propertyName === 'defaultValue' && !(value === null || value === '')) {
                defaultValues.push({
                    parentNode: item,
                    typeAnnotation: item.typeAnnotation,
                    value,
                });
            }
            item.update({
                [propertyName]: value,
            });
            //有函数或者组件引用了view的全局逻辑或全局变量名称
            if ((propertyName === 'name' || propertyName === 'calleeName') && dynamicNames[value]
                && item.parentKey !== 'property' && item.concept !== 'StructureProperty') {
                handleDatas.push({
                    item,
                    propertyName,
                });
            }
            if (instanceOfBaseNode(value) && callback) {
                callback(item[propertyName]);
            }
        }
    },
    _push(item, propertyName, value) {
        if (!item[propertyName]) {
            item[propertyName] = [];
        }
        value.parentNode = item;
        value.parentKey = propertyName;
        item[propertyName].push(value);
        const index = item[propertyName].length;
        value.create({
            index,
            parentNode: item,
            parentKey: propertyName,
        });
    },
    _rename() {
        handleDatas.forEach(({ item, propertyName }) => {
            const changeName = item[propertyName];
            if (dynamicNames[changeName] && changeName !== dynamicNames[changeName])
                item.update({
                    [propertyName]: dynamicNames[changeName],
                });
        });
        handleDatas = [];
        dynamicNames = {};
    },
    _changeDefaultValue() {
        defaultValues.forEach(({ parentNode, typeAnnotation, value }) => {
            const defaultValue = getDefaultValue(typeAnnotation, value);
            parentNode.update({ defaultValue });
        });
        defaultValues = [];
    },
    _startNames(...initialNames) {
        initialNames.forEach((name) => {
            dynamicNames[name] = name;
        });
    },
};
exports.default = exports.ops;
//# sourceMappingURL=operators.js.map