@lcap/nasl 0.3.9-beta

package/src/types/process/Process.ts

@@ -0,0 +1,306 @@
+import { immutable, circular, action, excludedInJSON } from '../decorators';
+import { config, history, LEVEL_ENUM, Vertex, MicroService, ProcessComponent, ProcessParam, ProcessReturn, ProcessProperty, ProcessInterface, vertexsMap, LogicItem, typeCheck, ActionOptions } from '..';
+import processService from '../../service/process';
+
+/**
+ * 流程类
+ */
+export class Process extends Vertex {
+    /**
+     * 概念类型
+     */
+    @immutable()
+    public readonly level: LEVEL_ENUM = LEVEL_ENUM.process;
+    /**
+     * 流程 Id
+     */
+    @immutable()
+    public readonly id: string = undefined;
+    /**
+     * 流程名称
+     */
+    @immutable()
+    public readonly name: string = undefined;
+    /**
+     * 流程标题
+     */
+    @immutable()
+    public readonly title: string = undefined;
+    /**
+     * 流程描述
+     */
+    @immutable()
+    public readonly description: string = undefined;
+    /**
+     * 流程组件集合
+     */
+    @immutable()
+    public readonly childShapes: Array<ProcessComponent> = [];
+    /**
+     * 流程输入参数
+     */
+    @immutable()
+    public readonly params: Array<any> = [];
+    /**
+     * 流程输出参数
+     */
+    @immutable()
+    public readonly returns: Array<any> = [];
+    /**
+     * 流程内置参数
+     */
+    @immutable()
+    public readonly properties: Array<any> = [];
+    /**
+     * 启动流程接口
+     */
+    @immutable()
+    public readonly launchProcessInterface: ProcessInterface = undefined;
+    /**
+     * 后端服务类型
+     */
+    @immutable()
+    public readonly serviceType: string = 'MICROSERVICE';
+    /**
+     * 所属后端服务 Id
+     */
+    @immutable()
+    public readonly serviceId: string = undefined;
+    /**
+     * 所属后端服务
+     */
+    @circular()
+    @immutable()
+    public readonly service: MicroService = undefined;
+    /**
+     * 树组件的子节点字段
+     */
+    @excludedInJSON()
+    @immutable()
+    public readonly childrenField: string = 'childShapes';
+    /**
+     * 树组件的子节点字段
+     */
+    @excludedInJSON()
+    @immutable()
+    public readonly moreChildrenFields: Array<string> = ['params', 'returns', 'properties', 'interfaces'];
+    /**
+     * 已存在名称集合
+     */
+    @excludedInJSON()
+    @immutable()
+    public readonly existingNames: Array<string> = [];
+    /**
+     * 接口列表，单纯用于 tree 展示
+     */
+    @excludedInJSON()
+    @immutable()
+    public readonly interfaces: Array<ProcessInterface> = [];
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Process>) {
+        super();
+        this.assign(source);
+    }
+    /**
+     * 添加流程
+     */
+    @action('添加流程')
+    async create(none?: void, actionOptions?: ActionOptions) {
+        config.defaultApp?.emit('saving');
+        this.assign({ editing: false, loading: true });
+        const body = this.toJSON();
+        const result = await processService.add({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'Process.create',
+                operationDesc: actionOptions?.actionDesc || `添加流程"${this.name}${this.title ? `(${this.title})` : ''}"`,
+            },
+            body,
+        });
+        this.assign(Process.from(result, this.service));
+        this.service.emit('interfacesChange');
+
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+        return this;
+    }
+    /**
+     * 删除流程
+     */
+    @action('删除流程')
+    async delete(none?: void, actionOptions?: ActionOptions) {
+        config.defaultApp?.emit('saving');
+        await processService.delete({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'Process.delete',
+                operationDesc: actionOptions?.actionDesc || `删除流程"${this.name}${this.title ? `(${this.title})` : ''}"`,
+            },
+            path: {
+                id: this.id,
+            },
+        });
+        typeCheck.deleteByProcess(this.id);
+        const index = this.service.processes.indexOf(this);
+        ~index && this.service.processes.splice(index, 1);
+        this.destroy();
+        this.service.emit('interfacesChange');
+
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+    }
+    /**
+     * 修改流程
+     */
+    async update(deep?: boolean, actionOptions?: ActionOptions, then?: () => Promise<any>) {
+        config.defaultApp?.emit('saving');
+        const body = this.toPlainJSON();
+        const result = await processService.update({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'Process.update',
+                operationDesc: actionOptions?.actionDesc || `修改流程"${this.name}${this.title ? `(${this.title})` : ''}"`,
+            },
+            body,
+        });
+        // 深度更新，需要同步更新 流程接口 和 UserTask 中的 完成任务接口
+        if (deep && result) {
+            const { childShapes = [], launchProcessInterface } = result;
+            const { name, path, method } = launchProcessInterface;
+            this.launchProcessInterface.assign({ name, path, method });
+            this.launchProcessInterface.logic.assign({ name });
+            this.childShapes.forEach((childShape) => {
+                const { type, completeTaskInterface } = childShape;
+                if (type === 'UserTask') {
+                    const newUserTask = childShapes.find((cShape: ProcessComponent) => cShape.id === childShape.id);
+                    const { name, path, method } = newUserTask.completeTaskInterface;
+                    completeTaskInterface.assign({ name, path, method });
+                    completeTaskInterface.logic.assign({ name });
+                }
+            });
+            this.service.emit('interfacesChange');
+        }
+
+        await then?.();
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+        return this;
+    }
+    /**
+     * 批量修改流程组件
+     */
+    async batchComponents(body: any, actionOptions?: ActionOptions) {
+        config.defaultApp?.emit('saving');
+        const result = await processService.batchComponents({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'Process.batchComponents',
+                operationDesc: `批量修改流程组件"${this.name}${this.title ? `(${this.title})` : ''}"`,
+            },
+            body,
+        });
+        let childShapes: Array<ProcessComponent> = [];
+        this.childShapes.forEach((processComponent) => {
+            const isDeleted = result.delete.find((node: any) => node.id === processComponent.id);
+            if (isDeleted) {
+                return;
+            }
+
+            const isUpdatedComp = result.update.find((node: any) => node.id === processComponent.id);
+            if (isUpdatedComp) {
+                childShapes.push(ProcessComponent.from(isUpdatedComp, this));
+                return;
+            }
+
+            childShapes.push(processComponent);
+        });
+        childShapes = childShapes.concat((result.add).map((childShape: any) => ProcessComponent.from(childShape, this)));
+        this.assign({ childShapes });
+        this.service.emit('interfacesChange');
+        this.checkType();
+        await config.defaultApp?.history.load();
+        config.defaultApp?.emit('saved');
+    }
+    /**
+     * 流程级别的类型检查
+     */
+    async checkType() {
+        const result = await processService.checkTypeProcess({
+            path: { id: this.id },
+        });
+        typeCheck.deleteByProcess(this.id);
+        typeCheck.pushAll(result);
+        result.forEach((typeCheckResult: any) => {
+            if (typeCheckResult.processComponentId) {
+                const processComponent = vertexsMap.get(typeCheckResult.processComponentId);
+                ProcessComponent.assignTypeCheckResult(processComponent as ProcessComponent, typeCheckResult);
+            }
+            if (typeCheckResult.logicId) {
+                const logicItem = vertexsMap.get(typeCheckResult.id);
+                LogicItem.assignTypeCheckResult(logicItem as LogicItem, typeCheckResult);
+            }
+        });
+    }
+    /**
+     * 设置流程名称
+     * @param name 名称
+     */
+    @action('设置流程名称')
+    async setName(name: string) {
+        const oldName = this.name;
+        this.assign({ name });
+        await this.update(true, {
+            actionDesc: `设置流程"${oldName}"的名称为"${name}"`,
+        });
+    }
+    /**
+     * 设置流程标题
+     * @param title 标题
+     */
+    @action('设置流程标题')
+    async setTitle(title: string) {
+        this.assign({ title });
+        await this.update(false, {
+            actionDesc: `设置流程"${this.name}"的标题为"${title}"`,
+        });
+    }
+    /**
+     * 设置流程描述
+     * @param description 描述
+     */
+    @action('设置流程描述')
+    async setDescription(description: string) {
+        this.assign({ description });
+        await this.update(false, {
+            actionDesc: `设置流程"${this.name}"的描述为"${description}"`,
+        });
+    }
+    /**
+     * 从后端 JSON 生成规范的 Param 对象
+     */
+    public static from(source: any, service: MicroService) {
+        const process = new Process(source);
+        process.assign({ service });
+        if (source) {
+            const { params = [], returns = [], properties = [], childShapes = [], launchProcessInterface } = source;
+            process.assign({
+                params: params.map((param: any) => ProcessParam.from(param, process)),
+                returns: returns.map((rn: any) => ProcessReturn.from(rn, process)),
+                properties: properties.map((property: any) => ProcessProperty.from(property, process)),
+                childShapes: childShapes.map((childShape: ProcessComponent) => ProcessComponent.from(childShape, process)),
+            });
+            if (launchProcessInterface) {
+                const ifce = ProcessInterface.from(launchProcessInterface, process);
+                process.assign({
+                    launchProcessInterface: ifce,
+                    interfaces: [ifce],
+                });
+            }
+        }
+        return process;
+    }
+}
+
+export default Process;

package/src/types/process/ProcessComponent.ts

@@ -0,0 +1,276 @@
+import { immutable, circular, action, excludedInJSON } from '../decorators';
+import { config, history, LEVEL_ENUM, Vertex, vertexsMap, Process, Logic, utils, ProcessComponentReturn, ProcessComponentVariable, ProcessComponentAttribute, ProcessComponentProperty, ProcessInterface, typeCheck, ActionOptions } from '..';
+import processService from '../../service/process';
+
+/**
+ * 流程组件类
+ */
+export class ProcessComponent extends Vertex {
+    /**
+     * 概念类型
+     */
+    @immutable()
+    public readonly level: LEVEL_ENUM = LEVEL_ENUM.processComponent;
+    /**
+     * 流程组件 Id
+     */
+    @immutable()
+    public readonly id: string = undefined;
+    /**
+     * 流程组件名称
+     */
+    @immutable()
+    public readonly name: string = undefined;
+    /**
+     * 流程组件标题
+     */
+    @immutable()
+    public readonly title: string = undefined;
+    /**
+     * 流程组件描述
+     */
+    @immutable()
+    public readonly description: string = undefined;
+    /**
+     * 流程组件类型
+     */
+    @immutable()
+    public readonly type: string = undefined;
+    /**
+     * 流程组件输出参数
+     */
+    @immutable()
+    public readonly returns: Array<any> = [];
+    /**
+     * 流程组件局部变量
+     */
+    @immutable()
+    public readonly variables: Array<any> = [];
+    /**
+     * 流程组件逻辑 ID
+     */
+    @immutable()
+    public readonly logicId: string = undefined;
+    /**
+     * 流程组件逻辑
+     */
+    @immutable()
+    public readonly logic: Logic = undefined;
+    /**
+     * 流程组件属性
+     */
+    @immutable()
+    public readonly destination: ProcessComponentAttribute = undefined;
+    /**
+     * 完成任务接口
+     */
+    @immutable()
+    public readonly completeTaskInterface: ProcessInterface = undefined;
+    /**
+     * 所属流程 Id
+     */
+    @immutable()
+    public readonly parentId: string = undefined;
+    /**
+     * 树组件的隐藏属性
+     */
+    @excludedInJSON()
+    public readonly hidden: boolean = false;
+    /**
+     * 类型检查详情
+     */
+    @excludedInJSON()
+    public readonly typeCheckResult: any = {};
+    /**
+     * 类型检查状态
+     */
+    @excludedInJSON()
+    public readonly typeCheckStatus: string = 'success';
+    /**
+     * 所属流程
+     */
+    @circular()
+    @immutable()
+    public readonly process: Process = undefined;
+    /**
+     * 树组件的子节点字段
+     */
+    @excludedInJSON()
+    @immutable()
+    public readonly moreChildrenFields: Array<string> = ['returns', 'variables', 'properties', 'interfaces'];
+    /**
+     * 已存在名称集合
+     */
+    @excludedInJSON()
+    @immutable()
+    public readonly existingNames: Array<string> = [];
+    /**
+     * 接口列表，单纯用于 tree 展示
+     */
+    @excludedInJSON()
+    @immutable()
+    public readonly interfaces: Array<ProcessInterface> = [];
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<ProcessComponent>) {
+        super();
+        this.assign(source);
+    }
+    /**
+     * 添加流程组件
+     */
+    @action('添加流程组件')
+    create() {
+        this.process.childShapes.push(this);
+        return this;
+    }
+    /**
+     * 删除流程组件
+     */
+    @action('删除流程组件')
+    delete() {
+        const index = this.process.childShapes.indexOf(this);
+        ~index && this.process.childShapes.splice(index, 1);
+        this.destroy();
+    }
+    /**
+     * 修改流程组件属性
+     */
+    async updateAttr(updateInterface?: boolean, actionOptions?: ActionOptions) {
+        config.defaultApp?.emit('saving');
+
+        const body = this.toPlainJSON();
+        utils.logger.debug('修改流程组件', body);
+        const { completeTaskInterface } = await processService.updateComponent({
+            headers: {
+                appId: config.defaultApp?.id,
+                operationAction: actionOptions?.actionName || 'ProcessComponent.updateAttr',
+                operationDesc: actionOptions?.actionDesc || `修改流程组件属性"${this.name}${this.title ? `(${this.title})` : ''}"`,
+            },
+            body,
+        });
+        // 流程接口会自动根据流程组件名称变化，更新流程接口的名称
+        if (updateInterface && completeTaskInterface) {
+            const { name, path, method } = completeTaskInterface;
+            this.completeTaskInterface.assign({ name, path, method });
+            this.completeTaskInterface.logic.assign({ name });
+            this.process.service.emit('interfacesChange');
+        }
+
+        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.updateAttr(true, {
+            actionDesc: `设置流程组件"${oldName}"的名称为"${name}"`,
+        });
+        // 流程逻辑会自动根据流程组件名称变化，更新逻辑的名称
+        if (this.logic) {
+            this.logic.assign({ name });
+        }
+    }
+    /**
+     * 设置流程组件标题
+     * @param title 标题
+     */
+    @action('设置流程组件标题')
+    async setTitle(title: string) {
+        this.assign({ title });
+        await this.updateAttr(false, {
+            actionDesc: `设置流程组件"${this.name}"的标题为"${title}"`,
+        });
+    }
+    /**
+     * 设置流程组件描述
+     * @param description 描述
+     */
+    @action('设置流程组件描述')
+    async setDescription(description: string) {
+        this.assign({ description });
+        await this.updateAttr(false, {
+            actionDesc: `设置流程组件"${this.name}"的描述为"${description}"`,
+        });
+    }
+    /**
+     * 设置流程组件值 (SequenceFlow)
+     * @param flowValue 值
+     */
+    @action('设置流程组件值')
+    async setFlowValue(flowValue: string) {
+        this.assign({ flowValue });
+        await this.updateAttr(false, {
+            actionDesc: `设置流程组件值`,
+        });
+    }
+    /**
+     * 设置流程组件任务完成人 (UserTask)
+     * @param assignee 任务完成人
+     */
+    @action('设置流程组件任务完成人')
+    async setAssignee(assignee: Array<string>) {
+        this.assign({ assignee });
+        await this.updateAttr(false, {
+            actionDesc: `设置流程组件任务完成人`,
+        });
+    }
+    /**
+     * 从后端 JSON 生成规范的 Param 对象
+     */
+    public static from(source: any, process: Process) {
+        const processComponent = new ProcessComponent(source);
+        processComponent.assign({
+            process,
+        });
+        if (source) {
+            const { returns = [], variables = [], properties = [], logicId, destination, completeTaskInterface, type } = source;
+            processComponent.assign({
+                hidden: ['StartNoneEvent', 'EndNoneEvent', 'SequenceFlow'].includes(type),
+                returns: returns.map((rn: any) => (ProcessComponentReturn.from(rn, processComponent))),
+                variables: variables.map((variable: any) => (ProcessComponentVariable.from(variable, processComponent))),
+                properties: properties.map((property: any) => (ProcessComponentProperty.from(property, processComponent))),
+            });
+            // 包含 logicId 时，自动初始化 logic
+            if (logicId) {
+                // 可能情况下，复用已有 Logic 缓存，防止重复打开多个同样的 logic 编辑器
+                processComponent.assign({
+                    logic: vertexsMap.get(logicId) || Logic.from({ id: logicId }, processComponent),
+                });
+            }
+            if (destination) {
+                processComponent.assign({
+                    destination: ProcessComponentAttribute.from(destination, processComponent),
+                });
+            }
+            if (completeTaskInterface) {
+                const ifce = ProcessInterface.from(completeTaskInterface, processComponent);
+                processComponent.assign({
+                    completeTaskInterface: ifce,
+                    interfaces: [ifce],
+                });
+            }
+        }
+        return processComponent;
+    }
+    static assignTypeCheckResult(processComponent: ProcessComponent, typeCheckResult: any) {
+        if (!processComponent || !typeCheckResult)
+            return;
+
+        typeCheck.push(typeCheckResult);
+        const typeCheckStatus = typeCheckResult.typeCheckNote?.status || 'success';
+        processComponent.assign({
+            typeCheckResult,
+            typeCheckStatus,
+        });
+    }
+}
+
+export default ProcessComponent;

package/src/types/process/ProcessComponentAttribute.ts

@@ -0,0 +1,131 @@
+import { immutable, excludedInJSON, action } from '../decorators';
+import { config, LEVEL_ENUM, ProcessComponent, Vertex, ActionOptions } from '..';
+import processService from '../../service/process';
+
+/**
+ * 流程节点属性
+ */
+export class ProcessComponentAttribute extends Vertex {
+    /**
+     * 概念类型
+     */
+    @immutable()
+    public readonly level: LEVEL_ENUM = LEVEL_ENUM.processComponentAttribute;
+    /**
+     * 流程节点属性类型
+     */
+    @immutable()
+    public readonly type: 'Destination' = undefined;
+    /**
+     * 名称
+     */
+    @immutable()
+    public readonly name: string = undefined;
+    /**
+     * 关联页面属性
+     */
+    @immutable()
+    public readonly pageRef: string = undefined;
+    /**
+     * 关联页面路由
+     */
+    @immutable()
+    public readonly url: string = undefined;
+    /**
+     * 流程组件 Id
+     */
+    @immutable()
+    public readonly processComponentId: string = undefined;
+    /**
+     * 流程组件 Id
+     */
+    @immutable()
+    public readonly destinationParams: Array<any> = [];
+    /**
+     * 流程节点
+     */
+    @excludedInJSON()
+    @immutable()
+    public readonly processComponent: ProcessComponent = undefined;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<ProcessComponentAttribute>) {
+        super();
+        source && this.assign(source);
+    }
+    /**
+     * 创建流程节点属性类型
+     */
+    @action('创建流程节点属性类型')
+    async create() {
+        const body = this.toJSON();
+        const result = await processService.addProcessAttribute({
+            body,
+        });
+        this.assign(result);
+        this.processComponent.assign({
+            destination: this,
+        });
+        ProcessComponentAttribute.checkType(this.id, this.processComponent);
+        return this;
+    }
+    /**
+     * 删除流程节点属性类型
+     */
+    @action('删除流程节点属性类型')
+    async delete() {
+        if (this.id) {
+            await processService.deleteProcessAttribute({ path: { id: this.id } });
+            this.processComponent.assign({
+                destination: null,
+            });
+        }
+        this.destroy();
+    }
+    /**
+     * 更新流程节点属性类型
+     */
+    @action('更新流程节点属性类型')
+    async update(none?: void, actionOptions?: ActionOptions) {
+        if (this.id) {
+            config.defaultApp?.emit('saving');
+
+            const body = this.toJSON();
+            const result = await processService.updateProcessAttribute({
+                headers: {
+                    appId: config.defaultApp?.id,
+                    operationAction: actionOptions?.actionName || 'ProcessComponentAttribute.update',
+                    operationDesc: actionOptions?.actionDesc || `更新流程节点属性类型"${this.name}"`,
+                },
+                body,
+            });
+            this.assign(result);
+            ProcessComponentAttribute.checkType(this.id, this.processComponent);
+
+            await config.defaultApp?.history.load();
+            config.defaultApp?.emit('saved');
+        }
+    }
+    /**
+     * 流程节点属性类型检查
+     */
+    public static async checkType(id: string, processComponent: ProcessComponent) {
+        const result = await processService.checkTypeProcessAttribute({
+            path: { id },
+        });
+        ProcessComponent.assignTypeCheckResult(processComponent, result);
+    }
+    /**
+     * 从后端 JSON 生成规范的 ProcessComponentAttribute 对象
+     */
+    public static from(source: any, processComponent: ProcessComponent) {
+        const processComponentVariable = new ProcessComponentAttribute(source);
+        processComponentVariable.assign({
+            processComponent,
+        });
+        return processComponentVariable;
+    }
+}
+
+export default ProcessComponentAttribute;