@lcap/nasl 0.3.9-beta

package/src/types/data/Structure.ts

@@ -0,0 +1,300 @@
+import { immutable, circular, excludedInJSON, action } from '../decorators';
+import {
+    config, utils, LEVEL_ENUM, Vertex, DataNode,
+    ObjectSchema, Service, dataTypesMap, updateDataTypeList,
+    StructureProperty, ActionOptions,
+} from '..';
+import { structureService } from '../../service/data';
+import { convert2RefType } from './dataTypeUtils';
+import { updateAllVariablesChildrenSchema } from '../index';
+
+/**
+ * 数据结构类
+ */
+export class Structure extends Vertex implements ObjectSchema {
+    /**
+     * 概念类型
+     */
+    @immutable()
+    public readonly level: LEVEL_ENUM = LEVEL_ENUM.structure;
+    /**
+     * Id
+     */
+    @immutable()
+    public readonly id: string = undefined;
+    /**
+     * dataTypes 中的唯一标识
+     */
+    @immutable()
+    public readonly schemaRef: string = undefined;
+    /**
+     * 名称
+     */
+    @immutable()
+    public readonly name: string = undefined;
+    /**
+     * 描述
+     */
+    @immutable()
+    public readonly description: string = undefined;
+    /**
+     * 类型
+     */
+    @immutable()
+    public readonly type: 'object' = 'object';
+    /**
+     * 属性列表
+     */
+    @immutable()
+    readonly propertyList: Array<StructureProperty> = [];
+
+    @immutable()
+    public readonly resolvers: string = undefined;
+    /**
+     * 所属服务 Id
+     */
+    @immutable()
+    public readonly serviceId: string = undefined;
+    /**
+     * catogory Name
+     */
+    @immutable()
+    public readonly category: string = undefined;
+    /**
+     * 所属服务类型
+     */
+    @immutable()
+    public readonly serviceType: string = undefined;
+    /**
+     * 所属实体 Id
+     */
+    @immutable()
+    public readonly entityId: string = undefined;
+    /**
+     * 所属服务
+     */
+    @immutable()
+    public readonly service: Service = undefined;
+    /**
+     * 父节点
+     */
+    @circular()
+    @immutable()
+    public readonly dataNode: DataNode = undefined;
+    /**
+     * 周边存在的名称
+     */
+    @excludedInJSON()
+    public existingNames: Array<string> = [];
+    /**
+     * 周边存在的名称
+     */
+    constructor(source?: Partial<Structure>) {
+        super();
+        source && this.assign(source);
+    }
+    /**
+     * 按当前 id 加载数据结构数据
+     * @requires this.id
+     */
+    async load() {
+        const result = await structureService.loadDetail({
+            query: {
+                id: this.id,
+            },
+            config: {
+                mock: config.mock,
+            },
+        });
+
+        this.assign(result);
+        return this;
+    }
+    /**
+     * 按当前 id 加载数据结构数据
+     * @requires this.id
+     */
+    async loadPro() {
+        const result = await structureService.loadDetail({
+            query: {
+                id: this.id,
+            },
+        });
+
+        Object.assign(result, result.definition);
+        delete result.definition;
+        convert2RefType(result);
+        const structure = new Structure(result);
+
+        const propertyList = structure.propertyList as Array<StructureProperty>;
+        propertyList.forEach((property, index) => {
+            property = propertyList[index] = new StructureProperty(property);
+            property.assign({ root: structure });
+        });
+
+        const service = this.dataNode.service;
+        structure.assign({
+            schemaRef: `#/${service.id}/${structure.id}`,
+            dataNode: service.data,
+            expanded: true,
+        });
+        dataTypesMap[structure.schemaRef] = structure;
+
+        this.assign(structure);
+
+        const pos = this.dataNode.structures.findIndex((item) => item.id === this.id);
+        if (pos === -1)
+            this.dataNode.structures.unshift(this);
+        else {
+            this.dataNode.structures.splice(pos, 1, structure);
+        }
+
+        updateDataTypeList();
+        updateAllVariablesChildrenSchema();
+        this.dataNode.service.emit('dataTypesChange');
+        this.dataNode.service.emit('vertexIdToNameChange', this.id, this.name);
+
+        return this;
+    }
+    /**
+     * 添加数据结构
+     */
+    @action('添加数据结构')
+    async create(none?: void, actionOptions?: ActionOptions, then?: () => Promise<any>) {
+        config.defaultApp?.emit('saving');
+
+        const body = this.toJSON();
+
+        utils.logger.debug('添加数据结构', body);
+        const result: Structure = await structureService.create({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'Structure.create',
+                operationDesc: actionOptions?.actionDesc || `添加数据结构"${this.name}"`,
+            },
+            body,
+        });
+
+        this.deepPick(result, ['id']);
+
+        this.assign({
+            schemaRef: `#/${this.dataNode.service.id}/${result.id}`,
+        });
+        dataTypesMap[this.schemaRef] = this;
+
+        await then?.();
+        updateDataTypeList();
+        this.dataNode.service.emit('dataTypesChange');
+        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 structureService.delete({
+                headers: {
+                    appId: config.defaultApp?.id,
+                    operationAction: actionOptions?.actionName || 'Structure.delete',
+                    operationDesc: actionOptions?.actionDesc || `删除数据结构"${this.name}"`,
+                },
+                query: {
+                    id: this.id,
+                },
+            });
+        }
+        const index = this.dataNode.structures.indexOf(this);
+        ~index && this.dataNode.structures.splice(index, 1);
+        this.dataNode.service.globalLogic.removeCategoryStructure(this);
+        delete dataTypesMap[this.schemaRef];
+
+        updateDataTypeList();
+        this.destroy();
+        this.dataNode.service.emit('dataTypesChange');
+
+        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('', ['propertyList']);
+
+        utils.logger.debug('修改数据结构', body);
+        const result: Structure = await structureService.update({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'Structure.update',
+                operationDesc: actionOptions?.actionDesc || `修改数据结构"${this.name}"`,
+            },
+            body,
+        });
+        convert2RefType(result);
+        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('vertexIdToNameChange', this.id, this.name);
+    }
+    /**
+     * 设置数据结构描述
+     * @param description 描述
+     */
+    @action('设置数据结构描述')
+    async setDescription(description: string) {
+        this.assign({ description });
+        await this.update(undefined, {
+            actionDesc: `设置数据结构"${this.name}"的描述为"${description}"`,
+        });
+    }
+    /**
+     * 从后端 JSON 生成规范的 Structure 对象
+     */
+    public static from(source: any, service: Service) {
+        convert2RefType(source);
+        const structure = new Structure(source);
+        structure.assign({
+            dataNode: service.data,
+            schemaRef: `#/${service.id}/${structure.id}`,
+        });
+
+        const propertyList = structure.propertyList as Array<StructureProperty>;
+        propertyList.forEach((property, index) => {
+            property = propertyList[index] = new StructureProperty(property);
+            property.assign({ root: structure });
+        });
+        structure.assign({ resolvers: undefined });
+
+        dataTypesMap[structure.schemaRef] = structure;
+        return structure;
+    }
+}
+
+export default Structure;

package/src/types/data/StructureProperty.ts

@@ -0,0 +1,332 @@
+import { immutable, circular, excludedInJSON, action } from '../decorators';
+import {
+    config, utils, LEVEL_ENUM, Vertex, Schema,
+    Structure, ActionOptions,
+} from '..';
+import { structureService } from '../../service/data';
+import { getBasicTypeDefaultValue } from './basicTypes';
+import { convert2RefType } from './dataTypeUtils';
+import { updateAllVariablesChildrenSchema } from '../logic/BaseVariable';
+import { schemaService } from '../../service/common';
+
+/**
+ * 数据结构属性类
+ */
+export class StructureProperty extends Vertex implements Schema {
+    /**
+     * 概念类型
+     */
+    @immutable()
+    public level: LEVEL_ENUM = LEVEL_ENUM.property;
+    /**
+     * Id
+     */
+    @immutable()
+    public readonly id: string = undefined;
+    /**
+     * 名称
+     */
+    @immutable()
+    public readonly name: string = undefined;
+    /**
+     * 标签
+     */
+    @immutable()
+    public readonly label: string = undefined;
+    /**
+     * 描述
+     */
+    @immutable()
+    public readonly description: string = undefined;
+    /**
+     * type
+     */
+    @immutable()
+    public readonly type: string = undefined;
+    /**
+     * 数据格式
+     */
+    @immutable()
+    public readonly format: string = undefined;
+    /**
+     * generic 数据格式
+     */
+    @immutable()
+    public readonly typeInstantiation: Schema = undefined;
+    /**
+     * 是否必须
+     */
+    @immutable()
+    public readonly required: boolean = undefined;
+    /**
+     * 数据类型
+     */
+    @immutable()
+    public readonly $ref: string = undefined;
+    /**
+     * 是否为数组，老的 Schema 中仍然用这种形式
+     */
+    @immutable()
+    public readonly isArray: boolean = undefined;
+    /**
+     * 规则列表
+     */
+    @immutable()
+    public readonly rules: any = undefined;
+    /**
+     * 默认值
+     */
+    @immutable()
+    public readonly defaultValue: string | boolean | number = undefined;
+    /**
+     * 父级 Id
+     */
+    @immutable()
+    public readonly structureId: string = undefined;
+    /**
+     * 父级引用
+     */
+    @circular()
+    @immutable()
+    public root: Structure = undefined;
+    /**
+     * 节点是否为叶子节点
+     * 前端 UI 状态
+     */
+    @excludedInJSON()
+    public isLeaf = true;
+    /**
+     * 周边存在的名称
+     */
+    @excludedInJSON()
+    public existingNames: Array<string> = [];
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<StructureProperty>) {
+        super();
+        source && this.assign(source);
+    }
+    /**
+     * 添加数据结构属性
+     */
+    @action('添加数据结构属性')
+    async create(none?: void, actionOptions?: ActionOptions) {
+        config.defaultApp?.emit('saving');
+        const body = this.toJSON();
+        body._posIndex = this.root.propertyList.indexOf(this);
+        utils.logger.debug('添加数据结构属性', body);
+        const result: StructureProperty = await structureService.addProperty({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'StructureProperty.create',
+                operationDesc: actionOptions?.actionDesc || `添加数据结构"${this.root.name}"属性"${this.name}"`,
+            },
+            body,
+        });
+        // convert2RefType(result);
+        this.deepPick(result, ['id']);
+
+        updateAllVariablesChildrenSchema();
+        this.root.dataNode.service.emit('dataTypesChange');
+        this.root.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 structureService.deleteProperty({
+                headers: {
+                    appId: config.defaultApp?.id,
+                    operationAction: actionOptions?.actionName || 'StructureProperty.delete',
+                    operationDesc: actionOptions?.actionDesc || `删除数据结构"${this.root.name}"属性"${this.name}"`,
+                },
+                query: {
+                    id: this.id,
+                },
+            });
+        }
+
+        const index = this.root.propertyList.indexOf(this);
+        ~index && this.root.propertyList.splice(index, 1);
+
+        updateAllVariablesChildrenSchema();
+        this.destroy();
+        this.root.dataNode.service.emit('dataTypesChange');
+
+        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();
+        delete body.schemaRef;
+        utils.logger.debug('修改数据结构属性', body);
+        const result = await structureService.updateProperty({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'StructureProperty.update',
+                operationDesc: actionOptions?.actionDesc || `修改数据结构"${this.root.name}"属性"${this.name}"`,
+            },
+            body,
+        });
+
+        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: `设置数据结构"${this.root.name}"的属性"${oldName}"的名称为"${name}"`,
+        });
+
+        this.root.dataNode.service.emit('dataTypesChange');
+        this.root.dataNode.service.emit('vertexIdToNameChange', this.id, this.name);
+    }
+    /**
+     * 设置数据结构属性标题
+     * @param label 标题
+     */
+    @action('设置数据结构属性标题')
+    async setLabel(label: string) {
+        this.assign({ label });
+        await this.update(undefined, {
+            actionDesc: `设置数据结构"${this.root.name}"的属性"${this.name}"的标题为"${label}"`,
+        });
+    }
+    /**
+     * 设置数据结构属性描述
+     * @param description 描述
+     */
+    @action('设置数据结构属性描述')
+    async setDescription(description: string) {
+        this.assign({ description });
+        await this.update(undefined, {
+            actionDesc: `设置数据结构"${this.root.name}"的属性"${this.name}"的描述为"${description}"`,
+        });
+    }
+    /**
+     * 查找schema 顶点被引用的逻辑顶点列表
+     */
+    async getSchemaUsage() {
+        const result = await schemaService.getSchemaUsage({
+            query: {
+                schemaId: this.id,
+                valSource: 'structure',
+            },
+        });
+        return result;
+    }
+    /**
+     * 设置数据结构属性类型
+     */
+    @action('设置数据结构属性类型')
+    async setDataType(schema: Schema) {
+        // 用于update失败后还原数据
+        const originalData = {
+            $ref: this.$ref,
+            type: this.type,
+            format: this.format,
+            typeInstantiation: this.typeInstantiation,
+            defaultValue: this.defaultValue,
+            rules: this.rules,
+        };
+        this.assign({
+            $ref: undefined, //引用到Entity或者structure
+            type: undefined,
+            format: undefined,
+            typeInstantiation: undefined,
+        });
+        this.assign(schema);
+        this.assign({
+            defaultValue: getBasicTypeDefaultValue(),
+            rules: [],
+        });
+        try {
+            await this.update(undefined, {
+                actionDesc: `设置数据结构"${this.root.name}"的属性"${this.name}"的类型为"${schema.typeKey}"`,
+            });
+
+            updateAllVariablesChildrenSchema();
+            this.root.dataNode.service.emit('dataTypesChange');
+        } catch (err) {
+            this.assign(convert2RefType(originalData));
+            config.defaultApp?.emit('saved');
+            throw err;
+        }
+    }
+    /**
+     * 设置数据结构属性是否为列表
+     * @param isArray
+     */
+    @action('设置数据结构属性是否为列表')
+    async setAsList(isArray: boolean) {
+        this.assign({ isArray });
+        this.assign({ defaultValue: getBasicTypeDefaultValue() });
+
+        await this.update(undefined, {
+            actionDesc: `设置数据结构"${this.root.name}"的属性"${this.name}"${isArray ? '为' : '不为'}列表`,
+        });
+
+        this.root.dataNode.service.emit('dataTypesChange');
+    }
+    /**
+     * 设置数据结构属性默认值
+     */
+    @action('设置数据结构属性默认值')
+    async setDefaultValue(defaultValue: string) {
+        this.assign({ defaultValue });
+        await this.update(undefined, {
+            actionDesc: `设置数据结构"${this.root.name}"的属性"${this.name}"的默认值为"${defaultValue}"`,
+        });
+
+        this.root.dataNode.service.emit('dataTypesChange');
+    }
+    /**
+     * 设置数据结构属性必须
+     * @param required 必须
+     */
+    @action('设置数据结构属性必须')
+    async setRequired(required: boolean) {
+        this.assign({ required });
+        await this.update(undefined, {
+            actionDesc: `设置数据结构"${this.root.name}"的属性"${this.name}"为"${required ? '必须' : '不必须'}"`,
+        });
+
+        this.root.dataNode.service.emit('dataTypesChange');
+    }
+    @action('设置数据结构属性规则')
+    async setRules(rules: any) {
+        this.assign({ rules });
+        await this.update(undefined, {
+            actionDesc: `设置数据结构属性规则`,
+        });
+    }
+    /**
+     * 从后端 JSON 生成规范的 StructureProperty 对象
+     */
+    public static from(source: any, root: Structure) {
+        convert2RefType(source.schema);
+    }
+}
+
+export default StructureProperty;

package/src/types/data/basicTypes.ts

@@ -0,0 +1,76 @@
+import { BasicSchema } from '..';
+
+export enum BASIC_TYPE {
+    Boolean = 'Boolean',
+    Integer = 'Integer',
+    Long = 'Long',
+    Decimal = 'Decimal',
+    String = 'String',
+    Text = 'Text',
+    Binary = 'Binary',
+    Date = 'Date',
+    Time = 'Time',
+    DateTime = 'DateTime',
+    Email = 'Email',
+}
+
+export const basicTypeList = [
+    { kind: 'basicType', text: 'Boolean 布尔值', value: '#/basicTypes/Boolean' },
+    { kind: 'basicType', text: 'Integer 整数', value: '#/basicTypes/Integer' },
+    { kind: 'basicType', text: 'Long 长整数', value: '#/basicTypes/Long' },
+    { kind: 'basicType', text: 'Double 小数', value: '#/basicTypes/Decimal' },
+    { kind: 'basicType', text: 'String 字符串', value: '#/basicTypes/String' },
+    { kind: 'basicType', text: 'Text 长文本', value: '#/basicTypes/Text' },
+    { kind: 'basicType', text: 'Binary 二进制流', value: '#/basicTypes/Binary' },
+    { kind: 'basicType', text: 'Date 日期', value: '#/basicTypes/Date' },
+    { kind: 'basicType', text: 'Time 时间', value: '#/basicTypes/Time' },
+    { kind: 'basicType', text: 'DateTime 日期时间', value: '#/basicTypes/DateTime' },
+    { kind: 'basicType', text: 'Email 电子邮箱', value: '#/basicTypes/Email' },
+];
+
+export const basicTypeMap: { [name: string]: BasicSchema } = {
+    '#/basicTypes/Boolean': { type: 'boolean', format: '' },
+    '#/basicTypes/Integer': { type: 'integer', format: 'int' },
+    '#/basicTypes/Long': { type: 'integer', format: 'long' },
+    '#/basicTypes/Decimal': { type: 'number', format: 'double' },
+    '#/basicTypes/String': { type: 'string', format: '' },
+    '#/basicTypes/Text': { type: 'string', format: 'text' },
+    '#/basicTypes/Binary': { type: 'string', format: 'binary' },
+    '#/basicTypes/Date': { type: 'string', format: 'date' },
+    '#/basicTypes/Time': { type: 'string', format: 'time' },
+    '#/basicTypes/DateTime': { type: 'string', format: 'date-time' },
+    '#/basicTypes/Email': { type: 'string', format: 'email' },
+};
+
+export function getBasicTypeName(type: string, format: string) {
+    if (type === 'boolean')
+        return BASIC_TYPE.Boolean;
+    else if (type === 'integer' && format === 'long')
+        return BASIC_TYPE.Long;
+    else if (type === 'integer')
+        return BASIC_TYPE.Integer;
+    else if (type === 'number')
+        return BASIC_TYPE.Decimal;
+    else if (type === 'string' && format === 'text')
+        return BASIC_TYPE.Text;
+    else if (type === 'string' && format === 'binary')
+        return BASIC_TYPE.Binary;
+    else if (type === 'string' && format === 'date')
+        return BASIC_TYPE.Date;
+    else if (type === 'string' && format === 'time')
+        return BASIC_TYPE.Time;
+    else if (type === 'string' && format === 'date-time')
+        return BASIC_TYPE.DateTime;
+    else if (type === 'string' && format === 'email')
+        return BASIC_TYPE.Email;
+    else if (type === 'string')
+        return BASIC_TYPE.String;
+}
+
+export function getBasicTypeRef(type: string, format: string) {
+    return `#/basicTypes/${getBasicTypeName(type, format)}`;
+}
+
+export function getBasicTypeDefaultValue(value?: any): void {
+    return undefined;
+}