wangli/workflow-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

流程定义流程实例部分代码开发

Browse Source
This commit is contained in:
lvshaohua 2023-06-08 18:13:49 +08:00
parent f7be7b64da
commit 33deba6d37
16 changed files with 420 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
workflow-engine-server/src/main/java/cn/axzo/server/common/enums/BpmErrorCodeConstants.java Normal file
View File

@ -0,0 +1,4 @@
package cn.axzo.server.common.enums;
public class BpmErrorCodeConstants {
}

123
workflow-engine-server/src/main/java/cn/axzo/server/common/enums/ErrorCode.java
View File

@ -13,6 +13,120 @@ import lombok.Getter;
@AllArgsConstructor
public enum ErrorCode implements IProjectRespCode {
// ========== 流程模型 1-009-002-000 ==========
MODEL_KEY_EXISTS("1009002000", "已经存在流程标识为【{}】的流程"),
MODEL_KEY_EXISTS2("1009002000", "已经存在流程标识为【{}】的流程"),
MODEL_NOT_EXISTS("1009002001","流程模型不存在"),
MODEL_KEY_VALID("1009002002",
"流程标识格式不正确，需要以字母或下划线开头，后接任意字母、数字、中划线、下划线、句点！"),
MODEL_DEPLOY_FAIL_FORM_NOT_CONFIG("1009002003",
"部署流程失败，原因：流程表单未配置，请点击【修改流程】按钮进行配置"),
MODEL_DEPLOY_FAIL_TASK_ASSIGN_RULE_NOT_CONFIG("1009002004", "部署流程失败，" +
"原因：用户任务({})未配置分配规则，请点击【配置审核人】按钮进行配置"),
MODEL_DEPLOY_FAIL_TASK_INFO_EQUALS("1009003005", "流程定义部署失败，原因：信息未发生变化"),
// ========== 流程定义 1-009-003-000 ==========
PROCESS_DEFINITION_KEY_NOT_MATCH("1009003000",
"流程定义的标识不一致 请修改 BPMN 流程图"),
PROCESS_DEFINITION_NAME_NOT_MATCH("1009003001",
"流程定义的名字期望是({})，当前是({})，请修改 BPMN 流程图"),
PROCESS_DEFINITION_NOT_EXISTS("1009003002", "流程定义不存在"),
PROCESS_DEFINITION_IS_SUSPENDED("1009003003", "流程定义处于挂起状态"),
PROCESS_DEFINITION_BPMN_MODEL_NOT_EXISTS("1009003004", "流程定义的模型不存在"),
// ========== 流程实例 1-009-004-000 ==========
PROCESS_INSTANCE_NOT_EXISTS("1009004000", "流程实例不存在"),
PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS("1009004001", "流程取消失败，流程不处于运行中"),
PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF("1009004002", "流程取消失败，该流程不是你发起的"),
// ========== 流程任务 1-009-005-000 ==========
TASK_COMPLETE_FAIL_NOT_EXISTS("1009005000", "审批任务失败，原因：该任务不处于未审批"),
TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF("1009005001", "审批任务失败，原因：该任务的审批人不是你"),
// ========== 流程任务分配规则 1-009-006-000 ==========
TASK_ASSIGN_RULE_EXISTS("1009006000", "流程({}) 的任务({}) 已经存在分配规则"),
TASK_ASSIGN_RULE_NOT_EXISTS("1009006001", "流程任务分配规则不存在"),
TASK_UPDATE_FAIL_NOT_MODEL("1009006002", "只有流程模型的任务分配规则，才允许被修改"),
TASK_CREATE_FAIL_NO_CANDIDATE_USER("1009006003", "操作失败，原因：找不到任务的审批人！"),
TASK_ASSIGN_SCRIPT_NOT_EXISTS("1009006004", "操作失败，原因：任务分配脚本({}) 不存在"),
TASK_ASSIGN_GET_USER_ERROR("1009006005", "通过【{}】获取任务候选人失败，失败原因：{}"),
USER_COMPANY_ID_NOT_EXISTS("1009006006", "缺失所在单位信息"),
TASK_ASSIGN_USER_NOT_ENOUGH("1009006007", "操作失败，原因：候选人数量{}小于循环基数{}"),
// ========== 动态表单模块 1-009-010-000 ==========
FORM_NOT_EXISTS("1009010000", "动态表单不存在"),
FORM_FIELD_REPEAT("1009010001", "表单项({}) 和 ({}) 使用了相同的字段名({})"),
FORM_CONFIG_ERROR("1009010002", "内置表单解析失败"),
FORM_CONFIG_ID_NOT_EXISTS("1009010003", "修改/删除业务表单时，ID不能为空"),
FORM_CONFIG_IN_USED("1009010004", "表单正在使用中，不能删除"),
FORM_CONFIG_CATEGORY_EXIST("1009010005", "当前所属业务已有绑定关系，不能重复新增"),
FORM_FIELD_DECODE_ERROR("1009010006", "表单Field格式不正确"),
FORM_CONFIG_CATEGORY_NOT_EXIST("1009010006", "表单信息不存在，请前往 配置管理->所属业务关联关系 添加表单绑定信息"),
// ========== 用户组模块 1-009-011-000 ==========
USER_GROUP_NOT_EXISTS("1009011000", "用户组不存在"),
USER_GROUP_IS_DISABLE("1009011001", "名字为【{}】的用户组已被禁用"),
// ========== 公共模板 1-009-012-000 ==========
COMMON_ERROR("1009012000", "{}"),
COMMON_MODEL_EXISTS("1009012001", "名字为【{}】的公共模型已经存在"),
COMMON_MODEL_PROJECT_ID_NOT_EXISTS("1009012002",
"应用类型选择租户时, 关联的项目[tenants]不能为空"),
COMMON_MODEL_FORM_CONFIG_NOT_EXISTS("1009012003",
"表单类型选择业务表单时, 业务表单不能为空"),
COMMON_MODEL_ID_IS_NULL("1009012004", "模型ID丢失, 请检查入参"),
COMMON_MODEL_TASK_ASSIGN_RULE_EXISTS("1009012005",
"流程({}) 的任务({}) 已经存在分配规则"),
COMMON_MODEL_TASK_ASSIGN_RULE_NOT_EXISTS("1009012006", "流程任务分配规则不存在"),
COMMON_MODEL_TASK_ASSIGN_RULE_TYPE_ILLEGAL("1009012007",
"({}) 的应用范围，不能配置 ({}) 审配人类型"),
COMMON_MODEL_FORM_FIELD_PERMISSION("1009012008",
"HTML 标签 ID 为 ({})和 Label 为 ({})的表单项配置权限信息只能只读/隐藏二选一，且不能为空"),
FORM_CONFIG_REGISTER_INFO_NOT_EXISTS("1009012009", "未获取到该业务表单的配置信息"),
COMMON_MODEL_PROCESS_FORM_NOT_EXISTS("1009012010", "流程表单已被删除, 请重新选择"),
GET_REMOTE_WORKSPACE_INFO_ERROR("1009012011", "调用远程接口出现异常, 接口: {}"),
COMMON_MODEL_ASSIGN_DATA_NOT_EXISTS("1009012012", "模板数据异常,未获取到租户"),
COMMON_MODEL_NOT_EXISTS("1009012013",
"流程模型模板不存在,或者模型未配置 BPMN 流程"),
BPM_PROCESS_DEFINITION_NOT_EXISTS("1009012014",
"未查询到可以用于发起工作流的流程定义ID, 请确认工作台与所属分类是否匹配"),
BPM_PROCESS_DEFINITION_RESULT_TOO_MANY("1009012015",
"数据出现异常,同一个工作台下,同一个所属分类,只能有一个流程定义"),
FORM_NOT_ENABLE("1009012016", "表单已经不可用"),
ILLEGAL_FORM_DATA("1009012017", "表单类型数据异常, 非法数据"),
BPMN_XML_NOT_EXISTS("1009012018", "BPMN 文件内容不存在,将终止发布"),
BPMN_XML_NOT_VALID("1009012019", "BPMN 文件内容不合法,将终止发布"),
DEPLOY_TENANTS_NOT_EXISTS("1009012020", "当前模型中未选择应用范围,将终止发布"),
DEPLOY_FORM_CONFIG_NOT_EXISTS("1009012021", "当前模型中未关联表单,将终止发布"),
DEPLOY_OPTIONS_NOT_EXISTS("1009012022", "当前模型中[{}]任务未分配审核人,将终止发布"),
DEPLOY_SOURCE_NOT_EXISTS("1009012023", "流程模型原数据丢失,将终止发布"),
GET_REMOTE_DATE_ERROR("1009012024", "调用远程接口 [{}] 发生异常: {}"),
PARTICIPATED_DATA_IS_EMPTY("1009012025",
"当前 [{}] 项目工作台(WorkspaceId={})下未获取到参与单位信息"),
PARTICIPATED_TYPE_DATA_IS_EMPTY("1009012026",
"当前 [{}] 项目工作台(WorkspaceId={})下未获取到{}数据"),
GET_SUPERIOR_UNIT_ID_ERROR("1009012027", "获取上级执行单位信息异常"),
MODEL_POOL_CANT_DEPLOY("1009012028", "模型已不部署,无需重复发布"),
PROCESS_DEFINITION_IS_SUSPENDED_CANT_DEPLOY("1009012029",
"模型处于挂起状态,无法发布"),
FLOWABLE_GENERAL_ERROR("1009013000", "流程引擎一般错误"),
FLOWABLE_ENGINE_OBJECT_NOT_FOUND("1009013001", "流程引擎内部错误：流程定义未找到"),
FLOWABLE_WRONG_DB("1009013002", "数据库版本与流程引擎版本不匹配"),
FLOWABLE_DB_OPTIMISTIC_LOCKING("1009013003", "引擎内部数据乐观锁死锁"),
FLOWABLE_TASK_ALREADY_CLAIMED("1009013004", "当前审批任务已有审批人"),
FLOWABLE_ILLEGAL_STATE("1009013005", "审批流状态异常"),
FLOWABLE_ILLEGAL_ARGUMENT("1009013006", "流程引擎存在非法参数"),
FLOWABLE_FORBIDDEN("1009013007", "当前流程引擎禁止访问"),
FLOWABLE_CLASS_LOADING_ERROR("1009013008", "流程引擎加载异常"),
USER_NOT_EXISTS("01001", "用户不存在，id=%s"),
USER_PHONE_EMAIL_IS_NULL("01002", "电话和邮箱不能都为空");
@ -24,4 +138,13 @@ public enum ErrorCode implements IProjectRespCode {
// 根据不同项目进行项目编码调整，可联系框架组获取项目编号(首位不能为0)
return "100";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

1
workflow-engine-server/src/main/java/cn/axzo/server/controller/web/UserController.java
View File

@ -1,6 +1,5 @@
package cn.axzo.server.controller.web;
import cn.axzo.server.service.user.UserService;
import cn.axzo.server.service.dto.request.user.NewUserDTO;
import cn.axzo.server.service.dto.request.user.UpdateUserDTO;
import cn.axzo.server.service.dto.request.user.UserQO;

1
workflow-engine-server/src/main/java/cn/axzo/server/controller/web/UserResource.java
View File

@ -8,7 +8,6 @@ import cn.axzo.server.service.dto.request.user.NewUserDTO;
import cn.axzo.server.service.dto.request.user.UpdateUserDTO;
import cn.axzo.server.service.dto.request.user.UserQO1;
import cn.axzo.server.service.dto.response.user.UserVO;
import cn.axzo.server.service.user.UserService;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

56
workflow-engine-server/src/main/java/cn/axzo/server/repository/UserDao.java
View File

@ -1,56 +0,0 @@
package cn.axzo.server.repository;
import cn.axzo.framework.domain.page.PageQO;
import cn.axzo.server.repository.mapper.UserMapper;
import cn.axzo.server.service.dto.request.user.UserQO;
import cn.axzo.server.service.dto.request.user.UserQO1;
import cn.axzo.server.repository.entity.user.User;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Repository;
/**
* @Author: liyong.tian
* @Date: 2022/9/5
* @Description:
*/
@Repository
@RequiredArgsConstructor
public class UserDao extends ServiceImpl<UserMapper, User> {
private final UserMapper userMapper;
public User findById(Long id) {
return userMapper.selectById(id);
}
public void delete(Long id) {
userMapper.deleteById(id);
}
public IPage<User> queryByPage(UserQO userQO) {
return userMapper.selectPage(userQO.toPage(),
Wrappers.lambdaQuery(User.class)
.eq(userQO.getId() != null, User::getId, userQO.getId())
.like(StringUtils.isNotBlank(userQO.getName()), User::getName, userQO.getName())
.like(StringUtils.isNotBlank(userQO.getPhone()), User::getPhone, userQO.getPhone())
.like(StringUtils.isNotBlank(userQO.getEmail()), User::getEmail, userQO.getEmail())
.orderByDesc(User::getCreateAt)
);
}
public IPage<User> find(UserQO1 userQO, PageQO page) {
return userMapper.selectPage(page.toPage(),
Wrappers.lambdaQuery(User.class)
.eq(userQO.getId() != null, User::getId, userQO.getId())
.like(StringUtils.isNotBlank(userQO.getName()), User::getName, userQO.getName())
.like(StringUtils.isNotBlank(userQO.getPhone()), User::getPhone, userQO.getPhone())
.like(StringUtils.isNotBlank(userQO.getEmail()), User::getEmail, userQO.getEmail())
.orderByDesc(User::getCreateAt)
);
}
}

14
workflow-engine-server/src/main/java/cn/axzo/server/repository/mapper/UserMapper.java
View File

@ -1,14 +0,0 @@
package cn.axzo.server.repository.mapper;
import cn.axzo.server.repository.entity.user.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* @Author: liyong.tian
* @Date: 2022/9/5
* @Description:
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {
}

10
workflow-engine-server/src/main/java/cn/axzo/server/service/BpmProcessDefinitionService.java Normal file
View File

@ -0,0 +1,10 @@
package cn.axzo.server.service;
import org.flowable.common.engine.impl.db.SuspensionState;
public interface BpmProcessDefinitionService {
Boolean updateProcessDefinitionSuspendedState(String processDefinitionId, SuspensionState state);
}

2
workflow-engine-server/src/main/java/cn/axzo/server/service/BpmProcessService.java → workflow-engine-server/src/main/java/cn/axzo/server/service/BpmProcessInstanceService.java
View File

@ -1,6 +1,6 @@
package cn.axzo.server.service;
public interface BpmProcessService {
public interface BpmProcessInstanceService {
Boolean updateProcessStatus(String processInstanceId, String status);

9
workflow-engine-server/src/main/java/cn/axzo/server/service/dto/process/definition/BpmProcessDefinitionCreateDTO.java Normal file
View File

@ -0,0 +1,9 @@
package cn.axzo.server.service.dto.process.definition;
public class BpmProcessDefinitionCreateDTO {
private String key;
private String name;
private String category;
private String tenantId;
}

2
workflow-engine-server/src/main/java/cn/axzo/server/service/dto/request/user/UpdateUserDTO.java
View File

@ -8,8 +8,6 @@ import org.apache.commons.lang3.StringUtils;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import static cn.axzo.server.common.enums.ErrorCode.USER_PHONE_EMAIL_IS_NULL;
/**
* @Author: liyong.tian
* @Date: 2022/9/5

63
workflow-engine-server/src/main/java/cn/axzo/server/service/impl/BpmModelServiceImpl.java
View File

@ -1,7 +1,8 @@
package cn.axzo.server.service.impl;
import cn.axzo.framework.domain.ServiceException;
import cn.axzo.server.common.enums.ErrorCode;
import cn.axzo.server.service.BpmModelService;
import cn.axzo.server.service.BpmProcessService;
import cn.axzo.server.service.converter.BpmModelConverter;
import cn.axzo.server.service.dto.request.model.BpmModelCreateDTO;
import cn.axzo.server.service.dto.request.model.BpmModelPageDTO;
@ -11,22 +12,22 @@ import cn.axzo.server.service.dto.response.model.BpmModelDetailVO;
import cn.axzo.server.service.dto.response.model.BpmModelPageItemVO;
import com.alibaba.fastjson.JSON;
import org.apache.commons.lang3.ObjectUtils;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.engine.RepositoryService;
import org.flowable.engine.repository.Model;
import org.flowable.engine.repository.ModelQuery;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.repository.ProcessDefinitionQuery;
import org.springframework.context.annotation.Lazy;
import javax.annotation.Resource;
import java.util.Map;
public class BpmModelServiceImpl implements BpmModelService {
@Resource
@Lazy
private RepositoryService repositoryService;
@Resource
private ProcessDefinition processDefinition;
@Resource
private BpmProcessDefinitionServiceImpl processDefinitionServiceImpl;
@Override
public PageResult<BpmModelPageItemVO> getModelPage(BpmModelPageDTO modelPageDTO) {
@ -36,6 +37,11 @@ public class BpmModelServiceImpl implements BpmModelService {
@Override
public String createBpmModel(BpmModelCreateDTO createDTO) {
Model existModel = repositoryService.createModelQuery().modelKey(createDTO.getKey()).singleResult();
if (!ObjectUtils.isEmpty(existModel)) {
throw new RuntimeException("模型已存在");
}
Model model = repositoryService.newModel();
model.setName(createDTO.getName());
model.setMetaInfo(JSON.toJSONString(createDTO.getMetaInfo()));
@ -43,19 +49,7 @@ public class BpmModelServiceImpl implements BpmModelService {
model.setKey(createDTO.getKey());
model.setTenantId(createDTO.getTenantId());
repositoryService.createDeploymentQuery().singleResult();
repositoryService.createModelQuery().modelKey("asdfasdf")
.singleResult();
if (!ObjectUtils.isEmpty(existModel)) {
throw new RuntimeException("模型已存在");
}
repositoryService.saveModel(model);
return model.getId();
}
@ -85,27 +79,26 @@ public class BpmModelServiceImpl implements BpmModelService {
@Override
public Boolean deployBpmModelById(String modelId) {
Model model = repositoryService.getModel(modelId);
Model model = this.repositoryService.getModel(modelId);
if (org.springframework.util.ObjectUtils.isEmpty(model)) {
throw new ServiceException(ErrorCode.MODEL_NOT_EXISTS);
}
byte[] bpmnBytes = this.repositoryService.getModelEditorSource(model.getId());
if (bpmnBytes == null) {
throw new RuntimeException("模型文件不存在");
} else {
BpmFormDO form = this.checkFormConfig(model.getMetaInfo());
this.taskAssignRuleService.checkTaskAssignRuleAllConfig(id);
BpmProcessDefinitionCreateReqDTO definitionCreateReqDTO = BpmModelConvert.INSTANCE.convert2(model, form).setBpmnBytes(bpmnBytes);
if (this.processDefinitionService.isProcessDefinitionEquals(definitionCreateReqDTO)) {
ProcessDefinition oldProcessInstance = this.processDefinitionService.getProcessDefinitionByDeploymentId(model.getDeploymentId());
if (oldProcessInstance != null && this.taskAssignRuleService.isTaskAssignRulesEquals(model.getId(), oldProcessInstance.getId())) {
throw ServiceExceptionUtil.exception(ErrorCodeConstants.MODEL_DEPLOY_FAIL_TASK_INFO_EQUALS);
}
}
throw new ServiceException(ErrorCode.MODEL_NOT_EXISTS);
}
String definitionId = this.processDefinitionService.createProcessDefinition(definitionCreateReqDTO);
this.updateProcessDefinitionSuspended(model.getDeploymentId());
ProcessDefinition definition = this.processDefinitionService.getProcessDefinition(definitionId);
model.setDeploymentId(definition.getDeploymentId());
this.repositoryService.saveModel(model);
this.taskAssignRuleService.copyTaskAssignRules(id, definition.getId());
processDefinitionServiceImpl.createProcessDeinition(model, bpmnBytes);
String definitionId = this.processDefinitionService.createProcessDefinition(definitionCreateReqDTO);
this.updateProcessDefinitionSuspended(model.getDeploymentId());
ProcessDefinition definition = this.processDefinitionService.getProcessDefinition(definitionId);
model.setDeploymentId(definition.getDeploymentId());
this.repositoryService.saveModel(model);
}
}
}

59
workflow-engine-server/src/main/java/cn/axzo/server/service/impl/BpmProcessDefinitionServiceImpl.java Normal file
View File

@ -0,0 +1,59 @@
package cn.axzo.server.service.impl;
import cn.axzo.framework.domain.ServiceException;
import cn.axzo.server.common.enums.ErrorCode;
import cn.axzo.server.service.BpmProcessDefinitionService;
import org.flowable.common.engine.impl.db.SuspensionState;
import org.flowable.engine.RepositoryService;
import org.flowable.engine.repository.Deployment;
import org.flowable.engine.repository.Model;
import org.flowable.engine.repository.ProcessDefinition;
import javax.annotation.Resource;
import java.util.Objects;
import static cn.axzo.server.common.enums.ErrorCode.PROCESS_DEFINITION_KEY_NOT_MATCH;
import static cn.axzo.server.common.enums.ErrorCode.PROCESS_DEFINITION_NAME_NOT_MATCH;
public class BpmProcessDefinitionServiceImpl implements BpmProcessDefinitionService {
private static final String BPMN_FILE_SUFFIX = ".bpmn";
@Resource
private RepositoryService repositoryService;
public String createProcessDeinition(Model model, byte[] bpmnBytes) {
if (model == null || bpmnBytes == null) {
return null;
}
Deployment deploy = repositoryService.createDeployment()
.key(model.getKey()).name(model.getName())
.category(model.getCategory())
.tenantId(String.valueOf(model.getTenantId()))
.addBytes(model.getKey() + BPMN_FILE_SUFFIX, bpmnBytes)
// 关闭 BPMN 文件内容校验
.disableBpmnValidation()
.deploy();
// 设置 ProcessDefinition 的 category 分类
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery()
.processDefinitionTenantId(deploy.getTenantId())
.deploymentId(deploy.getId()).singleResult();
repositoryService.setProcessDefinitionCategory(definition.getId(), model.getCategory());
// 注意 1，ProcessDefinition 的 key 和 name 是通过 BPMN 中的 <bpmn2:process /> 的 id 和 name 决定
// 注意 2，目前该项目的设计上，需要保证 Model、Deployment、ProcessDefinition 使用相同的 key，保证关联性。
// 否则，会导致 ProcessDefinition 的分页无法查询到。
if (!Objects.equals(model.getKey(), definition.getKey())) {
throw new ServiceException(PROCESS_DEFINITION_KEY_NOT_MATCH);
}
if (!Objects.equals(model.getName(), definition.getName())) {
throw new ServiceException(PROCESS_DEFINITION_NAME_NOT_MATCH);
}
return definition.getId();
}
@Override
public Boolean updateProcessDefinitionSuspendedState(String processDefinitionId, SuspensionState state) {
this.processDefinitionService.updateProcessDefinitionState(processDefinitionId, state.getStateCode());
}
}

185
workflow-engine-server/src/main/java/cn/axzo/server/service/impl/BpmProcessServiceImpl.java
View File

@ -1,4 +1,189 @@
package cn.axzo.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.flowable.engine.*;
import org.flowable.engine.history.HistoricProcessInstance;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.engine.runtime.ProcessInstanceQuery;
import org.flowable.task.api.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.*;
public class BpmProcessServiceImpl {
@Autowired
private TaskService engineTaskService;
@Autowired
private RepositoryService repositoryService;
@Autowired
private ManagementService managementService;
@Autowired
private RuntimeService runtimeService;
@Autowired
private BpmProcessInstanceExtMapper processInstanceExtMapper;
@Autowired
@Lazy // 解决循环依赖
private BpmTaskService taskService;
@Autowired
private BpmProcessDefinitionService processDefinitionService;
@Autowired
private HistoryService historyService;
@Resource
private BpmProcessInstanceResultEventPublisher processInstanceResultEventPublisher;
@Autowired
private CustomIdGeneratorService customIdGeneratorService;
@Override
public ProcessInstance getProcessInstance(String id, String tenantId) {
ProcessInstanceQuery instanceQuery = runtimeService.createProcessInstanceQuery()
.processInstanceId(id);
if (StrUtil.isNotBlank(tenantId)) {
instanceQuery.processInstanceTenantId(tenantId);
}
return instanceQuery.singleResult();
}
@Override
public ProcessInstance getProcessInstance(String id, String tenantId, boolean hasVariable) {
ProcessInstanceQuery instanceQuery = runtimeService.createProcessInstanceQuery();
instanceQuery.processInstanceId(id);
if (hasVariable) {
instanceQuery.includeProcessVariables();
}
if (StrUtil.isNotBlank(tenantId)) {
instanceQuery.processInstanceTenantId(tenantId);
}
return instanceQuery.singleResult();
}
@Override
public List<ProcessInstance> getProcessInstances(Set<String> ids) {
return runtimeService.createProcessInstanceQuery().processInstanceIds(ids).list();
}
@Override
public PageResult<BpmProcessInstancePageItemRespVO> getMyProcessInstancePage(
BpmProcessInstanceMyPageReqVO pageReqVO) {
// 通过 BpmProcessInstanceExtDO 表，先查询到对应的分页
PageResult<BpmProcessInstanceExtDO> pageResult = processInstanceExtMapper.selectPage(null,
pageReqVO);
if (CollUtil.isEmpty(pageResult.getList())) {
return new PageResult<>(pageResult.getTotal());
}
// 获得流程 Task Map
List<String> processInstanceIds = convertList(pageResult.getList(),
BpmProcessInstanceExtDO::getProcessInstanceId);
Map<String, List<Task>> taskMap = taskService.getTaskMapByProcessInstanceIds(
processInstanceIds);
// 转换返回
return BpmProcessInstanceConvert.INSTANCE.convertPage(pageResult, taskMap);
}
@Override
@Transactional(rollbackFor = Exception.class)
public String createProcessInstance(@Valid BpmProcessInstanceCreateReqVO reqVO) {
// 获得流程定义
ProcessDefinition definition = processDefinitionService.getProcessDefinition2(
reqVO.getProcessDefinitionId());
// 发起流程
reqVO.getVariables().put(INTERNAL_EXECUTIVE_UNIT_ID, reqVO.getExecutiveUnitId());
return createProcessInstanceForAxzo(reqVO.getWorkspaceId(), reqVO.getCompanyId(),
reqVO.getIdentityId(), reqVO.getStartUserName(), reqVO.getCustomProcessInstanceName(),
definition, reqVO.getVariables(), null);
}
@Override
@Transactional(rollbackFor = Exception.class)
public String createProcessInstance(@Valid BpmProcessInstanceCreateReqDTO reqDTO) {
ProcessDefinition definition = processDefinitionService.getActiveProcessDefinition(
reqDTO.getProcessDefinitionKey());
return createProcessInstanceForAxzo(reqDTO.getWorkspaceId(), reqDTO.getCompanyId(),
reqDTO.getIdentityId(), reqDTO.getUserName(), reqDTO.getCustomProcessInstanceName(),
definition, reqDTO.getVariables(), reqDTO.getBusinessKey());
}
@Override
public String createProcessInstance(Long userId,
@Valid BpmProcessInstanceCreateReqDTO createReqDTO) {
// 获得流程定义
ProcessDefinition definition = processDefinitionService.getActiveProcessDefinition(
createReqDTO.getProcessDefinitionKey());
// 发起流程
return createProcessInstance0(userId, definition, createReqDTO.getVariables(),
createReqDTO.getBusinessKey());
}
@Override
public BpmProcessInstanceRespVO getProcessInstanceVO(String id, String tenantId) {
// 获得流程实例
HistoricProcessInstance processInstance = getHistoricProcessInstance(id, tenantId);
if (processInstance == null) {
return null;
}
BpmProcessInstanceExtDO processInstanceExt = processInstanceExtMapper.selectByProcessInstanceId(
id, tenantId);
Assert.notNull(processInstanceExt, "流程实例拓展({}) 不存在", id);
// 获得流程定义
ProcessDefinition processDefinition = processDefinitionService
.getProcessDefinition(processInstance.getProcessDefinitionId());
Assert.notNull(processDefinition, "流程定义({}) 不存在", processInstance.getProcessDefinitionId());
BpmProcessDefinitionExtDO processDefinitionExt = processDefinitionService.getProcessDefinitionExt(
processInstance.getProcessDefinitionId());
Assert.notNull(processDefinitionExt, "流程定义拓展({}) 不存在", id);
String bpmnXml = processDefinitionService.getProcessDefinitionBpmnXML(
processInstance.getProcessDefinitionId());
// 拼接数据
BpmProcessInstanceRespVO bpmProcessInstanceRespVO = BpmProcessInstanceConvert.INSTANCE.convert2(
processInstance, processInstanceExt, processDefinition, processDefinitionExt, bpmnXml, null,
null);
// 设置发起人姓名
String startUserName = processInstanceExtMapper.selectOne(
new QueryWrapper<BpmProcessInstanceExtDO>().lambda()
.eq(BpmProcessInstanceExtDO::getProcessInstanceId, processInstance.getId()))
.getStartUserName();
BpmProcessInstanceRespVO.User startUser = bpmProcessInstanceRespVO.getStartUser();
startUser.setStartUserName(startUserName);
bpmProcessInstanceRespVO.setStartUser(startUser);
// 拼接结果
return bpmProcessInstanceRespVO;
}
@Override
public void cancelProcessInstance(@Valid BpmProcessInstanceCancelReqVO cancelReqVO) {
// 校验流程实例存在
ProcessInstance instance = getProcessInstance(cancelReqVO.getId(),
String.valueOf(cancelReqVO.getWorkspaceId()));
if (instance == null) {
throw exception(PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS);
}
// 只能取消自己的
Long workspaceId = cancelReqVO.getWorkspaceId();
Long identityId = cancelReqVO.getIdentityId();
if (!Objects.equals(instance.getStartUserId(),
workspaceId + "_" + identityId)) {
throw exception(PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF);
}
Map<String, Object> variables = new HashMap<>();
variables.put(INTERNAL_END_USER_WORKSPACE_ID, cancelReqVO.getWorkspaceId());
variables.put(INTERNAL_END_USER_NAME, cancelReqVO.getName());
variables.put(INTERNAL_END_USER_IDENTITY_ID, cancelReqVO.getIdentityId());
runtimeService.setVariables(instance.getProcessInstanceId(), variables);
// 通过删除流程实例，实现流程实例的取消,
// 删除流程实例，正则执行任务ACT_RU_TASK. 任务会被删除。通过历史表查询
deleteProcessInstance(cancelReqVO.getId(),
BpmProcessInstanceDeleteReasonEnum.CANCEL_TASK.format(cancelReqVO.getReason()));
}
}

29
workflow-engine-server/src/main/java/cn/axzo/server/service/user/UserService.java
View File

@ -1,29 +0,0 @@
package cn.axzo.server.service.user;
import cn.axzo.framework.domain.page.PageQO;
import cn.axzo.framework.domain.page.PageResp;
import cn.axzo.server.service.dto.request.user.NewUserDTO;
import cn.axzo.server.service.dto.request.user.UpdateUserDTO;
import cn.axzo.server.service.dto.request.user.UserQO;
import cn.axzo.server.service.dto.request.user.UserQO1;
import cn.axzo.server.service.dto.response.user.UserVO;
import cn.azxo.framework.common.model.CommonPageResponse;
/**
* @Author: liyong.tian
* @Date: 2022/9/2
* @Description:
*/
public interface UserService {
UserVO create(NewUserDTO dto);
UserVO update(Long id, UpdateUserDTO dto);
UserVO getOne(Long id);
void delete(Long id);
CommonPageResponse<UserVO> queryByPage(UserQO userQO);
PageResp<UserVO> find(UserQO1 userQo, PageQO page);
}

82
workflow-engine-server/src/main/java/cn/axzo/server/service/user/impl/UserServiceImpl.java
View File

@ -1,82 +0,0 @@
package cn.axzo.server.service.user.impl;
import cn.axzo.framework.domain.page.PageQO;
import cn.axzo.framework.domain.page.PageResp;
import cn.axzo.framework.domain.web.ApiException;
import cn.axzo.server.common.enums.ErrorCode;
import cn.axzo.server.service.dto.request.user.NewUserDTO;
import cn.axzo.server.service.dto.request.user.UpdateUserDTO;
import cn.axzo.server.service.dto.request.user.UserQO;
import cn.axzo.server.service.dto.request.user.UserQO1;
import cn.axzo.server.service.dto.response.user.UserVO;
import cn.axzo.server.repository.entity.user.User;
import cn.axzo.server.repository.UserDao;
import cn.axzo.server.service.user.UserService;
import cn.axzo.server.service.converter.UserConverter;
import cn.azxo.framework.common.model.CommonPageResponse;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @Author: liyong.tian
* @Date: 2022/9/2
* @Description:
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
private final UserConverter userConverter;
private final UserDao userDao;
@Override
public UserVO create(NewUserDTO dto) {
User user = userConverter.toEntity(dto);
userDao.save(user);
return userConverter.toVo(user);
}
@Override
public UserVO update(Long id, UpdateUserDTO dto) {
User user = userDao.findById(id);
if (user == null) {
throw new ApiException(ErrorCode.USER_NOT_EXISTS, id);
}
userConverter.updateEntity(dto, user);
return userConverter.toVo(user);
}
@Override
public UserVO getOne(Long id) {
User user = userDao.findById(id);
return userConverter.toVo(user);
}
@Override
public void delete(Long id) {
userDao.delete(id);
}
@Override
public CommonPageResponse<UserVO> queryByPage(UserQO userQo) {
IPage<User> page = userDao.queryByPage(userQo);
List<User> userList = page.getRecords();
if (CollectionUtils.isEmpty(userList)) {
return CommonPageResponse.zero(userQo.getPage(), userQo.getPageSize());
}
return new CommonPageResponse<>(page.getCurrent(), page.getSize(), page.getTotal(), userConverter.toVo(page.getRecords()));
}
@Override
public PageResp<UserVO> find(UserQO1 userQo, PageQO page) {
IPage<User> userPage = userDao.find(userQo, page);
return PageResp.list(userPage, userConverter.toVo(userPage.getRecords()));
}
}

3
workflow-engine-server/src/main/java/cn/axzo/server/service/util/BpmTransformUtil.java → workflow-engine-server/src/main/java/cn/axzo/server/service/utils/BpmTransformUtil.java
View File

@ -1,4 +1,4 @@
package cn.axzo.server.service.util;
package cn.axzo.server.service.utils;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
@ -9,7 +9,6 @@ import org.flowable.bpmn.converter.BpmnXMLConverter;
import org.flowable.bpmn.model.*;
import org.flowable.bpmn.model.Process;
import org.flowable.engine.delegate.TaskListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import java.lang.reflect.InvocationTargetException;