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

Merge branch 'feature/REQ-1609'

Browse Source
This commit is contained in:
wangli 2023-12-15 11:07:04 +08:00
commit fa522c944e
42 changed files with 825 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
workflow-engine-api/src/main/java/cn/axzo/workflow/client/feign/bpmn/ProcessModelApi.java
View File

@ -126,4 +126,8 @@ public interface ProcessModelApi {
@Operation(summary = "查询流程模型使用的分类列表")
@GetMapping("/api/process/model/category/ids")
CommonResponse<List<String>> getModelCategoryList();
@Operation(summary = "查询模型的租户集合")
@GetMapping("/api/process/model/tenant/ids")
CommonResponse<List<String>> getTenantIds();
}

5
workflow-engine-common/src/main/java/cn/axzo/workflow/common/constant/BpmnConstants.java
View File

@ -29,9 +29,6 @@ public interface BpmnConstants {
@Deprecated
String OLD_INTERNAL_TASK_RELATION_ASSIGNEE_INFO_SNAPSHOT = "[_ASSIGNEE_INFO_SNAPSHOT_]";
String INTERNAL_ACTIVITY_RELATION_ASSIGNEE_LIST_INFO_SNAPSHOT = "[_ACTIVITY_INFO_SNAPSHOT_]";
String COUNTERSIGN_REMAIN_ASSIGNER_LIST = "[_COUNTERSIGN_REMAIN_ASSIGNER_LIST_]";
String COUNTERSIGN_ORIGIN_ASSIGNER = "[_COUNTERSIGN_ORIGIN_ASSIGNER_]";
String PROCESS_PREFIX = "Flowable";
String TASK_ASSIGNEE_SKIP_FLAT = "taskSkip";
String FLOW_NODE_JSON = "jsonValue";
@ -57,7 +54,6 @@ public interface BpmnConstants {
String CONFIG_BUTTON_TYPE_CURRENT = "current";
String CONFIG_BUTTON_TYPE_HISTORY = "history";
String CONFIG_BUTTON_TYPE_CARBON_COPY = "carbonCopy";
String ELEMENT_ATTRIBUTE_NAME = "name";
String ELEMENT_ATTRIBUTE_VALUE = "value";
String ELEMENT_ATTRIBUTE_DESC = "desc";
@ -72,7 +68,6 @@ public interface BpmnConstants {
String END_EVENT_ID = "endEventNode";
String BPM_MODEL_CATEGORY = "bpm_model_category";
String BPM_ALLOW_SKIP_USER_TASK = "_INTERNAL_SKIP_USER_TASK_";
String BPM_ALLOW_AUTO_REJECTION = "_INTERNAL_AUTO_REJECTION";
/**
* 用于国内审批节点填写审批建议
* <p>

2
workflow-engine-common/src/main/java/cn/axzo/workflow/common/model/request/bpmn/task/BpmnTaskCountersignDTO.java
View File

@ -48,7 +48,7 @@ public class BpmnTaskCountersignDTO implements Serializable {
@ApiModelProperty(value = "加签任务转发给谁")
@NotNull(message = "加签任务接收人不能为空")
@NotEmpty(message = "加签任务接收人不能为空")
private List<BpmnTaskDelegateAssigner> targetAssignerList;
@ApiModelProperty(value = "加签任务原发起人")

44
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/BpmnInstanceRespCode.java Normal file
View File

@ -0,0 +1,44 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 流程实例响应码
*
* @author wangli
* @since 2023/12/14 16:34
*/
@Getter
@AllArgsConstructor
public enum BpmnInstanceRespCode implements IModuleRespCode {
PROCESS_OPERATION_PARAM_VALID_ERROR("001", "参数缺失, 请确保传入了 ID 或 businessKey 对流程实例进行操作"),
PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS("002", "流程取消失败，流程不处于运行中"),
PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF("003", "流程取消失败，该流程不是你发起的"),
PROCESS_INSTANCE_NOT_EXISTS("004", "流程实例不存在或已结束"),
PROCESS_INSTANCE_ID_NOT_EXISTS("005", "流程实例【{}】不存在"),
PROCESS_INSTANCE_CANCELLED("006", "流程实例已取消"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "05";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

45
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/BpmnModelRespCode.java Normal file
View File

@ -0,0 +1,45 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 流程模型响应码
*
* @author wangli
* @since 2023/12/14 16:25
*/
@Getter
@AllArgsConstructor
public enum BpmnModelRespCode implements IModuleRespCode {
MODEL_KEY_EXISTS("001", "已经存在流程标识为【{}】的流程"),
MODEL_ID_NOT_EXISTS("002", "流程模型ID【{}】不存在"),
MODEL_KEY_NOT_EXISTS("003", "流程模型KEY【{}】不存在"),
MODEL_NOT_EXISTS("004", "流程模型不存在"),
BPMN_BYTES_NOT_EXISTS("005", "模型定义内容字节码不存在"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "03";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

46
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/BpmnProcessDefinitionRespCode.java Normal file
View File

@ -0,0 +1,46 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 流程定义响应码
*
* @author wangli
* @since 2023/12/14 16:34
*/
@Getter
@AllArgsConstructor
public enum BpmnProcessDefinitionRespCode implements IModuleRespCode {
PROCESS_DEFINITION_BPMN_NOT_EXISTS("001", "模型ID【{}】的定义内容不存在"),
PROCESS_DEFINITION_ID_NOT_EXISTS("002", "流程定义ID【{}】不存在"),
PROCESS_DEFINITION_DEPLOY_ID_NOT_EXISTS("003", "流程定义部署ID【{}】不存在"),
PROCESS_DEFINITION_KEY_NOT_EXISTS("004", "流程定义KEY【{}】不存在"),
PROCESS_DEFINITION_RESULT_TOO_MANY("005", "租户【{}】中存在多条分类为【{}】的流程定义,不允许直接变更状态"),
PROCESS_DEFINITION_IS_SUSPENDED("006", "流程定义KEY【{}】处于挂起状态"),
PROCESS_DEFINITION_KEY_NOT_MATCH("007", "流程定义的标识不一致, 请修改 BPMN 流程图"),
PROCESS_DEFINITION_NAME_NOT_MATCH("008", "流程定义的名字期望是({})，当前是({})，请修改 BPMN 流程图"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "04";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

47
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/BpmnTaskRespCode.java Normal file
View File

@ -0,0 +1,47 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 流程模型响应码
*
* @author wangli
* @since 2023/12/14 16:25
*/
@Getter
@AllArgsConstructor
public enum BpmnTaskRespCode implements IModuleRespCode {
TASK_COMPLETE_FAIL_NOT_EXISTS("001", "未找到指定审批任务"),
TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF("002", "该任务的审批人不是你"),
TASK_APOSTILLE_NOT_SUPPORT("003", "当前加签模式不支持"),
TASK_REMIND_ERROR_NOT_EXISTS("004", "当前审批节点没有待审批任务, 不能催办"),
ACTIVITY_TRIGGER_NOT_EXISTS("005", "触发 ID:【{}】不存在"),
CALC_TASK_ASSIGNEE_ERROR("006", "执行计算审批候选人出现异常: {}"),
ASSIGNEE_HAS_BEEN_EXISTS("007", "你选择的人员已是审批人，请检查后提交"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "06";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

43
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/CategoryRespCode.java Normal file
View File

@ -0,0 +1,43 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 分类响应码
*
* @author wangli
* @since 2023/12/14 16:25
*/
@Getter
@AllArgsConstructor
public enum CategoryRespCode implements IModuleRespCode {
CATEGORY_VALUE_EXISTS("001", "分类值【{}】已经存在"),
CATEGORY_ID_NOT_EXISTS("002", "指定分类【{}】不存在"),
CATEGORY_DATA_ERROR("003", "分类数据异常"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "01";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

48
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/ConvertorRespCode.java Normal file
View File

@ -0,0 +1,48 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* BPMN 协议转换异常
*
* @author wangli
* @since 2023/12/14 16:25
*/
@Getter
@AllArgsConstructor
public enum ConvertorRespCode implements IModuleRespCode {
CONVERTOR_UNKNOW_NODE_TYPE("001", "节点类型【{}】暂不支持"),
CONVERTOR_META_DATA_FORMAT_ERROR("002", "JSON 数据格式有误-{}: {}"),
CONVERTOR_COMMON_ERROR("003", "JSON 转 BPMN 失败, 原因:【{}】"),
CONVERTOR_NODE_TYPE_NOT_SUPPORT("004", "【{}】节点类型, ID:【{}】暂不支持"),
CONVERTOR_OPERATION_STRING_TYPE_ERROR("005", "条件节点运算符【{}】暂不支持"),
CONVERTOR_OPERATION_NUMBER_TYPE_ERROR("006", "条件节点运算符【{}】暂不支持"),
CONVERTOR_OPERATION_RADIO_TYPE_ERROR("007", "条件节点运算符【{}】暂不支持"),
CONVERTOR_OPERATION_CHECKBOX_TYPE_ERROR("008", "条件节点运算符【{}】暂不支持"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "02";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

43
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/FlowableEngineRespCode.java Normal file
View File

@ -0,0 +1,43 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 流程模型响应码
*
* @author wangli
* @since 2023/12/14 16:25
*/
@Getter
@AllArgsConstructor
public enum FlowableEngineRespCode implements IModuleRespCode {
ENGINE_EXECUTION_LOST_ID_ERROR("001", "Execution 丢失"),
ENGINE_USER_TASK_CALC_ERROR("002", "计算用户任务节点的审批发生异常: 【{}】"),
ENGINE_USER_TASK_TYPE_NOT_SUPPORT("003", "审批指定方式暂不支持"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "10";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

42
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/FormDefinitionRespCode.java Normal file
View File

@ -0,0 +1,42 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 表单定义响应码
*
* @author wangli
* @since 2023/12/14 16:25
*/
@Getter
@AllArgsConstructor
public enum FormDefinitionRespCode implements IModuleRespCode {
FORM_DEFINITION_NOT_EXISTS("001", "表单定义内容转换出错, 建议重新修改表单定义后重试"),
FORM_DEFINITION_PARSER_ERROR("002", "表单定义内容解析出错"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "08";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

42
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/FormModelRespCode.java Normal file
View File

@ -0,0 +1,42 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 表单模型响应码
*
* @author wangli
* @since 2023/12/14 16:25
*/
@Getter
@AllArgsConstructor
public enum FormModelRespCode implements IModuleRespCode {
FORM_MODEL_NOT_EXISTS("001", "表单模型不存在"),
FORM_MODEL_ID_NOT_EXISTS("002", "表单模型ID【{}】不存在"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "07";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

42
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/code/OtherRespCode.java Normal file
View File

@ -0,0 +1,42 @@
package cn.axzo.workflow.core.common.code;
import cn.axzo.framework.domain.web.code.IModuleRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 流程模型响应码
*
* @author wangli
* @since 2023/12/14 16:25
*/
@Getter
@AllArgsConstructor
public enum OtherRespCode implements IModuleRespCode {
MES_PUSH_OBJECT_BUILD_ERROR("001", "构建消息推送对象异常"),
REPEAT_SUBMIT_TIME_ERROR_TIPS("002", "重复提交间隔时间不能小于{}秒"),
REPEAT_SUBMIT_ERROR_TIPS("002", "{}"),
;
private String code;
private String message;
@Override
public String getModuleCode() {
return "99";
}
@Override
public String getProjectCode() {
return "988";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}

423
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/enums/BpmnErrorCode.java
View File

@ -1,211 +1,212 @@
package cn.axzo.workflow.core.common.enums;
import cn.axzo.framework.domain.web.code.IProjectRespCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @Author: liyong.tian
* @Date: 2022/9/5
* @Description: 响应码规范：一共8位，取值范围0~9，3位项目编号(首位不能为0)+2位模块编号+3位自定义编号
*/
@Getter
@AllArgsConstructor
public enum BpmnErrorCode implements IProjectRespCode {
// ========== category 01-001 ==========
CATEGORY_VALUE_EXISTS("01001", "分类值【{}】已经存在"),
CATEGORY_ID_NOT_EXISTS("01002", "指定分类【{}】不存在"),
CATEGORY_DATA_ERROR("01003", "分类数据异常"),
// ========== convertor 02-001 ==========
CONVERTOR_UNKNOW_NODE_TYPE("02001", "节点类型【{}】暂不支持"),
CONVERTOR_META_DATA_FORMAT_ERROR("02002", "JSON 数据格式有误-{}: {}"),
CONVERTOR_COMMON_ERROR("02003", "JSON 转 BPMN 失败, 原因:【{}】"),
CONVERTOR_NODE_TYPE_NOT_SUPPORT("02004", "【{}】节点类型, ID:【{}】暂不支持"),
CONVERTOR_OPERATION_STRING_TYPE_ERROR("02005", "条件节点运算符【{}】暂不支持"),
CONVERTOR_OPERATION_NUMBER_TYPE_ERROR("02006", "条件节点运算符【{}】暂不支持"),
CONVERTOR_OPERATION_RADIO_TYPE_ERROR("02007", "条件节点运算符【{}】暂不支持"),
CONVERTOR_OPERATION_CHECKBOX_TYPE_ERROR("02008", "条件节点运算符【{}】暂不支持"),
// ========== bpmn model 03-001 ==========
MODEL_KEY_EXISTS("03001", "已经存在流程标识为【{}】的流程"),
MODEL_ID_NOT_EXISTS("03002", "流程模型ID【{}】不存在"),
MODEL_KEY_NOT_EXISTS("03003", "流程模型KEY【{}】不存在"),
MODEL_NOT_EXISTS("03004", "流程模型不存在"),
BPMN_BYTES_NOT_EXISTS("03005", "模型定义内容字节码不存在"),
// ========== bpmn processDefinition 04-001 ==========
PROCESS_DEFINITION_BPMN_NOT_EXISTS("04001", "模型ID【{}】的定义内容不存在"),
PROCESS_DEFINITION_ID_NOT_EXISTS("04002", "流程定义ID【{}】不存在"),
PROCESS_DEFINITION_DEPLOY_ID_NOT_EXISTS("04003", "流程定义部署ID【{}】不存在"),
PROCESS_DEFINITION_KEY_NOT_EXISTS("04004", "流程定义KEY【{}】不存在"),
PROCESS_DEFINITION_RESULT_TOO_MANY("04005", "租户【{}】中存在多条分类为【{}】的流程定义,不允许直接变更状态"),
PROCESS_DEFINITION_IS_SUSPENDED("04006", "流程定义KEY【{}】处于挂起状态"),
PROCESS_DEFINITION_KEY_NOT_MATCH("04007", "流程定义的标识不一致, 请修改 BPMN 流程图"),
PROCESS_DEFINITION_NAME_NOT_MATCH("04008", "流程定义的名字期望是({})，当前是({})，请修改 BPMN 流程图"),
// "数据出现异常,同一个工作台下,同一个所属分类,只能有一个流程定义"),
// ========== bpmn processInstance 05-001 ==========
PROCESS_OPERATION_PARAM_VALID_ERROR("05001", "参数缺失, 请确保传入了 ID 或 businessKey 对流程实例进行操作"),
PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS("05002", "流程取消失败，流程不处于运行中"),
PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF("05003", "流程取消失败，该流程不是你发起的"),
PROCESS_INSTANCE_NOT_EXISTS("05004", "流程实例不存在或已结束"),
PROCESS_INSTANCE_ID_NOT_EXISTS("05005", "流程实例【{}】不存在"),
PROCESS_INSTANCE_CANCELLED("05006", "流程实例已取消"),
// ========== bpmn task 06-001 ==========
TASK_COMPLETE_FAIL_NOT_EXISTS("06001", "未找到指定审批任务"),
TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF("06002", "该任务的审批人不是你"),
TASK_APOSTILLE_NOT_SUPPORT("06003", "当前加签模式不支持"),
TASK_REMIND_ERROR_NOT_EXISTS("06004", "当前审批节点没有待审批任务, 不能催办"),
ACTIVITY_TRIGGER_NOT_EXISTS("06005", "触发 ID:【{}】不存在"),
CALC_TASK_ASSIGNEE_ERROR("06006", "执行计算审批候选人出现异常: {}"),
// ========== form Model 07-001 ==========
FORM_MODEL_NOT_EXISTS("07001", "表单模型不存在"),
FORM_MODEL_ID_NOT_EXISTS("07002", "表单模型ID【{}】不存在"),
// ========== form Definition 08-001 ==========
FORM_DEFINITION_NOT_EXISTS("08001", "表单定义内容转换出错, 建议重新修改表单定义后重试"),
FORM_DEFINITION_PARSER_ERROR("08002", "表单定义内容解析出错"),
// ========== form Instance 09-001 ==========
// ========== flowable Engine 10-001 ==========
ENGINE_EXECUTION_LOST_ID_ERROR("10001", "Execution 丢失"),
ENGINE_USER_TASK_CALC_ERROR("10002", "计算用户任务节点的审批发生异常: 【{}】"),
ENGINE_USER_TASK_TYPE_NOT_SUPPORT("10003", "审批指定方式暂不支持"),
// ========== flowable Engine 99-001 ==========
MES_PUSH_OBJECT_BUILD_ERROR("99001", "构建消息推送对象异常"),
REPEAT_SUBMIT_TIME_ERROR_TIPS("99002", "重复提交间隔时间不能小于{}秒"),
REPEAT_SUBMIT_ERROR_TIPS("99002", "{}"),
// // ========== 流程模型 01-001 ==========
//
//
// MODEL_KEY_VALID("9002002",
// "流程标识格式不正确，需要以字母或下划线开头，后接任意字母、数字、中划线、下划线、句点！"),
// MODEL_DEPLOY_FAIL_FORM_NOT_CONFIG("9002003",
// "部署流程失败，原因：流程表单未配置，请点击【修改流程】按钮进行配置"),
// MODEL_DEPLOY_FAIL_TASK_ASSIGN_RULE_NOT_CONFIG("9002004", "部署流程失败，" +
// "原因：用户任务({})未配置分配规则，请点击【配置审核人】按钮进行配置"),
// MODEL_DEPLOY_FAIL_TASK_INFO_EQUALS("9003005", "流程定义部署失败，原因：信息未发生变化"),
//
// // ========== 流程定义 1-009-003-000 ==========
//
//
// PROCESS_DEFINITION_NOT_EXISTS("9003002", "流程定义不存在"),
//
// PROCESS_DEFINITION_BPMN_MODEL_NOT_EXISTS("9003004", "流程定义的模型不存在"),
//
// // ========== 流程实例 1-009-004-000 ==========
//
//
// // ========== 流程任务 1-009-005-000 ==========
//
//
// // ========== 流程任务分配规则 1-009-006-000 ==========
// TASK_ASSIGN_RULE_EXISTS("9006000", "流程({}) 的任务({}) 已经存在分配规则"),
// TASK_ASSIGN_RULE_NOT_EXISTS("9006001", "流程任务分配规则不存在"),
// TASK_UPDATE_FAIL_NOT_MODEL("9006002", "只有流程模型的任务分配规则，才允许被修改"),
// TASK_CREATE_FAIL_NO_CANDIDATE_USER("9006003", "操作失败，原因：找不到任务的审批人！"),
// TASK_ASSIGN_SCRIPT_NOT_EXISTS("9006004", "操作失败，原因：任务分配脚本({}) 不存在"),
// TASK_ASSIGN_GET_USER_ERROR("9006005", "通过【{}】获取任务候选人失败，失败原因：{}"),
// USER_COMPANY_ID_NOT_EXISTS("9006006", "缺失所在单位信息"),
// TASK_ASSIGN_USER_NOT_ENOUGH("9006007", "操作失败，原因：候选人数量{}小于循环基数{}"),
//
// // ========== 动态表单模块 1-009-010-000 ==========
// FORM_NOT_EXISTS("9010000", "动态表单不存在"),
// FORM_FIELD_REPEAT("9010001", "表单项({}) 和 ({}) 使用了相同的字段名({})"),
// FORM_CONFIG_ERROR("9010002", "内置表单解析失败"),
//
// FORM_CONFIG_ID_NOT_EXISTS("9010003", "修改/删除业务表单时，ID不能为空"),
//
// FORM_CONFIG_IN_USED("9010004", "表单正在使用中，不能删除"),
//
// FORM_CONFIG_CATEGORY_EXIST("9010005", "当前所属业务已有绑定关系，不能重复新增"),
//
// FORM_FIELD_DECODE_ERROR("9010006", "表单Field格式不正确"),
//
// FORM_CONFIG_CATEGORY_NOT_EXIST("9010006", "表单信息不存在，请前往 配置管理->所属业务关联关系 添加表单绑定信息"),
//
// // ========== 用户组模块 1-009-011-000 ==========
// USER_GROUP_NOT_EXISTS("9011000", "用户组不存在"),
// USER_GROUP_IS_DISABLE("9011001", "名字为【{}】的用户组已被禁用"),
//
// // ========== 公共模板 1-009-012-000 ==========
// COMMON_ERROR("9012000", "{}"),
// COMMON_MODEL_EXISTS("9012001", "名字为【{}】的公共模型已经存在"),
// COMMON_MODEL_PROJECT_ID_NOT_EXISTS("9012002",
// "应用类型选择租户时, 关联的项目[tenants]不能为空"),
// COMMON_MODEL_FORM_CONFIG_NOT_EXISTS("9012003",
// "表单类型选择业务表单时, 业务表单不能为空"),
// COMMON_MODEL_ID_IS_NULL("9012004", "模型ID丢失, 请检查入参"),
// COMMON_MODEL_TASK_ASSIGN_RULE_EXISTS("9012005",
// "流程({}) 的任务({}) 已经存在分配规则"),
// COMMON_MODEL_TASK_ASSIGN_RULE_NOT_EXISTS("9012006", "流程任务分配规则不存在"),
// COMMON_MODEL_TASK_ASSIGN_RULE_TYPE_ILLEGAL("9012007",
// "({}) 的应用范围，不能配置 ({}) 审配人类型"),
// COMMON_MODEL_FORM_FIELD_PERMISSION("9012008",
// "HTML 标签 ID 为 ({})和 Label 为 ({})的表单项配置权限信息只能只读/隐藏二选一，且不能为空"),
// FORM_CONFIG_REGISTER_INFO_NOT_EXISTS("9012009", "未获取到该业务表单的配置信息"),
// COMMON_MODEL_PROCESS_FORM_NOT_EXISTS("9012010", "流程表单已被删除, 请重新选择"),
// GET_REMOTE_WORKSPACE_INFO_ERROR("9012011", "调用远程接口出现异常, 接口: {}"),
// COMMON_MODEL_ASSIGN_DATA_NOT_EXISTS("9012012", "模板数据异常,未获取到租户"),
// COMMON_MODEL_NOT_EXISTS("9012013",
// "流程模型模板不存在,或者模型未配置 BPMN 流程"),
// BPM_PROCESS_DEFINITION_NOT_EXISTS("9012014",
// "未查询到可以用于发起工作流的流程定义ID, 请确认工作台与所属分类是否匹配"),
//
//
// FORM_NOT_ENABLE("9012016", "表单已经不可用"),
// ILLEGAL_FORM_DATA("9012017", "表单类型数据异常, 非法数据"),
// BPMN_XML_NOT_EXISTS("9012018", "BPMN 文件内容不存在,将终止发布"),
// BPMN_XML_NOT_VALID("9012019", "BPMN 文件内容不合法,将终止发布"),
// DEPLOY_TENANTS_NOT_EXISTS("9012020", "当前模型中未选择应用范围,将终止发布"),
// DEPLOY_FORM_CONFIG_NOT_EXISTS("9012021", "当前模型中未关联表单,将终止发布"),
// DEPLOY_OPTIONS_NOT_EXISTS("9012022", "当前模型中[{}]任务未分配审核人,将终止发布"),
// DEPLOY_SOURCE_NOT_EXISTS("9012023", "流程模型原数据丢失,将终止发布"),
// GET_REMOTE_DATE_ERROR("9012024", "调用远程接口 [{}] 发生异常: {}"),
// PARTICIPATED_DATA_IS_EMPTY("9012025",
// "当前 [{}] 项目工作台(WorkspaceId={})下未获取到参与单位信息"),
// PARTICIPATED_TYPE_DATA_IS_EMPTY("9012026",
// "当前 [{}] 项目工作台(WorkspaceId={})下未获取到{}数据"),
// GET_SUPERIOR_UNIT_ID_ERROR("9012027", "获取上级执行单位信息异常"),
// MODEL_POOL_CANT_DEPLOY("9012028", "模型已不部署,无需重复发布"),
// PROCESS_DEFINITION_IS_SUSPENDED_CANT_DEPLOY("9012029",
// "模型处于挂起状态,无法发布"),
//
//
// FLOWABLE_GENERAL_ERROR("9013000", "流程引擎一般错误"),
// FLOWABLE_ENGINE_OBJECT_NOT_FOUND("9013001", "流程引擎内部错误：流程定义未找到"),
// FLOWABLE_WRONG_DB("9013002", "数据库版本与流程引擎版本不匹配"),
// FLOWABLE_DB_OPTIMISTIC_LOCKING("9013003", "引擎内部数据乐观锁死锁"),
// FLOWABLE_TASK_ALREADY_CLAIMED("9013004", "当前审批任务已有审批人"),
// FLOWABLE_ILLEGAL_STATE("9013005", "审批流状态异常"),
// FLOWABLE_ILLEGAL_ARGUMENT("9013006", "流程引擎存在非法参数"),
// FLOWABLE_FORBIDDEN("9013007", "当前流程引擎禁止访问"),
// FLOWABLE_CLASS_LOADING_ERROR("9013008", "流程引擎加载异常"),
//
//
// USER_NOT_EXISTS("01001", "用户不存在，id=%s"),
// USER_PHONE_EMAIL_IS_NULL("01002", "电话和邮箱不能都为空");
;
private String code;
private String message;
@Override
public String getProjectCode() {
// 根据不同项目进行项目编码调整，可联系框架组获取项目编号(首位不能为0)
return "100";
}
public void setCode(String code) {
this.code = code;
}
public void setMessage(String message) {
this.message = message;
}
}
//package cn.axzo.workflow.core.common.enums;
//
//import cn.axzo.framework.domain.web.code.IProjectRespCode;
//import lombok.AllArgsConstructor;
//import lombok.Getter;
//
///**
// * @Author: liyong.tian
// * @Date: 2022/9/5
// * @Description: 响应码规范：一共8位，取值范围0~9，3位项目编号(首位不能为0)+2位模块编号+3位自定义编号
// */
//@Getter
//@AllArgsConstructor
//public enum BpmnErrorCode implements IProjectRespCode {
// // ========== category 01-001 ==========
// CATEGORY_VALUE_EXISTS("01001", "分类值【{}】已经存在"),
// CATEGORY_ID_NOT_EXISTS("01002", "指定分类【{}】不存在"),
// CATEGORY_DATA_ERROR("01003", "分类数据异常"),
//
// // ========== convertor 02-001 ==========
// CONVERTOR_UNKNOW_NODE_TYPE("02001", "节点类型【{}】暂不支持"),
// CONVERTOR_META_DATA_FORMAT_ERROR("02002", "JSON 数据格式有误-{}: {}"),
// CONVERTOR_COMMON_ERROR("02003", "JSON 转 BPMN 失败, 原因:【{}】"),
// CONVERTOR_NODE_TYPE_NOT_SUPPORT("02004", "【{}】节点类型, ID:【{}】暂不支持"),
// CONVERTOR_OPERATION_STRING_TYPE_ERROR("02005", "条件节点运算符【{}】暂不支持"),
// CONVERTOR_OPERATION_NUMBER_TYPE_ERROR("02006", "条件节点运算符【{}】暂不支持"),
// CONVERTOR_OPERATION_RADIO_TYPE_ERROR("02007", "条件节点运算符【{}】暂不支持"),
// CONVERTOR_OPERATION_CHECKBOX_TYPE_ERROR("02008", "条件节点运算符【{}】暂不支持"),
//
//
// // ========== bpmn model 03-001 ==========
// MODEL_KEY_EXISTS("03001", "已经存在流程标识为【{}】的流程"),
// MODEL_ID_NOT_EXISTS("03002", "流程模型ID【{}】不存在"),
// MODEL_KEY_NOT_EXISTS("03003", "流程模型KEY【{}】不存在"),
// MODEL_NOT_EXISTS("03004", "流程模型不存在"),
// BPMN_BYTES_NOT_EXISTS("03005", "模型定义内容字节码不存在"),
//
// // ========== bpmn processDefinition 04-001 ==========
// PROCESS_DEFINITION_BPMN_NOT_EXISTS("04001", "模型ID【{}】的定义内容不存在"),
// PROCESS_DEFINITION_ID_NOT_EXISTS("04002", "流程定义ID【{}】不存在"),
// PROCESS_DEFINITION_DEPLOY_ID_NOT_EXISTS("04003", "流程定义部署ID【{}】不存在"),
// PROCESS_DEFINITION_KEY_NOT_EXISTS("04004", "流程定义KEY【{}】不存在"),
// PROCESS_DEFINITION_RESULT_TOO_MANY("04005", "租户【{}】中存在多条分类为【{}】的流程定义,不允许直接变更状态"),
// PROCESS_DEFINITION_IS_SUSPENDED("04006", "流程定义KEY【{}】处于挂起状态"),
// PROCESS_DEFINITION_KEY_NOT_MATCH("04007", "流程定义的标识不一致, 请修改 BPMN 流程图"),
// PROCESS_DEFINITION_NAME_NOT_MATCH("04008", "流程定义的名字期望是({})，当前是({})，请修改 BPMN 流程图"),
// // "数据出现异常,同一个工作台下,同一个所属分类,只能有一个流程定义"),
// // ========== bpmn processInstance 05-001 ==========
// PROCESS_OPERATION_PARAM_VALID_ERROR("05001", "参数缺失, 请确保传入了 ID 或 businessKey 对流程实例进行操作"),
// PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS("05002", "流程取消失败，流程不处于运行中"),
// PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF("05003", "流程取消失败，该流程不是你发起的"),
// PROCESS_INSTANCE_NOT_EXISTS("05004", "流程实例不存在或已结束"),
// PROCESS_INSTANCE_ID_NOT_EXISTS("05005", "流程实例【{}】不存在"),
// PROCESS_INSTANCE_CANCELLED("05006", "流程实例已取消"),
// // ========== bpmn task 06-001 ==========
// TASK_COMPLETE_FAIL_NOT_EXISTS("06001", "未找到指定审批任务"),
// TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF("06002", "该任务的审批人不是你"),
// TASK_APOSTILLE_NOT_SUPPORT("06003", "当前加签模式不支持"),
// TASK_REMIND_ERROR_NOT_EXISTS("06004", "当前审批节点没有待审批任务, 不能催办"),
// ACTIVITY_TRIGGER_NOT_EXISTS("06005", "触发 ID:【{}】不存在"),
// CALC_TASK_ASSIGNEE_ERROR("06006", "执行计算审批候选人出现异常: {}"),
// ASSIGNEE_HAS_BEEN_EXISTS("06007", "你选择的人员已是审批人，请检查后提交"),
//
// // ========== form Model 07-001 ==========
// FORM_MODEL_NOT_EXISTS("07001", "表单模型不存在"),
// FORM_MODEL_ID_NOT_EXISTS("07002", "表单模型ID【{}】不存在"),
// // ========== form Definition 08-001 ==========
// FORM_DEFINITION_NOT_EXISTS("08001", "表单定义内容转换出错, 建议重新修改表单定义后重试"),
// FORM_DEFINITION_PARSER_ERROR("08002", "表单定义内容解析出错"),
// // ========== form Instance 09-001 ==========
// // ========== flowable Engine 10-001 ==========
// ENGINE_EXECUTION_LOST_ID_ERROR("10001", "Execution 丢失"),
// ENGINE_USER_TASK_CALC_ERROR("10002", "计算用户任务节点的审批发生异常: 【{}】"),
// ENGINE_USER_TASK_TYPE_NOT_SUPPORT("10003", "审批指定方式暂不支持"),
// // ========== flowable Engine 99-001 ==========
// MES_PUSH_OBJECT_BUILD_ERROR("99001", "构建消息推送对象异常"),
// REPEAT_SUBMIT_TIME_ERROR_TIPS("99002", "重复提交间隔时间不能小于{}秒"),
// REPEAT_SUBMIT_ERROR_TIPS("99002", "{}"),
//
//
//
//
// // // ========== 流程模型 01-001 ==========
// //
// //
// // MODEL_KEY_VALID("9002002",
// // "流程标识格式不正确，需要以字母或下划线开头，后接任意字母、数字、中划线、下划线、句点！"),
// // MODEL_DEPLOY_FAIL_FORM_NOT_CONFIG("9002003",
// // "部署流程失败，原因：流程表单未配置，请点击【修改流程】按钮进行配置"),
// // MODEL_DEPLOY_FAIL_TASK_ASSIGN_RULE_NOT_CONFIG("9002004", "部署流程失败，" +
// // "原因：用户任务({})未配置分配规则，请点击【配置审核人】按钮进行配置"),
// // MODEL_DEPLOY_FAIL_TASK_INFO_EQUALS("9003005", "流程定义部署失败，原因：信息未发生变化"),
// //
// // // ========== 流程定义 1-009-003-000 ==========
// //
// //
// // PROCESS_DEFINITION_NOT_EXISTS("9003002", "流程定义不存在"),
// //
// // PROCESS_DEFINITION_BPMN_MODEL_NOT_EXISTS("9003004", "流程定义的模型不存在"),
// //
// // // ========== 流程实例 1-009-004-000 ==========
// //
// //
// // // ========== 流程任务 1-009-005-000 ==========
// //
// //
// // // ========== 流程任务分配规则 1-009-006-000 ==========
// // TASK_ASSIGN_RULE_EXISTS("9006000", "流程({}) 的任务({}) 已经存在分配规则"),
// // TASK_ASSIGN_RULE_NOT_EXISTS("9006001", "流程任务分配规则不存在"),
// // TASK_UPDATE_FAIL_NOT_MODEL("9006002", "只有流程模型的任务分配规则，才允许被修改"),
// // TASK_CREATE_FAIL_NO_CANDIDATE_USER("9006003", "操作失败，原因：找不到任务的审批人！"),
// // TASK_ASSIGN_SCRIPT_NOT_EXISTS("9006004", "操作失败，原因：任务分配脚本({}) 不存在"),
// // TASK_ASSIGN_GET_USER_ERROR("9006005", "通过【{}】获取任务候选人失败，失败原因：{}"),
// // USER_COMPANY_ID_NOT_EXISTS("9006006", "缺失所在单位信息"),
// // TASK_ASSIGN_USER_NOT_ENOUGH("9006007", "操作失败，原因：候选人数量{}小于循环基数{}"),
// //
// // // ========== 动态表单模块 1-009-010-000 ==========
// // FORM_NOT_EXISTS("9010000", "动态表单不存在"),
// // FORM_FIELD_REPEAT("9010001", "表单项({}) 和 ({}) 使用了相同的字段名({})"),
// // FORM_CONFIG_ERROR("9010002", "内置表单解析失败"),
// //
// // FORM_CONFIG_ID_NOT_EXISTS("9010003", "修改/删除业务表单时，ID不能为空"),
// //
// // FORM_CONFIG_IN_USED("9010004", "表单正在使用中，不能删除"),
// //
// // FORM_CONFIG_CATEGORY_EXIST("9010005", "当前所属业务已有绑定关系，不能重复新增"),
// //
// // FORM_FIELD_DECODE_ERROR("9010006", "表单Field格式不正确"),
// //
// // FORM_CONFIG_CATEGORY_NOT_EXIST("9010006", "表单信息不存在，请前往 配置管理->所属业务关联关系 添加表单绑定信息"),
// //
// // // ========== 用户组模块 1-009-011-000 ==========
// // USER_GROUP_NOT_EXISTS("9011000", "用户组不存在"),
// // USER_GROUP_IS_DISABLE("9011001", "名字为【{}】的用户组已被禁用"),
// //
// // // ========== 公共模板 1-009-012-000 ==========
// // COMMON_ERROR("9012000", "{}"),
// // COMMON_MODEL_EXISTS("9012001", "名字为【{}】的公共模型已经存在"),
// // COMMON_MODEL_PROJECT_ID_NOT_EXISTS("9012002",
// // "应用类型选择租户时, 关联的项目[tenants]不能为空"),
// // COMMON_MODEL_FORM_CONFIG_NOT_EXISTS("9012003",
// // "表单类型选择业务表单时, 业务表单不能为空"),
// // COMMON_MODEL_ID_IS_NULL("9012004", "模型ID丢失, 请检查入参"),
// // COMMON_MODEL_TASK_ASSIGN_RULE_EXISTS("9012005",
// // "流程({}) 的任务({}) 已经存在分配规则"),
// // COMMON_MODEL_TASK_ASSIGN_RULE_NOT_EXISTS("9012006", "流程任务分配规则不存在"),
// // COMMON_MODEL_TASK_ASSIGN_RULE_TYPE_ILLEGAL("9012007",
// // "({}) 的应用范围，不能配置 ({}) 审配人类型"),
// // COMMON_MODEL_FORM_FIELD_PERMISSION("9012008",
// // "HTML 标签 ID 为 ({})和 Label 为 ({})的表单项配置权限信息只能只读/隐藏二选一，且不能为空"),
// // FORM_CONFIG_REGISTER_INFO_NOT_EXISTS("9012009", "未获取到该业务表单的配置信息"),
// // COMMON_MODEL_PROCESS_FORM_NOT_EXISTS("9012010", "流程表单已被删除, 请重新选择"),
// // GET_REMOTE_WORKSPACE_INFO_ERROR("9012011", "调用远程接口出现异常, 接口: {}"),
// // COMMON_MODEL_ASSIGN_DATA_NOT_EXISTS("9012012", "模板数据异常,未获取到租户"),
// // COMMON_MODEL_NOT_EXISTS("9012013",
// // "流程模型模板不存在,或者模型未配置 BPMN 流程"),
// // BPM_PROCESS_DEFINITION_NOT_EXISTS("9012014",
// // "未查询到可以用于发起工作流的流程定义ID, 请确认工作台与所属分类是否匹配"),
// //
// //
// // FORM_NOT_ENABLE("9012016", "表单已经不可用"),
// // ILLEGAL_FORM_DATA("9012017", "表单类型数据异常, 非法数据"),
// // BPMN_XML_NOT_EXISTS("9012018", "BPMN 文件内容不存在,将终止发布"),
// // BPMN_XML_NOT_VALID("9012019", "BPMN 文件内容不合法,将终止发布"),
// // DEPLOY_TENANTS_NOT_EXISTS("9012020", "当前模型中未选择应用范围,将终止发布"),
// // DEPLOY_FORM_CONFIG_NOT_EXISTS("9012021", "当前模型中未关联表单,将终止发布"),
// // DEPLOY_OPTIONS_NOT_EXISTS("9012022", "当前模型中[{}]任务未分配审核人,将终止发布"),
// // DEPLOY_SOURCE_NOT_EXISTS("9012023", "流程模型原数据丢失,将终止发布"),
// // GET_REMOTE_DATE_ERROR("9012024", "调用远程接口 [{}] 发生异常: {}"),
// // PARTICIPATED_DATA_IS_EMPTY("9012025",
// // "当前 [{}] 项目工作台(WorkspaceId={})下未获取到参与单位信息"),
// // PARTICIPATED_TYPE_DATA_IS_EMPTY("9012026",
// // "当前 [{}] 项目工作台(WorkspaceId={})下未获取到{}数据"),
// // GET_SUPERIOR_UNIT_ID_ERROR("9012027", "获取上级执行单位信息异常"),
// // MODEL_POOL_CANT_DEPLOY("9012028", "模型已不部署,无需重复发布"),
// // PROCESS_DEFINITION_IS_SUSPENDED_CANT_DEPLOY("9012029",
// // "模型处于挂起状态,无法发布"),
// //
// //
// // FLOWABLE_GENERAL_ERROR("9013000", "流程引擎一般错误"),
// // FLOWABLE_ENGINE_OBJECT_NOT_FOUND("9013001", "流程引擎内部错误：流程定义未找到"),
// // FLOWABLE_WRONG_DB("9013002", "数据库版本与流程引擎版本不匹配"),
// // FLOWABLE_DB_OPTIMISTIC_LOCKING("9013003", "引擎内部数据乐观锁死锁"),
// // FLOWABLE_TASK_ALREADY_CLAIMED("9013004", "当前审批任务已有审批人"),
// // FLOWABLE_ILLEGAL_STATE("9013005", "审批流状态异常"),
// // FLOWABLE_ILLEGAL_ARGUMENT("9013006", "流程引擎存在非法参数"),
// // FLOWABLE_FORBIDDEN("9013007", "当前流程引擎禁止访问"),
// // FLOWABLE_CLASS_LOADING_ERROR("9013008", "流程引擎加载异常"),
// //
// //
// // USER_NOT_EXISTS("01001", "用户不存在，id=%s"),
// // USER_PHONE_EMAIL_IS_NULL("01002", "电话和邮箱不能都为空");
// ;
//
// private String code;
// private String message;
//
// @Override
// public String getProjectCode() {
// // 根据不同项目进行项目编码调整，可联系框架组获取项目编号(首位不能为0)
// return "100";
// }
//
// public void setCode(String code) {
// this.code = code;
// }
//
//
// public void setMessage(String message) {
// this.message = message;
// }
//}

4
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/utils/BpmTransformUtil.java
View File

@ -39,8 +39,8 @@ import static cn.axzo.workflow.common.constant.BpmnConstants.AND_SIGN_EXPRESSION
import static cn.axzo.workflow.common.constant.BpmnConstants.END_EVENT_ID;
import static cn.axzo.workflow.common.constant.BpmnConstants.INTERNAL_TASK_RELATION_ASSIGNEE_LIST_INFO;
import static cn.axzo.workflow.common.constant.BpmnConstants.OR_SIGN_EXPRESSION_ONE_PASS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_META_DATA_FORMAT_ERROR;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_UNKNOW_NODE_TYPE;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_META_DATA_FORMAT_ERROR;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_UNKNOW_NODE_TYPE;
import static org.flowable.bpmn.model.ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION;
import static org.flowable.engine.delegate.BaseExecutionListener.EVENTNAME_END;
import static org.flowable.engine.delegate.BaseExecutionListener.EVENTNAME_START;

9
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/utils/BpmnExpressionTranslator.java
View File

@ -7,10 +7,11 @@ import com.google.common.collect.Lists;
import java.util.List;
import java.util.Objects;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_OPERATION_CHECKBOX_TYPE_ERROR;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_OPERATION_NUMBER_TYPE_ERROR;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_OPERATION_RADIO_TYPE_ERROR;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_OPERATION_STRING_TYPE_ERROR;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_OPERATION_CHECKBOX_TYPE_ERROR;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_OPERATION_NUMBER_TYPE_ERROR;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_OPERATION_RADIO_TYPE_ERROR;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_OPERATION_STRING_TYPE_ERROR;
/**
* 表达式翻译器

2
workflow-engine-core/src/main/java/cn/axzo/workflow/core/common/utils/BpmnJsonConverterUtil.java
View File

@ -89,7 +89,7 @@ import static cn.axzo.workflow.common.constant.BpmnConstants.TEMPLATE_PENDING_ME
import static cn.axzo.workflow.common.constant.BpmnConstants.TEMPLATE_SMS_MESSAGE_ID;
import static cn.axzo.workflow.common.enums.BpmnFlowNodeType.NODE_CONDITION;
import static cn.axzo.workflow.common.enums.BpmnFlowNodeType.NODE_EMPTY;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_COMMON_ERROR;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_COMMON_ERROR;
import static cn.axzo.workflow.core.common.utils.BpmnMetaParserHelper.getButtonConfig;
import static cn.axzo.workflow.core.common.utils.BpmnMetaParserHelper.getFieldConfig;
import static cn.axzo.workflow.core.common.utils.BpmnMetaParserHelper.getNoticeConfig;

2
workflow-engine-core/src/main/java/cn/axzo/workflow/core/converter/json/AbstractBpmnJsonConverter.java
View File

@ -12,7 +12,7 @@ import org.flowable.bpmn.model.UserTask;
import static cn.axzo.workflow.common.constant.BpmnConstants.CONFIG_NODE_TYPE;
import static cn.axzo.workflow.common.constant.BpmnConstants.FLOW_NODE_JSON;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_NODE_TYPE_NOT_SUPPORT;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_NODE_TYPE_NOT_SUPPORT;
/**
* 抽象的 JSON 转 BPMN 协议的转换器

5
workflow-engine-core/src/main/java/cn/axzo/workflow/core/converter/json/NotSupportConverter.java
View File

@ -5,7 +5,8 @@ import cn.axzo.workflow.core.common.exception.WorkflowEngineException;
import org.flowable.bpmn.model.FlowElement;
import org.flowable.bpmn.model.Process;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_NODE_TYPE_NOT_SUPPORT;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_NODE_TYPE_NOT_SUPPORT;
/**
* 默认的不支持的节点转换器
@ -23,7 +24,7 @@ public class NotSupportConverter extends AbstractBpmnJsonConverter<NotSupportCon
public static class NotSupportFlowElement extends FlowElement {
@Override
public FlowElement clone() {
return null;
return new NotSupportFlowElement();
}
}
}

3
workflow-engine-core/src/main/java/cn/axzo/workflow/core/deletage/approverscope/EntWorkspaceProcessor.java
View File

@ -36,7 +36,8 @@ public class EntWorkspaceProcessor implements ApproverScopeProcessor {
if (!CollectionUtils.isEmpty(orgDTO.getOrgScopes())) {
List<OrgScope> orgScopes = orgDTO.getOrgScopes().stream()
.filter(o -> WorkspaceType.ENT == WorkspaceType.getType(o.getWorkspaceType()))
.filter(o -> Objects.equals(WorkspaceType.ENT, WorkspaceType.getType(o.getWorkspaceType()))
|| Objects.equals(WorkspaceType.OMS, WorkspaceType.getType(o.getWorkspaceType())))
.collect(Collectors.toList());
build.setOrgScopes(orgScopes);
}

2
workflow-engine-core/src/main/java/cn/axzo/workflow/core/engine/event/MessagePushEventBuilder.java
View File

@ -4,7 +4,7 @@ import cn.axzo.workflow.common.model.request.bpmn.BpmnNoticeConf;
import cn.axzo.workflow.common.model.request.bpmn.task.BpmnTaskDelegateAssigner;
import cn.axzo.workflow.core.common.exception.WorkflowEngineException;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.MES_PUSH_OBJECT_BUILD_ERROR;
import static cn.axzo.workflow.core.common.code.OtherRespCode.MES_PUSH_OBJECT_BUILD_ERROR;
import static cn.axzo.workflow.core.engine.event.MessagePushEventType.NOTICE;
import static cn.axzo.workflow.core.engine.event.MessagePushEventType.PENDING_COMPLETE;
import static cn.axzo.workflow.core.engine.event.MessagePushEventType.PENDING_PUSH;

2
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/BpmnProcessModelService.java
View File

@ -66,4 +66,6 @@ public interface BpmnProcessModelService {
void changeStatus(String modelId, Integer status, BpmnTaskDelegateAssigner operator);
List<String> getModelCategoryList();
List<String> getTenantIds();
}

3
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/BpmnProcessActivityServiceImpl.java
View File

@ -10,7 +10,8 @@ import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Objects;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.ACTIVITY_TRIGGER_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnTaskRespCode.ACTIVITY_TRIGGER_NOT_EXISTS;
@Service
@Slf4j

17
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/BpmnProcessDefinitionServiceImpl.java
View File

@ -33,14 +33,14 @@ import java.util.Set;
import java.util.stream.Collectors;
import static cn.axzo.workflow.common.constant.BpmnConstants.BPMN_FILE_SUFFIX;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.BPMN_BYTES_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.MODEL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_DEPLOY_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_KEY_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_KEY_NOT_MATCH;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_NAME_NOT_MATCH;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_RESULT_TOO_MANY;
import static cn.axzo.workflow.core.common.code.BpmnModelRespCode.BPMN_BYTES_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnModelRespCode.MODEL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_DEPLOY_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_KEY_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_KEY_NOT_MATCH;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_NAME_NOT_MATCH;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_RESULT_TOO_MANY;
import static cn.axzo.workflow.core.common.utils.BpmnCollectionUtils.addIfNotNull;
import static cn.axzo.workflow.core.common.utils.BpmnCollectionUtils.convertMap;
import static java.util.Collections.emptyList;
@ -225,7 +225,6 @@ public class BpmnProcessDefinitionServiceImpl implements BpmnProcessDefinitionSe
List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery()
.processDefinitionTenantId(tenantId)
.processDefinitionCategory(category)
.active()
.latestVersion()
.list();
if (!CollectionUtils.isEmpty(list) && list.size() != 1) {

18
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/BpmnProcessInstanceServiceImpl.java
View File

@ -81,15 +81,15 @@ import static cn.axzo.workflow.common.constant.BpmnConstants.INTERNAL_SPECIFY_NE
import static cn.axzo.workflow.common.constant.BpmnConstants.OLD_INTERNAL_INITIATOR;
import static cn.axzo.workflow.common.enums.BpmnFlowNodeMode.AND;
import static cn.axzo.workflow.common.enums.BpmnFlowNodeMode.OR;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_IS_SUSPENDED;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_KEY_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_INSTANCE_CANCELLED;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_INSTANCE_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_INSTANCE_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_OPERATION_PARAM_VALID_ERROR;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_INSTANCE_CANCELLED;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_INSTANCE_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_INSTANCE_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_OPERATION_PARAM_VALID_ERROR;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_IS_SUSPENDED;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_KEY_NOT_EXISTS;
import static cn.axzo.workflow.core.common.utils.BpmnNativeQueryUtil.countSql;
import static cn.axzo.workflow.core.common.utils.BpmnNativeQueryUtil.sqlConnectors;

19
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/BpmnProcessModelServiceImpl.java
View File

@ -51,11 +51,11 @@ import static cn.axzo.workflow.common.constant.BpmnConstants.ENABLED;
import static cn.axzo.workflow.common.constant.MetaInfoConstants.MODEL_DESCRIPTION;
import static cn.axzo.workflow.common.constant.MetaInfoConstants.MODEL_TYPE;
import static cn.axzo.workflow.common.constant.MetaInfoConstants.MODEL_TYPE_PROCESS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.MODEL_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.MODEL_KEY_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.MODEL_KEY_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.MODEL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_DEFINITION_BPMN_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnModelRespCode.MODEL_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnModelRespCode.MODEL_KEY_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnModelRespCode.MODEL_KEY_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnModelRespCode.MODEL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnProcessDefinitionRespCode.PROCESS_DEFINITION_BPMN_NOT_EXISTS;
import static cn.axzo.workflow.core.common.utils.BpmnNativeQueryUtil.countSql;
import static cn.axzo.workflow.core.common.utils.BpmnNativeQueryUtil.sqlConnectors;
@ -438,6 +438,15 @@ public class BpmnProcessModelServiceImpl implements BpmnProcessModelService {
return list.stream().map(Model::getCategory).collect(Collectors.toList());
}
@Override
public List<String> getTenantIds() {
List<Model> list = repositoryService.createModelQuery().list();
if (CollectionUtils.isEmpty(list)) {
return Collections.emptyList();
}
return list.stream().map(Model::getTenantId).collect(Collectors.toList());
}
private void updateProcessDefinitionSuspended(String deploymentId) {
if (StringUtils.hasLength(deploymentId)) {
ProcessDefinition oldDefinition =

191
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/BpmnProcessTaskServiceImpl.java
View File

@ -1,6 +1,5 @@
package cn.axzo.workflow.core.service.impl;
import cn.axzo.framework.core.util.StringUtil;
import cn.axzo.workflow.common.enums.BpmnCountersignType;
import cn.axzo.workflow.common.enums.BpmnProcessInstanceResultEnum;
import cn.axzo.workflow.common.model.request.bpmn.BpmnNoticeConf;
@ -33,8 +32,6 @@ import cn.axzo.workflow.core.service.converter.BpmnTaskDonePageItemConverter;
import cn.axzo.workflow.core.service.converter.BpmnTaskTodoPageItemConverter;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import org.flowable.bpmn.model.Activity;
import org.flowable.bpmn.model.BpmnModel;
@ -82,6 +79,7 @@ import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import java.util.stream.Collectors;
@ -89,8 +87,6 @@ import static cn.axzo.workflow.common.constant.BpmnConstants.COMMENT_TYPE_ADVICE
import static cn.axzo.workflow.common.constant.BpmnConstants.COMMENT_TYPE_AUTO_PASSED;
import static cn.axzo.workflow.common.constant.BpmnConstants.COMMENT_TYPE_OPERATION_COUNTERSIGN;
import static cn.axzo.workflow.common.constant.BpmnConstants.COMMENT_TYPE_OPERATION_TRANSFER;
import static cn.axzo.workflow.common.constant.BpmnConstants.COUNTERSIGN_ORIGIN_ASSIGNER;
import static cn.axzo.workflow.common.constant.BpmnConstants.COUNTERSIGN_REMAIN_ASSIGNER_LIST;
import static cn.axzo.workflow.common.constant.BpmnConstants.INTERNAL_ACTIVITY_RELATION_ASSIGNEE_LIST_INFO_SNAPSHOT;
import static cn.axzo.workflow.common.constant.BpmnConstants.INTERNAL_DELETE_PROCESS_FLAG;
import static cn.axzo.workflow.common.constant.BpmnConstants.INTERNAL_END_TENANT_ID;
@ -110,12 +106,13 @@ import static cn.axzo.workflow.common.enums.BpmnProcessInstanceResultEnum.PROCES
import static cn.axzo.workflow.common.enums.BpmnProcessInstanceResultEnum.REJECTED;
import static cn.axzo.workflow.common.enums.BpmnProcessInstanceResultEnum.TRANSFER;
import static cn.axzo.workflow.common.enums.BpmnProcessInstanceResultEnum.valueOfStatus;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_INSTANCE_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_INSTANCE_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.TASK_APOSTILLE_NOT_SUPPORT;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.TASK_COMPLETE_FAIL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.TASK_REMIND_ERROR_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_INSTANCE_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_INSTANCE_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnTaskRespCode.ASSIGNEE_HAS_BEEN_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnTaskRespCode.TASK_APOSTILLE_NOT_SUPPORT;
import static cn.axzo.workflow.core.common.code.BpmnTaskRespCode.TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF;
import static cn.axzo.workflow.core.common.code.BpmnTaskRespCode.TASK_COMPLETE_FAIL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnTaskRespCode.TASK_REMIND_ERROR_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnProcessTaskResultEnum.REJECTION_AUTO_COMPLETED;
import static cn.axzo.workflow.core.common.utils.BpmnCollectionUtils.convertSet;
import static cn.axzo.workflow.core.common.utils.BpmnNativeQueryUtil.countSql;
@ -326,106 +323,27 @@ public class BpmnProcessTaskServiceImpl implements BpmnProcessTaskService {
}
saveAttachment(dto.getAttachmentList(), instance.getId(), task.getId());
//add by zuoqinbo 处理加签[分为向前加签和向后加签]或转交的任务
String parentTaskId = task.getParentTaskId();
if (StringUtils.hasLength(parentTaskId)) {
List<Task> subTasks = taskService.getSubTasks(parentTaskId);
long subTaskCount = subTasks.size();
TaskEntity taskEntity = (TaskEntity) taskService.createTaskQuery().taskId(parentTaskId).singleResult();
//当前任务是加签任务,parentTask下没有其他子任务 subTaskCount == 0
//目前子任务是依次顺序审批, taskService.complete(task.getId()) 已经把当前任务完成,则subTaskCount == 0
log.info("加签父任务:{},子任务:{},subTaskCount:{},正在进行审批！", parentTaskId, task.getId(), subTaskCount);
if (subTaskCount == 0) {
//让剩余加签人进行处理
List<BpmnTaskDelegateAssigner> remainAssignerList =
(List<BpmnTaskDelegateAssigner>) taskService.getVariable(parentTaskId,
COUNTERSIGN_REMAIN_ASSIGNER_LIST, List.class);
log.info("加签列表: {}", JSON.toJSONString(remainAssignerList));
//如果加签流程还未流转完，还有剩余加签人
if (!CollectionUtils.isEmpty(remainAssignerList)) {
BpmnTaskDelegateAssigner remainAssigner = remainAssignerList.remove(0);
log.info("加签父任务:{},下一级流程处理人:{},", parentTaskId,
JSONUtil.toJsonStr(Lists.newArrayList(remainAssigner)));
taskService.setVariable(taskEntity.getId(), COUNTERSIGN_REMAIN_ASSIGNER_LIST, remainAssignerList);
this.createSubTask(taskEntity, parentTaskId, remainAssigner);
} else {
// 递归上去直到没有 parentId
log.info("加签人与被加签人都审批完毕");
recursionCompleteParentTask(parentTaskId);
}
}
}
// 完成任务，审批通过
taskService.complete(task.getId(), runtimeService.getVariables(task.getExecutionId()));
}
private void recursionCompleteParentTask(String parentTaskId) {
if (!StringUtils.hasLength(parentTaskId)) {
return;
}
taskService.complete(parentTaskId);
Task parentTask = getTask(parentTaskId, null, null);
if (Objects.nonNull(parentTask)) {
recursionCompleteParentTask(parentTaskId);
}
}
/**
* 创建加签子任务
* A加签给A A再加签给A
* A加签给B B再加签给A 再加签给B
* A加签给B B加签给C 再加签A
* A加签给B B加签给C 再加签D
*
* @param countersignDTO 加签参数
* @param taskEntity 父任务
*/
@SuppressWarnings("unchecked")
private void createSignSubTasks(BpmnTaskCountersignDTO countersignDTO, TaskEntity taskEntity) {
//如果还有预留或者继承的加签人
List<BpmnTaskDelegateAssigner> targetAssignerList =
(List<BpmnTaskDelegateAssigner>) taskService.getVariable(taskEntity.getId(),
COUNTERSIGN_REMAIN_ASSIGNER_LIST);
List<BpmnTaskDelegateAssigner> newTargetAssignerList = Lists.newArrayList();
//为了保证顺序，优先使用当前剩余加签人列表
newTargetAssignerList.addAll(countersignDTO.getTargetAssignerList());
//再添加之前剩余加签人列表
if (!CollectionUtils.isEmpty(targetAssignerList)) {
newTargetAssignerList.addAll(targetAssignerList);
}
private void createSignSubTasksV2(BpmnTaskCountersignDTO countersignDTO, TaskEntity taskEntity, List<BpmnTaskDelegateAssigner> taskAssignerListSnapshot) {
// 这个节点下所有审批人快照
String activityListSnapshot =
INTERNAL_ACTIVITY_RELATION_ASSIGNEE_LIST_INFO_SNAPSHOT + taskEntity.getTaskDefinitionKey();
List<BpmnTaskDelegateAssigner> taskAssignerListSnapshot =
runtimeService.getVariable(taskEntity.getProcessInstanceId(),
activityListSnapshot, List.class);
taskAssignerListSnapshot.addAll(newTargetAssignerList);
taskAssignerListSnapshot.addAll(countersignDTO.getTargetAssignerList());
runtimeService.setVariable(taskEntity.getProcessInstanceId(), activityListSnapshot, taskAssignerListSnapshot);
log.info("正在进行加签任务:{},待加签人合并列表:{}", taskEntity.getId(), JSONUtil.toJsonStr(taskAssignerListSnapshot));
// 向前加签
BpmnTaskDelegateAssigner assigner =
(BpmnTaskDelegateAssigner) runtimeService.getVariable(taskEntity.getProcessInstanceId(),
INTERNAL_TASK_RELATION_ASSIGNEE_INFO + taskEntity.getId());
if (Objects.equals(BpmnCountersignType.FORWARD_COUNTERSIGN.getType(), countersignDTO.getCountersignType())) {
newTargetAssignerList.add(assigner);
} else {
// 向后加签
newTargetAssignerList.add(0, assigner);
}
log.info("正在进行加签任务:{},待加签人合并列表:{}", taskEntity.getId(), JSONUtil.toJsonStr(newTargetAssignerList));
if (!CollectionUtils.isEmpty(newTargetAssignerList)) {
// 因为当前的审批人会帮他结束任务,以便生成加签日志, 所以在这里重新加入审批人
countersignDTO.getTargetAssignerList().add(countersignDTO.getOriginAssigner());
countersignDTO.getTargetAssignerList().forEach(assigner -> {
String parentTaskId = taskEntity.getParentTaskId();
if (!StringUtils.hasLength(parentTaskId)) {
parentTaskId = taskEntity.getId();
}
String finalParentTaskId = parentTaskId;
BpmnTaskDelegateAssigner removeAssigner = newTargetAssignerList.remove(0);
//创建一个待加签任务，并且分配给下一个加签人
this.createSubTask(taskEntity, finalParentTaskId, removeAssigner);
//动态设置剩余加签人列表,用于任务传递
taskService.setVariable(taskEntity.getId(), COUNTERSIGN_REMAIN_ASSIGNER_LIST, newTargetAssignerList);
}
this.createSubTask(taskEntity, parentTaskId, assigner);
});
}
/**
@ -437,40 +355,13 @@ public class BpmnProcessTaskServiceImpl implements BpmnProcessTaskService {
*/
protected void createSubTask(TaskEntity parentTask, String parentTaskId, BpmnTaskDelegateAssigner assigner) {
if (parentTask != null) {
//1.生成新的工作流子任务
// IdGenerator idGenerator = springProcessEngineConfiguration.getIdGenerator();
// task = (TaskEntity) taskService.newTask(idGenerator.getNextId());
// task.setCategory(parentTask.getCategory());
// task.setDescription(parentTask.getDescription());
// task.setTenantId(parentTask.getTenantId());
// task.setName(parentTask.getName());
// task.setAssignee(assigner.buildAssigneeId());
// task.setParentTaskId(parentTaskId);
// task.setProcessDefinitionId(parentTask.getProcessDefinitionId());
// task.setProcessInstanceId(parentTask.getProcessInstanceId());
// task.setTaskDefinitionKey(parentTask.getTaskDefinitionKey());
// task.setTaskDefinitionId(parentTask.getTaskDefinitionId());
// task.setPriority(parentTask.getPriority());
// task.setCreateTime(new Date());
Map<String, Object> executionVariables = new HashMap<>();
executionVariables.put("assigneeName", assigner.buildAssigneeId());
// Execution execution = runtimeService.executeActivityInAdhocSubProcess(parentTask.getExecutionId(), parentTask.getTaskDefinitionKey());
Execution subExecution = runtimeService.addMultiInstanceExecution(parentTask.getTaskDefinitionKey(), parentTask.getProcessInstanceId(), executionVariables);
Execution subExecution = runtimeService.addMultiInstanceExecution(parentTask.getTaskDefinitionKey(),
parentTask.getProcessInstanceId(), executionVariables);
Task subTask = taskService.createTaskQuery().executionId(subExecution.getId()).singleResult();
subTask.setParentTaskId(parentTaskId);
taskService.saveTask(subTask);
// ExecutionEntity concurrentExecution = CommandContextUtil.getExecutionEntityManager()
// .createChildExecution((ExecutionEntity) multiInstanceRootExecution);
// Execution subExecution = runtimeService.createExecutionQuery()
// .parentId(parentTask.getExecutionId()) // 将新执行实例设置为当前执行实例的子实例
// .activityId(parentTask.getTaskDefinitionKey()) // 指定活动ID
// .singleResult();
// task.setExecutionId(subExecution.getId());
log.info("流程加签父任务:{},", parentTaskId);
// taskService.saveTask(task);
// springProcessEngineConfiguration.getCommandExecutor().execute(new CustomEventAssignment(parentTask.getProcessDefinitionId(), parentTask.getTaskDefinitionKey(), task));
}
}
@ -637,7 +528,9 @@ public class BpmnProcessTaskServiceImpl implements BpmnProcessTaskService {
BpmnTaskDelegateAssigner assigner = Objects.nonNull(assginerSnapshot) ?
(BpmnTaskDelegateAssigner) assginerSnapshot.getValue() : null;
vo.setAssignee(Objects.isNull(assigner) ? "" : assigner.getAssignee());
if (!Objects.equals(TASK_ASSIGNEE_SKIP_FLAT, vo.getAssignee())) {
vo.setAssignee(Objects.isNull(assigner) ? "" : assigner.getAssignee());
}
vo.setAssigneeSnapshot(assigner);
}
return vos;
@ -740,6 +633,13 @@ public class BpmnProcessTaskServiceImpl implements BpmnProcessTaskService {
public void transferTask(BpmnTaskAssigneeDTO dto) {
Task task = checkTask(dto.getOriginAssigner().buildAssigneeId(), dto.getTaskId());
List<BpmnTaskDelegateAssigner> originAssingeeList = runtimeService.getVariable(task.getProcessInstanceId(),
INTERNAL_ACTIVITY_RELATION_ASSIGNEE_LIST_INFO_SNAPSHOT + task.getTaskDefinitionKey(), List.class);
Optional<BpmnTaskDelegateAssigner> exists = originAssingeeList.stream().filter(i -> Objects.equals(i.buildAssigneeId(), dto.getTargetAssigner().buildAssigneeId())).findAny();
if (exists.isPresent()) {
throw new WorkflowEngineException(ASSIGNEE_HAS_BEEN_EXISTS);
}
task.setAssignee(TASK_ASSIGNEE_SKIP_FLAT);
((TaskEntity) task).setScopeType("TRANSFER");
taskService.saveTask(task);
@ -752,8 +652,6 @@ public class BpmnProcessTaskServiceImpl implements BpmnProcessTaskService {
}
Authentication.setAuthenticatedUserId(null);
List<BpmnTaskDelegateAssigner> originAssingeeList = runtimeService.getVariable(task.getProcessInstanceId(),
INTERNAL_ACTIVITY_RELATION_ASSIGNEE_LIST_INFO_SNAPSHOT + task.getTaskDefinitionKey(), List.class);
for (BpmnTaskDelegateAssigner assigner : originAssingeeList) {
if (Objects.equals(assigner.buildAssigneeId(), dto.getOriginAssigner().buildAssigneeId())) {
originAssingeeList.remove(assigner);
@ -796,15 +694,29 @@ public class BpmnProcessTaskServiceImpl implements BpmnProcessTaskService {
@Transactional(rollbackFor = Exception.class)
public void countersignTask(BpmnTaskCountersignDTO dto) {
Task task = checkTask(dto.getOriginAssigner().buildAssigneeId(), dto.getTaskId());
// 这个节点下所有审批人快照
String activityListSnapshot =
INTERNAL_ACTIVITY_RELATION_ASSIGNEE_LIST_INFO_SNAPSHOT + task.getTaskDefinitionKey();
List<BpmnTaskDelegateAssigner> taskAssignerListSnapshot =
runtimeService.getVariable(task.getProcessInstanceId(),
activityListSnapshot, List.class);
AtomicInteger existsCount = new AtomicInteger();
taskAssignerListSnapshot.forEach(i -> {
dto.getTargetAssignerList().forEach(j -> {
if (Objects.equals(i.buildAssigneeId(), j.buildAssigneeId())) {
existsCount.getAndIncrement();
}
});
});
if (existsCount.intValue() > 0) {
throw new WorkflowEngineException(ASSIGNEE_HAS_BEEN_EXISTS);
}
if (BpmnCountersignType.isValidAppType(dto.getCountersignType()) != null) {
//加签不能改变BPMN2.0原流程定义，因为下一个流程实例，不需要加签
String parentTaskId = task.getParentTaskId();
BpmnTaskDelegateAssigner originAssigner = dto.getOriginAssigner();
//更新当前父任务信息，如果该父任务被加签后，当前任务用户将看不到该代办信息
//或者其他方式隐藏
if (StringUtil.isEmpty(parentTaskId)) {
task.setAssignee(TASK_ASSIGNEE_SKIP_FLAT);
}
task.setAssignee(TASK_ASSIGNEE_SKIP_FLAT);
((TaskEntity) task).setScopeType(dto.getCountersignType());
taskService.saveTask(task);
// 设置评论
@ -815,7 +727,8 @@ public class BpmnProcessTaskServiceImpl implements BpmnProcessTaskService {
message.append("、");
}
}
message.append(" 等 ").append(dto.getTargetAssignerList().size()).append(" 人会签");
message.append(" 等 ").append(dto.getTargetAssignerList().size()).append(" 人进行审批");
BpmnTaskDelegateAssigner originAssigner = dto.getOriginAssigner();
Authentication.setAuthenticatedUserId(originAssigner.buildAssigneeId());
taskService.addComment(task.getId(), task.getProcessInstanceId(), COMMENT_TYPE_OPERATION_COUNTERSIGN,
message.toString());
@ -825,11 +738,11 @@ public class BpmnProcessTaskServiceImpl implements BpmnProcessTaskService {
}
Authentication.setAuthenticatedUserId(null);
//更新父任务待加签人列表
taskService.setVariable(task.getId(), COUNTERSIGN_ORIGIN_ASSIGNER, originAssigner.buildAssigneeId());
// taskService.setVariable(task.getId(), COUNTERSIGN_ORIGIN_ASSIGNER, originAssigner.buildAssigneeId());
//该父任务加签时，会创建子任务用于分配给其他人加签
//目前多个子任务时，会按照加签人的顺序依次进行加签操作，
//例如 加签按顺序依次分配给A、B、C三人,需A任务进行完成后，进行B任务、再进行C任务
this.createSignSubTasks(dto, (TaskEntity) task);
this.createSignSubTasksV2(dto, (TaskEntity) task, taskAssignerListSnapshot);
} else {
throw new WorkflowEngineException(TASK_APOSTILLE_NOT_SUPPORT);
}

7
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/CategoryServiceImpl.java
View File

@ -25,9 +25,10 @@ import java.util.List;
import java.util.Objects;
import java.util.Optional;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CATEGORY_DATA_ERROR;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CATEGORY_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CATEGORY_VALUE_EXISTS;
import static cn.axzo.workflow.core.common.code.CategoryRespCode.CATEGORY_DATA_ERROR;
import static cn.axzo.workflow.core.common.code.CategoryRespCode.CATEGORY_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.CategoryRespCode.CATEGORY_VALUE_EXISTS;
@Service
@RequiredArgsConstructor

3
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/ExtAxAxReModelServiceImpl.java
View File

@ -15,7 +15,8 @@ import javax.annotation.Resource;
import java.util.List;
import java.util.Objects;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.MODEL_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnModelRespCode.MODEL_ID_NOT_EXISTS;
/**
* 模型扩展表操作服务实现

9
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/FormDefinitionServiceImpl.java
View File

@ -17,10 +17,11 @@ import javax.annotation.Nullable;
import javax.annotation.Resource;
import java.util.Objects;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.FORM_DEFINITION_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.FORM_DEFINITION_PARSER_ERROR;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.FORM_MODEL_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.FORM_MODEL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.FormDefinitionRespCode.FORM_DEFINITION_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.FormDefinitionRespCode.FORM_DEFINITION_PARSER_ERROR;
import static cn.axzo.workflow.core.common.code.FormModelRespCode.FORM_MODEL_ID_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.FormModelRespCode.FORM_MODEL_NOT_EXISTS;
/**
* 表单定义 Service 实现

5
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/FormInstanceServiceImpl.java
View File

@ -16,8 +16,9 @@ import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Objects;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.TASK_COMPLETE_FAIL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnTaskRespCode.TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF;
import static cn.axzo.workflow.core.common.code.BpmnTaskRespCode.TASK_COMPLETE_FAIL_NOT_EXISTS;
/**
* 表单实例 Service 实现

2
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/impl/FormModelServiceImpl.java
View File

@ -31,7 +31,7 @@ import java.util.Objects;
import static cn.axzo.workflow.common.constant.BpmnConstants.FORM_FILE_SUFFIX;
import static cn.axzo.workflow.common.constant.MetaInfoConstants.MODEL_TYPE;
import static cn.axzo.workflow.common.constant.MetaInfoConstants.MODEL_TYPE_FORM;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.FORM_MODEL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.FormModelRespCode.FORM_MODEL_NOT_EXISTS;
import static cn.axzo.workflow.core.common.utils.BpmnNativeQueryUtil.countSql;
import static cn.axzo.workflow.core.common.utils.BpmnNativeQueryUtil.sqlConnectors;

3
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/support/ExpressionConditionCmd.java
View File

@ -11,7 +11,8 @@ import org.flowable.engine.impl.persistence.entity.ExecutionEntity;
import java.io.Serializable;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.ENGINE_EXECUTION_LOST_ID_ERROR;
import static cn.axzo.workflow.core.common.code.FlowableEngineRespCode.ENGINE_EXECUTION_LOST_ID_ERROR;
/**
* 流程定义内部的表达式评估命令器

3
workflow-engine-core/src/main/java/cn/axzo/workflow/core/service/support/FlowNodeForecastService.java
View File

@ -25,7 +25,8 @@ import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_INSTANCE_NOT_EXISTS;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_INSTANCE_NOT_EXISTS;
/**
* 审批实例的运行节点预测/推断

2
workflow-engine-server/src/main/java/cn/axzo/workflow/server/common/aspectj/RepeatSubmitAspect.java
View File

@ -26,7 +26,7 @@ import java.util.Collection;
import java.util.Map;
import java.util.StringJoiner;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.REPEAT_SUBMIT_ERROR_TIPS;
import static cn.axzo.workflow.core.common.code.OtherRespCode.REPEAT_SUBMIT_ERROR_TIPS;
/**
* 防止重复提交拦截器

7
workflow-engine-server/src/main/java/cn/axzo/workflow/server/controller/delegate/AbstractBpmnTaskAssigneeSelector.java
View File

@ -24,9 +24,10 @@ import java.util.Objects;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CALC_TASK_ASSIGNEE_ERROR;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.CONVERTOR_META_DATA_FORMAT_ERROR;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.ENGINE_USER_TASK_CALC_ERROR;
import static cn.axzo.workflow.core.common.code.BpmnTaskRespCode.CALC_TASK_ASSIGNEE_ERROR;
import static cn.axzo.workflow.core.common.code.ConvertorRespCode.CONVERTOR_META_DATA_FORMAT_ERROR;
import static cn.axzo.workflow.core.common.code.FlowableEngineRespCode.ENGINE_USER_TASK_CALC_ERROR;
/**
* 抽象的流程任务审批人选择器

26
workflow-engine-server/src/main/java/cn/axzo/workflow/server/controller/delegate/AdminTaskAssigneeSelector.java
View File

@ -13,6 +13,7 @@ import org.flowable.bpmn.model.UserTask;
import org.flowable.engine.delegate.DelegateExecution;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.Collections;
import java.util.List;
@ -39,17 +40,20 @@ public class AdminTaskAssigneeSelector extends AbstractBpmnTaskAssigneeSelector
@Override
protected List<BpmnTaskDelegateAssigner> invokeService(UserTask userTask, DelegateExecution execution,
ApproverScopeDTO scopeDto) {
ListFlowTaskAssignerReq req = ListFlowTaskAssignerReq.builder()
.orgScopes(scopeDto.getOrgScopes().stream()
.map(e -> BeanUtil
.copyProperties(e, ListFlowTaskAssignerReq.OrgScope.class))
.collect(Collectors.toList()))
.workerTeamScopes(scopeDto.getWorkerTeamScopes().stream()
.map(w -> BeanUtil
.copyProperties(w, ListFlowTaskAssignerReq.OrgScope.class))
.collect(Collectors.toList()))
.build();
ListFlowTaskAssignerReq.ListFlowTaskAssignerReqBuilder builder = ListFlowTaskAssignerReq.builder();
if (!CollectionUtils.isEmpty(scopeDto.getOrgScopes())) {
builder.orgScopes(scopeDto.getOrgScopes().stream()
.map(e -> BeanUtil
.copyProperties(e, ListFlowTaskAssignerReq.OrgScope.class))
.collect(Collectors.toList()));
}
if (!CollectionUtils.isEmpty(scopeDto.getWorkerTeamScopes())) {
builder.workerTeamScopes(scopeDto.getWorkerTeamScopes().stream()
.map(w -> BeanUtil
.copyProperties(w, ListFlowTaskAssignerReq.OrgScope.class))
.collect(Collectors.toList()));
}
ListFlowTaskAssignerReq req = builder.build();
List<FlowTaskAssignerResp> flowTaskAssigners =
parseApiResult(() -> flowSupportApi.listTaskAssignerAdmin(req), "通过管理员查询审批人", req);

3
workflow-engine-server/src/main/java/cn/axzo/workflow/server/controller/delegate/InitiatorLeaderRecursionTaskAssigneeSelector.java
View File

@ -9,7 +9,8 @@ import org.springframework.stereotype.Component;
import java.util.List;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.ENGINE_USER_TASK_TYPE_NOT_SUPPORT;
import static cn.axzo.workflow.core.common.code.FlowableEngineRespCode.ENGINE_USER_TASK_TYPE_NOT_SUPPORT;
/**
* todo 本期需求不实现

23
workflow-engine-server/src/main/java/cn/axzo/workflow/server/controller/listener/notice/RocketMqMessagePushEventListener.java
View File

@ -33,8 +33,6 @@ import java.util.Objects;
import java.util.stream.Collectors;
import static cn.axzo.workflow.common.constant.BpmnConstants.BIZ_ORG_RELATION;
import static cn.axzo.workflow.common.constant.BpmnConstants.COUNTERSIGN_ORIGIN_ASSIGNER;
import static cn.axzo.workflow.common.constant.BpmnConstants.COUNTERSIGN_REMAIN_ASSIGNER_LIST;
import static cn.axzo.workflow.common.constant.BpmnConstants.INTERNAL_ACTIVITY_RELATION_ASSIGNEE_LIST_INFO_SNAPSHOT;
import static cn.axzo.workflow.common.constant.BpmnConstants.INTERNAL_DELETE_PROCESS_FLAG;
import static cn.axzo.workflow.common.constant.BpmnConstants.INTERNAL_END_TENANT_ID;
@ -101,8 +99,6 @@ public class RocketMqMessagePushEventListener implements BpmnMessagePushEventLis
INTERNAL_TASK_RELATION_ASSIGNEE_LIST_INFO,
INTERNAL_TASK_RELATION_ASSIGNEE_INFO,
INTERNAL_ACTIVITY_RELATION_ASSIGNEE_LIST_INFO_SNAPSHOT,
COUNTERSIGN_REMAIN_ASSIGNER_LIST,
COUNTERSIGN_ORIGIN_ASSIGNER,
NUMBER_OF_INSTANCES,
MULTI_INSTANCE_LOOP_COUNTER
);
@ -136,7 +132,8 @@ public class RocketMqMessagePushEventListener implements BpmnMessagePushEventLis
return;
}
if (log.isDebugEnabled()) {
log.debug("RocketMqMessagePushEventListener#onPendingPush...msgTemplateId: {}, receivePerson: {}", event.getNoticeConfig().getNotice().getNoticeMessageId(), JSON.toJSONString(event.getAssigner()));
log.debug("RocketMqMessagePushEventListener#onPendingPush...msgTemplateId: {}, receivePerson: {}",
event.getNoticeConfig().getPending().getPendingMessageId(), JSON.toJSONString(event.getAssigner()));
}
if (Objects.nonNull(event.getNoticeConfig().getPending())) {
MessagePushDTO dto = build(event.getNoticeConfig().getPending().getPendingMessageId(), PROCESS_PUSH_PENDING,
@ -146,7 +143,8 @@ public class RocketMqMessagePushEventListener implements BpmnMessagePushEventLis
}
if (log.isDebugEnabled()) {
log.debug("RocketMqMessagePushEventListener#onPendingPush...end, msgTemplateId: {}, receivePerson: {}", event.getNoticeConfig().getNotice().getNoticeMessageId(), JSON.toJSONString(event.getAssigner()));
log.debug("RocketMqMessagePushEventListener#onPendingPush...end, msgTemplateId: {}, receivePerson: {}",
event.getNoticeConfig().getPending().getPendingMessageId(), JSON.toJSONString(event.getAssigner()));
}
}
@ -158,13 +156,16 @@ public class RocketMqMessagePushEventListener implements BpmnMessagePushEventLis
return;
}
if (log.isDebugEnabled()) {
log.debug("RocketMqMessagePushEventListener#onPendingComplete...msgTemplateId: {}, receivePerson: {}", event.getNoticeConfig().getNotice().getNoticeMessageId(), JSON.toJSONString(event.getAssigner()));
log.debug("RocketMqMessagePushEventListener#onPendingComplete...msgTemplateId: {}, receivePerson: {}",
event.getNoticeConfig().getPending().getPendingMessageId(), JSON.toJSONString(event.getAssigner()));
}
MessagePushDTO dto = build(event.getNoticeConfig().getPending().getPendingMessageId(), PROCESS_PUSH_PENDING_COMPLETE,
event, null);
sendMessageQueue(dto, PROCESS_PUSH_PENDING_COMPLETE);
if (log.isDebugEnabled()) {
log.debug("RocketMqMessagePushEventListener#onPendingComplete...end, msgTemplateId: {}, receivePerson: {}", event.getNoticeConfig().getNotice().getNoticeMessageId(), JSON.toJSONString(event.getAssigner()));
log.debug("RocketMqMessagePushEventListener#onPendingComplete...end, msgTemplateId: {}, receivePerson: " +
"{}", event.getNoticeConfig().getPending().getPendingMessageId(),
JSON.toJSONString(event.getAssigner()));
}
}
@ -177,13 +178,15 @@ public class RocketMqMessagePushEventListener implements BpmnMessagePushEventLis
return;
}
if (log.isDebugEnabled()) {
log.debug("RocketMqMessagePushEventListener#onSms...msgTemplateId: {}, receivePerson: {}", event.getNoticeConfig().getNotice().getNoticeMessageId(), JSON.toJSONString(event.getAssigner()));
log.debug("RocketMqMessagePushEventListener#onSms...msgTemplateId: {}, receivePerson: {}",
event.getNoticeConfig().getSms().getSmsId(), JSON.toJSONString(event.getAssigner()));
}
MessagePushDTO dto = build(event.getNoticeConfig().getSms().getSmsId(), PROCESS_PUSH_SMS, event,
collectionVariable(event));
sendMessageQueue(dto, PROCESS_PUSH_SMS);
if (log.isDebugEnabled()) {
log.debug("RocketMqMessagePushEventListener#onSms...end, msgTemplateId: {}, receivePerson: {}", event.getNoticeConfig().getNotice().getNoticeMessageId(), JSON.toJSONString(event.getAssigner()));
log.debug("RocketMqMessagePushEventListener#onSms...end, msgTemplateId: {}, receivePerson: {}",
event.getNoticeConfig().getSms().getSmsId(), JSON.toJSONString(event.getAssigner()));
}
}

2
workflow-engine-server/src/main/java/cn/axzo/workflow/server/controller/listener/task/MessagePushTaskEventListener.java
View File

@ -51,7 +51,7 @@ public class MessagePushTaskEventListener implements BpmnTaskEventListener, Orde
@Override
public void onAssigned(DelegateTask delegateTask) {
if (log.isDebugEnabled()) {
log.debug("MessagePushTaskEventListener#onAssigned...{}", delegateTask.getTaskDefinitionKey());
log.debug("MessagePushTaskEventListener#onAssigned...{}, assignee: {}, taskId: {}", delegateTask.getTaskDefinitionKey(), delegateTask.getAssignee(), delegateTask.getId());
}
if (Objects.equals(TASK_ASSIGNEE_SKIP_FLAT, delegateTask.getAssignee())) {
// 转交功能原审批人完成待办, 由于在流程引擎侧, 任务是不会在转交时立即结束, 但待办消息需要立即完成,

2
workflow-engine-server/src/main/java/cn/axzo/workflow/server/controller/web/bpmn/BpmnProcessInstanceController.java
View File

@ -40,7 +40,7 @@ import javax.validation.constraints.NotNull;
import java.util.List;
import static cn.axzo.workflow.common.constant.BpmnConstants.BIZ_ORG_RELATION;
import static cn.axzo.workflow.core.common.enums.BpmnErrorCode.PROCESS_OPERATION_PARAM_VALID_ERROR;
import static cn.axzo.workflow.core.common.code.BpmnInstanceRespCode.PROCESS_OPERATION_PARAM_VALID_ERROR;
import static cn.azxo.framework.common.model.CommonResponse.success;
@Slf4j

8
workflow-engine-server/src/main/java/cn/axzo/workflow/server/controller/web/bpmn/BpmnProcessModelController.java
View File

@ -213,4 +213,12 @@ public class BpmnProcessModelController implements ProcessModelApi {
log.info("获取已经使用过的分类集合getModelCategoryList");
return success(bpmnProcessModelService.getModelCategoryList());
}
@Operation(summary = "查询模型的租户集合")
@GetMapping("/tenant/ids")
@Override
public CommonResponse<List<String>> getTenantIds() {
log.info("查询模型的租户集合getTenantIds");
return success(bpmnProcessModelService.getTenantIds());
}
}