@lcap/nasl 0.3.9-beta

package/src/types/data/Enum.ts

@@ -0,0 +1,235 @@
+import { immutable, circular, excludedInJSON, action } from '../decorators';
+import {
+    config, utils, LEVEL_ENUM, Vertex, DataNode, EnumItem, Service,
+    convert2RefType, updateDataTypeList, ActionOptions,
+} from '..';
+import { enumService } from '../../service/data';
+import { dataTypesMap } from './dataTypes';
+
+/**
+ * 枚举类型
+ */
+export class Enum extends Vertex {
+    /**
+     * 概念类型
+     */
+    @immutable()
+    public readonly level: LEVEL_ENUM = LEVEL_ENUM.enum; // 后面换成 enum
+    /**
+     * 枚举 Id
+     */
+    @immutable()
+    public readonly id: string = undefined;
+    /**
+     * dataTypes 中的唯一标识
+     */
+    @immutable()
+    public readonly schemaRef: string = undefined;
+    /**
+     * 枚举名称
+     */
+    @immutable()
+    public readonly name: string = undefined;
+    /**
+     * 枚举标题
+     */
+    @immutable()
+    public readonly label: string = undefined;
+    /**
+     * 枚举描述
+     */
+    @immutable()
+    public readonly description: string = undefined;
+    /**
+     * 枚举类型
+     * @deprecated 兼容老版
+     */
+    @immutable()
+    public readonly type: 'enum' = 'enum';
+    /**
+     * 枚举项
+     */
+    @immutable()
+    public readonly enumItemList: Array<EnumItem> = [];
+    /**
+     * 所属服务 Id
+     */
+    @immutable()
+    public readonly serviceId: string = undefined;
+    /**
+     * 所属服务类型
+     */
+    @immutable()
+    public readonly serviceType: string = undefined;
+    /**
+     * 所属服务
+     */
+    @immutable()
+    public readonly service: Service = undefined;
+    /**
+     * 父节点
+     */
+    @circular()
+    @immutable()
+    public readonly dataNode: DataNode = undefined;
+
+    @excludedInJSON()
+    public existingNames: Array<string> = [];
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Enum>) {
+        super();
+        source && this.assign(source);
+    }
+    /**
+     * 添加枚举
+     */
+    @action('添加枚举')
+    async create(none?: void, actionOptions?: ActionOptions) {
+        const body = this.toJSON();
+        utils.logger.debug('添加枚举', body);
+
+        const result: Enum = await enumService.create({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'Enum.create',
+                operationDesc: actionOptions?.actionDesc || `添加枚举"${this.name}"`,
+            },
+            body,
+        });
+        this.deepPick(result, ['id']);
+
+        this.assign({
+            schemaRef: `#/${this.dataNode.service.id}/${result.id}`,
+        });
+        dataTypesMap[this.schemaRef] = this;
+        updateDataTypeList();
+        this.dataNode.service.emit('dataTypesChange');
+        this.dataNode.service.emit('enumsChange');
+        this.dataNode.service.emit('vertexIdToNameChange', this.id, this.name);
+
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+        return this;
+    }
+    /**
+     * 删除枚举
+     */
+    @action('删除枚举')
+    async delete(none?: void, actionOptions?: ActionOptions) {
+        config.defaultApp?.emit('saving');
+
+        if (this.id) {
+            await enumService.delete({
+                headers: {
+                    appId: config.defaultApp?.id,
+                    operationAction: actionOptions?.actionName || 'Enum.delete',
+                    operationDesc: actionOptions?.actionDesc || `删除枚举"${this.name}"`,
+                },
+                query: {
+                    id: this.id,
+                },
+            });
+
+            const index = this.dataNode.enums.indexOf(this);
+            ~index && this.dataNode.enums.splice(index, 1);
+            delete dataTypesMap[this.schemaRef];
+        }
+
+        updateDataTypeList();
+        this.destroy();
+        this.dataNode.service.emit('dataTypesChange');
+        this.dataNode.service.emit('enumsChange');
+
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+    }
+    /**
+     * 修改枚举
+     */
+    async update(
+        none?: void, actionOptions?: ActionOptions, then?: () => Promise<any>,
+    ) {
+        config.defaultApp?.emit('saving');
+
+        const body = this.toJSON('', ['enumItemList']);
+        utils.logger.debug('修改枚举', body);
+        const result: Enum = await enumService.update({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'Enum.update',
+                operationDesc: actionOptions?.actionDesc || `修改枚举"${this.name}"`,
+            },
+            body,
+        });
+        this.plainAssign(result);
+
+        await then?.();
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+        return this;
+    }
+    /**
+     * 设置枚举名称
+     * @param name 名称
+     */
+    @action('设置枚举名称')
+    async setName(name: string) {
+        const oldName = this.name;
+        this.assign({ name });
+        await this.update(undefined, {
+            actionDesc: `设置枚举"${oldName}"的名称为"${name}"`,
+        });
+
+        updateDataTypeList();
+        this.dataNode.service.emit('dataTypesChange');
+        this.dataNode.service.emit('enumsChange');
+        this.dataNode.service.emit('vertexIdToNameChange', this.id, this.name);
+    }
+    /**
+     * 设置枚举标题
+     * @param name 标题
+     */
+    @action('设置枚举标题')
+    async setLabel(label: string) {
+        const oldLabel = this.label;
+        this.assign({ label });
+        await this.update(undefined, {
+            actionDesc: `设置枚举"${oldLabel}"的标题为"${label}"`,
+        });
+    }
+    /**
+     * 设置枚举描述
+     * @param description 描述
+     */
+    @action('设置枚举描述')
+    async setDescription(description: string) {
+        this.assign({ description });
+        await this.update(undefined, {
+            actionDesc: `设置枚举"${this.name}"的描述为"${description}"`,
+        });
+    }
+    /**
+     * 从后端 JSON 生成规范的 Enum 对象
+     */
+    public static from(source: any, service: Service) {
+        convert2RefType(source);
+        const enumObject = new Enum(source);
+        enumObject.assign({
+            dataNode: service.data,
+            schemaRef: `#/${service.id}/${enumObject.id}`,
+        });
+
+        const enumItemList = enumObject.enumItemList as Array<EnumItem>;
+        enumItemList.forEach((property, index) => {
+            property = enumItemList[index] = new EnumItem(property);
+            property.assign({ root: enumObject });
+        });
+
+        dataTypesMap[enumObject.schemaRef] = enumObject;
+        return enumObject;
+    }
+}
+
+export default Enum;

package/src/types/data/EnumItem.ts

@@ -0,0 +1,156 @@
+import { action, circular, immutable } from '../decorators';
+import { config, history, Vertex, Enum, utils, LEVEL_ENUM, ActionOptions } from '..';
+import { enumPropertyService } from '../../service/data';
+
+/**
+ * 枚举项
+ */
+export class EnumItem extends Vertex {
+    /**
+     * 概念类型
+     */
+    @immutable()
+    public readonly level: LEVEL_ENUM = LEVEL_ENUM.enumItem;
+    /**
+     * Id
+     */
+    @immutable()
+    public readonly id: string = undefined;
+    /**
+     * 值
+     */
+    @immutable()
+    public readonly value: string = undefined;
+    /**
+     * 名称
+     */
+    @immutable()
+    public readonly label: string = undefined;
+    /**
+     * 枚举 Id
+     */
+    @immutable()
+    public readonly enumId: string = undefined;
+    /**
+     * 父级引用
+     */
+    @circular()
+    @immutable()
+    public root: Enum = undefined;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<EnumItem>) {
+        super();
+        source && this.assign(source);
+    }
+    /**
+     * 添加枚举项
+     */
+    @action('添加枚举项')
+    async create(none?: void, actionOptions?: ActionOptions) {
+        config.defaultApp?.emit('saving');
+
+        const body = this.toJSON();
+        utils.logger.debug('添加枚举项', body);
+
+        const result: EnumItem = await enumPropertyService.create({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'EnumItem.create',
+                operationDesc: actionOptions?.actionDesc || `添加枚举项"${this.label}"`,
+            },
+            body,
+        });
+        this.deepPick(result, ['id']);
+
+        this.root.dataNode.service.emit('dataTypesChange');
+        this.root.dataNode.service.emit('enumsChange');
+        this.root.dataNode.service.emit('vertexIdToNameChange', this.id, this.label);
+
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+        return this;
+    }
+    /**
+     * 删除枚举项
+     */
+    @action('删除枚举项')
+    async delete(none?: void, actionOptions?: ActionOptions) {
+        config.defaultApp?.emit('saving');
+
+        if (this.id) {
+            await enumPropertyService.delete({
+                headers: {
+                    appId: config.defaultApp?.id,
+                    operationAction: actionOptions?.actionName || 'EnumItem.delete',
+                    operationDesc: actionOptions?.actionDesc || `删除枚举项"${this.label}"`,
+                },
+                query: {
+                    id: this.id,
+                },
+            });
+        }
+
+        const index = this.root.enumItemList.indexOf(this);
+        ~index && this.root.enumItemList.splice(index, 1);
+        this.destroy();
+        this.root.dataNode.service.emit('dataTypesChange');
+        this.root.dataNode.service.emit('enumsChange');
+
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+    }
+    /**
+     * 修改枚举项
+     */
+    async update(none?: void, actionOptions?: ActionOptions, then?: () => Promise<any>) {
+        config.defaultApp?.emit('saving');
+        const body = this.toJSON();
+
+        body._posIndex = this.root.enumItemList.indexOf(this);
+        await enumPropertyService.update({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'EnumItem.update',
+                operationDesc: actionOptions?.actionDesc || `修改枚举项"${this.name}"`,
+            },
+            body,
+        });
+
+        await then?.();
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+        return this;
+    }
+    /**
+     * 设置枚举项值
+     * @param value
+     */
+    async setValue(value: string) {
+        this.assign({ value });
+        await this.update(undefined, {
+            actionDesc: '设置枚举项值',
+        });
+
+        this.root.dataNode.service.emit('dataTypesChange');
+        this.root.dataNode.service.emit('enumsChange');
+        this.root.dataNode.service.emit('vertexIdToNameChange', this.id, this.value);
+    }
+    /**
+     * 设置枚举项标题
+     * @param value
+     */
+    async setLabel(label: string) {
+        this.assign({ label });
+        await this.update(undefined, {
+            actionDesc: '设置枚举项标题',
+        });
+
+        this.root.dataNode.service.emit('dataTypesChange');
+        this.root.dataNode.service.emit('enumsChange');
+        this.root.dataNode.service.emit('vertexIdToNameChange', this.id, this.value);
+    }
+}
+
+export default EnumItem;

package/src/types/data/GlobalLogicNode.ts

@@ -0,0 +1,201 @@
+import { immutable, circular } from '../decorators';
+import {
+    LEVEL_ENUM, Vertex, Service, Entity,
+    Interface, Process, Structure, dataTypesMap,
+} from '..';
+import { updateDataTypeList } from '../data/dataTypes';
+
+export interface Category {
+    level: LEVEL_ENUM.category;
+    name: string;
+    categoryInterfaces: Array<Interface>;
+    categoryStructures: Array<Structure>;
+    isLeaf: false;
+    structureExpanded: false;
+    interfaceExpanded: false;
+}
+/**
+ * 数据分类
+ */
+export class GlobalLogicNode extends Vertex {
+    /**
+     * 概念类型
+     */
+    @immutable()
+    public readonly level: LEVEL_ENUM = LEVEL_ENUM.gloablLogicNode;
+
+    @immutable()
+    public readonly type: 'logics' | 'interfaces' = undefined;
+    @immutable()
+    public globalLogics: Array<Interface> = [];
+    public entityLogics: Array<Entity> = [];
+    public processLogics: Array<Process> = [];
+    public interfaces: Array<Interface> = [];
+    public structures: Array<Structure> = [];
+    public categories: Array<Category> = [];
+
+    @circular()
+    @immutable()
+    public readonly service: Service = undefined;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<GlobalLogicNode>) {
+        super();
+        source && this.assign(source);
+    }
+
+    createOrGetCatogory(category: string) {
+        let ciInstance = this.categories.find((ci) => ci.name === category);
+
+        if (!ciInstance) {
+            ciInstance = {
+                level: LEVEL_ENUM.category,
+                name: category,
+                categoryInterfaces: [],
+                categoryStructures: [],
+                isLeaf: false,
+                interfaceExpanded: false,
+                structureExpanded: false,
+            };
+            this.categories.unshift(ciInstance);
+        }
+        return ciInstance;
+    }
+
+    addCategoryInterface(iface: Interface) {
+        const category = iface.category;
+        const ciInstance = this.createOrGetCatogory(category);
+        ciInstance.categoryInterfaces.unshift(iface);
+    }
+
+    addCategoryStructure(sturct: Structure) {
+        const category = sturct.category;
+        const ciInstance = this.createOrGetCatogory(category);
+        const index = ciInstance.categoryStructures.findIndex((s) => s.id === sturct.id);
+        if (index >= 0) {
+            const [oldstruct] = ciInstance.categoryStructures.splice(index, 1, sturct);
+            oldstruct.destroy();
+        } else {
+            ciInstance.categoryStructures.unshift(sturct);
+        }
+        updateDataTypeList();
+    }
+
+    checkExternalInterface(category: string, name: string) {
+        let itface;
+        const categoryInstance = this.categories.find((ci) => {
+            itface = ci.categoryInterfaces.find((itface) => itface.name === name);
+            return ci.name === category && !!itface;
+        });
+        return categoryInstance ? {
+            category: categoryInstance,
+            interface: itface,
+        } : null;
+    }
+
+    removeCategory(categoryInstance: Category) {
+        if (!categoryInstance.categoryInterfaces.length && !categoryInstance.categoryStructures.length) {
+            const index = this.categories.indexOf(categoryInstance);
+            ~index && this.categories.splice(index, 1);
+        }
+    }
+
+    removeCategoryStructure(sturct: Structure) {
+        const category = sturct.category;
+        const ciInstance = this.createOrGetCatogory(category);
+        const index = ciInstance.categoryStructures.findIndex((s) => s.id === sturct.id);
+        if (index >= 0) {
+            ciInstance.categoryStructures.splice(index, 1);
+        }
+        this.removeCategory(ciInstance);
+    }
+
+    removeInterface(itface: Interface) {
+        if (itface.serviceType === 'external') {
+            const category = itface.category;
+            const categoryInstance = this.categories.find((ci) => ci.name === category);
+            const index = categoryInstance.categoryInterfaces.indexOf(itface);
+            ~index && categoryInstance.categoryInterfaces.splice(index, 1);
+            this.removeCategory(categoryInstance);
+        }
+        if (itface.serviceType === 'micro') {
+            if (itface.exportedInterface) {
+                itface.exportedInterface.delete();
+            }
+            const index = this.globalLogics.indexOf(itface);
+            ~index && this.globalLogics.splice(index, 1);
+        }
+    }
+
+    syncEntityLogics() {
+        const entityLogics: Array<Entity> = [];
+        this.service.data.entities.forEach((entity) => {
+            entityLogics.push(entity);
+        });
+        this.entityLogics = entityLogics;
+    }
+
+    syncStructures(structuresOrigin: Array<Structure>) {
+        const structures = this.structures;
+        const smap: { [id: string]: Structure } = {};
+        // removeRef
+        structures.forEach((s) => {
+            delete dataTypesMap[s.schemaRef];
+            smap[s.id] = s;
+        });
+
+        this.categories.forEach((category) => {
+            category.categoryStructures.forEach((s) => {
+                delete dataTypesMap[s.schemaRef];
+                smap[s.id] = s;
+            });
+        });
+
+        function replaceInStructureList(structures: Array<Structure>, structureNode: Structure) {
+            const sid = structureNode.id;
+            const index = structures.findIndex((s) => s.id === sid);
+            structures.splice(index, 1, structureNode);
+            delete smap[sid];
+        }
+
+        function removeInStructureList(structures: Array<Structure>, structureNode: Structure) {
+            const sid = structureNode.id;
+            const index = structures.findIndex((s) => s.id === sid);
+            structures.splice(index, 1);
+            structureNode.destroy();
+        }
+
+        structuresOrigin.forEach((item) => {
+            const structureNode = Structure.from(item, this.service);
+            const sid = structureNode.id;
+            if (structureNode.serviceType === 'external' && structureNode.category) {
+                const category = this.categories.find((c) => c.name === structureNode.category);
+                if (category && smap[sid]) {
+                    replaceInStructureList(category.categoryStructures, structureNode);
+                } else {
+                    this.addCategoryStructure(structureNode);
+                }
+            } else {
+                if (smap[sid]) {
+                    replaceInStructureList(structures, structureNode);
+                } else {
+                    structures.unshift(structureNode);
+                }
+            }
+        });
+        Object.keys(smap).forEach((key) => {
+            const struct = smap[key];
+            if (struct.category) {
+                const category = this.categories.find((c) => c.name === struct.category);
+                removeInStructureList(category.categoryStructures, struct);
+            } else {
+                removeInStructureList(structures, struct);
+            }
+        });
+
+        updateDataTypeList();
+    }
+}
+
+export default GlobalLogicNode;