package cn.tzzfj.scaffold.module.bpm.controller.admin.definition;

/**

 * <p> Project: scaffold - BpmModelController  </p>

 *

 * 管理后台 - 流程模型

 * 

 * @author Tz

 * @date 2025/10/25 15:26

 * @version 1.0.0

 * @since 1.0.0

 */

@Tag(name = "管理后台 - 流程模型")

@RestController

@RequestMapping("/bpm/model")

@Validated

public class BpmModelController {

    @Resource

    private BpmModelService modelService;

    @Resource

    private BpmFormService formService;

    @Resource

    private BpmCategoryService categoryService;

    @Resource

    private BpmProcessDefinitionService processDefinitionService;

    @Resource

    private AdminUserApi adminUserApi;

    @Resource

    private DeptApi deptApi;

    @GetMapping("/list")

    @Operation(summary = "获得模型分页")

    @Parameter(name = "name", description = "模型名称", example = "Tz")

    public CommonResult<List<BpmModelRespVO>> getModelList(@RequestParam(value = "name", required = false) String name) {

        List<Model> list = modelService.getModelList(name);

        if (CollUtil.isEmpty(list)) {

            return success(Collections.emptyList());

        }

        // 获得 Form 表单

        Set<Long> formIds = convertSet(list, model -> {

            BpmModelMetaInfoVO metaInfo = BpmModelConvert.INSTANCE.parseMetaInfo(model);

            return metaInfo != null ? metaInfo.getFormId() : null;

        });

        Map<Long, BpmFormDO> formMap = formService.getFormMap(formIds);

        // 获得 Category Map

        Map<String, BpmCategoryDO> categoryMap = categoryService.getCategoryMap(

                convertSet(list, Model::getCategory));

        // 获得 Deployment Map

        Map<String, Deployment> deploymentMap = processDefinitionService.getDeploymentMap(

                convertSet(list, Model::getDeploymentId));

        // 获得 ProcessDefinition Map

        List<ProcessDefinition> processDefinitions = processDefinitionService.getProcessDefinitionListByDeploymentIds(

                deploymentMap.keySet());

        Map<String, ProcessDefinition> processDefinitionMap = convertMap(processDefinitions, ProcessDefinition::getDeploymentId);

        // 获得 User Map、Dept Map

        Set<Long> userIds = convertSetByFlatMap(list, model -> {

            BpmModelMetaInfoVO metaInfo = BpmModelConvert.INSTANCE.parseMetaInfo(model);

            return metaInfo != null ? metaInfo.getStartUserIds().stream() : Stream.empty();

        });

        Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(userIds);

        Set<Long> deptIds = convertSetByFlatMap(list, model -> {

            BpmModelMetaInfoVO metaInfo = BpmModelConvert.INSTANCE.parseMetaInfo(model);

            return metaInfo != null && metaInfo.getStartDeptIds() != null ? metaInfo.getStartDeptIds().stream() : Stream.empty();

        });

        Map<Long, DeptRespDTO> deptMap = deptApi.getDeptMap(deptIds);

        // 最总组合信息返回

        return success(BpmModelConvert.INSTANCE.buildModelList(list,

                formMap, categoryMap, deploymentMap, processDefinitionMap, userMap, deptMap));

    }

    @GetMapping("/get")

    @Operation(summary = "获得模型")

    @Parameter(name = "id", description = "编号", required = true, example = "1024")

    @PreAuthorize("@ss.hasPermission('bpm:model:query')")

    public CommonResult<BpmModelRespVO> getModel(@RequestParam("id") String id) {

        Model model = modelService.getModel(id);

        if (model == null) {

            return null;

        }

        byte[] bpmnBytes = modelService.getModelBpmnXML(id);

        BpmSimpleModelNodeVO simpleModel = modelService.getSimpleModel(id);

        return success(BpmModelConvert.INSTANCE.buildModel(model, bpmnBytes, simpleModel));

    }

    @PostMapping("/create")

    @Operation(summary = "新建模型")

    @PreAuthorize("@ss.hasPermission('bpm:model:create')")

    public CommonResult<String> createModel(@Valid @RequestBody BpmModelSaveReqVO createRetVO) {

        return success(modelService.createModel(createRetVO));

    }

    @PutMapping("/update")

    @Operation(summary = "修改模型")

    @PreAuthorize("@ss.hasPermission('bpm:model:update')")

    public CommonResult<Boolean> updateModel(@Valid @RequestBody BpmModelSaveReqVO modelVO) {

        modelService.updateModel(getLoginUserId(), modelVO);

        return success(true);

    }

    @PutMapping("/update-sort-batch")

    @Operation(summary = "批量修改模型排序")

    @Parameter(name = "ids", description = "编号数组", required = true, example = "1,2,3")

    public CommonResult<Boolean> updateModelSortBatch(@RequestParam("ids") List<String> ids) {

        modelService.updateModelSortBatch(getLoginUserId(), ids);

        return success(true);

    }

    @PostMapping("/deploy")

    @Operation(summary = "部署模型")

    @Parameter(name = "id", description = "编号", required = true, example = "1024")

    @PreAuthorize("@ss.hasPermission('bpm:model:deploy')")

    public CommonResult<Boolean> deployModel(@RequestParam("id") String id) {

        modelService.deployModel(getLoginUserId(), id);

        return success(true);

    }

    @PutMapping("/update-state")

    @Operation(summary = "修改模型的状态", description = "实际更新的部署的流程定义的状态")

    @PreAuthorize("@ss.hasPermission('bpm:model:update')")

    public CommonResult<Boolean> updateModelState(@Valid @RequestBody BpmModelUpdateStateReqVO reqVO) {

        modelService.updateModelState(getLoginUserId(), reqVO.getId(), reqVO.getState());

        return success(true);

    }

    @Deprecated

    @PutMapping("/update-bpmn")

    @Operation(summary = "修改模型的 BPMN")

    @PreAuthorize("@ss.hasPermission('bpm:model:update')")

    public CommonResult<Boolean> updateModelBpmn(@Valid @RequestBody BpmModeUpdateBpmnReqVO reqVO) {

        modelService.updateModelBpmnXml(reqVO.getId(), reqVO.getBpmnXml());

        return success(true);

    }

    @DeleteMapping("/delete")

    @Operation(summary = "删除模型")

    @Parameter(name = "id", description = "编号", required = true, example = "1024")

    @PreAuthorize("@ss.hasPermission('bpm:model:delete')")

    public CommonResult<Boolean> deleteModel(@RequestParam("id") String id) {

        modelService.deleteModel(getLoginUserId(), id);

        return success(true);

    }

    @DeleteMapping("/clean")

    @Operation(summary = "清理模型")

    @Parameter(name = "id", description = "编号", required = true, example = "1024")

    @PreAuthorize("@ss.hasPermission('bpm:model:clean')")

    public CommonResult<Boolean> cleanModel(@RequestParam("id") String id) {

        modelService.cleanModel(getLoginUserId(), id);

        return success(true);

    }

    // ========== 仿钉钉 / 飞书的精简模型 =========

    @GetMapping("/simple/get")

    @Operation(summary = "获得仿钉钉流程设计模型")

    @Parameter(name = "modelId", description = "流程模型编号", required = true, example = "a2c5eee0-eb6c-11ee-abf4-0c37967c420a")

    public CommonResult<BpmSimpleModelNodeVO> getSimpleModel(@RequestParam("id") String modelId){

        return success(modelService.getSimpleModel(modelId));

    }

    @Deprecated

    @PostMapping("/simple/update")

    @Operation(summary = "保存仿钉钉流程设计模型")

    @PreAuthorize("@ss.hasPermission('bpm:model:update')")

    public CommonResult<Boolean> updateSimpleModel(@Valid @RequestBody BpmSimpleModelUpdateReqVO reqVO) {

        modelService.updateSimpleModel(getLoginUserId(), reqVO);

        return success(Boolean.TRUE);

    }

}

package cn.tzzfj.scaffold.module.bpm.service.definition;

/**

 * <p> Project: scaffold - BpmModelServiceImpl  </p>

 *

 * 流程模型实现：主要进行 Flowable {@link Model} 的维护

 * 

 * @author Tz

 * @date 2025/10/25 15:26

 * @version 1.0.0

 * @since 1.0.0

 */

@Service

@Validated

@Slf4j

public class BpmModelServiceImpl implements BpmModelService {

    @Resource

    private RepositoryService repositoryService;

    @Resource

    private BpmProcessDefinitionService processDefinitionService;

    @Resource

    private BpmFormService bpmFormService;

    @Resource

    private BpmTaskCandidateInvoker taskCandidateInvoker;

    @Resource

    private HistoryService historyService;

    @Resource

    private RuntimeService runtimeService;

    @Resource

    private TaskService taskService;

    @Resource

    private BpmProcessInstanceCopyService processInstanceCopyService;

    @Override

    public List<Model> getModelList(String name) {

        ModelQuery modelQuery = repositoryService.createModelQuery();

        if (StrUtil.isNotEmpty(name)) {

            modelQuery.modelNameLike("%" + name + "%");

        }

        modelQuery.modelTenantId(FlowableUtils.getTenantId());

        return modelQuery.list();

    }

    @Override

    public Long getModelCountByCategory(String category) {

        return repositoryService.createModelQuery()

                .modelCategory(category)

                .modelTenantId(FlowableUtils.getTenantId())

                .count();

    }

    @Override

    @Transactional(rollbackFor = Exception.class)

    public String createModel(@Valid BpmModelSaveReqVO createReqVO) {

        if (!ValidationUtils.isXmlNCName(createReqVO.getKey())) {

            throw exception(MODEL_KEY_VALID);

        }

        // 1. 校验流程标识已经存在

        Model keyModel = getModelByKey(createReqVO.getKey());

        if (keyModel != null) {

            throw exception(MODEL_KEY_EXISTS, createReqVO.getKey());

        }

        // 2. 创建 Model 对象

        createReqVO.setSort(System.currentTimeMillis()); // 使用当前时间，作为排序

        Model model = repositoryService.newModel();

        BpmModelConvert.INSTANCE.copyToModel(model, createReqVO);

        model.setTenantId(FlowableUtils.getTenantId());

        // 3. 保存模型

        saveModel(model, createReqVO);

        return model.getId();

    }

    @Override

    @Transactional(rollbackFor = Exception.class) // 因为进行多个操作，所以开启事务

    public void updateModel(Long userId, BpmModelSaveReqVO updateReqVO) {

        // 1. 校验流程模型存在

        Model model = validateModelManager(updateReqVO.getId(), userId);

        // 2. 填充 Model 信息

        BpmModelConvert.INSTANCE.copyToModel(model, updateReqVO);

        // 3. 保存模型

        saveModel(model, updateReqVO);

    }

    /**

     * 保存模型的基本信息、流程图

     *

     * @param model 模型

     * @param saveReqVO 保存信息

     */

    private void saveModel(Model model, BpmModelSaveReqVO saveReqVO) {

        // 1. 保存模型的基础信息

        repositoryService.saveModel(model);

        // 2. 保存流程图

        if (ObjUtil.equals(BpmModelTypeEnum.BPMN.getType(), saveReqVO.getType())

                && StrUtil.isNotEmpty(saveReqVO.getBpmnXml())) {

            updateModelBpmnXml(model.getId(), saveReqVO.getBpmnXml());

        } else if (ObjUtil.equals(BpmModelTypeEnum.SIMPLE.getType(), saveReqVO.getType())

                && saveReqVO.getSimpleModel() != null) {

            // JSON 转换成 bpmnModel

            BpmnModel bpmnModel = SimpleModelUtils.buildBpmnModel(model.getKey(), model.getName(),

                    saveReqVO.getSimpleModel());

            // 保存 Bpmn XML

            updateModelBpmnXml(model.getId(), BpmnModelUtils.getBpmnXml(bpmnModel));

            // 保存 JSON 数据

            updateModelSimpleJson(model.getId(), saveReqVO.getSimpleModel());

        }

    }

    @Override

    @Transactional(rollbackFor = Exception.class)

    public void updateModelSortBatch(Long userId, List<String> ids) {

        // 1.1 校验流程模型存在

        List<Model> models = repositoryService.createModelQuery()

                .modelTenantId(FlowableUtils.getTenantId()).list();

        models.removeIf(model -> !ids.contains(model.getId()));

        if (ids.size() != models.size()) {

            throw exception(MODEL_NOT_EXISTS);

        }

        Map<String, Model> modelMap = convertMap(models, Model::getId);

        // 1.2 校验是否为管理员

        ids.forEach(id -> validateModelManager(id, userId));

        // 保存排序

        long sort = System.currentTimeMillis(); // 使用时间戳 - i 作为排序

        for (int i = ids.size() - 1; i > 0; i--) {

            Model model = modelMap.get(ids.get(i));

            // 更新模型

            BpmModelMetaInfoVO metaInfo = BpmModelConvert.INSTANCE.parseMetaInfo(model).setSort(sort);

            model.setMetaInfo(JsonUtils.toJsonString(metaInfo));

            repositoryService.saveModel(model);

            // 更新排序

            processDefinitionService.updateProcessDefinitionSortByModelId(model.getId(), sort);

            sort--;

        }

    }

    private Model validateModelExists(String id) {

        Model model = repositoryService.getModel(id);

        if (model == null) {

            throw exception(MODEL_NOT_EXISTS);

        }

        return model;

    }

    /**

     * 校验是否有流程模型的管理权限

     *

     * @param id     流程模型编号

     * @param userId 用户编号

     * @return 流程模型

     */

    private Model validateModelManager(String id, Long userId) {

        Model model = validateModelExists(id);

        BpmModelMetaInfoVO metaInfo = BpmModelConvert.INSTANCE.parseMetaInfo(model);

        if (metaInfo == null || !CollUtil.contains(metaInfo.getManagerUserIds(), userId)) {

            throw exception(MODEL_UPDATE_FAIL_NOT_MANAGER, model.getName());

        }

        return model;

    }

    @Override

    @Transactional(rollbackFor = Exception.class) // 因为进行多个操作，所以开启事务

    public void deployModel(Long userId, String id) {

        // 1.1 校验流程模型存在

        Model model = validateModelManager(id, userId);

        BpmModelMetaInfoVO metaInfo = BpmModelConvert.INSTANCE.parseMetaInfo(model);

        // 1.2 校验流程图

        byte[] bpmnBytes = getModelBpmnXML(model.getId());

        validateBpmnXml(bpmnBytes, metaInfo.getType());

        // 1.3 校验表单已配

        BpmFormDO form = validateFormConfig(metaInfo);

        // 1.4 校验任务分配规则已配置

        taskCandidateInvoker.validateBpmnConfig(bpmnBytes);

        // 1.5 获取仿钉钉流程设计器模型数据

        String simpleJson = getModelSimpleJson(model.getId());

        // 2.1 创建流程定义

        String definitionId = processDefinitionService.createProcessDefinition(model, metaInfo, bpmnBytes, simpleJson,

                form);

        // 2.2 将老的流程定义进行挂起。也就是说，只有最新部署的流程定义，才可以发起任务。

        updateProcessDefinitionSuspended(model.getDeploymentId());

        // 2.3 更新 model 的 deploymentId，进行关联

        ProcessDefinition definition = processDefinitionService.getProcessDefinition(definitionId);

        model.setDeploymentId(definition.getDeploymentId());

        repositoryService.saveModel(model);

    }

    private void validateBpmnXml(byte[] bpmnBytes, Integer type) {

        BpmnModel bpmnModel = BpmnModelUtils.getBpmnModel(bpmnBytes);

        if (bpmnModel == null) {

            throw exception(MODEL_NOT_EXISTS);

        }

        // 1. 没有 StartEvent

        StartEvent startEvent = BpmnModelUtils.getStartEvent(bpmnModel);

        if (startEvent == null) {

            throw exception(MODEL_DEPLOY_FAIL_BPMN_START_EVENT_NOT_EXISTS);

        }

        // 2. 校验 UserTask 的 name 都配置了

        List<UserTask> userTasks = BpmnModelUtils.getBpmnModelElements(bpmnModel, UserTask.class);

        userTasks.forEach(userTask -> {

            if (StrUtil.isEmpty(userTask.getName())) {

                throw exception(MODEL_DEPLOY_FAIL_BPMN_USER_TASK_NAME_NOT_EXISTS, userTask.getId());

            }

        });

        // 3. 校验第一个用户任务节点的规则类型是否为 “审批人自选”，BPMN 设计器，校验第一个用户任务节点，SIMPLE 设计器，第一个节点固定为发起人所以校验第二个用户任务节点

        UserTask firUserTask = CollUtil.get(userTasks, BpmModelTypeEnum.BPMN.getType().equals(type) ? 0 : 1);

        if (firUserTask == null) {

            return;

        }

        Integer candidateStrategy = parseCandidateStrategy(firUserTask);

        if (Objects.equals(candidateStrategy, BpmTaskCandidateStrategyEnum.APPROVE_USER_SELECT.getStrategy())) {

            throw exception(MODEL_DEPLOY_FAIL_FIRST_USER_TASK_CANDIDATE_STRATEGY_ERROR, firUserTask.getName());

        }

    }

    @Override

    @Transactional(rollbackFor = Exception.class)

    public void deleteModel(Long userId, String id) {

        // 校验流程模型存在

        Model model = validateModelManager(id, userId);

        // 执行删除

        repositoryService.deleteModel(id);

        // 禁用流程定义

        updateProcessDefinitionSuspended(model.getDeploymentId());

    }

    @Override

    public void cleanModel(Long userId, String id) {

        // 1. 校验流程模型存在

        Model model = validateModelManager(id, userId);

        // 2. 清理所有流程数据

        // 2.1 先取消所有正在运行的流程

        List<ProcessInstance> processInstances = runtimeService.createProcessInstanceQuery()

                .processDefinitionKey(model.getKey()).list();

        processInstances.forEach(processInstance -> {

            runtimeService.deleteProcessInstance(processInstance.getId(),

                    BpmReasonEnum.CANCEL_BY_SYSTEM.getReason());

            historyService.deleteHistoricProcessInstance(processInstance.getId());

            processInstanceCopyService.deleteProcessInstanceCopy(processInstance.getId());

        });

        // 2.2 再从历史中删除所有相关的流程数据

        List<HistoricProcessInstance> historicProcessInstances = historyService.createHistoricProcessInstanceQuery()

                .processDefinitionKey(model.getKey()).list();

        historicProcessInstances.forEach(historicProcessInstance -> {

            historyService.deleteHistoricProcessInstance(historicProcessInstance.getId());

            processInstanceCopyService.deleteProcessInstanceCopy(historicProcessInstance.getId());

        });

        // 2.3 清理所有 Task

        List<Task> tasks = taskService.createTaskQuery()

                .processDefinitionKey(model.getKey()).list();

        tasks.forEach(task -> taskService.deleteTask(task.getId(),BpmReasonEnum.CANCEL_BY_PROCESS_CLEAN.getReason()));

    }

    @Override

    public void updateModelState(Long userId, String id, Integer state) {

        // 1.1 校验流程模型存在

        Model model = validateModelManager(id, userId);

        // 1.2 校验流程定义存在

        ProcessDefinition definition = processDefinitionService

                .getProcessDefinitionByDeploymentId(model.getDeploymentId());

        if (definition == null) {

            throw exception(PROCESS_DEFINITION_NOT_EXISTS);

        }

        // 2. 更新状态

        processDefinitionService.updateProcessDefinitionState(definition.getId(), state);

    }

    @Override

    public BpmnModel getBpmnModelByDefinitionId(String processDefinitionId) {

        return repositoryService.getBpmnModel(processDefinitionId);

    }

    @Override

    public BpmSimpleModelNodeVO getSimpleModel(String modelId) {

        Model model = validateModelExists(modelId);

        // 通过 ACT_RE_MODEL 表 EDITOR_SOURCE_EXTRA_VALUE_ID_ ，获取仿钉钉快搭模型的 JSON 数据

        String json = getModelSimpleJson(model.getId());

        return JsonUtils.parseObject(json, BpmSimpleModelNodeVO.class);

    }

    @Override

    public void updateSimpleModel(Long userId, BpmSimpleModelUpdateReqVO reqVO) {

        // 1. 校验流程模型存在

        Model model = validateModelManager(reqVO.getId(), userId);

        // 2.1 JSON 转换成 bpmnModel

        BpmnModel bpmnModel = SimpleModelUtils.buildBpmnModel(model.getKey(), model.getName(), reqVO.getSimpleModel());

        // 2.2 保存 Bpmn XML

        updateModelBpmnXml(model.getId(), BpmnModelUtils.getBpmnXml(bpmnModel));

        // 2.3 保存 JSON 数据

        updateModelSimpleJson(model.getId(), reqVO.getSimpleModel());

    }

    /**

     * 校验流程表单已配置

     *

     * @param metaInfo 流程模型元数据

     * @return 表单配置

     */

    private BpmFormDO validateFormConfig(BpmModelMetaInfoVO metaInfo) {

        if (metaInfo == null || metaInfo.getFormType() == null) {

            throw exception(MODEL_DEPLOY_FAIL_FORM_NOT_CONFIG);

        }

        // 校验表单存在

        if (Objects.equals(metaInfo.getFormType(), BpmModelFormTypeEnum.NORMAL.getType())) {

            if (metaInfo.getFormId() == null) {

                throw exception(MODEL_DEPLOY_FAIL_FORM_NOT_CONFIG);

            }

            BpmFormDO form = bpmFormService.getForm(metaInfo.getFormId());

            if (form == null) {

                throw exception(FORM_NOT_EXISTS);

            }

            return form;

        } else {

            if (StrUtil.isEmpty(metaInfo.getFormCustomCreatePath())

                    || StrUtil.isEmpty(metaInfo.getFormCustomViewPath())) {

                throw exception(MODEL_DEPLOY_FAIL_FORM_NOT_CONFIG);

            }

            return null;

        }

    }

    @Override

    public void updateModelBpmnXml(String id, String bpmnXml) {

        if (StrUtil.isEmpty(bpmnXml)) {

            return;

        }

        repositoryService.addModelEditorSource(id, StrUtil.utf8Bytes(bpmnXml));

    }

    @SuppressWarnings("JavaExistingMethodCanBeUsed")

    private String getModelSimpleJson(String id) {

        byte[] bytes = repositoryService.getModelEditorSourceExtra(id);

        if (ArrayUtil.isEmpty(bytes)) {

            return null;

        }

        return StrUtil.utf8Str(bytes);

    }

    private void updateModelSimpleJson(String id, BpmSimpleModelNodeVO node) {

        if (node == null) {

            return;

        }

        byte[] bytes = JsonUtils.toJsonByte(node);

        repositoryService.addModelEditorSourceExtra(id, bytes);

    }

    /**

     * 挂起 deploymentId 对应的流程定义

     * <p>

     * 注意：这里一个 deploymentId 只关联一个流程定义

     *

     * @param deploymentId 流程发布 Id

     */

    private void updateProcessDefinitionSuspended(String deploymentId) {

        if (StrUtil.isEmpty(deploymentId)) {

            return;

        }

        ProcessDefinition oldDefinition = processDefinitionService.getProcessDefinitionByDeploymentId(deploymentId);

        if (oldDefinition == null) {

            return;

        }

        processDefinitionService.updateProcessDefinitionState(oldDefinition.getId(),

                SuspensionState.SUSPENDED.getStateCode());

    }

    private Model getModelByKey(String key) {

        return repositoryService.createModelQuery()

                .modelTenantId(FlowableUtils.getTenantId())

                .modelKey(key).singleResult();

    }

    @Override

    public Model getModel(String id) {

        return repositoryService.getModel(id);

    }

    @Override

    public byte[] getModelBpmnXML(String id) {

        return repositoryService.getModelEditorSource(id);

    }

}

/**

 * <p> Project: scaffold - BpmProcessDefinitionController  </p>

 *

 * 管理后台 - 流程定义

 * 

 * @author Tz

 * @date 2025/10/25 15:26

 * @version 1.0.0

 * @since 1.0.0

 */

@Tag(name = "管理后台 - 流程定义")

@RestController

@RequestMapping("/bpm/process-definition")

@Validated

public class BpmProcessDefinitionController {

    @Resource

    private BpmProcessDefinitionService processDefinitionService;

    @Resource

    private BpmFormService formService;

    @Resource

    private BpmCategoryService categoryService;

    @GetMapping("/page")

    @Operation(summary = "获得流程定义分页")

    @PreAuthorize("@ss.hasPermission('bpm:process-definition:query')")

    public CommonResult<PageResult<BpmProcessDefinitionRespVO>> getProcessDefinitionPage(

            BpmProcessDefinitionPageReqVO pageReqVO) {

        PageResult<ProcessDefinition> pageResult = processDefinitionService.getProcessDefinitionPage(pageReqVO);

        if (CollUtil.isEmpty(pageResult.getList())) {

            return success(PageResult.empty(pageResult.getTotal()));

        }

        // 获得 Category Map

        Map<String, BpmCategoryDO> categoryMap = categoryService.getCategoryMap(

                convertSet(pageResult.getList(), ProcessDefinition::getCategory));

        // 获得 Deployment Map

        Map<String, Deployment> deploymentMap = processDefinitionService.getDeploymentMap(

                convertSet(pageResult.getList(), ProcessDefinition::getDeploymentId));

        // 获得 BpmProcessDefinitionInfoDO Map

        Map<String, BpmProcessDefinitionInfoDO> processDefinitionMap = processDefinitionService.getProcessDefinitionInfoMap(

                convertSet(pageResult.getList(), ProcessDefinition::getId));

        // 获得 Form Map

        Map<Long, BpmFormDO> formMap = formService.getFormMap(

               convertSet(processDefinitionMap.values(), BpmProcessDefinitionInfoDO::getFormId));

        return success(BpmProcessDefinitionConvert.INSTANCE.buildProcessDefinitionPage(

                pageResult, deploymentMap, processDefinitionMap, formMap, categoryMap));

    }

    @GetMapping ("/list")

    @Operation(summary = "获得流程定义列表")

    @Parameter(name = "suspensionState", description = "挂起状态", required = true, example = "1") // 参见 Flowable SuspensionState 枚举

    public CommonResult<List<BpmProcessDefinitionRespVO>> getProcessDefinitionList(

            @RequestParam("suspensionState") Integer suspensionState) {

        // 1.1 获得开启的流程定义

        List<ProcessDefinition> list = processDefinitionService.getProcessDefinitionListBySuspensionState(suspensionState);

        if (CollUtil.isEmpty(list)) {

            return success(Collections.emptyList());

        }

        // 1.2 移除不可见的流程定义

        Map<String, BpmProcessDefinitionInfoDO> processDefinitionMap = processDefinitionService.getProcessDefinitionInfoMap(

                convertSet(list, ProcessDefinition::getId));

        Long userId = getLoginUserId();

        list.removeIf(processDefinition -> {

            BpmProcessDefinitionInfoDO processDefinitionInfo = processDefinitionMap.get(processDefinition.getId());

            return processDefinitionInfo == null // 不存在

                    || Boolean.FALSE.equals(processDefinitionInfo.getVisible()) //visible 不可见

                    || !processDefinitionService.canUserStartProcessDefinition(processDefinitionInfo, userId); // 无权限发起

        });

        // 2. 拼接 VO 返回

        return success(BpmProcessDefinitionConvert.INSTANCE.buildProcessDefinitionList(

                list, null, processDefinitionMap, null, null));

    }

    @GetMapping("/simple-list")

    @Operation(summary = "获得流程定义精简列表", description = "只包含未挂起的流程，主要用于前端的下拉选项")

    public CommonResult<List<BpmProcessDefinitionRespVO>> getSimpleProcessDefinitionList() {

        // 只查询未挂起的流程

        List<ProcessDefinition> list = processDefinitionService.getProcessDefinitionListBySuspensionState(

                SuspensionState.ACTIVE.getStateCode());

        // 拼接 VO 返回，只返回 id、name、key

        return success(convertList(list, definition -> new BpmProcessDefinitionRespVO()

                .setId(definition.getId()).setName(definition.getName()).setKey(definition.getKey())));

    }

    @GetMapping ("/get")

    @Operation(summary = "获得流程定义")

    @Parameter(name = "id", description = "流程编号", required = true, example = "1024")

    @Parameter(name = "key", description = "流程定义标识", required = true, example = "1024")

    public CommonResult<BpmProcessDefinitionRespVO> getProcessDefinition(

            @RequestParam(value = "id", required = false) String id,

            @RequestParam(value = "key", required = false) String key) {

        ProcessDefinition processDefinition = id != null ? processDefinitionService.getProcessDefinition(id)

                : processDefinitionService.getActiveProcessDefinition(key);

        if (processDefinition == null) {