package jnpf.flowable.util;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.core.util.ObjectUtil;
|
import com.baomidou.dynamic.datasource.annotation.DSTransactional;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.google.common.collect.ImmutableList;
|
import com.google.common.collect.ImmutableMap;
|
import jnpf.base.ActionResult;
|
import jnpf.base.Pagination;
|
import jnpf.base.UserInfo;
|
import jnpf.base.entity.VisualdevEntity;
|
import jnpf.base.model.ColumnDataModel;
|
import jnpf.base.model.VisualDevJsonModel;
|
import jnpf.base.model.VisualWebTypeEnum;
|
import jnpf.base.model.flow.FlowFormDataModel;
|
import jnpf.base.model.flow.FlowStateModel;
|
import jnpf.base.model.schedule.ScheduleNewCrForm;
|
import jnpf.constant.DataInterfaceVarConst;
|
import jnpf.constant.JnpfConst;
|
import jnpf.constant.MsgCode;
|
import jnpf.constant.PermissionConst;
|
import jnpf.database.model.superQuery.SuperJsonModel;
|
import jnpf.database.model.superQuery.SuperQueryJsonModel;
|
import jnpf.exception.WorkFlowException;
|
import jnpf.flowable.entity.*;
|
import jnpf.flowable.enums.*;
|
import jnpf.flowable.job.FlowJobUtil;
|
import jnpf.flowable.mapper.*;
|
import jnpf.flowable.model.candidates.CandidateCheckFo;
|
import jnpf.flowable.model.candidates.CandidateCheckVo;
|
import jnpf.flowable.model.candidates.CandidateListModel;
|
import jnpf.flowable.model.candidates.CandidateUserVo;
|
import jnpf.flowable.model.flowable.*;
|
import jnpf.flowable.model.message.FlowMsgModel;
|
import jnpf.flowable.model.operator.AddSignModel;
|
import jnpf.flowable.model.record.NodeRecordModel;
|
import jnpf.flowable.model.record.RecordVo;
|
import jnpf.flowable.model.task.*;
|
import jnpf.flowable.model.templatejson.FlowFormModel;
|
import jnpf.flowable.model.templatejson.FlowParamModel;
|
import jnpf.flowable.model.templatenode.FlowErrorModel;
|
import jnpf.flowable.model.templatenode.nodejson.*;
|
import jnpf.flowable.model.trigger.*;
|
import jnpf.flowable.model.util.*;
|
import jnpf.message.model.SentMessageForm;
|
import jnpf.message.model.TriggerDataModel;
|
import jnpf.message.model.TriggerModel;
|
import jnpf.model.visualJson.FieLdsModel;
|
import jnpf.model.visualJson.FormDataModel;
|
import jnpf.model.visualJson.TableModel;
|
import jnpf.onlinedev.model.PaginationModel;
|
import jnpf.permission.entity.*;
|
import jnpf.util.*;
|
import jnpf.util.visiual.JnpfKeyConsts;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Component
|
public class OperatorUtil {
|
|
@Autowired
|
private ServiceUtil serviceUtil;
|
@Autowired
|
private MsgUtil msgUtil;
|
@Autowired
|
private FlowAbleUrl flowAbleUrl;
|
@Autowired
|
private RedisUtil redisUtil;
|
@Autowired
|
private ConditionUtil conditionUtil;
|
@Autowired
|
private FlowUtil flowUtil;
|
|
@Autowired
|
private CandidatesMapper candidatesMapper;
|
@Autowired
|
private LaunchUserMapper launchUserMapper;
|
@Autowired
|
private RecordMapper recordMapper;
|
@Autowired
|
private TaskMapper taskMapper;
|
@Autowired
|
private OperatorMapper operatorMapper;
|
@Autowired
|
private TemplateMapper templateMapper;
|
@Autowired
|
private TemplateJsonMapper templateJsonMapper;
|
@Autowired
|
private TemplateNodeMapper templateNodeMapper;
|
@Autowired
|
private TaskLineMapper taskLineMapper;
|
@Autowired
|
private RevokeMapper revokeMapper;
|
@Autowired
|
private NodeRecordMapper nodeRecordMapper;
|
@Autowired
|
private SubtaskDataMapper subtaskDataMapper;
|
@Autowired
|
private CirculateMapper circulateMapper;
|
@Autowired
|
private RejectDataMapper rejectDataMapper;
|
@Autowired
|
private EventLogMapper eventLogMapper;
|
@Autowired
|
private TriggerTaskMapper triggerTaskMapper;
|
@Autowired
|
private TriggerRecordMapper triggerRecordMapper;
|
|
|
//-------------------------------operatorUtil------------------------------------------------------------
|
|
// 组建FlowMethod
|
public FlowMethod getFlowMethod(FlowMethod flowMethod) {
|
FlowModel flowModel = flowMethod.getFlowModel();
|
String nodeCode = flowMethod.getNodeCode();
|
Map<String, NodeModel> nodes = flowMethod.getNodes();
|
FlowModel model = JsonUtil.getJsonToBean(flowModel, FlowModel.class);
|
model.setHandleOpinion("系统审批");
|
model.setSignImg(null);
|
model.setFileList(null);
|
model.setHandleStatus(FlowNature.AuditCompletion);
|
model.setTaskEntity(flowMethod.getTaskEntity());
|
model.setFlowableTaskId(flowMethod.getFlowableTaskId());
|
FlowMethod method = new FlowMethod();
|
method.setFlowModel(model);
|
NodeModel nodeModel = nodes.get(nodeCode);
|
method.setNodeModel(nodeModel);
|
method.setNodeCode(nodeCode);
|
return method;
|
}
|
|
// 处理撤销的经办
|
public void handleRevokeOperator(FlowMethod flowMethod) throws Exception {
|
FlowModel flowModel = flowMethod.getFlowModel();
|
String taskId = flowMethod.getTaskId();
|
TaskEntity taskEntity = flowMethod.getTaskEntity();
|
String instanceId = taskEntity.getInstanceId();
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
Map<String, NodeModel> nodes = flowModel.getNodes();
|
NodeModel global = nodes.get(NodeEnum.global.getType());
|
List<OperatorEntity> operatorEntities = new ArrayList<>();
|
// 生成经办，获取之前同意的经办，再次生成经办
|
List<OperatorEntity> operatorList = operatorMapper.getList(taskId)
|
.stream().filter(e -> ObjectUtil.equals(e.getHandleStatus(), FlowNature.AuditCompletion)
|
&& !ObjectUtil.equals(e.getStatus(), OperatorStateEnum.Futility.getCode())).collect(Collectors.toList());
|
List<FlowableTaskModel> taskModelList = flowAbleUrl.getCurrentTask(instanceId);
|
|
// 原来的当前节点
|
List<String> srcCurrentList = StringUtil.isNotEmpty(taskEntity.getCurrentNodeCode()) ?
|
Arrays.stream(taskEntity.getCurrentNodeCode().split(",")).collect(Collectors.toList()) : new ArrayList<>();
|
|
updateCurrentNode(taskModelList, nodes, taskEntity);
|
|
List<NodeRecordEntity> nodeRecordList = nodeRecordMapper.getList(taskId);
|
nodeRecordList = nodeRecordList.stream()
|
.sorted(Comparator.comparing(NodeRecordEntity::getCreatorTime).reversed()).collect(Collectors.toList());
|
|
for (FlowableTaskModel flowableTaskModel : taskModelList) {
|
// 当前节点已存在，跳过
|
if (CollectionUtil.isNotEmpty(srcCurrentList) && srcCurrentList.contains(flowableTaskModel.getTaskKey())) {
|
continue;
|
}
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeCode(), flowableTaskModel.getTaskKey())).findFirst().orElse(null);
|
if (null == nodeEntity) {
|
continue;
|
}
|
// 处理子流程、办理节点、外部节点
|
List<String> typeList = ImmutableList.of(NodeEnum.subFlow.getType(), NodeEnum.processing.getType(), NodeEnum.outside.getType());
|
if (typeList.contains(nodeEntity.getNodeType())) {
|
CompleteFo completeFo = new CompleteFo();
|
completeFo.setTaskId(flowableTaskModel.getTaskId());
|
flowAbleUrl.complete(completeFo);
|
this.handleRevokeOperator(flowMethod);
|
continue;
|
}
|
|
String nodeCode = flowableTaskModel.getTaskKey();
|
String nodeId = flowableTaskModel.getTaskId();
|
flowMethod.setFlowableTaskId(flowableTaskModel.getTaskId());
|
flowMethod.setNodes(nodes);
|
flowMethod.setNodeCode(nodeCode);
|
// 判断拒绝
|
NodeRecordEntity nodeRecord = nodeRecordList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeCode(), flowableTaskModel.getTaskKey())).findFirst().orElse(new NodeRecordEntity());
|
if (ObjectUtil.equals(nodeRecord.getNodeStatus(), NodeStateEnum.reject.getCode())) {
|
// 系统通过
|
FlowMethod method = this.getFlowMethod(flowMethod);
|
this.autoAudit(method);
|
continue;
|
}
|
List<OperatorEntity> list = operatorList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeCode(), nodeCode)).collect(Collectors.toList());
|
if (CollectionUtil.isNotEmpty(list)) {
|
if ((list.size() == 1 && ObjectUtil.equals(list.get(0).getHandleId(), FlowNature.SYSTEM_CODE))) {
|
// 系统通过
|
FlowMethod method = this.getFlowMethod(flowMethod);
|
this.autoAudit(method);
|
continue;
|
}
|
for (OperatorEntity operator : list) {
|
OperatorEntity operatorEntity = this.createOperator(operator, OperatorStateEnum.Revoke.getCode(), operator.getHandleId(), global);
|
operatorEntity.setTaskId(taskEntity.getId());
|
operatorEntity.setNodeId(nodeId);
|
operatorEntity.setParentId(FlowNature.ParentId);
|
operatorEntities.add(operatorEntity);
|
}
|
}
|
}
|
if (CollectionUtil.isNotEmpty(operatorEntities)) {
|
operatorMapper.insert(operatorEntities);
|
addOperatorList(operatorEntities, flowModel);
|
// 消息
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setOperatorList(operatorEntities);
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
}
|
}
|
|
|
// 校验经办
|
public OperatorEntity checkOperator(String id) throws WorkFlowException {
|
OperatorEntity operator = operatorMapper.getInfo(id);
|
if (null == operator) {
|
throw new WorkFlowException(MsgCode.FA001.get());
|
}
|
if (null == operator.getSignTime()) {
|
throw new WorkFlowException(MsgCode.WF087.get());
|
}
|
if (null == operator.getStartHandleTime()) {
|
throw new WorkFlowException(MsgCode.WF088.get());
|
}
|
if (null != operator.getHandleStatus()) {
|
throw new WorkFlowException(MsgCode.WF031.get());
|
}
|
return operator;
|
}
|
|
|
//验证流程权限
|
public void checkOperatorPermission(String id) throws WorkFlowException {
|
OperatorEntity operator = operatorMapper.getInfo(id);
|
if (Objects.equals(operator.getHandleId(), UserProvider.getLoginUserId())) {
|
return;
|
}
|
List<DelegateEntity> delegateList = flowUtil.getByToUserId(UserProvider.getLoginUserId());
|
List<String> handleId = new ArrayList<>();
|
Map<String, String[]> delegateListAll = new HashMap<>();
|
for (DelegateEntity delegate : delegateList) {
|
if (StringUtil.isNotEmpty(delegate.getFlowId())) {
|
String[] flowIds = delegate.getFlowId().split(",");
|
delegateListAll.put(delegate.getUserId(), flowIds);
|
} else {
|
handleId.add(delegate.getUserId());
|
}
|
}
|
if (handleId.contains(operator.getHandleId())) {
|
return;
|
}
|
boolean isCheckOperator = false;
|
TaskEntity task = taskMapper.getInfo(operator.getTaskId());
|
for (String userId : delegateListAll.keySet()) {
|
List<String> templateId = Arrays.asList(delegateListAll.get(userId));
|
if (Objects.equals(userId, operator.getHandleId()) && templateId.contains(task.getTemplateId())) {
|
isCheckOperator = true;
|
break;
|
}
|
}
|
if (!isCheckOperator) {
|
throw new WorkFlowException(MsgCode.AD104.get());
|
}
|
}
|
|
// 创建经办
|
public List<OperatorEntity> createOperator(FlowMethod flowMethod) {
|
List<String> userIds = flowMethod.getUserIds();
|
NodeModel nodeModel = flowMethod.getNodeModel();
|
FlowModel flowModel = flowMethod.getFlowModel();
|
List<OperatorEntity> entityList = new ArrayList<>();
|
if (userIds.isEmpty()) {
|
return entityList;
|
}
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
String flowableTaskId = flowModel.getFlowableTaskId();
|
NodeModel global = flowModel.getNodes().get(NodeEnum.global.getType());
|
|
// 是否签收
|
Boolean signFor = global.getHasSignFor();
|
flowMethod.setTaskEntity(taskEntity);
|
flowMethod.setSignFor(signFor);
|
flowMethod.setFlowableTaskId(flowableTaskId);
|
|
if (nodeModel.getCounterSign().equals(FlowNature.ImproperApprover)) {
|
List<String> list = improperSort(userIds, nodeModel);
|
if (CollectionUtil.isNotEmpty(list)) {
|
OperatorEntity entity = this.createOperatorEntity(flowMethod);
|
entity.setHandleId(list.get(0));
|
entity.setHandleAll(String.join(",", list));
|
entity.setParentId(FlowNature.ParentId);
|
entityList.add(entity);
|
}
|
} else {
|
// 或签、会签
|
for (String userId : userIds) {
|
OperatorEntity entity = this.createOperatorEntity(flowMethod);
|
entity.setHandleId(userId);
|
entity.setParentId(FlowNature.ParentId);
|
entityList.add(entity);
|
}
|
}
|
|
if (CollectionUtil.isNotEmpty(entityList)) {
|
operatorMapper.insert(entityList);
|
}
|
return entityList;
|
}
|
|
public OperatorEntity createOperatorEntity(FlowMethod flowMethod) {
|
TaskEntity taskEntity = flowMethod.getTaskEntity();
|
TemplateNodeEntity nodeEntity = flowMethod.getNodeEntity();
|
NodeModel nodeModel = flowMethod.getNodeModel();
|
Boolean signFor = flowMethod.getSignFor();
|
String flowableTaskId = flowMethod.getFlowableTaskId();
|
OperatorEntity entity = new OperatorEntity();
|
entity.setId(RandomUtil.uuId());
|
entity.setIsProcessing(ObjectUtil.equals(nodeEntity.getNodeType(), NodeEnum.processing.getType()) ? FlowNature.Processing : FlowNature.NotProcessing);
|
entity.setNodeId(flowableTaskId);
|
entity.setNodeName(nodeModel.getNodeName());
|
entity.setNodeCode(nodeEntity.getNodeCode());
|
entity.setStatus(OperatorStateEnum.Runing.getCode());
|
Boolean flowTodo = serviceUtil.getFlowTodo();
|
if (flowTodo) {
|
entity.setSignTime(new Date());
|
entity.setStartHandleTime(new Date());
|
} else {
|
Boolean flowSign = serviceUtil.getFlowSign();
|
if (flowSign) {
|
entity.setSignTime(new Date());
|
} else {
|
if (!signFor) {
|
entity.setSignTime(new Date());
|
}
|
}
|
}
|
entity.setCompletion(FlowNature.Normal);
|
entity.setTaskId(taskEntity.getId());
|
entity.setEngineType(taskEntity.getEngineType());
|
return entity;
|
}
|
|
// 判断节点的审批结果
|
public boolean checkAudit(FlowMethod flowMethod) throws WorkFlowException {
|
OperatorEntity operator = flowMethod.getOperatorEntity();
|
NodeModel nodeModel = flowMethod.getNodeModel();
|
NodeModel global = flowMethod.getNodes().get(NodeEnum.global.getType());
|
Integer handleStatus = flowMethod.getHandleStatus();
|
Boolean isCandidates = flowMethod.getIsCandidates();
|
boolean result = false;
|
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, operator.getTaskId())
|
.eq(OperatorEntity::getNodeCode, operator.getNodeCode())
|
.eq(OperatorEntity::getParentId, FlowNature.ParentId)
|
.ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode());
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
|
Boolean auditFlag = flowMethod.getAuditFlag();
|
if (auditFlag) {
|
for (OperatorEntity entity : list) {
|
if (ObjectUtil.equals(entity.getId(), operator.getId())) {
|
entity.setHandleStatus(operator.getHandleStatus());
|
break;
|
}
|
}
|
}
|
List<LaunchUserEntity> stepUserList = launchUserMapper.getTaskList(operator.getTaskId());
|
LaunchUserEntity launchUser = stepUserList.stream().filter(e -> e.getNodeCode().equals(operator.getNodeCode())).findFirst().orElse(null);
|
|
boolean isStep = Objects.equals(OperatorEnum.Step.getCode(), nodeModel.getAssigneeType());
|
Integer counterSign = isStep ? FlowNature.FixedApprover : nodeModel.getCounterSign();
|
if (FlowNature.FixedApprover.equals(counterSign)) {
|
// 或签，一人同意或拒绝
|
if (!isCandidates) {
|
result = checkStep(list, nodeModel, launchUser);
|
} else {
|
result = operator.getHandleStatus().equals(handleStatus);
|
}
|
} else if (FlowNature.FixedJointlyApprover.equals(counterSign)) {
|
// 会签
|
long numAudit;
|
long numReject;
|
if (auditFlag) {
|
numAudit = list.stream().filter(e -> FlowNature.AuditCompletion.equals(e.getHandleStatus())).count();
|
numReject = list.stream().filter(e -> FlowNature.RejectCompletion.equals(e.getHandleStatus())).count();
|
} else {
|
numAudit = list.stream()
|
.filter(e -> FlowNature.AuditCompletion.equals(e.getHandleStatus()) && null != e.getHandleTime()).count();
|
numReject = list.stream()
|
.filter(e -> FlowNature.RejectCompletion.equals(e.getHandleStatus()) && null != e.getHandleTime()).count();
|
}
|
CounterSignConfig config = nodeModel.getCounterSignConfig();
|
|
// 判断计算方式，延后计算（在所有审批人审批完成后进行规则判断）
|
int type = config.getCalculateType();
|
if (ObjectUtil.equals(type, FlowNature.CALCULATE_TYPE_DELAY)) {
|
int auditCount = (int) list.stream().filter(e -> null != e.getHandleStatus()).count();
|
if (list.size() != auditCount) {
|
return false;
|
}
|
}
|
|
int auditNum = config.getAuditNum();
|
int auditRatio = config.getAuditRatio();
|
int rejectNum = config.getRejectNum();
|
int rejectRatio = config.getRejectRatio();
|
|
if (config.getAuditType().equals(FlowNature.Percent)) {
|
// 百分比
|
int res = (int) (numAudit * 100 / list.size());
|
result = res >= auditRatio;
|
} else if (config.getAuditType().equals(FlowNature.Number)) {
|
// 人数
|
result = numAudit >= auditNum;
|
}
|
// 同意比例没通过，再计算拒绝的比例
|
if (!result) {
|
if (config.getRejectType().equals(FlowNature.Percent)) {
|
// 百分比
|
int res = (int) (numReject * 100 / list.size());
|
result = res >= rejectRatio;
|
} else if (config.getRejectType().equals(FlowNature.Number)) {
|
// 人数
|
result = numReject >= rejectNum;
|
} else {
|
// 同意取反
|
if (numReject > 0) {
|
if (config.getAuditType().equals(FlowNature.Percent)) {
|
int res = (int) (numReject * 100 / list.size());
|
result = res >= (100 - auditRatio);
|
} else if (config.getAuditType().equals(FlowNature.Number)) {
|
result = numReject >= (list.size() - auditNum);
|
}
|
}
|
}
|
if (result && ObjectUtil.equals(type, FlowNature.CALCULATE_TYPE_DELAY)) {
|
flowMethod.setHandleStatus(FlowNature.RejectCompletion);
|
}
|
} else {
|
if (ObjectUtil.equals(type, FlowNature.CALCULATE_TYPE_DELAY)) {
|
flowMethod.setHandleStatus(FlowNature.AuditCompletion);
|
}
|
}
|
} else if (FlowNature.ImproperApprover.equals(counterSign)) {
|
// 依次审批
|
if (ObjectUtil.equals(handleStatus, FlowNature.RejectCompletion)) {
|
// 拒绝直接返回true，根据拒绝是否继续流转，直接结束 或 流转一下节点
|
return true;
|
}
|
List<String> allList = StringUtil.isNotEmpty(operator.getHandleAll()) ? Arrays.stream(operator.getHandleAll().split(",")).collect(Collectors.toList()) : new ArrayList<>();
|
|
String userId = operator.getHandleId();
|
// 转审的经办，通过记录获取原来的审批人
|
if (ObjectUtil.equals(operator.getStatus(), OperatorStateEnum.Transfer.getCode())) {
|
RecordEntity record = recordMapper.getTransferRecord(operator.getId());
|
String handleId = record.getHandleId();
|
if (StringUtil.isNotBlank(handleId)) {
|
userId = handleId;
|
}
|
}
|
int index = allList.indexOf(userId);
|
// 最后一人直接返回
|
if (index == allList.size() - 1) {
|
return true;
|
}
|
if (flowMethod.getAuditFlag()) {
|
return false;
|
}
|
String handleId = "";
|
if (index != -1) {
|
handleId = allList.get(index + 1);
|
}
|
OperatorEntity entity = this.createOperator(operator, OperatorStateEnum.Runing.getCode(), handleId, global);
|
operatorMapper.insert(entity);
|
|
this.improperApproverMessage(flowMethod, entity);
|
}
|
if (!flowMethod.getAuditFlag()) {
|
flowMethod.setTaskId(operator.getTaskId());
|
flowMethod.setNodeCode(operator.getNodeCode());
|
if (result) {
|
// 结束该节点的其他经办
|
endOperator(flowMethod);
|
} else {
|
//当前审批完，结束协办数据
|
endAssist(flowMethod);
|
}
|
}
|
return result;
|
}
|
|
//判断逐级
|
public boolean checkStep(List<OperatorEntity> list, NodeModel nodeModel, LaunchUserEntity launchUser) {
|
if (null != launchUser) {
|
String positionId = launchUser.getPositionId();
|
List<String> positionList = Arrays.asList(positionId.split(","));
|
String organizeId = launchUser.getOrganizeId();
|
List<String> organizeList = Arrays.asList(organizeId.split(","));
|
//判断结束层级
|
ApproversConfig approversConfig = nodeModel.getApproversConfig();
|
Integer end = approversConfig.getEnd();
|
boolean isOrganize = Objects.equals(end, FlowNature.Organization);
|
int endLevel = isOrganize ? approversConfig.getOriginLevel() : approversConfig.getLevel();
|
int totalLevel = positionList.size() + organizeList.size() - 1;
|
int level = totalLevel - list.size();
|
//判断逐级是否结束
|
boolean result = isOrganize ? level > endLevel : list.size() < Math.min(totalLevel - (positionList.size() == 1 ? 1 : 0), endLevel);
|
return !result;
|
}
|
return true;
|
}
|
|
// 依次审批消息
|
public void improperApproverMessage(FlowMethod flowMethod, OperatorEntity entity) throws WorkFlowException {
|
FlowModel flowModel = flowMethod.getFlowModel();
|
List<CirculateEntity> circulateList = flowMethod.getCirculateList();
|
TemplateNodeEntity nodeEntity = flowMethod.getNodeEntity();
|
TaskEntity taskEntity = flowMethod.getTaskEntity();
|
List<TemplateNodeEntity> nodeEntityList = flowMethod.getNodeEntityList();
|
|
List<OperatorEntity> entityList = new ArrayList<>();
|
entityList.add(entity);
|
// 消息
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setCirculateList(circulateList);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setNodeCode(nodeEntity.getNodeCode());
|
flowMsgModel.setOperatorList(entityList);
|
flowMsgModel.setCopy(true);
|
flowMsgModel.setApprove(true);
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
}
|
|
// 结束协办
|
public void endAssist(FlowMethod flowMethod) {
|
OperatorEntity operator = flowMethod.getOperatorEntity();
|
String taskId = flowMethod.getTaskId();
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId).eq(OperatorEntity::getParentId, operator.getId())
|
.eq(OperatorEntity::getStatus, OperatorStateEnum.Assist.getCode());
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
if (CollectionUtil.isNotEmpty(list)) {
|
for (OperatorEntity entity : list) {
|
entity.setCompletion(FlowNature.Action);
|
}
|
operatorMapper.updateById(list);
|
}
|
}
|
|
// 结束经办
|
public void endOperator(FlowMethod flowMethod) {
|
String taskId = flowMethod.getTaskId();
|
String nodeCode = flowMethod.getNodeCode();
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId)
|
.isNull(OperatorEntity::getHandleStatus);
|
if (StringUtil.isNotEmpty(nodeCode)) {
|
queryWrapper.lambda().eq(OperatorEntity::getNodeCode, nodeCode);
|
}
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
if (CollectionUtil.isNotEmpty(list)) {
|
for (OperatorEntity entity : list) {
|
entity.setCompletion(FlowNature.Action);
|
}
|
operatorMapper.updateById(list);
|
}
|
}
|
|
// 结束加签经办
|
public void endAddSign(String taskId, String parentId) {
|
List<OperatorEntity> list = new ArrayList<>();
|
this.getAddSignChildren(parentId, list);
|
if (CollectionUtil.isNotEmpty(list)) {
|
operatorMapper.updateById(list);
|
}
|
}
|
|
// 撤回复原
|
public void recallRestore(OperatorEntity operator, String nodeId, List<String> userIds) {
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, operator.getTaskId())
|
.eq(OperatorEntity::getNodeCode, operator.getNodeCode()).eq(OperatorEntity::getNodeId, nodeId)
|
.eq(OperatorEntity::getCompletion, FlowNature.Action).isNull(OperatorEntity::getHandleTime);
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
if (CollectionUtil.isEmpty(list)) {
|
return;
|
}
|
|
List<OperatorEntity> updateList = new ArrayList<>();
|
for (OperatorEntity operatorEntity : list) {
|
if (ObjectUtil.equals(operatorEntity.getParentId(), operator.getParentId())) {
|
updateList.add(operatorEntity);
|
if (null != userIds) {
|
userIds.add(operatorEntity.getHandleId());
|
}
|
}
|
}
|
|
if (CollectionUtil.isNotEmpty(updateList)) {
|
Date date = new Date();
|
UpdateWrapper<OperatorEntity> wrapper = new UpdateWrapper<>();
|
List<String> ids = updateList.stream().map(OperatorEntity::getId).collect(Collectors.toList());
|
wrapper.lambda().in(OperatorEntity::getId, ids)
|
.set(OperatorEntity::getCreatorTime, date)
|
.set(OperatorEntity::getStatus, OperatorStateEnum.Runing.getCode())
|
.set(OperatorEntity::getCompletion, FlowNature.Normal)
|
.set(OperatorEntity::getHandleStatus, null);
|
operatorMapper.update(wrapper);
|
// 作废记录
|
recordMapper.invalid(updateList);
|
}
|
|
List<OperatorEntity> deleteList = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(updateList)) {
|
for (OperatorEntity op : updateList) {
|
this.getAddSignChildren(op.getId(), deleteList);
|
}
|
if (CollectionUtil.isNotEmpty(deleteList)) {
|
deleteList.forEach(e -> e.setStatus(OperatorStateEnum.Futility.getCode()));
|
operatorMapper.updateById(deleteList);
|
// 作废记录
|
recordMapper.invalid(deleteList);
|
}
|
}
|
}
|
|
public List<OperatorEntity> getAddSignChildren(String operatorId, List<OperatorEntity> list) {
|
list = null == list ? new ArrayList<>() : list;
|
List<OperatorEntity> childList = this.getChildList(operatorId);
|
if (CollectionUtil.isNotEmpty(childList)) {
|
for (OperatorEntity operator : childList) {
|
operator.setCompletion(FlowNature.Action);
|
list.add(operator);
|
this.getAddSignChildren(operator.getId(), list);
|
}
|
}
|
return list;
|
}
|
|
// 判断自动审批
|
public int checkAuto(FlowMethod flowMethod) {
|
NodeModel nodeModel = flowMethod.getNodeModel();
|
if (nodeModel.getHasAutoApprover()) {
|
AutoAuditRule autoAuditRule = nodeModel.getAutoAuditRule();
|
if (null != autoAuditRule) {
|
List<ProperCond> conditions = autoAuditRule.getConditions();
|
flowMethod.setConditions(conditions);
|
flowMethod.setMatchLogic(autoAuditRule.getMatchLogic());
|
if (conditionUtil.hasCondition(flowMethod)) {
|
return 1;
|
}
|
}
|
AutoAuditRule autoRejectRule = nodeModel.getAutoRejectRule();
|
if (null != autoRejectRule) {
|
List<ProperCond> conditions = autoRejectRule.getConditions();
|
flowMethod.setConditions(conditions);
|
flowMethod.setMatchLogic(autoRejectRule.getMatchLogic());
|
if (conditionUtil.hasCondition(flowMethod)) {
|
return 2;
|
}
|
}
|
}
|
return 3;
|
}
|
|
// 节点的自动审批
|
public void autoAudit(FlowMethod flowMethod) throws Exception {
|
FlowModel flowModel = flowMethod.getFlowModel();
|
|
OperatorEntity entity = this.saveSystemOperator(flowMethod);
|
if (null == entity) {
|
return;
|
}
|
audit(entity, flowModel);
|
}
|
|
public void autoAudit(OperatorEntity entity, FlowModel flowModel) throws Exception {
|
if (null == entity || null == flowModel) {
|
return;
|
}
|
audit(entity, flowModel);
|
}
|
|
public void audit(OperatorEntity operator, FlowModel flowModel) throws Exception {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
//判断是否审批过
|
if (null != operator.getHandleStatus()) {
|
return;
|
}
|
isSuspend(taskEntity);
|
isCancel(taskEntity);
|
|
if (null == flowModel.getUserInfo()) {
|
flowModel.setUserInfo(UserProvider.getUser());
|
}
|
RevokeEntity revokeEntity = revokeMapper.getRevokeTask(taskEntity.getId());
|
if (null != revokeEntity) {
|
// 处理撤销的经办
|
addTask(ImmutableList.of(revokeEntity.getTaskId()));
|
handleRevoke(flowModel, operator, revokeEntity);
|
return;
|
}
|
|
addTask(ImmutableList.of(taskEntity.getId()));
|
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(e.getNodeCode(), operator.getNodeCode())).findFirst().orElse(null);
|
if (nodeEntity == null) {
|
throw new WorkFlowException(MsgCode.WF076.get());
|
}
|
flowModel.setNodeEntity(nodeEntity);
|
String deploymentId = flowModel.getDeploymentId();
|
Map<String, NodeModel> nodes = flowModel.getNodes();
|
NodeModel nodeModel = nodes.get(operator.getNodeCode());
|
// 全局节点
|
TemplateNodeEntity globalEntity = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(NodeEnum.global.getType(), e.getNodeType())).findFirst().orElse(new TemplateNodeEntity());
|
NodeModel global = JsonUtil.getJsonToBean(globalEntity.getNodeJson(), NodeModel.class);
|
|
// 表单
|
Map<String, Object> formData = flowModel.getFormData();
|
|
if (CollectionUtil.isNotEmpty(flowModel.getCandidateList())) {
|
// 或签，删除其他人选择的候选人
|
if (ObjectUtil.equals(nodeModel.getCounterSign(), FlowNature.FixedApprover)) {
|
NextOrPrevFo nextOrPrevFo = new NextOrPrevFo();
|
nextOrPrevFo.setDeploymentId(flowModel.getDeploymentId());
|
nextOrPrevFo.setTaskKey(operator.getNodeCode());
|
List<FlowableNodeModel> nextModels = flowAbleUrl.getNext(nextOrPrevFo);
|
List<String> nextCodes = nextModels.stream().map(FlowableNodeModel::getId).collect(Collectors.toList());
|
if (CollectionUtil.isNotEmpty(nextCodes)) {
|
candidatesMapper.deleteByCodes(operator.getTaskId(), nextCodes);
|
}
|
}
|
}
|
// 保存候选人、异常人
|
flowUtil.create(flowModel, operator.getTaskId(), nodeEntityList, operator);
|
|
// 流程参数
|
updateGlobalParam(taskEntity, nodeModel, global, flowModel.getFormData());
|
flowModel.setTaskEntity(taskEntity);
|
|
FlowMethod flowMethod = new FlowMethod();
|
Integer handleStatus = flowModel.getHandleStatus();
|
boolean isAudit = handleStatus.equals(FlowNature.AuditCompletion);
|
if (isAudit) {
|
operator.setHandleStatus(FlowNature.AuditCompletion);
|
flowMethod.setType(RecordEnum.audit.getCode());
|
flowModel.setEventStatus(EventEnum.Approve.getStatus());
|
} else {
|
operator.setHandleStatus(FlowNature.RejectCompletion);
|
flowMethod.setType(RecordEnum.reject.getCode());
|
flowModel.setEventStatus(EventEnum.Reject.getStatus());
|
}
|
|
// 同意、拒绝
|
operator.setHandleTime(new Date());
|
operator.setCompletion(FlowNature.Action);
|
operatorMapper.updateById(operator);
|
if (StringUtil.isNotBlank(operator.getDraftData())) {
|
// 清除草稿数据
|
UpdateWrapper<OperatorEntity> updateWrapper = new UpdateWrapper<>();
|
updateWrapper.lambda().eq(OperatorEntity::getId, operator.getId())
|
.set(OperatorEntity::getDraftData, null);
|
operatorMapper.update(updateWrapper);
|
}
|
// 记录
|
flowMethod.setFlowModel(flowModel);
|
flowMethod.setOperatorEntity(operator);
|
recordMapper.createRecord(flowMethod);
|
|
flowMethod.setTaskEntity(taskEntity);
|
flowMethod.setNodeEntity(nodeEntity);
|
flowMethod.setNodeEntityList(nodeEntityList);
|
flowMethod.setDeploymentId(deploymentId);
|
flowMethod.setFormData(formData);
|
flowMethod.setNodes(nodes);
|
flowMethod.setNodeCode(operator.getNodeCode());
|
flowMethod.setNodeModel(nodeModel);
|
flowMethod.setHandleStatus(handleStatus);
|
// 抄送
|
List<CirculateEntity> circulateList = new ArrayList<>();
|
if (flowModel.getCopyMsgFlag()) {
|
circulateList = circulateList(flowMethod);
|
}
|
flowMethod.setCirculateList(circulateList);
|
|
// 判断加签比例
|
if (!StringUtil.equals(operator.getParentId(), FlowNature.ParentId)) {
|
handleAddCounterSign(operator, flowModel);
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setCirculateList(circulateList);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setNodeCode(nodeEntity.getNodeCode());
|
flowMsgModel.setWait(false);
|
flowMsgModel.setCopy(true);
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
return;
|
}
|
// 选择分支
|
candidatesMapper.createBranch(flowModel.getBranchList(), operator);
|
|
|
// 指派的经办无需计算比例，或系统审批
|
if (!ObjectUtil.equals(operator.getStatus(), OperatorStateEnum.Assigned.getCode())
|
|| ObjectUtil.equals(operator.getHandleId(), FlowNature.SYSTEM_CODE)) {
|
// 判断比例
|
boolean auditRes = checkAudit(flowMethod);
|
if (!auditRes) {
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setCirculateList(circulateList);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setNodeCode(nodeEntity.getNodeCode());
|
flowMsgModel.setWait(false);
|
flowMsgModel.setCopy(true);
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
return;
|
}
|
//逐级审批过
|
List<LaunchUserEntity> launchUserList = launchUserMapper.getTaskList(operator.getTaskId());
|
LaunchUserEntity launchUser = launchUserList.stream().filter(e -> e.getNodeCode().equals(operator.getNodeCode())).findFirst().orElse(null);
|
if (launchUser != null) {
|
if (isAudit || global.getHasContinueAfterReject()) {
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, operator.getTaskId())
|
.eq(OperatorEntity::getNodeCode, operator.getNodeCode())
|
.eq(OperatorEntity::getParentId, FlowNature.ParentId)
|
.ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode());
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
boolean result = checkStep(list, nodeModel, launchUser);
|
if (!result) {
|
String positionId = launchUser.getPositionId() != null ? launchUser.getPositionId() : "";
|
List<String> positionList = Arrays.asList(positionId.split(","));
|
String organizeId = launchUser.getOrganizeId() != null ? launchUser.getOrganizeId() : "";
|
List<String> organizeList = Arrays.asList(organizeId.split(","));
|
//获取逐级下个审批人
|
FlowMethod jsonToBean = new FlowMethod();
|
flowModel.setFlowableTaskId(operator.getNodeId());
|
jsonToBean.setTaskEntity(flowMethod.getTaskEntity());
|
jsonToBean.setFlowModel(flowModel);
|
jsonToBean.setNodeEntityList(flowMethod.getNodeEntityList());
|
jsonToBean.setNodeEntity(flowMethod.getNodeEntity());
|
jsonToBean.setSubFormData(flowMethod.getSubFormData());
|
jsonToBean.setExtraRule(true);
|
jsonToBean.setNodeModel(nodeModel);
|
jsonToBean.setOperatorEntity(operator);
|
UserEntity userEntity = new UserEntity();
|
userEntity.setPositionId(positionList.get(positionList.size() - 1));
|
userEntity.setOrganizeId(organizeList.get(organizeList.size() - 1));
|
String managerByLevel = flowUtil.getManagerByLevel(userEntity, list.size() + 1);
|
UserEntity userInfo = serviceUtil.getUserInfo(managerByLevel);
|
if (userInfo == null) {
|
throw new WorkFlowException(MsgCode.WF153.get());
|
}
|
jsonToBean.setUserIds(ImmutableList.of(managerByLevel));
|
List<OperatorEntity> entityList = createOperator(jsonToBean);
|
for (OperatorEntity entity : entityList) {
|
entity.setHandleAll(operator.getId());
|
}
|
operatorMapper.updateById(entityList);
|
addOperatorList(entityList, flowModel);
|
|
// 消息
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setCirculateList(circulateList);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setNodeCode(nodeEntity.getNodeCode());
|
flowMsgModel.setOperatorList(entityList);
|
if (flowModel.getCopyMsgFlag()) {
|
flowMsgModel.setCopy(true);
|
}
|
if (isAudit) {
|
flowMsgModel.setApprove(true);
|
} else {
|
flowMsgModel.setReject(true);
|
}
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
return;
|
}
|
}
|
}
|
}
|
//审批事件
|
addEvent(flowModel);
|
Integer tempStatus = flowMethod.getHandleStatus() != null ? flowMethod.getHandleStatus() : handleStatus;
|
// 判断拒绝后是否继续流转
|
if (FlowNature.RejectCompletion.equals(tempStatus) && !global.getHasContinueAfterReject()) {
|
flowMethod.setOperatorEntity(operator);
|
flowMethod.setFlowModel(flowModel);
|
handleEndTask(flowMethod);
|
launchUserMapper.deleteStepUser(taskEntity.getId());
|
return;
|
}
|
|
flowModel.setOperatorEntity(operator);
|
boolean isRejectDataId = taskEntity.getRejectDataId() != null;
|
if (isRejectDataId) {
|
handleRejectData(flowModel);
|
} else {
|
List<String> branchList = candidatesMapper.getBranch(operator.getTaskId(), operator.getNodeCode());
|
Map<String, Boolean> resMap;
|
if (branchList.isEmpty()) {
|
resMap = conditionUtil.handleCondition(flowMethod);
|
conditionUtil.checkCondition(resMap, nodes);
|
} else {
|
resMap = conditionUtil.getForBranch(flowMethod, branchList);
|
}
|
taskLineMapper.create(taskEntity.getId(), resMap);
|
|
// 完成
|
CompleteFo fo = new CompleteFo();
|
fo.setTaskId(operator.getNodeId());
|
fo.setVariables(new HashMap<>(resMap));
|
flowAbleUrl.complete(fo);
|
}
|
// 节点记录
|
NodeRecordModel nodeRecordModel = new NodeRecordModel();
|
nodeRecordModel.setTaskId(operator.getTaskId());
|
nodeRecordModel.setNodeId(operator.getNodeId());
|
nodeRecordModel.setNodeCode(operator.getNodeCode());
|
nodeRecordModel.setNodeName(operator.getNodeName());
|
nodeRecordModel.setNodeStatus(isAudit ? NodeStateEnum.pass.getCode() : NodeStateEnum.reject.getCode());
|
nodeRecordMapper.create(nodeRecordModel);
|
|
// 生成下一节点
|
List<OperatorEntity> entityList = this.handleOperator(flowModel);
|
// 删除选择分支
|
candidatesMapper.deleteBranch(operator.getTaskId(), operator.getNodeCode());
|
|
//删除逐级数据
|
launchUserMapper.delete(operator.getTaskId(), ImmutableList.of(operator.getNodeCode()));
|
|
if (!isRejectDataId) {
|
boolean isProcessing = ObjectUtil.equals(nodeEntity.getNodeType(), NodeEnum.processing.getType());
|
flowModel.setAction(ObjectUtil.equals(handleStatus, FlowNature.RejectCompletion) ? 2 : isProcessing ? 4 : 1);
|
handleTrigger(operator, flowModel);
|
}
|
|
// 判断任务是否结束
|
flowModel.setHandleStatus(flowMethod.getHandleStatus() != null ? flowMethod.getHandleStatus() : handleStatus);
|
isFinished(flowModel);
|
|
// 消息
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setCirculateList(circulateList);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setNodeCode(nodeEntity.getNodeCode());
|
flowMsgModel.setOperatorList(entityList);
|
if (flowModel.getCopyMsgFlag()) {
|
flowMsgModel.setCopy(true);
|
}
|
if (isAudit) {
|
flowMsgModel.setApprove(true);
|
} else {
|
flowMsgModel.setReject(true);
|
}
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
|
// 系统审批
|
systemAudit();
|
}
|
|
// 系统审批
|
public void systemAudit() {
|
List<SystemAuditModel> systemList = SystemAuditHolder.getAll();
|
if (CollectionUtil.isNotEmpty(systemList)) {
|
List<SystemAuditModel> jsonToList = JsonUtil.getJsonToList(systemList, SystemAuditModel.class);
|
|
SystemAuditHolder.clear();
|
Map<String, TaskEntity> taskMap = new HashMap<>();
|
for (SystemAuditModel model : jsonToList) {
|
OperatorEntity operator = model.getOperator();
|
FlowModel flowModel = model.getFlowModel();
|
try {
|
String taskId = operator.getTaskId();
|
TaskEntity task = taskMap.get(taskId) != null ? taskMap.get(taskId) : taskMapper.getInfo(taskId);
|
if (Objects.equals(task.getStatus(), TaskStatusEnum.REJECTED.getCode())) {
|
continue;
|
}
|
flowModel.setTaskEntity(task);
|
this.autoAudit(operator, flowModel);
|
taskMap.put(taskId, task);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
}
|
|
public OperatorEntity saveSystemOperator(FlowMethod flowMethod) {
|
NodeModel nodeModel = flowMethod.getNodeModel();
|
FlowModel flowModel = flowMethod.getFlowModel();
|
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
String flowableTaskId = flowModel.getFlowableTaskId();
|
|
OperatorEntity entity = new OperatorEntity();
|
entity.setStatus(OperatorStateEnum.Runing.getCode());
|
entity.setCompletion(FlowNature.Action);
|
entity.setParentId(FlowNature.ParentId);
|
|
entity.setTaskId(taskEntity.getId());
|
entity.setNodeCode(nodeModel.getNodeId());
|
entity.setNodeId(flowableTaskId);
|
entity.setNodeName(nodeModel.getNodeName());
|
entity.setEngineType(taskEntity.getEngineType());
|
|
entity.setSignTime(new Date());
|
entity.setStartHandleTime(new Date());
|
entity.setHandleId(FlowNature.SYSTEM_CODE);
|
entity.setHandleTime(new Date());
|
entity.setIsProcessing(ObjectUtil.equals(nodeModel.getType(), NodeEnum.processing.getType()) ? FlowNature.Processing : FlowNature.NotProcessing);
|
|
operatorMapper.insert(entity);
|
|
return entity;
|
}
|
|
// 全局属性的自动审批
|
public boolean handleGlobalAuto(FlowMethod flowMethod) throws WorkFlowException {
|
OperatorEntity entity = flowMethod.getOperatorEntity();
|
NodeModel global = flowMethod.getNodeModel();
|
FlowModel flowModel = flowMethod.getFlowModel();
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
String deploymentId = flowModel.getDeploymentId();
|
if (null == entity.getSignTime()) {
|
entity.setSignTime(new Date());
|
}
|
|
// 自动提交规则
|
AutoSubmitConfig autoSubmitConfig = global.getAutoSubmitConfig();
|
// 相邻节点审批人重复
|
if (autoSubmitConfig.getAdjacentNodeApproverRepeated()) {
|
// 获取上一级节点编码
|
List<String> nodeCodeList = new ArrayList<>();
|
flowUtil.prevNodeList(deploymentId, entity.getNodeCode(), nodeEntityList, nodeCodeList);
|
if (CollectionUtil.isNotEmpty(nodeCodeList)) {
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskEntity.getId())
|
.eq(OperatorEntity::getHandleId, entity.getHandleId()).isNotNull(OperatorEntity::getHandleStatus)
|
.ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode())
|
.in(OperatorEntity::getNodeCode, nodeCodeList);
|
long count = operatorMapper.selectCount(queryWrapper);
|
if (count > 0) {
|
entity.setStartHandleTime(new Date());
|
return true;
|
}
|
}
|
}
|
// 审批人审批过该流程
|
if (autoSubmitConfig.getApproverHasApproval()) {
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskEntity.getId())
|
.eq(OperatorEntity::getHandleId, entity.getHandleId()).ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode())
|
.isNotNull(OperatorEntity::getHandleStatus);
|
long count = operatorMapper.selectCount(queryWrapper);
|
if (count > 0) {
|
entity.setStartHandleTime(new Date());
|
return true;
|
}
|
}
|
// 发起人与审批人重复
|
if (autoSubmitConfig.getInitiatorApproverRepeated()) {
|
if (StringUtil.equals(taskEntity.getCreatorUserId(), entity.getHandleId())) {
|
entity.setStartHandleTime(new Date());
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public List<OperatorEntity> getChildList(String id) {
|
QueryWrapper<OperatorEntity> wrapper = new QueryWrapper<>();
|
wrapper.lambda().eq(OperatorEntity::getParentId, id)
|
.ne(OperatorEntity::getStatus, OperatorStateEnum.Assist.getCode());
|
return operatorMapper.selectList(wrapper);
|
}
|
|
// 处理加签审批比例
|
public void handleAddCounterSign(OperatorEntity operator, FlowModel flowModel) throws Exception {
|
if (null == operator.getParentId()) {
|
return;
|
}
|
OperatorEntity parentEntity = operatorMapper.getInfo(operator.getParentId());
|
if (null == parentEntity) {
|
return;
|
}
|
String handleParameter = parentEntity.getHandleParameter();
|
AddSignModel addSignModel = JsonUtil.getJsonToBean(handleParameter, AddSignModel.class);
|
if (null == addSignModel) {
|
return;
|
}
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
List<OperatorEntity> list = this.getChildList(operator.getParentId());
|
|
int total = list.size();
|
long countAudit = list.stream().filter(e -> FlowNature.AuditCompletion.equals(e.getHandleStatus()) && null != e.getHandleTime()).count();
|
long countReject = list.stream().filter(e -> FlowNature.RejectCompletion.equals(e.getHandleStatus()) && null != e.getHandleTime()).count();
|
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setAddSignModel(addSignModel);
|
flowMethod.setOperatorEntity(parentEntity);
|
flowMethod.setFlowModel(flowModel);
|
if (ObjectUtil.equals(addSignModel.getCounterSign(), FlowNature.ImproperApprover)) {
|
if (ObjectUtil.equals(flowModel.getHandleStatus(), FlowNature.RejectCompletion)) {
|
Map<String, NodeModel> nodes = flowModel.getNodes();
|
NodeModel global = nodes.get(NodeEnum.global.getType());
|
// 101003前加签给10001、10002、10003，不管是否开启拒绝继续流转，10001通过，10002拒绝，应该回到101003那里
|
// 后加签逻辑：流程设置继续流转，依次审批中只要有人拒绝，其他审批人不用审批流程就流转下一节点；流程未设置继续流转，依次审批中只要有人拒绝，就拒绝回发起节点
|
if (ObjectUtil.equals(addSignModel.getAddSignType(), FlowNature.Later) && !global.getHasContinueAfterReject()) {
|
flowMethod.setTaskEntity(taskEntity);
|
handleEndTask(flowMethod);
|
} else {
|
this.handleAddSign(flowMethod);
|
}
|
return;
|
}
|
String userId = operator.getHandleId();
|
// 转审的经办，通过记录获取原来的审批人
|
if (ObjectUtil.equals(operator.getStatus(), OperatorStateEnum.Transfer.getCode())) {
|
RecordEntity record = recordMapper.getTransferRecord(operator.getId());
|
String handleId = record.getHandleId();
|
if (StringUtil.isNotBlank(handleId)) {
|
userId = handleId;
|
}
|
}
|
List<String> idList = addSignModel.getAddSignUserIdList();
|
int index = idList.indexOf(userId);
|
if (index == idList.size() - 1) {
|
// 依次审批最后一个人
|
this.handleAddSign(flowMethod);
|
} else {
|
NodeModel global = flowModel.getNodes().get(NodeEnum.global.getType());
|
String handleId = idList.get(index + 1);
|
OperatorEntity entity = this.createOperator(operator, OperatorStateEnum.AddSign.getCode(), handleId, global);
|
operatorMapper.insert(entity);
|
flowMethod.setNodeEntity(flowModel.getNodeEntity());
|
flowMethod.setTaskEntity(taskEntity);
|
flowMethod.setNodeEntityList(flowModel.getNodeEntityList());
|
this.improperApproverMessage(flowMethod, entity);
|
}
|
} else if (ObjectUtil.equals(addSignModel.getCounterSign(), FlowNature.FixedJointlyApprover)) {
|
// 会签
|
Integer ratio = addSignModel.getAuditRatio();
|
|
int rejectRatio = 100 - ratio;
|
int rejectRes = (int) (countReject * 100 / total);
|
if (rejectRes != 0 && rejectRes >= rejectRatio) {
|
// 直接拒绝
|
flowMethod.setHandleStatus(FlowNature.RejectCompletion);
|
this.handleAddSign(flowMethod);
|
this.endAddSign(taskEntity.getId(), parentEntity.getId());
|
return;
|
}
|
|
int res = (int) (countAudit * 100 / total);
|
if (res >= ratio) {
|
flowMethod.setHandleStatus(FlowNature.AuditCompletion);
|
this.handleAddSign(flowMethod);
|
this.endAddSign(taskEntity.getId(), parentEntity.getId());
|
}
|
} else {
|
int auditFlag = FlowNature.AuditCompletion;
|
// 或签
|
if (countReject >= 1) {
|
auditFlag = FlowNature.RejectCompletion;
|
}
|
flowMethod.setHandleStatus(auditFlag);
|
this.handleAddSign(flowMethod);
|
this.endAddSign(taskEntity.getId(), parentEntity.getId());
|
}
|
}
|
|
public void handleAddSign(FlowMethod flowMethod) throws Exception {
|
AddSignModel addSignModel = flowMethod.getAddSignModel();
|
OperatorEntity parentEntity = flowMethod.getOperatorEntity();
|
FlowModel flowModel = flowMethod.getFlowModel();
|
if (addSignModel.getAddSignType().equals(FlowNature.Later)) {
|
// 后加签需要默认同意
|
flowModel.setHandleStatus(FlowNature.AuditCompletion);
|
UserEntity userEntity = serviceUtil.getUserInfo(parentEntity.getHandleId());
|
UserInfo userInfo = JsonUtil.getJsonToBean(UserProvider.getUser(), UserInfo.class);
|
userInfo.setUserId(userEntity.getId());
|
userInfo.setUserName(userEntity.getRealName());
|
flowModel.setUserInfo(userInfo);
|
flowModel.setCopyMsgFlag(false);
|
parentEntity.setHandleStatus(null);
|
audit(parentEntity, flowModel);
|
flowModel.setCopyMsgFlag(true);
|
} else {
|
UpdateWrapper<OperatorEntity> updateWrapper = new UpdateWrapper<>();
|
updateWrapper.lambda().eq(OperatorEntity::getId, parentEntity.getId())
|
.set(OperatorEntity::getCreatorTime, new Date())
|
.set(OperatorEntity::getCompletion, FlowNature.Normal);
|
NodeModel global = flowModel.getNodes().get(NodeEnum.global.getType());
|
Boolean flowTodo = serviceUtil.getFlowTodo();
|
if (!flowTodo) {
|
updateWrapper.lambda().set(OperatorEntity::getStartHandleTime, null);
|
Boolean flowSign = serviceUtil.getFlowSign();
|
if (!flowSign) {
|
if (global != null && global.getHasSignFor()) {
|
updateWrapper.lambda().set(OperatorEntity::getSignTime, null);
|
}
|
}
|
}
|
operatorMapper.update(updateWrapper);
|
parentEntity = operatorMapper.selectById(parentEntity.getId());
|
// 超时经办
|
List<OperatorEntity> list = new ArrayList<>();
|
list.add(parentEntity);
|
for (OperatorEntity operatorEntity : list) {
|
FlowJobUtil.deleteByOperatorId(operatorEntity.getId(), redisUtil);
|
}
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
UserEntity userEntity = serviceUtil.getUserInfo(taskEntity.getCreatorUserId());
|
if (null != userEntity) {
|
FlowModel model = JsonUtil.getJsonToBean(flowModel, FlowModel.class);
|
UserInfo userInfo = model.getUserInfo();
|
userInfo.setUserName(userEntity.getRealName());
|
userInfo.setUserAccount(userEntity.getAccount());
|
userInfo.setUserId(userEntity.getId());
|
model.setUserInfo(userInfo);
|
addOperatorList(list, model);
|
}
|
}
|
}
|
|
// 设置可减签的人员名称
|
public List<CandidateUserVo> getReduceUsers(List<OperatorEntity> todoList, Pagination pagination) {
|
List<String> ids = todoList.stream().map(OperatorEntity::getHandleId).collect(Collectors.toList());
|
return getUserModel(ids, pagination);
|
}
|
|
|
// 处理退回数据，当前的经办通过计算比例后进入该方法，无需变更状态
|
public void handleRejectData(FlowModel flowModel) throws WorkFlowException {
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
OperatorEntity operatorEntity = flowModel.getOperatorEntity();
|
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
String currentNodeCode = taskEntity.getCurrentNodeCode();
|
// 待提交（即未发起）重新发起，需要获取当前节点
|
String instanceId = taskEntity.getInstanceId();
|
if (instanceId != null) {
|
List<FlowableTaskModel> taskModelList = flowAbleUrl.getCurrentTask(instanceId);
|
List<String> currentCodes = taskModelList.stream().map(FlowableTaskModel::getTaskKey).collect(Collectors.toList());
|
currentNodeCode = String.join(",", currentCodes);
|
}
|
|
String rejectDataId = taskEntity.getRejectDataId();
|
|
RejectDataEntity rejectData = rejectDataMapper.getInfo(taskEntity.getRejectDataId());
|
if (!ObjectUtil.equals(rejectData.getNodeCode(), operatorEntity.getNodeCode())) {
|
throw new WorkFlowException("当前节点无法操作");
|
}
|
String taskJson = rejectData.getTaskJson();
|
String operatorJson = rejectData.getOperatorJson();
|
String eventJson = rejectData.getEventLogJson();
|
|
List<OperatorEntity> srcOperatorList = JsonUtil.getJsonToList(operatorJson, OperatorEntity.class);
|
// 获取被退回的节点编码，用于表单值传递
|
List<String> nodeCodes = srcOperatorList.stream().sorted(Comparator.comparing(OperatorEntity::getCreatorTime))
|
.map(OperatorEntity::getNodeCode).distinct().collect(Collectors.toList());
|
|
List<EventLogEntity> srcEventList = JsonUtil.getJsonToList(eventJson, EventLogEntity.class);
|
|
TaskEntity srcTask = JsonUtil.getJsonToBean(taskJson, TaskEntity.class);
|
String srcCurrentNodeCode = srcTask.getCurrentNodeCode();
|
// 跳转
|
JumpFo fo = new JumpFo();
|
fo.setInstanceId(instanceId);
|
List<String> sourceList = StringUtil.isNotEmpty(currentNodeCode) ? Arrays.stream(currentNodeCode.split(",")).collect(Collectors.toList()) : new ArrayList<>();
|
List<String> targetList = StringUtil.isNotEmpty(srcCurrentNodeCode) ? Arrays.stream(srcCurrentNodeCode.split(",")).collect(Collectors.toList()) : new ArrayList<>();
|
|
List<String> source = sourceList.stream().filter(e -> !targetList.contains(e)).collect(Collectors.toList());
|
List<String> target = targetList.stream().filter(e -> !sourceList.contains(e)).collect(Collectors.toList());
|
fo.setSource(source);
|
fo.setTarget(target);
|
flowAbleUrl.jump(fo);
|
|
// 跳转后，获取当前的节点信息，更新经办
|
List<FlowableTaskModel> taskModelList = flowAbleUrl.getCurrentTask(instanceId);
|
if (CollectionUtil.isNotEmpty(taskModelList)) {
|
for (OperatorEntity operator : srcOperatorList) {
|
FlowableTaskModel model = taskModelList.stream()
|
.filter(e -> ObjectUtil.equals(e.getTaskKey(), operator.getNodeCode())).findFirst().orElse(null);
|
if (null != model) {
|
operator.setNodeId(model.getTaskId());
|
}
|
operator.setCreatorTime(new Date());
|
}
|
}
|
// 还原经办
|
operatorMapper.updateById(srcOperatorList);
|
|
//还原外部节点
|
eventLogMapper.updateById(srcEventList);
|
|
// 还原任务
|
UpdateWrapper<TaskEntity> updateWrapper = new UpdateWrapper<>();
|
updateWrapper.lambda().eq(TaskEntity::getId, srcTask.getId())
|
.set(TaskEntity::getInstanceId, instanceId)
|
.set(TaskEntity::getCurrentNodeCode, srcTask.getCurrentNodeCode())
|
.set(TaskEntity::getCurrentNodeName, srcTask.getCurrentNodeName())
|
.set(TaskEntity::getStatus, srcTask.getStatus())
|
.set(TaskEntity::getStartTime, srcTask.getStartTime())
|
.set(TaskEntity::getRejectDataId, null);
|
taskMapper.update(updateWrapper);
|
|
// 赋值更新后的任务
|
flowModel.setTaskEntity(srcTask);
|
|
rejectDataMapper.deleteById(rejectDataId);
|
|
// 处理表单值传递
|
for (TemplateNodeEntity nodeEntity : nodeEntityList) {
|
if (nodeCodes.contains(nodeEntity.getNodeCode())) {
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setTaskEntity(taskEntity);
|
flowMethod.setNodeEntity(nodeEntity);
|
flowMethod.setNodeEntityList(nodeEntityList);
|
flowMethod.setFlowModel(flowModel);
|
flowMethod.setIsAssign(true);
|
dataTransfer(flowMethod);
|
}
|
}
|
}
|
|
// 获取任务 节点下的经办
|
public List<OperatorEntity> getByNodeCode(String taskId, String nodeCode) {
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId)
|
.eq(OperatorEntity::getNodeCode, nodeCode)
|
.ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode());
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
if (CollectionUtil.isNotEmpty(list)) {
|
return list;
|
}
|
return new ArrayList<>();
|
}
|
|
// 处理指派
|
public OperatorEntity handleAssign(FlowModel flowModel) throws WorkFlowException {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
NodeModel global = flowModel.getNodes().get(NodeEnum.global.getType());
|
String nodeCode = flowModel.getNodeCode();
|
String assignUserId = flowModel.getHandleIds();
|
NodeModel nodeModel = flowModel.getNodes().get(nodeCode);
|
Integer transferState = ObjectUtil.equals(nodeModel.getType(), NodeEnum.processing.getType()) ?
|
OperatorStateEnum.TransferProcessing.getCode() : OperatorStateEnum.Transfer.getCode();
|
|
Integer state = flowModel.getAutoTransferFlag() ? transferState : OperatorStateEnum.Assigned.getCode();
|
|
List<OperatorEntity> operatorList = this.getByNodeCode(taskEntity.getId(), nodeCode);
|
if (CollectionUtil.isNotEmpty(operatorList)) {
|
// 作废记录
|
recordMapper.invalid(operatorList);
|
// 删除原来的经办
|
operatorMapper.deleteByIds(operatorList);
|
|
OperatorEntity operator = operatorList.get(0);
|
operator.setParentId(FlowNature.ParentId);
|
// 生成指派经办
|
OperatorEntity entity = this.createOperator(operator, state, assignUserId, global);
|
|
operatorMapper.insert(entity);
|
return entity;
|
} else {
|
OperatorEntity entity = new OperatorEntity();
|
entity.setId(RandomUtil.uuId());
|
NodeModel node = flowModel.getNodes().get(nodeCode);
|
entity.setNodeName(node.getNodeName());
|
List<FlowableTaskModel> currentTask = flowAbleUrl.getCurrentTask(taskEntity.getInstanceId());
|
FlowableTaskModel model = currentTask.stream().filter(e -> e.getTaskKey().equals(nodeCode)).findFirst().orElse(null);
|
if (null == model) {
|
throw new WorkFlowException(MsgCode.FA001.get());
|
}
|
entity.setNodeId(model.getTaskId());
|
entity.setNodeCode(nodeCode);
|
entity.setStatus(state);
|
entity.setTaskId(taskEntity.getId());
|
entity.setEngineType(taskEntity.getEngineType());
|
Boolean flowTodo = serviceUtil.getFlowTodo();
|
if (flowTodo) {
|
entity.setSignTime(new Date());
|
entity.setStartHandleTime(new Date());
|
} else {
|
Boolean flowSign = serviceUtil.getFlowSign();
|
if (flowSign) {
|
entity.setSignTime(new Date());
|
} else {
|
if (global != null && !global.getHasSignFor()) {
|
entity.setSignTime(new Date());
|
}
|
}
|
}
|
if (node.getCounterSign().equals(FlowNature.ImproperApprover)) {
|
entity.setHandleAll(assignUserId);
|
}
|
entity.setHandleId(assignUserId);
|
entity.setParentId(FlowNature.ParentId);
|
entity.setCompletion(FlowNature.Normal);
|
operatorMapper.insert(entity);
|
return entity;
|
}
|
}
|
|
public void handleRevoke(FlowModel flowModel, OperatorEntity operator, RevokeEntity revokeEntity) throws Exception {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
Integer handleStatus = flowModel.getHandleStatus();
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(e.getNodeCode(), operator.getNodeCode())).findFirst().orElse(null);
|
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setNodeEntity(nodeEntity);
|
flowMethod.setNodeEntityList(nodeEntityList);
|
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setNodeCode(operator.getNodeCode());
|
flowMsgModel.setWait(false);
|
List<OperatorEntity> operatorList = new ArrayList<>();
|
OperatorEntity entity = new OperatorEntity();
|
entity.setNodeCode(operator.getNodeCode());
|
entity.setHandleId(taskEntity.getCreatorUserId());
|
operatorList.add(entity);
|
flowMsgModel.setOperatorList(operatorList);
|
|
TaskEntity task = taskMapper.selectById(revokeEntity.getTaskId());
|
boolean endFlag = false;
|
if (ObjectUtil.equals(handleStatus, FlowNature.AuditCompletion)) {
|
flowMsgModel.setApprove(true);
|
// 消息
|
msgUtil.message(flowMsgModel);
|
operator.setHandleStatus(FlowNature.AuditCompletion);
|
flowMethod.setType(RecordEnum.audit.getCode());
|
} else {
|
operator.setHandleStatus(FlowNature.RejectCompletion);
|
flowMethod.setType(RecordEnum.reject.getCode());
|
// 结束
|
endFlag = true;
|
}
|
|
// 经办记录
|
flowMethod.setFlowModel(flowModel);
|
flowMethod.setOperatorEntity(operator);
|
recordMapper.createRecord(flowMethod);
|
|
operator.setHandleTime(new Date());
|
operator.setCompletion(FlowNature.Action);
|
operatorMapper.updateById(operator);
|
|
flowMethod.setTaskEntity(taskEntity);
|
List<CirculateEntity> circulateList = circulateList(flowMethod);
|
flowMethod.setCirculateList(circulateList);
|
|
if (endFlag) {
|
flowMethod.setIsRevoke(true);
|
handleEndTask(flowMethod);
|
revokeMapper.deleteRevoke(taskEntity.getId());
|
return;
|
}
|
// 判断撤销经办的比例
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, operator.getTaskId()).eq(OperatorEntity::getNodeCode, operator.getNodeCode())
|
.ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode());
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
|
long count = list.stream().filter(e -> ObjectUtil.equals(e.getHandleStatus(), FlowNature.AuditCompletion)).count();
|
if (count == list.size()) {
|
// 节点记录
|
NodeRecordModel nodeRecordModel = new NodeRecordModel();
|
nodeRecordModel.setTaskId(operator.getTaskId());
|
nodeRecordModel.setNodeId(operator.getNodeId());
|
nodeRecordModel.setNodeCode(operator.getNodeCode());
|
nodeRecordModel.setNodeName(operator.getNodeName());
|
nodeRecordModel.setNodeStatus(NodeStateEnum.pass.getCode());
|
nodeRecordMapper.create(nodeRecordModel);
|
|
// 节点通过
|
CompleteFo fo = new CompleteFo();
|
fo.setTaskId(operator.getNodeId());
|
flowAbleUrl.complete(fo);
|
|
flowMethod.setTaskId(revokeEntity.getTaskId());
|
flowMethod.setTaskEntity(taskEntity);
|
this.handleRevokeOperator(flowMethod);
|
|
// 判断结束，更新源任务的状态
|
if (isFinished(flowModel)) {
|
if (null != task) {
|
endRevoke(task);
|
}
|
}
|
}
|
}
|
|
public OperatorEntity createOperator(OperatorEntity operator, Integer state, String handleId, NodeModel global) {
|
OperatorEntity entity = new OperatorEntity();
|
entity.setId(RandomUtil.uuId());
|
entity.setNodeName(operator.getNodeName());
|
entity.setNodeId(operator.getNodeId());
|
entity.setNodeCode(operator.getNodeCode());
|
entity.setStatus(state);
|
entity.setTaskId(operator.getTaskId());
|
entity.setIsProcessing(operator.getIsProcessing());
|
entity.setEngineType(operator.getEngineType());
|
Boolean flowTodo = serviceUtil.getFlowTodo();
|
if (flowTodo) {
|
entity.setSignTime(new Date());
|
entity.setStartHandleTime(new Date());
|
} else {
|
Boolean flowSign = serviceUtil.getFlowSign();
|
if (flowSign) {
|
entity.setSignTime(new Date());
|
} else {
|
if (global != null && !global.getHasSignFor()) {
|
entity.setSignTime(new Date());
|
}
|
}
|
}
|
entity.setHandleId(handleId);
|
entity.setHandleAll(operator.getHandleAll());
|
entity.setParentId(operator.getParentId());
|
entity.setCompletion(FlowNature.Normal);
|
return entity;
|
}
|
|
// 处理子流程
|
public void handleSubFlow(TemplateNodeEntity nodeEntity, FlowModel flowModel) throws Exception {
|
if (!nodeEntity.getNodeType().equals(NodeEnum.subFlow.getType())) {
|
return;
|
}
|
NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
Map<String, List<String>> errorRuleUserList = flowModel.getErrorRuleUserList();
|
|
String templateId = nodeModel.getFlowId();
|
TemplateEntity template = templateMapper.selectById(templateId);
|
if (null == template) {
|
return;
|
}
|
if (!ObjectUtil.equals(template.getStatus(), TemplateStatueEnum.up.getCode())) {
|
throw new WorkFlowException(MsgCode.WF140.get());
|
}
|
String flowId = template.getFlowId();
|
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(flowId);
|
if (null == jsonEntity) {
|
return;
|
}
|
List<TemplateNodeEntity> subNodeEntityList = templateNodeMapper.getList(jsonEntity.getId());
|
Map<String, NodeModel> subNodes = new HashMap<>();
|
for (TemplateNodeEntity node : subNodeEntityList) {
|
subNodes.put(node.getNodeCode(), JsonUtil.getJsonToBean(node.getNodeJson(), NodeModel.class));
|
}
|
FlowMethod method = new FlowMethod();
|
method.setDeploymentId(jsonEntity.getFlowableId());
|
TemplateNodeEntity subStart = subNodeEntityList.stream()
|
.filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(new TemplateNodeEntity());
|
method.setNodeCode(subStart.getNodeCode());
|
method.setNodes(subNodes);
|
method.setNodeEntityList(subNodeEntityList);
|
|
List<NodeModel> nextApprover = flowUtil.getNextApprover(method);
|
boolean autoSubmit = ObjectUtil.equals(nodeModel.getAutoSubmit(), 1);
|
if (autoSubmit) {
|
if (flowUtil.checkBranch(subStart)) {
|
throw new WorkFlowException(MsgCode.WF121.get());
|
}
|
if (!flowUtil.checkNextCandidates(nextApprover)) {
|
throw new WorkFlowException(MsgCode.WF121.get());
|
}
|
}
|
|
String nodeCode = nodeModel.getNodeId();
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
String deploymentId = flowModel.getDeploymentId();
|
Map<String, NodeModel> nodes = flowModel.getNodes();
|
String flowableTaskId = flowModel.getFlowableTaskId();
|
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setFlowModel(flowModel);
|
flowMethod.setTaskEntity(taskEntity);
|
flowMethod.setNodeEntity(nodeEntity);
|
flowMethod.setNodeEntityList(nodeEntityList);
|
flowMethod.setErrorRule(true);
|
flowMethod.setExtraRule(true);
|
// 获取上一级节点
|
List<String> nodeCodeList = new ArrayList<>();
|
flowUtil.prevNodeList(deploymentId, nodeCode, nodeEntityList, nodeCodeList);
|
nodeCodeList = nodeCodeList.stream().distinct().collect(Collectors.toList());
|
String parentCode;
|
if (nodeCodeList.size() == 1) {
|
parentCode = nodeCodeList.get(0);
|
} else if (nodeCodeList.size() > 1) {
|
// 如果子流程是合流节点 就存最后一个审批的分流节点
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskEntity.getId())
|
.in(OperatorEntity::getNodeCode, nodeCodeList).isNotNull(OperatorEntity::getHandleStatus)
|
.orderByDesc(OperatorEntity::getHandleTime);
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
if (CollectionUtil.isNotEmpty(list)) {
|
parentCode = list.get(0).getNodeCode();
|
} else {
|
parentCode = null;
|
}
|
} else {
|
TemplateNodeEntity startNode = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(e.getNodeType(), NodeEnum.start.getType())).findFirst().orElse(new TemplateNodeEntity());
|
parentCode = startNode.getNodeCode();
|
}
|
TemplateNodeEntity parentNode = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(e.getNodeCode(), parentCode)).findFirst().orElse(new TemplateNodeEntity());
|
String formId = parentNode.getFormId();
|
Map<String, Boolean> resMap = new HashMap<>();
|
Map<String, Map<String, Object>> allData = FlowContextHolder.getAllData();
|
Map<String, Object> formData = allData.get(taskEntity.getId() + JnpfConst.SIDE_MARK + formId);
|
if (nodeModel.getIsAsync().equals(FlowNature.ChildAsync)) {
|
flowMethod.setDeploymentId(deploymentId);
|
flowMethod.setNodeCode(nodeCode);
|
flowMethod.setFormData(formData);
|
flowMethod.setNodes(nodes);
|
flowMethod.setTaskEntity(taskEntity);
|
resMap = conditionUtil.handleCondition(flowMethod);
|
conditionUtil.checkCondition(resMap, nodes);
|
}
|
// 表单数据传递
|
formData = flowUtil.createOrUpdate(flowMethod);
|
flowMethod.setSubFormData(formData);
|
|
List<String> userIds = flowUtil.userListAll(flowMethod);
|
List<UserEntity> userList = serviceUtil.getUserName(userIds, true);
|
if (userList.isEmpty()) {
|
userIds.add(serviceUtil.getAdmin());
|
}
|
|
Integer createRule = nodeModel.getCreateRule();
|
boolean inTurn = ObjectUtil.equals(createRule, 1);
|
int flag = 0;
|
List<FlowModel> subTaskData = new ArrayList<>();
|
|
UserInfo userInfo = flowModel.getUserInfo();
|
|
Map<String, FlowModel> taskMap = new HashMap<>();
|
for (UserEntity user : userList) {
|
flag++;
|
FlowModel model = new FlowModel();
|
model.setSubCode(nodeCode);
|
model.setParentId(taskEntity.getId());
|
model.setDeploymentId(jsonEntity.getFlowableId());
|
|
Map<String, Object> map = new HashMap<>();
|
if (CollectionUtil.isNotEmpty(formData)) {
|
map = new HashMap<>(formData);
|
}
|
map.put(FlowFormConstant.FLOWID, flowId);
|
model.setFormData(map);
|
model.setFlowId(flowId);
|
model.setErrorRuleUserList(errorRuleUserList);
|
|
// 自动提交 0.否
|
if (autoSubmit) {
|
model.setStatus(TaskStatusEnum.RUNNING.getCode());
|
} else {
|
model.setSubFlow(true);
|
}
|
|
SubParameterModel subParameter = new SubParameterModel();
|
subParameter.setParentCode(parentCode);
|
subParameter.setNodeId(flowableTaskId);
|
model.setSubParameter(subParameter);
|
|
UserInfo info = JsonUtil.getJsonToBean(userInfo, UserInfo.class);
|
info.setUserName(user.getRealName());
|
info.setUserAccount(user.getAccount());
|
info.setUserId(user.getId());
|
model.setUserInfo(info);
|
|
model.setIsAsync(nodeModel.getIsAsync());
|
model.setIsFlow(1);
|
|
TaskEntity subTask = new TaskEntity();
|
subTask.setCreatorUserId(user.getId());
|
model.setTaskEntity(subTask);
|
|
// 依次创建，只创建第一个人的，存储后续的人员参数
|
if (inTurn && flag > 1) {
|
subTaskData.add(model);
|
continue;
|
}
|
|
if (nodeModel.getAutoSubmit().equals(1)) {
|
model.setNodeEntityList(subNodeEntityList);
|
if (flowUtil.checkNextError(model, nextApprover, false, false) != 0) {
|
throw new WorkFlowException(MsgCode.WF121.get());
|
}
|
}
|
|
UserProvider.setLocalLoginUser(info);
|
// 生成任务，根据是否自动发起进行提交
|
saveOrSubmit(model);
|
|
// 组装消息发送的人
|
OperatorEntity operator = new OperatorEntity();
|
operator.setHandleId(user.getId());
|
operator.setNodeCode(nodeEntity.getNodeCode());
|
// 子流程任务
|
TaskEntity task = model.getTaskEntity();
|
operator.setTaskId(task.getId());
|
|
List<OperatorEntity> operatorList = new ArrayList<>();
|
operatorList.add(operator);
|
|
// 消息
|
if (ObjectUtil.equals(nodeModel.getAutoSubmit(), 0)) {
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setOperatorList(operatorList);
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setTaskEntity(task);
|
flowMsgModel.setNodeCode(nodeCode);
|
flowMsgModel.setWait(false);
|
flowMsgModel.setLaunch(true);
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
}
|
|
taskMap.put(task.getId(), model);
|
}
|
|
// 保存依次创建的子流程数据
|
subtaskDataMapper.save(subTaskData);
|
|
for (String taskId : taskMap.keySet()) {
|
FlowModel model = taskMap.get(taskId);
|
if (model == null) {
|
continue;
|
}
|
this.autoAudit(model);
|
}
|
|
UserProvider.setLocalLoginUser(userInfo);
|
|
// 异步，直接通过节点，后续继续递归下一级节点生成经办
|
if (nodeModel.getIsAsync().equals(FlowNature.ChildAsync)) {
|
flowMethod.setFlowableTaskId(flowableTaskId);
|
flowMethod.setResMap(resMap);
|
completeNode(flowMethod);
|
}
|
|
//子流程自动审批，更新主流程的当前节点
|
String instanceId = taskEntity.getInstanceId();
|
List<FlowableTaskModel> taskModelList = flowAbleUrl.getCurrentTask(instanceId);
|
if (CollectionUtil.isEmpty(taskModelList)) {
|
return;
|
}
|
updateCurrentNode(taskModelList, nodes, taskEntity);
|
}
|
|
// 完成节点
|
public void completeNode(FlowMethod flowMethod) throws Exception {
|
FlowModel flowModel = flowMethod.getFlowModel();
|
String flowableTaskId = flowMethod.getFlowableTaskId();
|
Map<String, Boolean> resMap = flowMethod.getResMap();
|
TaskEntity taskEntity = flowMethod.getTaskEntity();
|
taskLineMapper.create(taskEntity.getId(), resMap);
|
CompleteFo completeFo = new CompleteFo();
|
completeFo.setTaskId(flowableTaskId);
|
completeFo.setVariables(new HashMap<>(resMap));
|
flowAbleUrl.complete(completeFo);
|
|
this.addTask(ImmutableList.of(taskEntity.getId()));
|
if (isFinished(flowModel)) {
|
return;
|
}
|
|
// 生成经办
|
List<OperatorEntity> operatorEntities = handleOperator(flowModel);
|
|
List<TemplateNodeEntity> nodeEntityList = flowMethod.getNodeEntityList();
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setOperatorList(operatorEntities);
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
|
if (taskEntity.getRejectDataId() == null) {
|
this.autoAudit(flowModel);
|
}
|
}
|
|
public void autoAudit(FlowModel flowModel) throws Exception {
|
flowModel.setAutoAudit(true);
|
this.autoAudit(flowModel, true);
|
}
|
|
public void autoAudit(FlowModel flowModel, Boolean flag) throws Exception {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
if (null == taskEntity) {
|
return;
|
}
|
flowModel.setBranchList(new ArrayList<>());
|
String taskId = taskEntity.getId();
|
List<OperatorEntity> operatorList = operatorMapper.getList(taskId);
|
operatorList = operatorList.stream().filter(e -> !ObjectUtil.equals(e.getStatus(), OperatorStateEnum.Back.getCode())
|
&& !ObjectUtil.equals(e.getCompletion(), FlowNature.Action)).collect(Collectors.toList());
|
this.autoAudit(flowModel, operatorList, flag);
|
}
|
|
@DSTransactional
|
public void autoAudit(FlowModel flowModel, List<OperatorEntity> operatorList, Boolean flag) throws Exception {
|
// flag标识为true时 需要排除未激活的经办
|
if (flag) {
|
operatorList = operatorList.stream()
|
.filter(e -> !ObjectUtil.equals(e.getStatus(), OperatorStateEnum.Waiting.getCode())).collect(Collectors.toList());
|
}
|
if (CollectionUtil.isEmpty(operatorList)) {
|
return;
|
}
|
String deploymentId = flowModel.getDeploymentId();
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
Map<String, NodeModel> nodes = flowModel.getNodes();
|
NodeModel global = nodes.get(NodeEnum.global.getType());
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
TemplateNodeEntity globalEntity = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(NodeEnum.global.getType(), e.getNodeType())).findFirst().orElse(new TemplateNodeEntity());
|
|
flowModel.setSignImg(null);
|
flowModel.setFileList(null);
|
Map<String, List<OperatorEntity>> map = operatorList.stream().collect(Collectors.groupingBy(OperatorEntity::getNodeCode));
|
List<String> handleIds = operatorList.stream().map(OperatorEntity::getHandleId).distinct().collect(Collectors.toList());
|
List<UserEntity> users = serviceUtil.getUserName(handleIds);
|
for (String key : map.keySet()) {
|
NodeModel model = nodes.get(key);
|
String modelFormId = model.getFormId();
|
modelFormId = StringUtil.isNotBlank(modelFormId) ? modelFormId : globalEntity.getFormId();
|
Map<String, Object> formData = serviceUtil.infoData(modelFormId,taskEntity.getId());
|
// 获取流程参数
|
getGlobalParam(taskEntity, model, global, formData);
|
flowModel.setTaskEntity(taskEntity);
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setTaskEntity(taskEntity);
|
flowMethod.setFormData(formData);
|
flowMethod.setDeploymentId(deploymentId);
|
flowMethod.setNodeCode(key);
|
flowMethod.setNodes(nodes);
|
// 判断节点的线的条件
|
Map<String, Boolean> resMap = conditionUtil.handleCondition(flowMethod);
|
try {
|
conditionUtil.checkCondition(resMap, nodes);
|
} catch (WorkFlowException e) {
|
continue;
|
}
|
List<NodeModel> nextApprover;
|
boolean mark = true;
|
try {
|
nextApprover = flowUtil.getNextApprover(flowMethod);
|
} catch (WorkFlowException e) {
|
nextApprover = null;
|
mark = false;
|
}
|
if (!mark) {
|
continue;
|
}
|
List<OperatorEntity> list = map.get(key);
|
if (CollectionUtil.isNotEmpty(list)) {
|
flowModel.setOperatorEntity(list.get(0));
|
}
|
boolean isBranch = flowUtil.checkBranch(model);
|
boolean nextCandidates = flowUtil.checkNextCandidates(nextApprover);
|
int nextError = flowUtil.checkNextError(flowModel, nextApprover, false, false);
|
if (!isBranch && nextCandidates && nextError == 0) {
|
for (OperatorEntity operator : list) {
|
operator = operatorMapper.selectById(operator.getId());
|
if (null == operator || ObjectUtil.equals(operator.getCompletion(), FlowNature.Action)) {
|
continue;
|
}
|
String handleId = operator.getHandleId();
|
String username = "";
|
String userId = "";
|
String userName = "";
|
String userAccount = "";
|
UserEntity user = users.stream().filter(e -> ObjectUtil.equals(e.getId(), handleId)).findFirst().orElse(null);
|
if (user != null) {
|
username = user.getAccount() + "(" + user.getRealName() + ")";
|
userId = user.getId();
|
userName = user.getRealName();
|
userAccount = user.getAccount();
|
}
|
String str = ObjectUtil.equals(operator.getIsProcessing(), FlowNature.NotProcessing) ? "自动审批通过" : "自动办理通过";
|
flowModel.setHandleOpinion(username + str);
|
FlowMethod method = new FlowMethod();
|
method.setOperatorEntity(operator);
|
method.setNodeModel(global);
|
method.setFlowModel(flowModel);
|
if (this.handleGlobalAuto(method)) {
|
if (taskEntity.getEndTime() != null) {
|
return;
|
}
|
UserInfo userInfo = flowModel.getUserInfo();
|
userInfo.setUserId(userId);
|
userInfo.setUserAccount(userAccount);
|
userInfo.setUserName(userName);
|
flowModel.setUserInfo(userInfo);
|
flowModel.setHandleStatus(FlowNature.AuditCompletion);
|
audit(operator, flowModel);
|
if (taskEntity.getRejectDataId() == null) {
|
this.autoAudit(flowModel);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
// 异常补偿
|
public void compensate(TaskEntity taskEntity) throws WorkFlowException {
|
String instanceId = taskEntity.getInstanceId();
|
CompensateFo fo = new CompensateFo();
|
fo.setInstanceId(instanceId);
|
List<String> sourceList = Arrays.stream(taskEntity.getCurrentNodeCode().split(",")).collect(Collectors.toList());
|
fo.setSource(sourceList);
|
List<FlowableTaskModel> models = flowAbleUrl.compensate(fo);
|
|
if (CollectionUtil.isNotEmpty(models)) {
|
FlowableTaskModel flowableTaskModel = models.get(0);
|
// 实例ID不一样，更新
|
String newInstanceId = flowableTaskModel.getInstanceId();
|
if (StringUtil.isNotBlank(newInstanceId) && !instanceId.equals(newInstanceId)) {
|
taskEntity.setInstanceId(newInstanceId);
|
taskMapper.updateById(taskEntity);
|
}
|
List<NodeRecordEntity> nodeRecords = nodeRecordMapper.getNodeRecord(taskEntity.getId());
|
List<String> nodeIds = nodeRecords.stream().map(NodeRecordEntity::getNodeId).filter(StringUtil::isNotBlank).collect(Collectors.toList());
|
// 更新经办关联的flowable的任务id
|
List<OperatorEntity> operatorList = operatorMapper.getList(taskEntity.getId());
|
List<OperatorEntity> updateList = new ArrayList<>();
|
// 更新记录关联的flowable的任务id
|
List<RecordEntity> recordList = recordMapper.getList(taskEntity.getId());
|
List<RecordEntity> updateRecordList = new ArrayList<>();
|
//外部节点
|
List<EventLogEntity> eventLogList = eventLogMapper.getList(taskEntity.getId());
|
List<EventLogEntity> updateEventLogList = new ArrayList<>();
|
|
if (CollectionUtil.isNotEmpty(nodeIds)) {
|
// 在节点记录中的存在的nodeId，不需要更新
|
operatorList = operatorList.stream().filter(e -> !nodeIds.contains(e.getNodeId())).collect(Collectors.toList());
|
recordList = recordList.stream().filter(e -> !nodeIds.contains(e.getNodeId())).collect(Collectors.toList());
|
}
|
|
for (FlowableTaskModel model : models) {
|
List<OperatorEntity> list = operatorList.stream()
|
.filter(e -> e.getNodeCode().equals(model.getTaskKey())).collect(Collectors.toList());
|
list.forEach(e -> e.setNodeId(model.getTaskId()));
|
updateList.addAll(list);
|
// 记录修改
|
List<RecordEntity> collect = recordList.stream()
|
.filter(e -> e.getNodeCode().equals(model.getTaskKey())).collect(Collectors.toList());
|
collect.forEach(e -> e.setNodeId(model.getTaskId()));
|
updateRecordList.addAll(collect);
|
//外部节点
|
List<EventLogEntity> logList = eventLogList.stream()
|
.filter(e -> e.getNodeCode().equals(model.getTaskKey())).collect(Collectors.toList());
|
logList.forEach(e -> e.setNodeId(model.getTaskId()));
|
updateEventLogList.addAll(logList);
|
}
|
operatorMapper.updateById(updateList);
|
recordMapper.updateRecords(updateRecordList);
|
eventLogMapper.updateById(updateEventLogList);
|
}
|
if (!ObjectUtil.equals(taskEntity.getParentId(), FlowNature.ParentId)) {
|
TaskEntity parent = taskMapper.selectById(taskEntity.getParentId());
|
if (null == parent) {
|
return;
|
}
|
this.compensate(parent);
|
List<FlowableTaskModel> currentModel = flowAbleUrl.getCurrentTask(parent.getInstanceId());
|
FlowableTaskModel model = currentModel.stream().filter(e -> ObjectUtil.equals(taskEntity.getSubCode(), e.getTaskKey())).findFirst().orElse(null);
|
if (null != model) {
|
SubParameterModel subParameter = JsonUtil.getJsonToBean(taskEntity.getSubParameter(), SubParameterModel.class);
|
subParameter.setNodeId(model.getTaskId());
|
taskEntity.setSubParameter(JsonUtil.getObjectToString(subParameter));
|
taskMapper.updateById(taskEntity);
|
}
|
}
|
}
|
|
|
/**
|
* 校验经办的任务是否暂停
|
*
|
* @param ids 经办主键集合
|
* @param resList 结果经办主键集合
|
* @param flag true则判断退签
|
*/
|
public void checkBatch(List<String> ids, List<String> resList, Boolean flag) throws WorkFlowException {
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().in(OperatorEntity::getId, ids);
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
List<String> taskIds = list.stream().map(OperatorEntity::getTaskId).collect(Collectors.toList());
|
List<TaskEntity> taskEntityList = taskIds.isEmpty() ? new ArrayList<>() : taskMapper.selectByIds(taskIds);
|
|
for (OperatorEntity operator : list) {
|
TaskEntity taskEntity = taskEntityList.stream()
|
.filter(e -> !Objects.equals(e.getStatus(), TaskStatusEnum.PAUSED.getCode())
|
&& e.getId().equals(operator.getTaskId())).findFirst().orElse(null);
|
if (null != taskEntity) {
|
resList.add(operator.getId());
|
}
|
}
|
if (CollectionUtil.isEmpty(resList)) {
|
throw new WorkFlowException(MsgCode.WF112.get());
|
}
|
|
if (flag) {
|
resList.clear();
|
List<String> flowIds = taskEntityList.stream().map(TaskEntity::getFlowId).collect(Collectors.toList());
|
List<TemplateNodeEntity> globalList = templateNodeMapper.getList(flowIds, NodeEnum.global.getType());
|
for (OperatorEntity operator : list) {
|
TaskEntity taskEntity = taskEntityList.stream()
|
.filter(e -> e.getId().equals(operator.getTaskId())).findFirst().orElse(null);
|
if (null != taskEntity) {
|
TemplateNodeEntity globalEntity = globalList.stream()
|
.filter(e -> e.getFlowId().equals(taskEntity.getFlowId())).findFirst().orElse(null);
|
if (null != globalEntity) {
|
NodeModel global = JsonUtil.getJsonToBean(globalEntity.getNodeJson(), NodeModel.class);
|
// 开启签收，允许退签
|
if (global.getHasSignFor()) {
|
resList.add(operator.getId());
|
}
|
}
|
}
|
}
|
if (CollectionUtil.isEmpty(resList)) {
|
throw new WorkFlowException(MsgCode.WF080.get());
|
}
|
}
|
}
|
|
public void checkBatchRevoke(List<String> ids, List<String> resList, Integer batchType) throws WorkFlowException {
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().in(OperatorEntity::getId, ids);
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
List<Integer> status = ImmutableList.of(2, 3);
|
for (OperatorEntity operator : list) {
|
if (status.contains(batchType) && ObjectUtil.equals(operator.getStatus(), OperatorStateEnum.Revoke.getCode())) {
|
continue;
|
}
|
resList.add(operator.getId());
|
}
|
if (CollectionUtil.isEmpty(resList)) {
|
if (ObjectUtil.equals(batchType, 2)) {
|
throw new WorkFlowException(MsgCode.WF126.get());
|
} else if (ObjectUtil.equals(batchType, 3)) {
|
throw new WorkFlowException(MsgCode.WF127.get());
|
}
|
}
|
}
|
|
// 判断终止
|
public void checkCancel(List<String> ids, List<String> resList) throws WorkFlowException {
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().in(OperatorEntity::getId, ids);
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
List<String> taskIds = list.stream().map(OperatorEntity::getTaskId).collect(Collectors.toList());
|
List<TaskEntity> taskEntityList = taskIds.isEmpty() ? new ArrayList<>() : taskMapper.selectByIds(taskIds);
|
|
for (OperatorEntity operator : list) {
|
TaskEntity taskEntity = taskEntityList.stream()
|
.filter(e -> !Objects.equals(e.getStatus(), TaskStatusEnum.CANCEL.getCode())
|
&& e.getId().equals(operator.getTaskId())).findFirst().orElse(null);
|
if (null != taskEntity) {
|
resList.add(operator.getId());
|
}
|
}
|
if (CollectionUtil.isEmpty(resList)) {
|
throw new WorkFlowException(MsgCode.WF123.get());
|
}
|
}
|
|
// 更新经办的接收时间
|
public void updateCreateTime(FlowModel flowModel) {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
String taskId = taskEntity.getId();
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId)
|
.isNull(OperatorEntity::getHandleStatus);
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
if (CollectionUtil.isNotEmpty(list)) {
|
list.forEach(e -> e.setCreatorTime(new Date()));
|
operatorMapper.updateById(list);
|
addOperatorList(list, flowModel);
|
}
|
}
|
|
/**
|
* 添加事件到线程变量
|
*/
|
public void addEvent(FlowModel flowModel) {
|
Integer status = flowModel.getEventStatus();
|
FlowModel model = new FlowModel();
|
model.setTaskEntity(flowModel.getTaskEntity());
|
model.setNodeEntity(flowModel.getNodeEntity());
|
model.setNodes(flowModel.getNodes());
|
model.setFormData(flowModel.getFormData());
|
if (ObjectUtil.equals(EventEnum.End.getStatus(), status)) {
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
TemplateNodeEntity start = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.start.getType())).findFirst().orElse(null);
|
if (null != start) {
|
model.setNodeEntity(start);
|
}
|
}
|
FlowEventHolder.addEvent(status, model, FlowContextHolder.getAllData());
|
}
|
|
|
/**
|
* 处理线程变量中的超时
|
*/
|
public void handleOperator() {
|
List<FlowOperatorModel> operatorListAll = FlowOperatorHolder.getOperatorList();
|
for (FlowOperatorModel model : operatorListAll) {
|
List<OperatorEntity> list = model.getList() != null ? model.getList() : new ArrayList<>();
|
Map<String, Map<String, Object>> allData = model.getAllData();
|
Map<String, List<OperatorEntity>> taskMap = list.stream().collect(Collectors.groupingBy(OperatorEntity::getTaskId));
|
for (String taskId : taskMap.keySet()) {
|
List<OperatorEntity> operatorList = taskMap.get(taskId) != null ? taskMap.get(taskId) : new ArrayList<>();
|
Map<String, List<OperatorEntity>> operatorMap = operatorList.stream().collect(Collectors.groupingBy(OperatorEntity::getNodeCode));
|
for (String nodeCode : operatorMap.keySet()) {
|
List<OperatorEntity> operator = operatorMap.get(nodeCode) != null ? operatorMap.get(nodeCode) : new ArrayList<>();
|
if (operator.isEmpty()) {
|
continue;
|
}
|
FlowModel flowModel = JsonUtil.getJsonToBean(model.getFlowModel(), FlowModel.class);
|
Map<String, NodeModel> nodes = flowModel.getNodes();
|
NodeModel global = nodes.get(NodeEnum.global.getType());
|
NodeModel nodeModel = nodes.get(nodeCode);
|
String modelFormId = nodeModel.getFormId();
|
modelFormId = StringUtil.isNotBlank(modelFormId) ? modelFormId : global.getFormId();
|
Map<String, Object> formData = allData.get(taskId + JnpfConst.SIDE_MARK + modelFormId);
|
if (formData != null) {
|
flowModel.setFormData(formData);
|
}
|
TimeUtil.timeModel(operator, flowModel, redisUtil);
|
}
|
}
|
}
|
FlowOperatorHolder.clear();
|
}
|
|
/**
|
* 添加超时到线程变量
|
*/
|
public void addOperatorList(List<OperatorEntity> list, FlowModel flowModel) {
|
if (!list.isEmpty()) {
|
FlowOperatorModel model = new FlowOperatorModel();
|
model.setList(JsonUtil.getJsonToList(list, OperatorEntity.class));
|
model.setFlowModel(JsonUtil.getJsonToBean(flowModel, FlowModel.class));
|
FlowOperatorHolder.addOperator(model, FlowContextHolder.getAllData());
|
}
|
}
|
|
//保存流程id
|
public void addTask(List<String> taskIdList) {
|
FlowStatusHolder.addTaskIdList(taskIdList);
|
}
|
|
//删除流程id
|
public void addDelTask(String taskId, String flowId) {
|
FlowStatusHolder.addDelTaskIdList(taskId, flowId);
|
}
|
|
public List<OperatorEntity> getList(String taskId, List<String> nodeCodes) {
|
if (StringUtil.isEmpty(taskId)) {
|
return new ArrayList<>();
|
}
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId).ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode());
|
if (CollectionUtil.isNotEmpty(nodeCodes)) {
|
queryWrapper.lambda().in(OperatorEntity::getNodeCode, nodeCodes);
|
}
|
queryWrapper.lambda().orderByDesc(OperatorEntity::getCreatorTime);
|
return operatorMapper.selectList(queryWrapper);
|
}
|
|
public void deleteInTurnOperator(OperatorEntity operator, String handleId) {
|
List<String> handleAll = new ArrayList<>();
|
if (operator.getHandleAll() != null) {
|
handleAll = Arrays.stream(operator.getHandleAll().split(",")).collect(Collectors.toList());
|
} else {
|
String handleParameter = operator.getHandleParameter();
|
AddSignModel addSignModel = JsonUtil.getJsonToBean(handleParameter, AddSignModel.class);
|
if (ObjectUtil.equals(addSignModel.getCounterSign(), FlowNature.ImproperApprover)) {
|
handleAll = addSignModel.getAddSignUserIdList();
|
}
|
}
|
int index = handleAll.indexOf(handleId);
|
if (index != -1 && index < handleAll.size() - 1) {
|
String nextHandleId = handleAll.get(index + 1);
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getNodeId, operator.getNodeId())
|
.eq(OperatorEntity::getHandleId, nextHandleId);
|
List<OperatorEntity> deleteList = operatorMapper.selectList(queryWrapper);
|
if (CollectionUtil.isNotEmpty(deleteList)) {
|
operatorMapper.deleteByIds(deleteList);
|
}
|
}
|
}
|
public void deleteStepOperator(OperatorEntity operator) {
|
if (operator != null) {
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, operator.getTaskId());
|
List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
|
List<OperatorEntity> deleteList = list.stream().filter(e -> Objects.equals(e.getHandleAll(), operator.getId())).collect(Collectors.toList());
|
if (CollectionUtil.isNotEmpty(deleteList)) {
|
operatorMapper.deleteByIds(deleteList);
|
}
|
}
|
}
|
|
// 处理嵌入的任务流程
|
public void handleTrigger(OperatorEntity operatorEntity, FlowModel flowModel) throws WorkFlowException {
|
String nodeCode = operatorEntity.getNodeCode();
|
Map<String, NodeModel> nodes = flowModel.getNodes();
|
List<String> nextList = new ArrayList<>();
|
nextList = getNextList(flowModel.getDeploymentId(), nodeCode, nodes, nextList);
|
if (CollectionUtil.isEmpty(nextList)) {
|
return;
|
}
|
|
Integer action = flowModel.getAction();
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
String flowId = taskEntity.getFlowId();
|
Map<String, Object> formData = flowModel.getFormData();
|
List<SystemAuditModel> systemList = SystemAuditHolder.getAll();
|
|
// 存在同步
|
boolean isAsync = false;
|
|
List<String> approveNode = new ArrayList<>();
|
Map<String, NodeModel> triggers = new HashMap<>();
|
for (String next : nextList) {
|
NodeModel nodeModel = nodes.get(next);
|
if (null != nodeModel) {
|
if (ObjectUtil.equals(nodeModel.getType(), NodeEnum.trigger.getType())) {
|
if (ObjectUtil.equals(nodeModel.getIsAsync(), FlowNature.ChildSync)) {
|
isAsync = true;
|
}
|
triggers.put(next, nodeModel);
|
} else if (ObjectUtil.equals(nodeModel.getType(), NodeEnum.approver.getType())) {
|
approveNode.add(nodeModel.getNodeId());
|
}
|
}
|
}
|
|
if (CollectionUtil.isEmpty(triggers)) {
|
return;
|
}
|
|
Boolean rejectTrigger = flowModel.getRejectTrigger();
|
if (ObjectUtil.equals(action, 3) || rejectTrigger) {
|
OutgoingFlowsFo flowsFo = new OutgoingFlowsFo();
|
flowsFo.setDeploymentId(flowModel.getDeploymentId());
|
flowsFo.setTaskKey(nodeCode);
|
List<String> outgoingFlows = flowAbleUrl.getOutgoingFlows(flowsFo);
|
Map<String, Object> variables = new HashMap<>();
|
for (String line : outgoingFlows) {
|
variables.put(line, true);
|
}
|
if (ObjectUtil.equals(action, 3)) {
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
TemplateNodeEntity end = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.end.getType())).findFirst().orElse(null);
|
if (null != end) {
|
// 将目标是结束节点的线 的值变更为false
|
FlowableNodeModel info = flowAbleUrl.getElementInfo(flowModel.getDeploymentId(), end.getNodeCode());
|
List<String> incomingList = info.getIncomingList();
|
if (CollectionUtil.isNotEmpty(incomingList)) {
|
for (String key : variables.keySet()) {
|
if (incomingList.contains(key)) {
|
variables.put(key, false);
|
}
|
}
|
}
|
}
|
}
|
CompleteFo fo = new CompleteFo();
|
fo.setTaskId(operatorEntity.getNodeId());
|
fo.setVariables(variables);
|
flowAbleUrl.complete(fo);
|
} else {
|
// 异步处理
|
if (!isAsync) {
|
// 获取线程存储的需要系统通过的经办
|
if (CollectionUtil.isNotEmpty(systemList)) {
|
for (SystemAuditModel model : systemList) {
|
try {
|
this.autoAudit(model.getOperator(), model.getFlowModel());
|
} catch (Exception e) {
|
}
|
}
|
systemList = new ArrayList<>();
|
}
|
}
|
}
|
|
UserInfo userInfo = UserProvider.getUser();
|
List<ExecuteAsyncModel> list = new ArrayList<>();
|
for (String key : triggers.keySet()) {
|
NodeModel nodeModel = nodes.get(key);
|
if (null == nodeModel) {
|
continue;
|
}
|
if (ObjectUtil.equals(nodeModel.getTriggerEvent(), 2)) {
|
if (!nodeModel.getActionList().contains(action)) {
|
continue;
|
}
|
}
|
List<OperatorEntity> operatorList = new ArrayList<>();
|
List<TaskEntity> subTaskList = new ArrayList<>();
|
Boolean sync = ObjectUtil.equals(nodeModel.getIsAsync(), FlowNature.ChildSync);
|
if (sync) {
|
if (CollectionUtil.isNotEmpty(approveNode)) {
|
operatorList = this.getList(taskEntity.getId(), approveNode);
|
if (CollectionUtil.isNotEmpty(operatorList)) {
|
for (OperatorEntity operator : operatorList) {
|
operator.setStatus(OperatorStateEnum.Waiting.getCode());
|
}
|
operatorMapper.updateById(operatorList);
|
}
|
// 子流程的处理
|
subTaskList = taskMapper.getSubTask(taskEntity.getId(), approveNode);
|
if (CollectionUtil.isNotEmpty(subTaskList)) {
|
for (TaskEntity subTask : subTaskList) {
|
Integer status = subTask.getStatus();
|
subTask.setHisStatus(status);
|
subTask.setStatus(-2);
|
}
|
taskMapper.updateById(subTaskList);
|
}
|
}
|
}
|
List<Map<String, Object>> dataList = new ArrayList<>();
|
dataList.add(formData);
|
ExecuteModel model = new ExecuteModel();
|
model.setFlowId(flowId);
|
model.setDataList(dataList);
|
model.setUserInfo(userInfo);
|
model.setParentId(FlowNature.ParentId);
|
model.setTaskId(taskEntity.getId());
|
model.setInstanceId(taskEntity.getInstanceId());
|
model.setGroupId(nodeModel.getGroupId());
|
model.setNodeCode(nodeCode);
|
model.setNodeId(operatorEntity.getNodeId());
|
model.setTriggerKey(key);
|
model.setIsAsync(nodeModel.getIsAsync());
|
if (ObjectUtil.equals(action, 3) || rejectTrigger) {
|
try {
|
execute(model);
|
} catch (Exception e) {
|
e.printStackTrace();
|
// TriggerRecordHolder.clear();
|
if (sync) {
|
cancel(taskEntity.getId(), flowModel, true);
|
}
|
}
|
flowModel.setBackId(model.getCurrentNodeId());
|
} else {
|
//flowAsyncUtil.execute(model, sync, operatorList, subTaskList, systemList, flowModel);
|
ExecuteAsyncModel asyncModel = new ExecuteAsyncModel();
|
asyncModel.setModel(model);
|
asyncModel.setSync(sync);
|
asyncModel.setOperatorList(operatorList);
|
asyncModel.setSubTaskList(subTaskList);
|
asyncModel.setSystemList(systemList);
|
asyncModel.setFlowModel(flowModel);
|
list.add(asyncModel);
|
}
|
}
|
try {
|
execute(list);
|
} catch (Exception e) {
|
e.printStackTrace();
|
// TriggerRecordHolder.clear();
|
}
|
SystemAuditHolder.clear();
|
}
|
|
public void execute(List<ExecuteAsyncModel> list) throws Exception {
|
for (ExecuteAsyncModel asyncModel : list) {
|
FlowModel flowModel = asyncModel.getFlowModel();
|
ExecuteModel model = asyncModel.getModel();
|
Boolean sync = asyncModel.getSync();
|
List<OperatorEntity> operatorList = asyncModel.getOperatorList();
|
List<SystemAuditModel> systemList = asyncModel.getSystemList();
|
List<TaskEntity> subTaskList = asyncModel.getSubTaskList();
|
this.execute(model, sync, operatorList, subTaskList, systemList, flowModel);
|
}
|
}
|
|
public void execute(ExecuteModel model, Boolean isAsync, List<OperatorEntity> operatorList, List<TaskEntity> subTaskList, List<SystemAuditModel> systemList, FlowModel flowModel) throws Exception {
|
try {
|
execute(model);
|
} catch (Exception e) {
|
e.printStackTrace();
|
// 终止流程
|
if (isAsync) {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
cancel(taskEntity.getId(), flowModel, true);
|
}
|
return;
|
}
|
// try {
|
// System.out.println("==================================================1");
|
// Thread.sleep(20000);
|
// System.out.println("==================================================2");
|
// } catch (InterruptedException e) {
|
// e.printStackTrace();
|
// }
|
if (isAsync) {
|
if (CollectionUtil.isNotEmpty(operatorList)) {
|
for (OperatorEntity operator : operatorList) {
|
operator.setStatus(OperatorStateEnum.Runing.getCode());
|
}
|
operatorMapper.updateById(operatorList);
|
}
|
if (CollectionUtil.isNotEmpty(subTaskList)) {
|
for (TaskEntity taskEntity : subTaskList) {
|
Integer hisStatus = taskEntity.getHisStatus();
|
taskEntity.setStatus(hisStatus);
|
}
|
taskMapper.updateById(subTaskList);
|
}
|
if (CollectionUtil.isNotEmpty(systemList)) {
|
for (SystemAuditModel systemAuditModel : systemList) {
|
try {
|
autoAudit(systemAuditModel.getOperator(), systemAuditModel.getFlowModel());
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
try {
|
autoAudit(flowModel, false);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
//更改状态
|
public void handleTaskStatus() {
|
Map<String, String> delTaskMap = FlowStatusHolder.getDelTaskMap();
|
for (String taskId : delTaskMap.keySet()) {
|
String flowId = delTaskMap.get(taskId);
|
if (StringUtil.isEmpty(flowId)) {
|
continue;
|
}
|
List<String> flowIdList = ImmutableList.of(flowId);
|
List<TemplateNodeEntity> list = templateNodeMapper.getList(flowIdList, null);
|
Set<String> formIds = list.stream().map(TemplateNodeEntity::getFormId).collect(Collectors.toSet());
|
FlowStateModel model = new FlowStateModel(new ArrayList<>(formIds), taskId, 0);
|
serviceUtil.saveState(model);
|
}
|
|
List<String> taskIdList = FlowStatusHolder.getTaskList();
|
if (!taskIdList.isEmpty()) {
|
List<TaskEntity> taskList = taskMapper.getInfosSubmit(taskIdList.toArray(new String[0]), TaskEntity::getId, TaskEntity::getStatus, TaskEntity::getFlowId);
|
List<String> flowIdList = taskList.stream().map(TaskEntity::getFlowId).collect(Collectors.toList());
|
List<TemplateNodeEntity> list = templateNodeMapper.getList(flowIdList, null);
|
for (TaskEntity task : taskList) {
|
String id = task.getId();
|
String flowId = task.getFlowId();
|
Integer status = task.getStatus();
|
Set<String> formIds = list.stream().filter(e -> e.getFlowId().equals(flowId)).map(TemplateNodeEntity::getFormId).collect(Collectors.toSet());
|
FlowStateModel model = new FlowStateModel(new ArrayList<>(formIds), id, status);
|
serviceUtil.saveState(model);
|
}
|
}
|
FlowStatusHolder.clear();
|
}
|
|
/**
|
* 处理线程变量中的事件
|
*/
|
public void handleEvent() throws WorkFlowException {
|
List<EventModel> allEvent = FlowEventHolder.getAllEvent();
|
for (EventModel eventModel : allEvent) {
|
String type = eventModel.getType();
|
if (Objects.equals(NodeEnum.approver.getType(), type)) {
|
flowUtil.event(eventModel.getFlowModel(), eventModel.getStatus(), eventModel.getAllData());
|
} else if (Objects.equals(NodeEnum.outside.getType(), type)) {
|
String interId = eventModel.getInterfaceId();
|
Map<String, String> parameterMap = eventModel.getParameterData();
|
String id = eventModel.getId();
|
ActionResult result = serviceUtil.infoToId(interId, parameterMap);
|
EventLogEntity eventLog = eventLogMapper.selectById(id);
|
if (eventLog != null) {
|
eventLog.setResult(JsonUtil.getObjectToString(result));
|
boolean retryResult = Objects.equals(200, result.getCode());
|
eventLog.setStatus(retryResult ? FlowNature.Success : FlowNature.Lose);
|
eventLogMapper.updateById(eventLog);
|
}
|
}
|
}
|
FlowEventHolder.clear();
|
}
|
|
/**
|
* 外部节点参数
|
*/
|
public Map<String, String> outsideData(FlowModel flowModel, List<TemplateJsonModel> templateJsonModelList, Map<String, Map<String, Object>> allData, String resultNodeCode, String eventId) throws WorkFlowException {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
TemplateNodeEntity startNode = nodeEntityList.stream()
|
.filter(e -> Objects.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(new TemplateNodeEntity());
|
String startNodeFormId = startNode.getFormId();
|
String taskId = taskEntity.getId();
|
Map<String, Object> formData = flowModel.getFormData();
|
formData.put(FlowConstant.StartNodeFormId, startNodeFormId);
|
TemplateNodeEntity prevNode = nodeEntityList.stream()
|
.filter(e -> Objects.equals(resultNodeCode, e.getNodeCode())).findFirst().orElse(new TemplateNodeEntity());
|
formData.put(FlowConstant.PREV_NODE_FORM_ID, prevNode.getFormId());
|
String nodeCode = flowModel.getNodeCode();
|
RecordEntity record = new RecordEntity();
|
record.setNodeCode(nodeCode);
|
record.setNodeId(eventId);
|
Map<String, Object> parameterData = new HashMap<>();
|
for (TemplateJsonModel templateJsonModel : templateJsonModelList) {
|
if (Objects.equals(FieldEnum.Field.getCode(), templateJsonModel.getSourceType())) {
|
String relationField = templateJsonModel.getRelationField();
|
String[] split = relationField.split("\\|");
|
String[] childTable = relationField.split("-");
|
if (split.length > 1) {
|
String formId = split[split.length - 1];
|
String field = split[0];
|
Map<String, Object> dataMap = allData.get(taskId + JnpfConst.SIDE_MARK + formId) != null ? allData.get(taskId + JnpfConst.SIDE_MARK + formId) : serviceUtil.infoData(formId, taskId);
|
parameterData.put(relationField, dataMap.get(field));
|
} else {
|
String field = split[split.length - 1];
|
parameterData.put(relationField, formData.get(field));
|
}
|
}
|
}
|
Map<String, Object> dataMap = new HashMap<>(formData);
|
dataMap.putAll(parameterData);
|
FlowModel parameterModel = new FlowModel();
|
parameterModel.setFormData(dataMap);
|
parameterModel.setRecordEntity(record);
|
parameterModel.setTaskEntity(taskEntity);
|
Map<String, String> data = flowUtil.parameterMap(parameterModel, templateJsonModelList);
|
return data;
|
}
|
|
//-------------------------------taskUtil------------------------------------------------------------
|
|
public void cancel(String id, FlowModel flowModel, boolean isCancel) throws WorkFlowException {
|
if (isCancel) {
|
// 任务流程的终止
|
TriggerTaskEntity triggerTask = triggerTaskMapper.selectById(id);
|
if (null != triggerTask) {
|
triggerTask.setStatus(TaskStatusEnum.CANCEL.getCode());
|
triggerTaskMapper.updateById(triggerTask);
|
return;
|
}
|
}
|
flowUtil.setFlowModel(id, flowModel);
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
isSuspend(taskEntity);
|
|
// 下架的判断
|
if (!isCancel) {
|
TemplateEntity template = templateMapper.selectById(taskEntity.getTemplateId());
|
if (null != template) {
|
if (!ObjectUtil.equals(template.getStatus(), TemplateStatueEnum.up.getCode())) {
|
throw new WorkFlowException(MsgCode.WF140.get());
|
}
|
}
|
}
|
|
List<String> idList = ImmutableList.of(id);
|
|
List<TaskEntity> taskList = new ArrayList<>();
|
// 递归获取子流程
|
for (String taskId : idList) {
|
List<String> childAllList = taskMapper.getChildAllList(taskId);
|
taskList.addAll(taskMapper.getOrderStaList(childAllList));
|
}
|
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
|
for (TaskEntity entity : taskList) {
|
isSuspend(entity);
|
// 记录
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setFlowModel(flowModel);
|
Integer type = isCancel ? RecordEnum.cancel.getCode() : RecordEnum.activate.getCode();
|
flowMethod.setType(type);
|
OperatorEntity operatorEntity = new OperatorEntity();
|
String code = StringUtil.isNotEmpty(entity.getCurrentNodeCode()) ? entity.getCurrentNodeCode() : FlowNature.START_CODE;
|
operatorEntity.setNodeCode(code);
|
String name = StringUtil.isNotEmpty(entity.getCurrentNodeName()) ? entity.getCurrentNodeName() : FlowNature.START_NAME;
|
operatorEntity.setNodeName(name);
|
operatorEntity.setTaskId(entity.getId());
|
operatorEntity.setHandleId(UserProvider.getLoginUserId());
|
flowMethod.setOperatorEntity(operatorEntity);
|
recordMapper.createRecord(flowMethod);
|
|
if (isCancel) {
|
// 终止，更新实例
|
entity.setHisStatus(entity.getStatus());
|
entity.setStatus(TaskStatusEnum.CANCEL.getCode());
|
taskMapper.updateById(entity);
|
|
// 消息
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setTaskEntity(entity);
|
flowMsgModel.setEnd(true);
|
msgUtil.message(flowMsgModel);
|
} else {
|
// 复活
|
entity.setStatus(entity.getHisStatus());
|
taskMapper.updateById(entity);
|
updateCreateTime(flowModel);
|
}
|
addTask(ImmutableList.of(entity.getId()));
|
}
|
}
|
|
|
|
// 提交撤销流程
|
public void submitOfRevoke(FlowModel flowModel) throws Exception {
|
TaskEntity task = flowModel.getTaskEntity();
|
List<TaskLineEntity> lineList = taskLineMapper.getList(task.getId());
|
if (CollectionUtil.isEmpty(lineList)) {
|
throw new WorkFlowException("无法撤销");
|
}
|
// 委托人的处理
|
UserInfo userInfo = flowModel.getUserInfo();
|
String creatorUserId = task.getCreatorUserId();
|
String delegateUserId = task.getDelegateUserId();
|
boolean isDelegate = !ObjectUtil.equals(userInfo.getUserId(), creatorUserId);
|
if (isDelegate) {
|
if (StringUtil.isNotEmpty(delegateUserId)) {
|
String token = AuthUtil.loginTempUser(task.getCreatorUserId(), UserProvider.getUser().getTenantId());
|
userInfo = UserProvider.getUser(token);
|
flowModel.setUserInfo(userInfo);
|
}
|
}
|
|
Map<String, Object> variables = new HashMap<>();
|
for (TaskLineEntity condition : lineList) {
|
variables.put(condition.getLineKey(), Boolean.valueOf(condition.getLineValue()));
|
}
|
|
TaskEntity entity = new TaskEntity();
|
entity.setId(RandomUtil.uuId());
|
entity.setType(1);
|
entity.setUrgent(task.getUrgent());
|
entity.setCreatorUserId(task.getCreatorUserId());
|
entity.setStartTime(new Date());
|
entity.setCreatorTime(new Date());
|
entity.setFullName(task.getFullName() + "的撤销申请");
|
entity.setFlowCategory(task.getFlowCategory());
|
entity.setFlowCode(task.getFlowCode());
|
entity.setFlowName(task.getFlowName());
|
entity.setFlowVersion(task.getFlowVersion());
|
entity.setFlowId(task.getFlowId());
|
entity.setTemplateId(task.getTemplateId());
|
entity.setParentId(task.getParentId());
|
entity.setFlowType(task.getFlowType());
|
entity.setStatus(TaskStatusEnum.RUNNING.getCode());
|
entity.setEngineType(task.getEngineType());
|
if (isDelegate) {
|
entity.setDelegateUserId(delegateUserId);
|
}
|
|
TemplateJsonEntity jsonEntity = templateJsonMapper.getInfo(task.getFlowId());
|
String instanceId = flowAbleUrl.startInstance(jsonEntity.getFlowableId(), variables);
|
entity.setInstanceId(instanceId);
|
|
if (taskMapper.insert(entity) > 0) {
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(new TemplateNodeEntity());
|
NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
// 记录
|
FlowMethod method = new FlowMethod();
|
method.setFlowModel(flowModel);
|
method.setType(RecordEnum.submit.getCode());
|
OperatorEntity operatorEntity = new OperatorEntity();
|
operatorEntity.setNodeCode(nodeEntity.getNodeCode());
|
operatorEntity.setNodeName(nodeModel.getNodeName());
|
operatorEntity.setTaskId(entity.getId());
|
operatorEntity.setHandleId(entity.getCreatorUserId());
|
if (StringUtil.isNotBlank(flowModel.getUserId())) {
|
method.setHandId(flowModel.getUserId());
|
}
|
operatorEntity.setHandleTime(entity.getStartTime());
|
method.setOperatorEntity(operatorEntity);
|
recordMapper.createRecord(method);
|
// 节点记录
|
NodeRecordModel nodeRecordModel = new NodeRecordModel();
|
nodeRecordModel.setTaskId(entity.getId());
|
nodeRecordModel.setNodeCode(nodeEntity.getNodeCode());
|
nodeRecordModel.setNodeName(nodeModel.getNodeName());
|
nodeRecordModel.setNodeStatus(NodeStateEnum.submit.getCode());
|
nodeRecordMapper.create(nodeRecordModel);
|
// 保存到撤销表
|
RevokeEntity revokeEntity = new RevokeEntity();
|
revokeEntity.setId(RandomUtil.uuId());
|
revokeEntity.setTaskId(task.getId());
|
revokeEntity.setRevokeTaskId(entity.getId());
|
|
RevokeFormDataModel model = new RevokeFormDataModel();
|
String billNumber = serviceUtil.getBillNumber();
|
model.setBillRule(billNumber);
|
model.setHandleOpinion(flowModel.getHandleOpinion());
|
Date date = new Date();
|
model.setCreatorTime(date.getTime());
|
model.setRevokeTaskId(task.getId());
|
model.setRevokeTaskName(task.getFullName());
|
String str = JsonUtil.getObjectToString(model);
|
revokeEntity.setFormData(str);
|
revokeMapper.insert(revokeEntity);
|
// 处理撤销经办
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setFlowModel(flowModel);
|
flowMethod.setTaskId(task.getId());
|
flowMethod.setTaskEntity(entity);
|
handleRevokeOperator(flowMethod);
|
// 自动审批
|
FlowModel revokeModel = JsonUtil.getJsonToBean(flowModel, FlowModel.class);
|
revokeModel.setTaskEntity(entity);
|
autoAudit(revokeModel);
|
// 判断结束
|
flowModel.setTaskEntity(entity);
|
if (this.isFinished(flowModel)) {
|
this.endRevoke(task);
|
}
|
}
|
}
|
|
public void endRevoke(TaskEntity task) {
|
QueryWrapper<TaskEntity> wrapper = new QueryWrapper<>();
|
wrapper.lambda().in(TaskEntity::getParentId, task.getId());
|
List<TaskEntity> subTaskList = taskMapper.selectList(wrapper);
|
// 变更子流程任务状态
|
if (CollectionUtil.isNotEmpty(subTaskList)) {
|
for (TaskEntity subTask : subTaskList) {
|
subTask.setStatus(TaskStatusEnum.REVOKED.getCode());
|
}
|
taskMapper.updateById(subTaskList);
|
}
|
task.setStatus(TaskStatusEnum.REVOKED.getCode());
|
taskMapper.updateById(task);
|
}
|
|
|
// 更新当前节点
|
public void updateCurrentNode(List<FlowableTaskModel> taskModelList, Map<String, NodeModel> nodes, TaskEntity taskEntity) {
|
List<String> currentNodeList = new ArrayList<>();
|
List<String> currentNodeNameList = new ArrayList<>();
|
|
List<String> nodeTypes = ImmutableList.of(NodeEnum.approver.getType(), NodeEnum.subFlow.getType(), NodeEnum.processing.getType(), NodeEnum.outside.getType());
|
for (FlowableTaskModel model : taskModelList) {
|
NodeModel nodeModel = nodes.get(model.getTaskKey());
|
if (null != nodeModel && nodeTypes.contains(nodeModel.getType())) {
|
currentNodeList.add(nodeModel.getNodeId());
|
currentNodeNameList.add(nodeModel.getNodeName());
|
}
|
}
|
if (CollectionUtil.isNotEmpty(currentNodeList)) {
|
// 更新任务的当前节点信息
|
taskEntity.setCurrentNodeName(String.join(",", currentNodeNameList));
|
taskEntity.setCurrentNodeCode(String.join(",", currentNodeList));
|
taskMapper.updateById(taskEntity);
|
}
|
}
|
|
|
// 拒绝结束流程
|
public void handleEndTask(FlowMethod flowMethod) throws Exception {
|
OperatorEntity operator = flowMethod.getOperatorEntity();
|
List<CirculateEntity> circulateList = flowMethod.getCirculateList();
|
FlowModel flowModel = flowMethod.getFlowModel();
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
|
// 触发
|
if (!flowMethod.getIsRevoke()) {
|
flowModel.setAction(2);
|
flowModel.setRejectTrigger(true);
|
handleTrigger(operator, flowModel);
|
}
|
|
// 直接结束流程
|
flowMethod.setState(TaskStatusEnum.REJECTED.getCode());
|
this.endTask(flowMethod);
|
// 处理当前节点
|
flowModel.setFinishFlag(false);
|
List<String> codes = Arrays.stream(taskEntity.getCurrentNodeCode().split(",")).collect(Collectors.toList());
|
codes.remove(operator.getNodeCode());
|
taskEntity.setCurrentNodeCode(String.join(",", codes));
|
|
// 节点记录
|
NodeRecordModel nodeRecordModel = new NodeRecordModel();
|
nodeRecordModel.setTaskId(operator.getTaskId());
|
nodeRecordModel.setNodeId(operator.getNodeId());
|
nodeRecordModel.setNodeCode(operator.getNodeCode());
|
nodeRecordModel.setNodeName(operator.getNodeName());
|
nodeRecordModel.setNodeStatus(NodeStateEnum.reject.getCode());
|
nodeRecordMapper.create(nodeRecordModel);
|
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setNodeCode(operator.getNodeCode());
|
flowMsgModel.setWait(false);
|
flowMsgModel.setReject(true);
|
flowMsgModel.setCopy(true);
|
List<OperatorEntity> operatorList = new ArrayList<>();
|
OperatorEntity entity = new OperatorEntity();
|
entity.setNodeCode(operator.getNodeCode());
|
entity.setHandleId(taskEntity.getCreatorUserId());
|
operatorList.add(entity);
|
flowMsgModel.setOperatorList(operatorList);
|
flowMsgModel.setCirculateList(circulateList);
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
|
this.isFinished(flowModel);
|
}
|
|
|
public void updateGlobalParam(TaskEntity taskEntity, NodeModel nodeModel, NodeModel global, Map<String, Object> formData) throws WorkFlowException {
|
this.getGlobalParam(taskEntity, nodeModel, global, formData);
|
taskMapper.updateById(taskEntity);
|
}
|
|
|
public void getGlobalParam(TaskEntity taskEntity, NodeModel nodeModel, NodeModel global, Map<String, Object> formData) throws WorkFlowException {
|
List<FlowParamModel> paramModelList = global.getGlobalParameterList();
|
if (CollectionUtil.isEmpty(paramModelList)) {
|
return;
|
}
|
formData = formData == null ? new HashMap<>() : formData;
|
List<TemplateJsonModel> list = new ArrayList<>();
|
for (GroupsModel group : nodeModel.getParameterList()) {
|
TemplateJsonModel model = new TemplateJsonModel();
|
model.setField(group.getField());
|
model.setSourceType(Objects.equals(FieldEnum.Condition.getCode(), group.getFieldValueType()) ? FieldEnum.System.getCode() : group.getFieldValueType());
|
model.setMsgTemplateId(group.getField());
|
list.add(model);
|
}
|
Map<String, Object> taskMap = taskEntity.getGlobalParameter() != null ? JsonUtil.stringToMap(taskEntity.getGlobalParameter()) : new HashMap<>();
|
if (CollectionUtil.isEmpty(taskMap)) {
|
for (FlowParamModel model : paramModelList) {
|
if (model.getDefaultValue() != null) {
|
taskMap.put(model.getFieldName(), model.getDefaultValue());
|
}
|
}
|
}
|
RecordEntity record = new RecordEntity();
|
record.setNodeCode(nodeModel.getNodeId());
|
// UserEntity createUser = serviceUtil.getUserInfo(taskEntity.getCreatorUserId());
|
// UserEntity delegate = StringUtil.isNotEmpty(taskEntity.getDelegateUserId()) ? serviceUtil.getUserInfo(taskEntity.getDelegateUserId()) : null;
|
FlowModel parameterModel = new FlowModel();
|
parameterModel.setFormData(formData);
|
parameterModel.setRecordEntity(record);
|
parameterModel.setTaskEntity(taskEntity);
|
Map<String, String> map = flowUtil.parameterMap(parameterModel, list);
|
taskMap.putAll(map);
|
for (FlowParamModel model : paramModelList) {
|
if (ObjectUtil.equals(model.getDataType(), "datetime")) {
|
String fieldName = model.getFieldName();
|
Long longVal = Long.valueOf(String.valueOf(taskMap.get(fieldName)));
|
taskMap.put(fieldName, longVal);
|
}
|
}
|
taskEntity.setGlobalParameter(JsonUtil.getObjectToString(taskMap));
|
}
|
|
/**
|
* 依次审批的排序
|
*
|
* @param userIds 用户主键集合
|
* @param nodeModel 节点属性
|
*/
|
public List<String> improperSort(List<String> userIds, NodeModel nodeModel) {
|
List<String> list = new ArrayList<>();
|
List<String> sortList = nodeModel.getApproversSortList();
|
if (sortList.isEmpty()) {
|
return userIds;
|
}
|
for (String id : sortList) {
|
List<String> collect = userIds.stream().filter(id::contains).collect(Collectors.toList());
|
list.addAll(collect);
|
}
|
return list.stream().distinct().collect(Collectors.toList());
|
}
|
|
// 结束任务
|
public void endTask(FlowMethod flowMethod) throws Exception {
|
TaskEntity taskEntity = flowMethod.getTaskEntity();
|
Integer state = flowMethod.getState();
|
taskEntity.setStatus(state);
|
taskEntity.setEndTime(new Date());
|
if (taskMapper.updateById(taskEntity) > 0) {
|
flowMethod.setTaskId(taskEntity.getId());
|
flowMethod.setNodeCode(null);
|
endOperator(flowMethod);
|
flowAbleUrl.deleteInstance(taskEntity.getInstanceId(), "reject");
|
}
|
}
|
|
|
/**
|
* 判断任务是否结束
|
*
|
* @param flowModel 参数
|
*/
|
public boolean isFinished(FlowModel flowModel) throws Exception {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
if (null == taskEntity.getId()) {
|
return false;
|
}
|
TaskEntity task = taskMapper.selectById(taskEntity.getId());
|
if (null != task && ObjectUtil.equals(task.getStatus(), TaskStatusEnum.CANCEL.getCode())) {
|
return false;
|
}
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
String instanceId = taskEntity.getInstanceId();
|
boolean flag;
|
FlowableInstanceModel instance = flowAbleUrl.getInstance(instanceId);
|
if (null != instance && null != instance.getEndTime()) {
|
flag = true;
|
} else {
|
List<String> historicEnd = flowAbleUrl.getHistoricEnd(instanceId);
|
flag = CollectionUtil.isNotEmpty(historicEnd);
|
}
|
if (flag) {
|
TemplateNodeEntity endNodeEntity = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(e.getNodeType(), NodeEnum.end.getType())).findFirst().orElse(null);
|
if (null != endNodeEntity) {
|
if (flowModel.getFinishFlag()) {
|
taskEntity.setCurrentNodeCode(FlowNature.END_CODE);
|
taskEntity.setCurrentNodeName(FlowNature.END_NAME);
|
}
|
Integer status = flowModel.getHandleStatus().equals(FlowNature.AuditCompletion) ?
|
TaskStatusEnum.PASSED.getCode() : TaskStatusEnum.REJECTED.getCode();
|
taskEntity.setStatus(status);
|
taskEntity.setEndTime(new Date());
|
if (taskMapper.updateById(taskEntity) > 0) {
|
this.subFlowOfEnd(flowModel);
|
//结束事件
|
flowModel.setEventStatus(EventEnum.End.getStatus());
|
addEvent(flowModel);
|
// 发送结束消息
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setEnd(true);
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
|
// 判断能否归档
|
public AuditModel getAuditModel(String taskId, FlowModel flowModel, OperatorEntity operator) {
|
TaskEntity task = taskMapper.selectById(taskId);
|
AuditModel model = new AuditModel();
|
if (operator != null && ObjectUtil.equals(operator.getStatus(), OperatorStateEnum.Revoke.getCode())) {
|
return model;
|
}
|
if (task != null) {
|
model.setTaskId(taskId);
|
if (task.getEndTime() != null) {
|
NodeModel global = flowModel.getNodes().get(NodeEnum.global.getType());
|
FileConfig config = global.getFileConfig();
|
if (config.getOn() && StringUtil.isNotBlank(config.getTemplateId())) {
|
model.setIsEnd(true);
|
}
|
}
|
}
|
return model;
|
}
|
|
|
// 子流程结束 要处理的事情
|
public void subFlowOfEnd(FlowModel flowModel) throws Exception {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
if (StringUtil.equals(FlowNature.ParentId, taskEntity.getParentId())) {
|
return;
|
}
|
// 获取父级节点集合
|
TaskEntity parentTask = taskMapper.getInfo(taskEntity.getParentId());
|
if (null == parentTask) {
|
throw new WorkFlowException(MsgCode.FA001.get());
|
}
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(parentTask.getFlowId());
|
String deploymentId = jsonEntity.getFlowableId();
|
List<TemplateNodeEntity> parentNodeList = templateNodeMapper.getList(parentTask.getFlowId());
|
|
String subCode = taskEntity.getSubCode();
|
SubParameterModel subParameter = JsonUtil.getJsonToBean(taskEntity.getSubParameter(), SubParameterModel.class);
|
String flowableTaskId = subParameter.getNodeId();
|
String parentCode = subParameter.getParentCode();
|
|
TemplateNodeEntity parentNode = parentNodeList.stream()
|
.filter(e -> e.getNodeCode().equals(parentCode)).findFirst().orElse(new TemplateNodeEntity());
|
TemplateNodeEntity subNode = parentNodeList.stream()
|
.filter(e -> e.getNodeCode().equals(subCode)).findFirst().orElse(new TemplateNodeEntity());
|
NodeModel nodeModel = JsonUtil.getJsonToBean(subNode.getNodeJson(), NodeModel.class);
|
if (nodeModel == null) {
|
return;
|
}
|
// 判断是否依次创建，存在依次创建的子流程数据，则发起子流程
|
if (!ObjectUtil.equals(nodeModel.getCreateRule(), FlowNature.ChildSync)) {
|
List<SubtaskDataEntity> list = subtaskDataMapper.getList(taskEntity.getParentId(), subCode);
|
if (CollectionUtil.isNotEmpty(list)) {
|
SubtaskDataEntity subtaskData = list.get(0);
|
FlowModel model = JsonUtil.getJsonToBean(subtaskData.getSubtaskJson(), FlowModel.class);
|
batchSaveOrSubmit(model);
|
subtaskDataMapper.deleteById(subtaskData);
|
autoAudit(model);
|
return;
|
}
|
}
|
|
// 判断下一级是否子流程节点，且是否存在候选人
|
NextOrPrevFo fo = new NextOrPrevFo();
|
fo.setDeploymentId(deploymentId);
|
fo.setTaskKey(subCode);
|
List<FlowableNodeModel> nextModels = flowAbleUrl.getNext(fo);
|
|
for (FlowableNodeModel nextModel : nextModels) {
|
TemplateNodeEntity nodeEntity = parentNodeList.stream().filter(e -> ObjectUtil.equals(e.getNodeCode(), nextModel.getId()))
|
.findFirst().orElse(new TemplateNodeEntity());
|
if (ObjectUtil.equals(nodeEntity.getNodeType(), NodeEnum.subFlow.getType())) {
|
NodeModel subFlow = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
TemplateEntity template = templateMapper.selectById(subFlow.getFlowId());
|
TemplateJsonEntity subJsonEntity = templateJsonMapper.selectById(template.getFlowId());
|
List<TemplateNodeEntity> subNodeList = templateNodeMapper.getList(template.getFlowId());
|
Map<String, NodeModel> subNodes = new HashMap<>();
|
for (TemplateNodeEntity node : subNodeList) {
|
subNodes.put(node.getNodeCode(), JsonUtil.getJsonToBean(node.getNodeJson(), NodeModel.class));
|
}
|
TemplateNodeEntity subStart = subNodeList.stream()
|
.filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(new TemplateNodeEntity());
|
|
FlowMethod method = new FlowMethod();
|
method.setDeploymentId(subJsonEntity.getFlowableId());
|
method.setNodes(subNodes);
|
method.setNodeEntityList(subNodeList);
|
method.setNodeCode(subStart.getNodeCode());
|
|
if (flowUtil.checkBranch(subStart)) {
|
throw new WorkFlowException(MsgCode.WF121.get());
|
}
|
List<NodeModel> nextApprover = flowUtil.getNextApprover(method);
|
if (!flowUtil.checkNextCandidates(nextApprover)) {
|
throw new WorkFlowException(MsgCode.WF121.get());
|
}
|
FlowModel model = new FlowModel();
|
model.setDeploymentId(flowModel.getDeploymentId());
|
model.setNodeEntityList(subNodeList);
|
if (flowUtil.checkNextError(model, nextApprover, false, false) != 0) {
|
throw new WorkFlowException(MsgCode.WF121.get());
|
}
|
}
|
}
|
|
if (nodeModel.getIsAsync().equals(FlowNature.ChildAsync)) {
|
// 异步已经完成节点
|
return;
|
}
|
// 父节点下的子流程
|
QueryWrapper<TaskEntity> wrapper = new QueryWrapper<>();
|
wrapper.lambda().eq(TaskEntity::getParentId, taskEntity.getParentId())
|
.eq(TaskEntity::getSubCode, subCode);
|
List<TaskEntity> subList = taskMapper.selectList(wrapper);
|
// 未审批集合
|
List<TaskEntity> unfinishedList = subList.stream()
|
.filter(e -> !e.getStatus().equals(TaskStatusEnum.PASSED.getCode()) && !e.getStatus().equals(TaskStatusEnum.REJECTED.getCode()))
|
.collect(Collectors.toList());
|
if (unfinishedList.isEmpty()) {
|
FlowModel model = JsonUtil.getJsonToBean(flowModel, FlowModel.class);
|
model.setFinishFlag(true);
|
subList = subList.stream().filter(e -> null != e.getEndTime())
|
.sorted(Comparator.comparing(TaskEntity::getEndTime).reversed()).collect(Collectors.toList());
|
if (CollectionUtil.isNotEmpty(subList)) {
|
TaskEntity finalTask = subList.get(0);
|
model.setHandleStatus(ObjectUtil.equals(finalTask.getStatus(), TaskStatusEnum.PASSED.getCode()) ? 1 : 0);
|
} else {
|
model.setHandleStatus(1);
|
}
|
String formId = parentNode.getFormId();
|
flowUtil.setFlowModel(parentTask.getId(), model);
|
Map<String, NodeModel> nodes = model.getNodes();
|
Map<String, Object> formData = serviceUtil.infoData(formId, parentTask.getId());
|
model.setFormData(formData);
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setDeploymentId(model.getDeploymentId());
|
flowMethod.setNodeCode(subCode);
|
flowMethod.setFormData(formData);
|
flowMethod.setNodes(nodes);
|
flowMethod.setTaskEntity(parentTask);
|
Map<String, Boolean> resMap = conditionUtil.handleCondition(flowMethod);
|
conditionUtil.checkCondition(resMap, nodes);
|
flowMethod.setFlowModel(model);
|
flowMethod.setFlowableTaskId(flowableTaskId);
|
flowMethod.setResMap(resMap);
|
flowMethod.setNodeEntityList(parentNodeList);
|
// 递归subCode的所有上级节点，获取审批节点的经办
|
model.setOperatorEntity(new OperatorEntity());
|
List<String> nodeCodeList = new ArrayList<>();
|
flowUtil.prevNodeList(flowModel.getDeploymentId(), subCode, parentNodeList, nodeCodeList);
|
if (CollectionUtil.isNotEmpty(nodeCodeList)) {
|
List<OperatorEntity> list = getList(parentTask.getId(), nodeCodeList);
|
if (CollectionUtil.isNotEmpty(list)) {
|
model.setOperatorEntity(list.get(0));
|
}
|
}
|
completeNode(flowMethod);
|
}
|
}
|
|
// 删除子流程（退回时若是重新审批）
|
public void deleteSubflow(String taskId, List<String> nodeCodeList) {
|
QueryWrapper<TaskEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(TaskEntity::getParentId, taskId);
|
if (CollectionUtil.isNotEmpty(nodeCodeList)) {
|
queryWrapper.lambda().in(TaskEntity::getSubCode, nodeCodeList);
|
}
|
List<TaskEntity> list = taskMapper.selectList(queryWrapper);
|
if (CollectionUtil.isNotEmpty(list)) {
|
List<String> idList = list.stream().map(TaskEntity::getId).distinct().collect(Collectors.toList());
|
List<String> idAll = new ArrayList<>();
|
taskMapper.deleTaskAll(idList, idAll);
|
List<TaskEntity> childList = taskMapper.getInfosSubmit(idAll.toArray(new String[]{}), TaskEntity::getId, TaskEntity::getFlowId);
|
for (TaskEntity entity : childList) {
|
addDelTask(entity.getId(), entity.getFlowId());
|
}
|
taskMapper.setIgnoreLogicDelete().deleteByIds(idAll);
|
taskMapper.clearIgnoreLogicDelete();
|
}
|
}
|
|
/**
|
* 判断任务是否在挂起状态
|
*
|
* @param taskEntity 任务
|
*/
|
public void isSuspend(TaskEntity taskEntity) throws WorkFlowException {
|
Integer status = taskEntity != null ? taskEntity.getStatus() : null;
|
if (TaskStatusEnum.PAUSED.getCode().equals(status)) {
|
throw new WorkFlowException(MsgCode.WF114.get());
|
}
|
}
|
|
/**
|
* 判断任务是否终止状态
|
*
|
* @param taskEntity 任务
|
*/
|
public void isCancel(TaskEntity taskEntity) throws WorkFlowException {
|
Integer status = taskEntity != null ? taskEntity.getStatus() : null;
|
if (ObjectUtil.equals(TaskStatusEnum.CANCEL.getCode(), status)) {
|
throw new WorkFlowException(MsgCode.WF123.get());
|
}
|
}
|
|
|
public void getByRule(List<String> userIdAll, UserEntity flowUser, int rule) {
|
if (flowUser != null) {
|
String userId = flowUser.getId();
|
//附加条件
|
switch (ExtraRuleEnum.getByCode(rule)) {
|
case role:
|
List<String> roleId = serviceUtil.getRoleObjectId(ImmutableList.of(userId)).stream().map(RoleRelationEntity::getRoleId).collect(Collectors.toList());
|
List<String> userIdList = serviceUtil.getListByRoleId(roleId).stream().map(RoleRelationEntity::getObjectId).collect(Collectors.toList());
|
List<String> roleUserId = userIdList.stream().filter(e -> !ObjectUtil.equals(e, userId)).collect(Collectors.toList());
|
userIdAll.addAll(roleUserId);
|
break;
|
case organize:
|
case group:
|
case position:
|
String type = Objects.equals(ExtraRuleEnum.group.getCode(), rule) ? PermissionConst.GROUP : PermissionConst.POSITION;
|
List<UserRelationEntity> userRelationList = serviceUtil.getListByUserIdAll(ImmutableList.of(userId));
|
List<String> objectIdList = new ArrayList<>();
|
List<String> idList = userRelationList.stream().filter(e -> ObjectUtil.equals(e.getObjectType(), type))
|
.map(UserRelationEntity::getObjectId).collect(Collectors.toList());
|
if (Objects.equals(ExtraRuleEnum.organize.getCode(), rule)) {
|
List<PositionEntity> positionList = serviceUtil.getPosList(idList);
|
List<String> organizeList = positionList.stream().map(PositionEntity::getOrganizeId).collect(Collectors.toList());
|
List<String> orgList = serviceUtil.getOrganizeList(organizeList).stream().filter(e -> Objects.equals(e.getCategory(), PermissionConst.DEPARTMENT)).map(OrganizeEntity::getId).collect(Collectors.toList());
|
objectIdList.addAll(orgList);
|
} else {
|
objectIdList.addAll(idList);
|
}
|
List<String> userIds = serviceUtil.getListByObjectIdAll(objectIdList).stream().map(UserRelationEntity::getUserId)
|
.filter(e -> !ObjectUtil.equals(e, userId)).collect(Collectors.toList());
|
userIdAll.addAll(userIds);
|
break;
|
}
|
}
|
}
|
|
|
|
//封装用户对象
|
public List<CandidateUserVo> getUserModel(List<String> ids, Pagination pagination) {
|
List<String> userIds = serviceUtil.getUserListAll(ids);
|
List<UserEntity> userList = serviceUtil.getUserName(userIds, pagination);
|
pagination.setTotal(pagination.getTotal());
|
List<String> userIdList = userList.stream().map(UserEntity::getId).collect(Collectors.toList());
|
List<UserRelationEntity> userRelationList = serviceUtil.getListByUserIdAll(userIdList);
|
Map<String, List<UserRelationEntity>> userMap = userRelationList.stream()
|
.filter(t -> PermissionConst.POSITION.equals(t.getObjectType())).collect(Collectors.groupingBy(UserRelationEntity::getUserId));
|
List<CandidateUserVo> list = new ArrayList<>();
|
for (UserEntity user : userList) {
|
CandidateUserVo vo = JsonUtil.getJsonToBean(user, CandidateUserVo.class);
|
vo.setFullName(user.getRealName() + "/" + user.getAccount());
|
vo.setHeadIcon(UploaderUtil.uploaderImg(user.getHeadIcon()));
|
List<UserRelationEntity> listByUserId = userMap.get(user.getId()) != null ? userMap.get(user.getId()) : new ArrayList<>();
|
StringJoiner joiner = new StringJoiner(",");
|
for (UserRelationEntity relation : listByUserId) {
|
StringJoiner name = new StringJoiner("/");
|
PositionEntity position = serviceUtil.getPositionInfo(relation.getObjectId());
|
if (position != null) {
|
OrganizeEntity organize = serviceUtil.getOrganizeInfo(position.getOrganizeId());
|
if (organize != null) {
|
List<String> organizeIdTree = new ArrayList<>(Arrays.asList(organize.getOrganizeIdTree().split(",")));
|
List<OrganizeEntity> organizeList = serviceUtil.getOrganizeList(organizeIdTree);
|
for (String organizeId : organizeIdTree) {
|
OrganizeEntity entity = organizeList.stream().filter(e -> Objects.equals(e.getId(), organizeId)).findFirst().orElse(null);
|
if (entity != null) {
|
name.add(entity.getFullName());
|
}
|
}
|
}
|
List<String> positionIdTree = new ArrayList<>(Arrays.asList(position.getPositionIdTree().split(",")));
|
List<PositionEntity> positionList = serviceUtil.getPosList(positionIdTree);
|
for (String positionId : positionIdTree) {
|
PositionEntity entity = positionList.stream().filter(e -> Objects.equals(e.getId(), positionId)).findFirst().orElse(null);
|
if (entity != null) {
|
name.add(entity.getFullName());
|
}
|
}
|
}
|
joiner.add(name.toString());
|
}
|
vo.setOrganize(joiner.toString());
|
list.add(vo);
|
}
|
return list;
|
}
|
|
|
/**
|
* 处理数据传递，并存储在线程，后续保存数据库
|
*/
|
public Map<String, Object> dataTransfer(FlowMethod flowMethod) throws WorkFlowException {
|
List<TemplateNodeEntity> nodeEntityList = flowMethod.getNodeEntityList();
|
FlowModel flowModel = flowMethod.getFlowModel();
|
Map<String, Object> formData = flowModel.getFormData();
|
TemplateNodeEntity globalEntity = nodeEntityList.stream().filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.global.getType())).findFirst().orElse(null);
|
// 判断是否能数据传递
|
if (null != globalEntity) {
|
NodeModel global = JsonUtil.getJsonToBean(globalEntity.getNodeJson(), NodeModel.class);
|
if (!global.getHasAloneConfigureForms()) {
|
return formData;
|
}
|
}
|
TemplateNodeEntity nodeEntity = flowMethod.getNodeEntity();
|
NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
if (CollectionUtil.isEmpty(nodeModel.getAssignList())) {
|
return formData;
|
}
|
TaskEntity taskEntity = flowMethod.getTaskEntity();
|
String rejectDataId = taskEntity.getRejectDataId();
|
//保存数据的表单
|
String formId = nodeEntity.getFormId();
|
String taskId = taskEntity.getId();
|
boolean isAssign = flowMethod.getIsAssign();
|
Map<String, Object> data = flowUtil.createOrUpdate(flowMethod);
|
String resultNodeCode = flowMethod.getResultNodeCode();
|
//判断是否是外部节点最后一个审批
|
TemplateNodeEntity resultNode = nodeEntityList.stream().filter(e -> Objects.equals(e.getNodeCode(), resultNodeCode)).findFirst().orElse(null);
|
if (resultNode != null && Objects.equals(resultNode.getNodeType(), NodeEnum.outside.getType())) {
|
//判断是否是从当前节点回来
|
if (StringUtil.isNotEmpty(rejectDataId)) {
|
return formData;
|
}
|
}
|
List<String> typeList = ImmutableList.of(NodeEnum.end.getType(), NodeEnum.subFlow.getType());
|
if (isAssign) {
|
boolean isWrite = !typeList.contains(nodeModel.getType());
|
FlowContextHolder.addChildData(taskId, formId, data, new ArrayList<>(), isWrite);
|
}
|
return data;
|
}
|
|
|
// 删除表单数据
|
public void deleteFormData(List<TaskEntity> taskList) throws Exception {
|
if (taskList.isEmpty()) {
|
return;
|
}
|
List<TemplateNodeEntity> nodeEntityList = new ArrayList<>();
|
List<String> flowIds = taskList.stream().map(TaskEntity::getFlowId).collect(Collectors.toList());
|
if (!flowIds.isEmpty()) {
|
nodeEntityList = templateNodeMapper.getList(flowIds, null);
|
}
|
|
for (TaskEntity taskEntity : taskList) {
|
List<String> formIds = nodeEntityList.stream().filter(e -> e.getFlowId().equals(taskEntity.getFlowId()) && StringUtil.isNotBlank(e.getFormId())).map(TemplateNodeEntity::getFormId).distinct().collect(Collectors.toList());
|
for (String formId : formIds) {
|
serviceUtil.deleteFormData(formId, taskEntity.getId());
|
}
|
}
|
}
|
|
|
public List<String> getNextList(String deploymentId, String nodeCode, Map<String, NodeModel> nodes, List<String> nextList) throws WorkFlowException {
|
nextList = nextList != null ? nextList : new ArrayList<>();
|
NextOrPrevFo fo = new NextOrPrevFo();
|
fo.setDeploymentId(deploymentId);
|
fo.setTaskKey(nodeCode);
|
List<FlowableNodeModel> nextModels = flowAbleUrl.getNext(fo);
|
for (FlowableNodeModel next : nextModels) {
|
|
NodeModel nodeModel = nodes.get(next.getId());
|
if (null != nodeModel) {
|
// 子流程往下递归
|
List<String> typeList = ImmutableList.of(NodeEnum.subFlow.getType());
|
if (typeList.contains(nodeModel.getType())) {
|
nextList.add(next.getId());
|
getNextList(deploymentId, next.getId(), nodes, nextList);
|
} else {
|
nextList.add(next.getId());
|
}
|
}
|
}
|
return nextList;
|
}
|
|
|
public void checkTemplateHide(String templateId) throws WorkFlowException {
|
TemplateEntity template = templateMapper.selectById(templateId);
|
if (null != template) {
|
List<Integer> templateStatus = ImmutableList.of(TemplateStatueEnum.up.getCode(), TemplateStatueEnum.downContinue.getCode());
|
if (!templateStatus.contains(template.getStatus())) {
|
throw new WorkFlowException(MsgCode.WF140.get());
|
}
|
}
|
}
|
|
|
public ActionResult launchFlow(FlowModel flowModel) throws Exception {
|
String templateId = flowModel.getTemplateId();
|
List<String> userIds = flowModel.getUserIds();
|
List<Map<String, Object>> formDataList = flowModel.getFormDataList();
|
if (CollectionUtil.isEmpty(formDataList)) {
|
return ActionResult.fail("未选择记录，发起失败");
|
}
|
TemplateEntity template = templateMapper.selectById(templateId);
|
if (null == template) {
|
return ActionResult.fail(MsgCode.WF122.get());
|
}
|
if (!ObjectUtil.equals(template.getStatus(), TemplateStatueEnum.up.getCode())) {
|
throw new WorkFlowException(MsgCode.WF140.get());
|
}
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(template.getFlowId());
|
List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(jsonEntity.getId());
|
Map<String, NodeModel> nodes = new HashMap<>();
|
for (TemplateNodeEntity node : nodeEntityList) {
|
nodes.put(node.getNodeCode(), JsonUtil.getJsonToBean(node.getNodeJson(), NodeModel.class));
|
}
|
FlowMethod method = new FlowMethod();
|
method.setDeploymentId(jsonEntity.getFlowableId());
|
TemplateNodeEntity startNode = nodeEntityList.stream().filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(new TemplateNodeEntity());
|
if (flowUtil.checkBranch(startNode)) {
|
throw new WorkFlowException(MsgCode.WF147.get());
|
}
|
method.setNodeCode(startNode.getNodeCode());
|
method.setNodes(nodes);
|
method.setNodeEntityList(nodeEntityList);
|
Map<String, Boolean> resMap = conditionUtil.handleCondition(method);
|
// 判断条件、候选人
|
try {
|
conditionUtil.checkCondition(resMap, nodes);
|
} catch (WorkFlowException e) {
|
throw new WorkFlowException(MsgCode.WF133.get());
|
}
|
method.setNextSubFlow(true);
|
List<NodeModel> nextApprover = flowUtil.getNextApprover(method);
|
if (!flowUtil.checkNextCandidates(nextApprover)) {
|
throw new WorkFlowException(MsgCode.WF134.get());
|
}
|
|
String flowId = jsonEntity.getId();
|
// 判断流程权限
|
List<String> userListAll = serviceUtil.getUserListAll(userIds);
|
FlowFormModel formIdAndFlowId = flowUtil.getFormIdAndFlowId(userListAll, templateId);
|
List<UserEntity> userList = serviceUtil.getUserName(flowModel.getHasPermission() ? formIdAndFlowId.getUserId() : formIdAndFlowId.getUserIdAll(), true);
|
if (CollectionUtil.isEmpty(userList)) {
|
throw new WorkFlowException(MsgCode.WF136.get());
|
}
|
for (UserEntity user : userList) {
|
UserInfo userInfo = new UserInfo();
|
userInfo.setUserId(user.getId());
|
userInfo.setUserName(user.getRealName());
|
|
FlowModel model = new FlowModel();
|
model.setUserInfo(userInfo);
|
model.setFlowId(flowId);
|
model.setStatus(TaskStatusEnum.RUNNING.getCode());
|
model.setDeploymentId(jsonEntity.getFlowableId());
|
model.setNodeEntityList(nodeEntityList);
|
for (Map<String, Object> formData : formDataList) {
|
model.setFormData(formData);
|
if (flowUtil.checkNextError(model, nextApprover, false, false) != 0) {
|
throw new WorkFlowException(MsgCode.WF135.get());
|
}
|
batchSaveOrSubmit(model);
|
flowUtil.event(model, 1);
|
TaskEntity taskEntity = model.getTaskEntity();
|
if (taskEntity.getRejectDataId() == null) {
|
autoAudit(model);
|
handleEvent();
|
}
|
handleTaskStatus();
|
}
|
}
|
return ActionResult.success(MsgCode.SU006.get());
|
}
|
|
|
public void batchSaveOrSubmit(FlowModel flowModel) throws Exception {
|
UserInfo userInfo = flowModel.getUserInfo();
|
if (null == userInfo) {
|
userInfo = UserProvider.getUser();
|
flowModel.setUserInfo(userInfo);
|
}
|
|
String delegateUser = flowModel.getDelegateUser();
|
if (StringUtil.isBlank(delegateUser)) {
|
this.saveOrSubmit(flowModel);
|
} else {
|
FlowModel model = JsonUtil.getJsonToBean(flowModel, FlowModel.class);
|
model.setDelegateUser(userInfo.getUserId());
|
model.setUserId(delegateUser);
|
UserEntity userEntity = serviceUtil.getUserInfo(delegateUser);
|
if (null != userEntity) {
|
UserInfo info = model.getUserInfo();
|
info.setUserName(userEntity.getRealName());
|
info.setUserAccount(userEntity.getAccount());
|
info.setUserId(userEntity.getId());
|
model.setUserInfo(info);
|
}
|
this.saveOrSubmit(model);
|
// 赋值给原来的FlowModel
|
BeanUtil.copyProperties(model, flowModel);
|
}
|
// 保存表单数据
|
FlowContextHolder.deleteFormOperator();
|
Map<String, Map<String, Object>> allData = FlowContextHolder.getAllData();
|
Map<String, List<Map<String, Object>>> formOperates = FlowContextHolder.getFormOperates();
|
List<String> writeIdList = FlowContextHolder.getWriteIdList();
|
for (String idAll : writeIdList) {
|
String[] idList = idAll.split(JnpfConst.SIDE_MARK);
|
List<Map<String, Object>> operates = formOperates.get(idAll);
|
Map<String, Object> formData = allData.get(idAll);
|
formData = formData == null ? new HashMap<>() : formData;
|
String flowId = (String) formData.get(FlowFormConstant.FLOWID);
|
FlowFormDataModel formDataModel = FlowFormDataModel.builder().formId(idList[1]).id(idList[0]).map(formData).formOperates(operates).flowId(flowId).isTransfer(true).build();
|
serviceUtil.saveOrUpdateFormData(formDataModel);
|
}
|
FlowContextHolder.clearAll();
|
}
|
|
|
// 提交或暂存
|
public void saveOrSubmit(FlowModel flowModel) throws Exception {
|
TemplateEntity templateEntity = null;
|
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(flowModel.getFlowId());
|
if (null == jsonEntity) {
|
templateEntity = templateMapper.getInfo(flowModel.getFlowId());
|
jsonEntity = templateJsonMapper.getInfo(templateEntity.getFlowId());
|
} else {
|
templateEntity = templateMapper.getInfo(jsonEntity.getTemplateId());
|
}
|
|
UserInfo userInfo = flowModel.getUserInfo();
|
List<String> branchList = flowModel.getBranchList();
|
//taskUtil.checkLaunchPermission(userInfo.getUserId(), templateEntity);
|
|
// 获取节点
|
List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(jsonEntity.getId());
|
if (CollectionUtil.isEmpty(nodeEntityList)) {
|
throw new WorkFlowException(MsgCode.WF076.get());
|
}
|
Map<String, NodeModel> nodes = new HashMap<>();
|
for (TemplateNodeEntity nodeEntity : nodeEntityList) {
|
nodes.put(nodeEntity.getNodeCode(), JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class));
|
}
|
|
flowModel.setJsonEntity(jsonEntity);
|
TaskEntity entity = flowUtil.createEntity(flowModel, templateEntity, nodes);
|
// 开始节点
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(null);
|
if (null == nodeEntity) {
|
throw new WorkFlowException(MsgCode.WF076.get());
|
}
|
String nodeCode = nodeEntity.getNodeCode();
|
// 传递部署id、节点集合
|
String deploymentId = jsonEntity.getFlowableId();
|
flowModel.setDeploymentId(deploymentId);
|
flowModel.setNodeEntityList(nodeEntityList);
|
flowModel.setNodes(nodes);
|
flowModel.setNodeEntity(nodeEntity);
|
|
NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
// 表单主键
|
String formId = nodeEntity.getFormId();
|
|
Map<String, Object> data = flowModel.getFormData();
|
data.put(FlowFormConstant.FLOWID, jsonEntity.getId());
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setDeploymentId(deploymentId);
|
flowMethod.setNodeCode(nodeCode);
|
flowMethod.setFormData(data);
|
flowMethod.setNodes(nodes);
|
flowMethod.setTaskEntity(entity);
|
// flowMethod.setJsonEntity(jsonEntity);
|
|
addTask(ImmutableList.of(entity.getId()));
|
FlowFormDataModel model = new FlowFormDataModel();
|
model.setFormId(formId);
|
model.setId(entity.getId());
|
model.setFormOperates(nodeModel.getFormOperates());
|
model.setMap(flowModel.getFormData());
|
model.setFlowId(jsonEntity.getId());
|
|
if (ObjectUtil.equals(TaskStatusEnum.TO_BE_SUBMIT.getCode(), flowModel.getStatus())) {
|
// 生成任务，保存表单数据
|
if (flowModel.getSubFlow()) {
|
model.setIsTransfer(true);
|
}
|
// 菜单入口、编辑
|
if (Objects.equals(flowModel.getIsFlow(), 0)) {
|
serviceUtil.saveOrUpdateFormData(model);
|
entity.setLastModifyTime(new Date());
|
entity.setLastModifyUserId(null != userInfo ? userInfo.getUserId() : UserProvider.getLoginUserId());
|
taskMapper.updateById(entity);
|
flowModel.setTaskEntity(entity);
|
return;
|
}
|
|
if (StringUtil.isEmpty(flowModel.getId())) {
|
entity.setStatus(TaskStatusEnum.TO_BE_SUBMIT.getCode());
|
if (taskMapper.insert(entity) > 0) {
|
// 保存表单数据
|
serviceUtil.saveOrUpdateFormData(model);
|
}
|
} else {
|
// 我发起的暂存 直接修改表单数据
|
serviceUtil.saveOrUpdateFormData(model);
|
}
|
flowModel.setTaskEntity(entity);
|
} else if (ObjectUtil.equals(TaskStatusEnum.RUNNING.getCode(), flowModel.getStatus())) {
|
// 退回到发起
|
if (null != entity.getRejectDataId()) {
|
serviceUtil.saveOrUpdateFormData(model);
|
RejectDataEntity rejectData = rejectDataMapper.getInfo(entity.getRejectDataId());
|
String taskJson = rejectData.getTaskJson();
|
|
TaskEntity srcTask = JsonUtil.getJsonToBean(taskJson, TaskEntity.class);
|
srcTask.setRejectDataId(rejectData.getId());
|
|
OperatorEntity operator = new OperatorEntity();
|
operator.setNodeCode(rejectData.getNodeCode());
|
|
|
flowModel.setOperatorEntity(operator);
|
flowModel.setTaskEntity(srcTask);
|
handleRejectData(flowModel);
|
|
|
// 记录
|
flowMethod.setFlowModel(flowModel);
|
flowMethod.setType(RecordEnum.submit.getCode());
|
OperatorEntity operatorEntity = new OperatorEntity();
|
operatorEntity.setNodeCode(nodeEntity.getNodeCode());
|
operatorEntity.setNodeName(nodeModel.getNodeName());
|
operatorEntity.setTaskId(entity.getId());
|
if (StringUtil.isNotBlank(flowModel.getUserId())) {
|
flowMethod.setHandId(flowModel.getUserId());
|
}
|
flowMethod.setOperatorEntity(operatorEntity);
|
recordMapper.createRecord(flowMethod);
|
|
return;
|
}
|
|
// 判断条件
|
Map<String, Boolean> resMap = new HashMap<>();
|
if (branchList.isEmpty()) {
|
resMap.putAll(conditionUtil.handleCondition(flowMethod));
|
// 全是false，说明没有分支可走
|
conditionUtil.checkCondition(resMap, nodes);
|
} else {
|
// 选择分支的处理
|
resMap.putAll(conditionUtil.getForBranch(flowMethod, branchList));
|
}
|
// 引擎启动的变量
|
Map<String, Object> variables = new HashMap<>(resMap);
|
// 生成引擎实例
|
String instanceId = entity.getInstanceId();
|
if (entity.getInstanceId() == null) {
|
taskLineMapper.create(entity.getId(), resMap);
|
instanceId = flowAbleUrl.startInstance(jsonEntity.getFlowableId(), variables);
|
entity.setInstanceId(instanceId);
|
}
|
entity.setEngineType(1);
|
entity.setStatus(TaskStatusEnum.RUNNING.getCode());
|
entity.setStartTime(new Date());
|
// 生成任务
|
try {
|
TaskEntity task = taskMapper.selectById(entity.getId());
|
if (null == task) {
|
taskMapper.insert(entity);
|
} else {
|
entity.setStatus(TaskStatusEnum.RUNNING.getCode());
|
taskMapper.updateById(entity);
|
}
|
flowModel.setTaskEntity(entity);
|
serviceUtil.saveOrUpdateFormData(model);
|
data = serviceUtil.infoData(formId, entity.getId());
|
// 表单数据存储
|
data.put(FlowFormConstant.FLOWID, jsonEntity.getId());
|
FlowContextHolder.addChildData(entity.getId(), nodeEntity.getFormId(), data, nodeModel.getFormOperates(), false);
|
flowModel.setFormData(data);
|
// 流程参数
|
NodeModel global = nodes.get(NodeEnum.global.getType());
|
updateGlobalParam(entity, nodeModel, global, flowModel.getFormData());
|
// 记录
|
flowMethod.setFlowModel(flowModel);
|
flowMethod.setType(RecordEnum.submit.getCode());
|
OperatorEntity operatorEntity = new OperatorEntity();
|
operatorEntity.setNodeCode(nodeEntity.getNodeCode());
|
operatorEntity.setNodeName(nodeModel.getNodeName());
|
operatorEntity.setTaskId(entity.getId());
|
if (StringUtil.isNotBlank(flowModel.getUserId())) {
|
flowMethod.setHandId(flowModel.getUserId());
|
}
|
operatorEntity.setHandleTime(entity.getStartTime());
|
flowMethod.setOperatorEntity(operatorEntity);
|
recordMapper.createRecord(flowMethod);
|
// 节点记录
|
NodeRecordModel nodeRecordModel = new NodeRecordModel();
|
nodeRecordModel.setTaskId(entity.getId());
|
nodeRecordModel.setNodeCode(nodeEntity.getNodeCode());
|
nodeRecordModel.setNodeName(nodeModel.getNodeName());
|
nodeRecordModel.setNodeStatus(NodeStateEnum.submit.getCode());
|
nodeRecordMapper.create(nodeRecordModel);
|
|
// 保存候选人、异常人
|
flowUtil.create(flowModel, entity.getId(), nodeEntityList, null);
|
// 保存发起用户信息
|
flowUtil.createLaunchUser(entity.getId(), entity.getCreatorUserId());
|
|
// 生成经办
|
List<OperatorEntity> operatorEntities = handleOperator(flowModel);
|
|
// 系统审批
|
systemAudit();
|
// 消息
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setTaskEntity(entity);
|
flowMsgModel.setFlowModel(flowModel);
|
flowMsgModel.setOperatorList(operatorEntities);
|
flowMsgModel.setFormData(FlowContextHolder.getAllData());
|
msgUtil.message(flowMsgModel);
|
|
} catch (WorkFlowException e) {
|
// 异常，手动删除实例
|
flowAbleUrl.deleteInstance(instanceId, "submitException");
|
throw e;
|
}
|
}
|
}
|
|
public List<OperatorEntity> handleOperator(FlowModel flowModel) throws Exception {
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
Map<String, NodeModel> nodes = flowModel.getNodes();
|
Map<String, Object> formData = flowModel.getFormData();
|
String instanceId = taskEntity.getInstanceId();
|
String deploymentId = flowModel.getDeploymentId();
|
NodeModel global = nodes.get(NodeEnum.global.getType());
|
OperatorEntity operatorEntity = flowModel.getOperatorEntity();
|
// 最终要返回一个所有节点下的审批人的集合
|
List<OperatorEntity> list = new ArrayList<>();
|
|
// 原来的当前节点
|
List<String> srcCurrentList = StringUtil.isNotEmpty(taskEntity.getCurrentNodeCode()) ? Arrays.stream(taskEntity.getCurrentNodeCode().split(",")).collect(Collectors.toList()) : new ArrayList<>();
|
|
// 获取引擎当前任务
|
List<FlowableTaskModel> taskModelList = flowAbleUrl.getCurrentTask(instanceId);
|
if (CollectionUtil.isEmpty(taskModelList)) {
|
return list;
|
}
|
updateCurrentNode(taskModelList, nodes, taskEntity);
|
List<String> types = ImmutableList.of(NodeEnum.subFlow.getType(), NodeEnum.approver.getType(), NodeEnum.processing.getType(), NodeEnum.outside.getType());
|
List<FlowErrorModel> errorList = new ArrayList<>();
|
|
// 生成经办
|
for (FlowableTaskModel model : taskModelList) {
|
// 当前节点已存在，跳过
|
if (CollectionUtil.isNotEmpty(srcCurrentList) && srcCurrentList.contains(model.getTaskKey())) {
|
continue;
|
}
|
// 获取对应的节点信息
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> e.getNodeCode().equals(model.getTaskKey())).findFirst().orElse(null);
|
if (null == nodeEntity) {
|
continue;
|
}
|
NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
if (nodeModel == null) {
|
continue;
|
}
|
// 不是审批、子流程、外部、办理节点
|
if (!types.contains(nodeModel.getType())) {
|
continue;
|
}
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setTaskEntity(taskEntity);
|
flowMethod.setNodeEntity(nodeEntity);
|
flowMethod.setNodeEntityList(nodeEntityList);
|
flowMethod.setFlowModel(flowModel);
|
// 流程参数
|
updateGlobalParam(taskEntity, nodeModel, global, flowModel.getFormData());
|
flowModel.setFlowableTaskId(model.getTaskId());
|
List<String> typeList = ImmutableList.of(NodeEnum.subFlow.getType(), NodeEnum.outside.getType());
|
// 处理子流程节点、外部节点，传递表单数据
|
boolean isOutside = Objects.equals(nodeModel.getType(), NodeEnum.outside.getType());
|
if (typeList.contains(nodeModel.getType())) {
|
if (StringUtil.isEmpty(taskEntity.getRejectDataId()) && CollectionUtil.isEmpty(flowModel.getErrorRuleUserList())) {
|
FlowMethod method = new FlowMethod();
|
method.setDeploymentId(flowModel.getDeploymentId());
|
method.setNodeCode(nodeModel.getNodeId());
|
method.setNodes(flowModel.getNodes());
|
method.setFormData(flowModel.getFormData());
|
List<NodeModel> nextApprover = flowUtil.getNextApprover(method);
|
int nextError = flowUtil.checkNextError(flowModel, nextApprover, true, true, true);
|
if (nextError == 3) {
|
errorList.addAll(flowModel.getErrorList());
|
flowModel.setErrorList(new ArrayList<>());
|
continue;
|
} else if (nextError == 2) {
|
throw new WorkFlowException(MsgCode.WF061.get());
|
}
|
}
|
flowModel.setOperatorEntity(operatorEntity);
|
if (isOutside) {
|
//外部节点
|
String eventId = RandomUtil.uuId();
|
Map<String, List<TemplateJsonModel>> outsideOptions = nodeModel.getOutsideOptions();
|
String resultNodeCode = flowUtil.resultNodeCode(flowMethod);
|
List<TemplateJsonModel> templateJsonModelList = outsideOptions.get(resultNodeCode) != null ? outsideOptions.get(resultNodeCode) : new ArrayList<>();
|
FlowModel outsideModel = JsonUtil.getJsonToBean(flowModel, FlowModel.class);
|
outsideModel.setNodeCode(nodeModel.getNodeId());
|
TemplateNodeEntity resultNode = nodeEntityList.stream().filter(e -> Objects.equals(e.getNodeCode(), resultNodeCode)).findFirst().orElse(null);
|
if (resultNode != null) {
|
outsideModel.setFormData(flowUtil.infoData(resultNode.getFormId(), taskEntity.getId()));
|
}
|
Map<String, String> parameterData = outsideData(outsideModel, templateJsonModelList, FlowContextHolder.getAllData(), resultNodeCode, eventId);
|
//保存外部节点事件数据
|
EventLogEntity eventLog = new EventLogEntity();
|
eventLog.setId(eventId);
|
eventLog.setTaskId(taskEntity.getId());
|
eventLog.setNodeId(model.getTaskId());
|
eventLog.setNodeName(nodeModel.getNodeName());
|
eventLog.setNodeCode(nodeModel.getNodeId());
|
eventLog.setType(nodeModel.getType());
|
eventLog.setUpNode(resultNodeCode);
|
eventLog.setInterfaceId(nodeModel.getFormId());
|
eventLog.setData(JsonUtil.getObjectToString(formData));
|
eventLog.setStatus(FlowNature.Lose);
|
if (StringUtil.isNotEmpty(operatorEntity.getHandleId())) {
|
eventLog.setCreatorUserId(operatorEntity.getHandleId());
|
}
|
eventLogMapper.create(eventLog);
|
EventModel event = JsonUtil.getJsonToBean(eventLog, EventModel.class);
|
event.setParameterData(parameterData);
|
FlowEventHolder.addOutsideEvent(event, FlowContextHolder.getAllData());
|
} else {
|
//子流程
|
handleSubFlow(nodeEntity, flowModel);
|
}
|
continue;
|
}
|
dataTransfer(flowMethod);
|
flowMethod.setNodeModel(nodeModel);
|
flowMethod.setFormData(formData);
|
flowMethod.setDeploymentId(deploymentId);
|
flowMethod.setNodeCode(nodeEntity.getNodeCode());
|
flowMethod.setNodes(nodes);
|
// 节点自动审批
|
if (taskEntity.getRejectDataId() == null) {
|
int flag = checkAuto(flowMethod);
|
if (flag == 1 || flag == 2) {
|
// 判断下一级是否存在候选人，存在候选人返回false
|
List<NodeModel> nextApprover;
|
boolean mark = true;
|
try {
|
nextApprover = flowUtil.getNextApprover(flowMethod);
|
} catch (WorkFlowException e) {
|
nextApprover = null;
|
mark = false;
|
}
|
Map<String, Boolean> resMap = conditionUtil.handleCondition(flowMethod);
|
try {
|
conditionUtil.checkCondition(resMap, nodes);
|
} catch (WorkFlowException e) {
|
mark = false;
|
}
|
// 下一节点的条件判断不满足，不触发系统审批
|
if (mark) {
|
boolean isBranch = flowUtil.checkBranch(nodeModel);
|
int nextError = flowUtil.checkNextError(flowModel, nextApprover, false, false);
|
if (!isBranch && flowUtil.checkNextCandidates(nextApprover) && nextError == 0) {
|
flowModel.setHandleOpinion("系统审批");
|
flowModel.setSignImg(null);
|
flowModel.setFileList(null);
|
flowModel.setHandleStatus(flag == 1 ? FlowNature.AuditCompletion : FlowNature.RejectCompletion);
|
flowMethod.setFlowModel(JsonUtil.getJsonToBean(flowModel, FlowModel.class));
|
flowMethod.setNodeModel(nodeModel);
|
OperatorEntity operator = saveSystemOperator(flowMethod);
|
SystemAuditModel systemAuditModel = new SystemAuditModel();
|
systemAuditModel.setOperator(operator);
|
systemAuditModel.setFlowModel(flowMethod.getFlowModel());
|
SystemAuditHolder.add(systemAuditModel);
|
continue;
|
}
|
}
|
}
|
}
|
|
// 获取审批人
|
flowMethod.setErrorRule(true);
|
flowMethod.setExtraRule(true);
|
List<String> userIds = flowUtil.userListAll(flowMethod);
|
// 获取正常的用户
|
List<UserEntity> users = serviceUtil.getUserName(userIds, true);
|
// 全局异常处理
|
if (users.isEmpty()) {
|
// 自动通过
|
Integer pass = flowMethod.getPass();
|
if (pass > 0) {
|
// 自动审批 要判断候选人等
|
boolean mark = true;
|
List<NodeModel> nextApprover;
|
try {
|
nextApprover = flowUtil.getNextApprover(flowMethod);
|
} catch (WorkFlowException e) {
|
// 异常节点（默认通过）下条件不满足、候选人，走admin兜底方案
|
nextApprover = null;
|
mark = false;
|
}
|
Map<String, Boolean> resMap = conditionUtil.handleCondition(flowMethod);
|
try {
|
conditionUtil.checkCondition(resMap, nodes);
|
} catch (WorkFlowException e) {
|
mark = false;
|
}
|
if (mark && !flowUtil.checkBranch(nodeModel) && flowUtil.checkNextCandidates(nextApprover)) {
|
flowModel.setHandleOpinion(ObjectUtil.equals(nodeModel.getType(), NodeEnum.processing.getType()) ? "默认办理通过" : "默认审批通过");
|
flowModel.setSignImg(null);
|
flowModel.setFileList(null);
|
flowModel.setHandleStatus(FlowNature.AuditCompletion);
|
flowMethod.setFlowModel(JsonUtil.getJsonToBean(flowModel, FlowModel.class));
|
flowMethod.setNodeModel(nodeModel);
|
OperatorEntity operator = saveSystemOperator(flowMethod);
|
SystemAuditModel systemAuditModel = new SystemAuditModel();
|
systemAuditModel.setOperator(operator);
|
systemAuditModel.setFlowModel(flowMethod.getFlowModel());
|
SystemAuditHolder.add(systemAuditModel);
|
continue;
|
} else {
|
String admin = serviceUtil.getAdmin();
|
UserEntity userEntity = serviceUtil.getUserInfo(admin);
|
users.add(userEntity);
|
}
|
}
|
// 上一节点审批人指定处理人
|
Integer node = flowMethod.getNode();
|
if (node > 0) {
|
flowUtil.handleErrorRule(nodeModel, errorList);
|
}
|
// 无法提交
|
Integer notSubmit = flowMethod.getNotSubmit();
|
if (notSubmit > 0) {
|
throw new WorkFlowException(MsgCode.WF061.get());
|
}
|
}
|
userIds = users.stream().map(UserEntity::getId).collect(Collectors.toList());
|
flowMethod.setNodeModel(nodeModel);
|
flowMethod.setUserIds(userIds);
|
flowMethod.setFlowModel(flowModel);
|
List<OperatorEntity> operator = createOperator(flowMethod);
|
list.addAll(operator);
|
//保存逐级用户数据
|
LaunchUserEntity launchUser = flowMethod.getLaunchUser();
|
if (launchUser != null) {
|
launchUserMapper.insert(launchUser);
|
}
|
}
|
|
if (!errorList.isEmpty()) {
|
AuditModel model = new AuditModel();
|
model.setErrorCodeList(new HashSet<>(errorList));
|
throw new WorkFlowException(200, JsonUtil.getObjectToString(model));
|
}
|
addOperatorList(list, flowModel);
|
return list;
|
}
|
|
|
public CandidateCheckVo checkCandidates(String id, CandidateCheckFo fo) throws WorkFlowException {
|
CandidateCheckVo vo = new CandidateCheckVo();
|
List<CandidateListModel> list = new ArrayList<>();
|
|
String flowId = fo.getFlowId();
|
String nodeCode = null;
|
Map<String, Object> formData = fo.getFormData();
|
String taskId = fo.getId();
|
|
TemplateEntity template;
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(flowId);
|
if (null == jsonEntity) {
|
template = templateMapper.getInfo(flowId);
|
jsonEntity = templateJsonMapper.getInfo(template.getFlowId());
|
} else {
|
template = templateMapper.getInfo(jsonEntity.getTemplateId());
|
}
|
if (ObjectUtil.equals(id, FlowNature.ParentId)) {
|
if (!ObjectUtil.equals(template.getStatus(), TemplateStatueEnum.up.getCode())) {
|
throw new WorkFlowException(MsgCode.WF140.get());
|
}
|
} else {
|
List<Integer> templateStatus = ImmutableList.of(TemplateStatueEnum.up.getCode(), TemplateStatueEnum.downContinue.getCode());
|
if (!templateStatus.contains(template.getStatus())) {
|
throw new WorkFlowException(MsgCode.WF140.get());
|
}
|
}
|
if (StringUtil.isNotBlank(fo.getDelegateUser())) {
|
List<String> launchPermission = serviceUtil.getPermission(fo.getDelegateUser());
|
if (ObjectUtil.equals(template.getVisibleType(), FlowNature.Authority) && !launchPermission.contains(template.getId())) {
|
throw new WorkFlowException(MsgCode.WF129.get());
|
}
|
}
|
|
List<TemplateNodeEntity> nodeEntities = templateNodeMapper.getList(jsonEntity.getId());
|
|
Map<String, NodeModel> nodes = new HashMap<>();
|
for (TemplateNodeEntity nodeEntity : nodeEntities) {
|
nodes.put(nodeEntity.getNodeCode(), JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class));
|
}
|
NodeModel global = nodes.get(NodeEnum.global.getType());
|
|
TemplateNodeEntity currentNode;
|
OperatorEntity operatorEntity = new OperatorEntity();
|
// 默认获取开始节点编码
|
if (StringUtil.equals(id, FlowNature.ParentId)) {
|
currentNode = nodeEntities.stream()
|
.filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(null);
|
} else {
|
operatorEntity = operatorMapper.getInfo(id);
|
if (operatorEntity == null) {
|
throw new WorkFlowException(MsgCode.FA001.get());
|
}
|
// 加签的经办无需选择候选人
|
if (!ObjectUtil.equals(operatorEntity.getParentId(), FlowNature.ParentId)) {
|
vo.setList(list);
|
return vo;
|
}
|
String finalNodeCode = operatorEntity.getNodeCode();
|
currentNode = nodeEntities.stream().filter(e -> StringUtil.equals(finalNodeCode, e.getNodeCode())).findFirst().orElse(null);
|
taskId = operatorEntity.getTaskId();
|
}
|
RevokeEntity revokeEntity = revokeMapper.getRevokeTask(taskId);
|
if (null != revokeEntity) {
|
vo.setList(list);
|
return vo;
|
}
|
if (null == currentNode) {
|
throw new WorkFlowException(MsgCode.WF076.get());
|
}
|
nodeCode = currentNode.getNodeCode();
|
NodeModel currentNodeModel = nodes.get(nodeCode);
|
String divideRule = currentNodeModel.getDivideRule();
|
boolean branchFlow = ObjectUtil.equals(DivideRuleEnum.CHOOSE.getType(), divideRule);
|
|
UserInfo userInfo = UserProvider.getUser();
|
// 判断条件
|
TaskEntity taskEntity = taskMapper.selectById(taskId);
|
if (taskEntity == null) {
|
FlowModel flowModel = new FlowModel();
|
flowModel.setFlowId(flowId);
|
flowModel.setFormData(formData);
|
flowModel.setDelegateUser(fo.getDelegateUser());
|
flowModel.setUserInfo(userInfo);
|
flowModel.setJsonEntity(jsonEntity);
|
taskEntity = flowUtil.createEntity(flowModel, template, nodes);
|
}
|
if (ObjectUtil.isNotEmpty(taskEntity.getRejectDataId())) {
|
return vo;
|
}
|
getGlobalParam(taskEntity, nodes.get(nodeCode), nodes.get(NodeEnum.global.getType()), formData);
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setDeploymentId(jsonEntity.getFlowableId());
|
flowMethod.setNodeCode(nodeCode);
|
flowMethod.setFormData(formData);
|
flowMethod.setNodes(nodes);
|
flowMethod.setTaskEntity(taskEntity);
|
flowMethod.setUserInfo(userInfo);
|
flowMethod.setIsCandidates(false);
|
Map<String, Boolean> resMap = conditionUtil.handleCondition(flowMethod);
|
|
CounterSignConfig counterSignConfig = currentNodeModel.getCounterSignConfig();
|
boolean delay = ObjectUtil.equals(counterSignConfig.getCalculateType(), FlowNature.CALCULATE_TYPE_DELAY);
|
// 全是false，说明没有分支可走
|
if (!branchFlow && !delay) {
|
// 拒绝 且 配置拒绝不允许继续流转 直接返回
|
if (ObjectUtil.equals(fo.getHandleStatus(), FlowNature.RejectCompletion) && !global.getHasContinueAfterReject()) {
|
vo.setList(list);
|
return vo;
|
}
|
conditionUtil.checkCondition(resMap, nodes);
|
} else {
|
// 选择分支、且不是最后一个审批人，直接返回
|
// 删除原先存在的下一级候选人
|
NextOrPrevFo nextOrPrevFo = new NextOrPrevFo();
|
nextOrPrevFo.setDeploymentId(jsonEntity.getFlowableId());
|
nextOrPrevFo.setTaskKey(currentNode.getNodeCode());
|
List<FlowableNodeModel> nextModels = flowAbleUrl.getNext(nextOrPrevFo);
|
List<String> nextCodes = nextModels.stream().map(FlowableNodeModel::getId).collect(Collectors.toList());
|
if (CollectionUtil.isNotEmpty(nextCodes)) {
|
candidatesMapper.deleteByCodes(taskId, nextCodes);
|
}
|
operatorEntity.setHandleStatus(fo.getHandleStatus());
|
flowMethod.setOperatorEntity(operatorEntity);
|
flowMethod.setNodeModel(currentNodeModel);
|
flowMethod.setHandleStatus(fo.getHandleStatus());
|
flowMethod.setAuditFlag(true);
|
boolean auditRes = checkAudit(flowMethod);
|
if (!auditRes) {
|
return vo;
|
}
|
if (ObjectUtil.equals(flowMethod.getHandleStatus(), FlowNature.RejectCompletion) && !global.getHasContinueAfterReject()) {
|
return vo;
|
}
|
}
|
List<String> typeList = ImmutableList.of(NodeEnum.eventTrigger.getType(), NodeEnum.timeTrigger.getType(),
|
NodeEnum.noticeTrigger.getType(), NodeEnum.webhookTrigger.getType(), NodeEnum.trigger.getType());
|
List<String> connectList = global.getConnectList();
|
List<String> flows = flowMethod.getOutgoingFlows();
|
// 判断排他
|
boolean isExclusive = ObjectUtil.equals(currentNodeModel.getDivideRule(), DivideRuleEnum.EXCLUSIVE.getType());
|
boolean exclusive = false;
|
// 根据true的分支获取节点
|
for (String key : flows) {
|
if (!connectList.contains(key)) {
|
continue;
|
}
|
if (!branchFlow) {
|
if (!resMap.get(key)) {
|
continue;
|
}
|
if (exclusive) { // 标识为true，说明排他的第一个条件为true
|
break;
|
}
|
if (isExclusive) {// 排他网关 变更标识
|
exclusive = true;
|
}
|
}
|
// 获取连接线的目标节点
|
List<String> nodeKey = flowAbleUrl.getTaskKeyAfterFlow(jsonEntity.getFlowableId(), key);
|
if (CollectionUtil.isEmpty(nodeKey)) {
|
continue;
|
}
|
NodeModel nodeModel = nodes.get(nodeKey.get(0));
|
if (null == nodeModel) {
|
continue;
|
}
|
if (typeList.contains(nodeModel.getType())) {
|
continue;
|
}
|
//处理全局的数据传递
|
Map<String, Object> dataMap = new HashMap<>();
|
for (String dataKey : formData.keySet()) {
|
dataMap.put(dataKey, formData.get(dataKey));
|
dataMap.put(dataKey + FlowNature.FORM_FIELD_SUFFIX, formData.get(dataKey));
|
}
|
FlowMethod jsonToBean = JsonUtil.getJsonToBean(flowMethod, FlowMethod.class);
|
jsonToBean.setNodeModel(nodeModel);
|
jsonToBean.setNodeEntityList(nodeEntities);
|
jsonToBean.setDeploymentId(jsonEntity.getFlowableId());
|
List<Assign> assignList = nodeModel.getAssignList().stream().filter(t -> t.getNodeId().equals(currentNode.getNodeCode())).collect(Collectors.toList());
|
Map<String, Object> nodeDataAll = flowUtil.formData(dataMap, assignList, taskEntity, jsonToBean);
|
getGlobalParam(taskEntity, nodeModel, nodes.get(NodeEnum.global.getType()), nodeDataAll);
|
operatorEntity.setHandleId(StringUtil.isEmpty(operatorEntity.getHandleId()) ? taskEntity.getCreatorUserId() : operatorEntity.getHandleId());
|
jsonToBean.setNodeEntityList(nodeEntities);
|
jsonToBean.setNodeEntity(nodeEntities.stream().filter(t -> t.getNodeCode().equals(nodeKey.get(0))).findFirst().orElse(new TemplateNodeEntity()));
|
FlowModel flowModel = new FlowModel();
|
flowModel.setOperatorEntity(operatorEntity);
|
flowModel.setDeploymentId(jsonEntity.getFlowableId());
|
flowModel.setFormData(nodeDataAll);
|
jsonToBean.setFlowModel(flowModel);
|
getCandidateListModel(jsonToBean, list);
|
List<String> nextTypeList = ImmutableList.of(NodeEnum.subFlow.getType());
|
if (nextTypeList.contains(nodeModel.getType())) {
|
// 判断子流程、外部节点，获取审批节点
|
jsonToBean.setNodeCode(nodeModel.getNodeId());
|
jsonToBean.setNextSubFlow(true);
|
List<NodeModel> nextApprover = flowUtil.getNextApprover(jsonToBean);
|
for (NodeModel node : nextApprover) {
|
List<Assign> nodeAssignList = node.getAssignList().stream().filter(t -> t.getNodeId().equals(currentNode.getNodeCode())).collect(Collectors.toList());
|
flowModel.setFormData(flowUtil.formData(dataMap, nodeAssignList, taskEntity, jsonToBean));
|
getGlobalParam(taskEntity, node, nodes.get(NodeEnum.global.getType()), nodeDataAll);
|
jsonToBean.setNodeModel(node);
|
jsonToBean.setNodeEntity(nodeEntities.stream().filter(t -> t.getNodeCode().equals(node.getNodeId())).findFirst().orElse(new TemplateNodeEntity()));
|
getCandidateListModel(jsonToBean, list);
|
}
|
}
|
}
|
// 获取已选择的候选人
|
Integer counterSign = currentNodeModel.getCounterSign();
|
if (StringUtil.isNotBlank(taskId) && !ObjectUtil.equals(counterSign, FlowNature.FixedApprover)) {
|
for (CandidateListModel model : list) {
|
List<CandidatesEntity> candidates = candidatesMapper.getList(taskId, model.getNodeCode());
|
String candidateStr = candidates.stream().map(CandidatesEntity::getCandidates).collect(Collectors.joining(","));
|
if (StringUtil.isNotEmpty(candidateStr)) {
|
List<String> selected = new ArrayList<>();
|
List<String> userIds = Arrays.stream(candidateStr.split(",")).distinct().collect(Collectors.toList());
|
List<UserEntity> userList = serviceUtil.getUserName(userIds);
|
for (UserEntity user : userList) {
|
selected.add(user.getRealName() + "/" + user.getAccount());
|
}
|
model.setSelected(String.join(";", selected));
|
}
|
}
|
}
|
if (branchFlow) {
|
vo.setType(1);
|
list = list.stream().peek(e -> e.setIsBranchFlow(true)).collect(Collectors.toList());
|
} else {
|
CandidateListModel listModel = list.stream().filter(e -> ObjectUtil.equals(e.getIsCandidates(), true)).findFirst().orElse(null);
|
if (null != listModel) {
|
vo.setType(2);
|
}
|
}
|
vo.setList(list);
|
return vo;
|
}
|
|
|
public void getCandidateListModel(FlowMethod flowMethod, List<CandidateListModel> list) throws WorkFlowException {
|
NodeModel nodeModel = flowMethod.getNodeModel();
|
CandidateListModel listModel = list.stream().filter(e -> ObjectUtil.equals(nodeModel.getNodeId(), e.getNodeCode())).findFirst().orElse(null);
|
if (null != listModel) {
|
return;
|
}
|
CandidateListModel model = new CandidateListModel();
|
model.setNodeCode(nodeModel.getNodeId());
|
model.setNodeName(nodeModel.getNodeName());
|
boolean isCandidate = nodeModel.getIsCandidates();
|
model.setIsCandidates(isCandidate);
|
if (isCandidate) {
|
List<String> userIds = flowUtil.userListAll(flowMethod);
|
List<UserEntity> users = serviceUtil.getUserName(userIds, true);
|
model.setHasCandidates(!users.isEmpty());
|
model.setSelectIdList(users.stream().map(UserEntity::getId).collect(Collectors.toList()));
|
}
|
list.add(model);
|
}
|
|
//-------------------------------circulateUtil------------------------------------------------------------
|
|
public List<CirculateEntity> circulateList(FlowMethod flowMethod) throws WorkFlowException {
|
FlowModel flowModel = flowMethod.getFlowModel();
|
List<CirculateEntity> circulateList = new ArrayList<>();
|
TaskEntity task = flowMethod.getTaskEntity();
|
OperatorEntity operator = flowMethod.getOperatorEntity();
|
TemplateNodeEntity nodeEntity = flowMethod.getNodeEntity();
|
NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
List<String> userIdAll = new ArrayList<>();
|
//附加规则
|
if (!ObjectUtil.equals(flowMethod.getType(), RecordEnum.reject.getCode())) {
|
userIdAll = serviceUtil.getUserListAll(nodeModel.getCirculateUser());
|
flowUtil.rule(userIdAll, task.getId(), nodeModel.getExtraCopyRule());
|
//抄送自己
|
if (nodeModel.getIsInitiatorCopy()) {
|
userIdAll.add(task.getCreatorUserId());
|
}
|
//抄送表单变量
|
if (nodeModel.getIsFormFieldCopy()) {
|
flowMethod.setIsAssign(false);
|
Map<String, Object> dataAll = flowUtil.createOrUpdate(flowMethod);
|
Object data = dataAll.get(nodeModel.getCopyFormField() + FlowNature.FORM_FIELD_SUFFIX);
|
if (data != null) {
|
List<String> list = new ArrayList<>();
|
try {
|
list.addAll(JsonUtil.getJsonToList(String.valueOf(data), String.class));
|
} catch (Exception e) {
|
}
|
if (data instanceof List) {
|
list.addAll((List) data);
|
} else {
|
list.addAll(Arrays.asList(String.valueOf(data).split(",")));
|
}
|
List<String> id = new ArrayList<>();
|
for (String s : list) {
|
id.add(s.split("--")[0]);
|
}
|
List<UserRelationEntity> listByObjectIdAll = serviceUtil.getListByObjectIdAll(id);
|
List<String> userList = serviceUtil.getUserListAll(list);
|
List<String> userPosition = listByObjectIdAll.stream().map(UserRelationEntity::getUserId).collect(Collectors.toList());
|
List<String> handleIdAll = new ArrayList<>();
|
handleIdAll.addAll(userPosition);
|
handleIdAll.addAll(id);
|
handleIdAll.addAll(userList);
|
userIdAll.addAll(handleIdAll);
|
}
|
}
|
}
|
//指定传阅人
|
userIdAll.addAll(Arrays.asList(StringUtil.isNotEmpty(flowModel.getCopyIds()) ? flowModel.getCopyIds().split(",") : new String[]{}));
|
//获取最新用户
|
List<UserEntity> userList = serviceUtil.getUserName(userIdAll, true);
|
List<String> userIdList = circulateMapper.getNodeList(operator.getTaskId(), operator.getNodeId()).stream().map(CirculateEntity::getUserId).collect(Collectors.toList());
|
for (UserEntity userEntity : userList) {
|
if (userIdList.contains(userEntity.getId())){
|
continue;
|
}
|
CirculateEntity circulate = new CirculateEntity();
|
circulate.setId(RandomUtil.uuId());
|
circulate.setUserId(userEntity.getId());
|
circulate.setNodeCode(nodeModel.getNodeId());
|
circulate.setNodeName(nodeModel.getNodeName());
|
circulate.setTaskId(task.getId());
|
circulate.setCirculateRead(0);
|
circulate.setOperatorId(operator.getId());
|
circulate.setNodeId(operator.getNodeId());
|
circulate.setCreatorTime(new Date());
|
circulateList.add(circulate);
|
}
|
circulateMapper.insert(circulateList);
|
return circulateList;
|
}
|
|
public List<RecordVo> getCirculateList(List<CirculateEntity> list){
|
List<RecordVo> vos = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(list)) {
|
List<UserEntity> userList = serviceUtil.getUserName(list.stream().map(CirculateEntity::getUserId).collect(Collectors.toList()));
|
for (CirculateEntity circulate : list) {
|
RecordVo vo = JsonUtil.getJsonToBean(circulate, RecordVo.class);
|
UserEntity userEntity = userList.stream().filter(t -> t.getId().equals(circulate.getUserId())).findFirst().orElse(null);
|
vo.setUserName(userEntity != null ? userEntity.getRealName() + "/" + userEntity.getAccount() : "");
|
if (userEntity != null) {
|
vo.setHeadIcon(UploaderUtil.uploaderImg(userEntity.getHeadIcon()));
|
}
|
vos.add(vo);
|
}
|
}
|
return vos;
|
}
|
|
//-------------------------------triggerUtil------------------------------------------------------------
|
|
public List<TriggerDataModel> getTriggerDataModel(TriggerDataFo fo) {
|
String modelId = fo.getModelId();
|
Integer trigger = fo.getTrigger();
|
List<String> dataId = fo.getDataId();
|
List<Map<String, Object>> dataMap = fo.getDataMap();
|
List<String> updateFields = fo.getUpdateFields();
|
List<TriggerDataModel> res = new ArrayList<>();
|
Map<String, NodeModel> triggerMap = this.getTriggerNode(modelId, trigger);
|
if (CollectionUtil.isNotEmpty(triggerMap)) {
|
for (String key : triggerMap.keySet()) {
|
NodeModel nodeModel = triggerMap.get(key);
|
// 判断指定字段修改
|
if (this.checkUpdateField(trigger, nodeModel, updateFields)) {
|
continue;
|
}
|
if (CollectionUtil.isNotEmpty(dataMap)) {
|
TriggerDataModel model = new TriggerDataModel();
|
model.setData(JsonUtil.getObjectToString(dataMap));
|
model.setFlowId(key);
|
res.add(model);
|
continue;
|
}
|
List<Map<String, Object>> dataList = this.getDataList(nodeModel, new HashMap<>(), dataId);
|
if (!dataList.isEmpty()) {
|
TriggerDataModel model = new TriggerDataModel();
|
model.setData(JsonUtil.getObjectToString(dataList));
|
model.setFlowId(key);
|
res.add(model);
|
}
|
}
|
}
|
return res;
|
}
|
|
// true表示 指定字段没有发生修改
|
public boolean checkUpdateField(Integer trigger, NodeModel nodeModel, List<String> updateFields) {
|
List<String> updateFieldList = nodeModel.getUpdateFieldList();
|
if (CollectionUtil.isEmpty(updateFieldList)) {
|
return false;
|
}
|
if (ObjectUtil.equals(nodeModel.getType(), NodeEnum.eventTrigger.getType()) && ObjectUtil.equals(trigger, 2)) {
|
// 任意字段发生修改，结果集合为空 说明指定字段（updateFieldList）不存在发生修改的字段（updateFields）中
|
List<String> list = updateFieldList.stream().filter(updateFields::contains).collect(Collectors.toList());
|
return CollectionUtil.isEmpty(list);
|
}
|
return false;
|
}
|
|
public Map<String, NodeModel> getTriggerNode(String formId, Integer trigger) {
|
QueryWrapper<TemplateNodeEntity> queryWrapper = new QueryWrapper<>();
|
List<String> typeList = ImmutableList.of(NodeEnum.eventTrigger.getType());
|
queryWrapper.lambda().in(TemplateNodeEntity::getNodeType, typeList)
|
.eq(TemplateNodeEntity::getFormId, formId);
|
List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.selectList(queryWrapper);
|
|
List<String> flowIds = new ArrayList<>();
|
for (TemplateNodeEntity nodeEntity : nodeEntityList) {
|
NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
if (ObjectUtil.equals(nodeModel.getTriggerFormEvent(), trigger)) {
|
flowIds.add(nodeEntity.getFlowId());
|
}
|
}
|
flowIds = flowIds.stream().distinct().collect(Collectors.toList());
|
|
// 获取启用的任务流程id，用于过滤节点
|
List<String> filterFlowIds = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(flowIds)) {
|
QueryWrapper<TemplateEntity> wrapper = new QueryWrapper<>();
|
wrapper.lambda().in(TemplateEntity::getFlowId, flowIds).eq(TemplateEntity::getType, FlowNature.Quest);
|
List<TemplateEntity> templateList = templateMapper.selectList(wrapper);
|
filterFlowIds = templateList.stream().map(TemplateEntity::getFlowId).collect(Collectors.toList());
|
}
|
|
// Map<flowId, 触发节点>
|
Map<String, NodeModel> map = new HashMap<>();
|
for (String flowId : filterFlowIds) {
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getFlowId(), flowId)).findFirst().orElse(null);
|
if (null != nodeEntity) {
|
map.put(flowId, JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class));
|
}
|
}
|
return map;
|
}
|
|
// @DSTransactional
|
public void handleTimeTrigger(TriggerModel triggerModel) throws Exception {
|
String flowId = triggerModel.getId();
|
UserInfo userInfo = triggerModel.getUserInfo();
|
|
List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(flowId);
|
TemplateNodeEntity timeTrigger = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.timeTrigger.getType())).findFirst().orElse(null);
|
if (null == timeTrigger) {
|
return;
|
}
|
// TemplateJsonEntity jsonEntity = templateJsonService.getById(flowId);
|
// NextOrPrevFo fo = new NextOrPrevFo();
|
// fo.setDeploymentId(jsonEntity.getFlowableId());
|
// fo.setTaskKey(timeTrigger.getNodeCode());
|
// List<FlowableNodeModel> next = flowAbleUrl.getNext(fo);
|
// if (CollectionUtil.isEmpty(next)) {
|
// return;
|
// }
|
// String nodeCode = next.get(0).getId();
|
// TemplateNodeEntity nodeEntity = nodeEntityList.stream().filter(e -> ObjectUtil.equals(e.getNodeCode(), nodeCode)).findFirst().orElse(null);
|
// ExecuteModel executeModel = new ExecuteModel();
|
// executeModel.setNodeModel(JsonUtil.getJsonToBean(nodeEntity, NodeModel.class));
|
// executeModel.setUserInfo(userInfo);
|
// List<Map<String, Object>> dataList = this.getData(executeModel);
|
|
ExecuteModel model = new ExecuteModel();
|
model.setFlowId(flowId);
|
model.setUserInfo(userInfo);
|
// model.setDataList(dataList);
|
this.execute(model);
|
}
|
|
// @DSTransactional
|
public void handleTrigger(TriggerDataModel dataModel, UserInfo userInfo) throws Exception {
|
List<Map<String, Object>> dataList = JsonUtil.getJsonToListMap(dataModel.getData());
|
ExecuteModel model = new ExecuteModel();
|
model.setFlowId(dataModel.getFlowId());
|
model.setDataList(dataList);
|
model.setUserInfo(userInfo);
|
model.setParentId(FlowNature.ParentId);
|
this.execute(model);
|
}
|
|
// 执行
|
public void execute(ExecuteModel model) throws Exception {
|
String flowId = model.getFlowId();
|
List<Map<String, Object>> dataList = model.getDataList();
|
String parentId = model.getParentId();
|
// if (dataList.isEmpty()) {
|
// return;
|
// }
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(flowId);
|
if (null != jsonEntity) {
|
TemplateEntity template = templateMapper.selectById(jsonEntity.getTemplateId());
|
if (template == null) {
|
return;
|
}
|
if (model.getTaskId() == null && !ObjectUtil.equals(template.getStatus(), TemplateStatueEnum.up.getCode())) {
|
return;
|
}
|
TaskEntity taskEntity = StringUtil.isNotEmpty(model.getTaskId()) ? taskMapper.selectById(model.getTaskId()) : null;
|
if (taskEntity != null) {
|
model.setTaskEntity(taskEntity);
|
}
|
model.setJsonEntity(jsonEntity);
|
// 重试判断
|
TriggerTaskEntity parentTask = triggerTaskMapper.selectById(parentId);
|
boolean isParentId = parentTask != null;
|
|
List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(flowId);
|
model.setNodeEntityList(nodeEntityList);
|
|
// 保存触发任务
|
TriggerTaskEntity entity = new TriggerTaskEntity();
|
entity.setId(RandomUtil.uuId());
|
entity.setFullName(template.getFullName());
|
entity.setParentId(isParentId ? parentTask.getId() : parentId);
|
entity.setParentTime(isParentId ? parentTask.getStartTime() : null);
|
entity.setFlowId(flowId);
|
entity.setStartTime(new Date());
|
entity.setData(JsonUtil.getObjectToString(dataList));
|
entity.setStatus(TaskStatusEnum.RUNNING.getCode());
|
entity.setTaskId(StringUtil.isNotEmpty(model.getTaskId()) ? model.getTaskId() : null);
|
entity.setNodeCode(StringUtil.isNotEmpty(model.getNodeCode()) ? model.getNodeCode() : null);
|
entity.setNodeId(StringUtil.isNotEmpty(model.getNodeId()) ? model.getNodeId() : null);
|
|
TemplateNodeEntity start = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.start.getType())).findFirst().orElse(new TemplateNodeEntity());
|
String deploymentId = jsonEntity.getFlowableId();
|
|
Map<String, Object> variables = this.getVariables(deploymentId, start.getNodeCode());
|
String instanceId = model.getInstanceId();
|
if (StringUtil.isEmpty(model.getInstanceId())) {
|
instanceId = flowAbleUrl.startInstance(deploymentId, variables);
|
entity.setInstanceId(instanceId);
|
model.setInstanceId(instanceId);
|
}
|
if (null != model.getIsAsync()) {
|
entity.setIsAsync(model.getIsAsync());
|
}
|
entity.setEngineType(1);
|
|
UserInfo userInfo = model.getUserInfo();
|
if (null != userInfo) {
|
entity.setCreatorUserId(userInfo.getUserId());
|
}
|
triggerTaskMapper.saveTriggerTask(entity);
|
model.setTriggerTask(entity);
|
if (StringUtil.isEmpty(entity.getTaskId())) {
|
triggerRecordMapper.createStart(entity.getId());
|
}
|
|
this.globalMsg(model, 1);
|
|
List<FlowableTaskModel> taskModelList = flowAbleUrl.getCurrentTask(instanceId);
|
// 触发节点
|
List<String> typeList = ImmutableList.of(NodeEnum.eventTrigger.getType(), NodeEnum.timeTrigger.getType(),
|
NodeEnum.noticeTrigger.getType(), NodeEnum.webhookTrigger.getType(), NodeEnum.trigger.getType());
|
|
String triggerKey = model.getTriggerKey();
|
|
TemplateNodeEntity triggerNode = null;
|
if (StringUtil.isNotEmpty(triggerKey)) {
|
triggerNode = nodeEntityList.stream().filter(e -> ObjectUtil.equals(e.getNodeCode(), triggerKey)).findFirst().orElse(null);
|
} else {
|
triggerNode = nodeEntityList.stream().filter(e -> typeList.contains(e.getNodeType())).findFirst().orElse(null);
|
}
|
if (null != triggerNode) {
|
for (Map<String, Object> map : dataList) {
|
map.put(DataInterfaceVarConst.FORM_ID, map.get(FlowFormConstant.ID));
|
}
|
TriggerHolder.addData(triggerNode.getNodeCode(), dataList);
|
NodeModel nodeModel = JsonUtil.getJsonToBean(triggerNode.getNodeJson(), NodeModel.class);
|
|
TemplateNodeEntity finalTriggerNode = triggerNode;
|
FlowableTaskModel taskModel = taskModelList.stream()
|
.filter(e -> ObjectUtil.equals(e.getTaskKey(), finalTriggerNode.getNodeCode())).findFirst().orElse(null);
|
if (null == taskModel) {
|
return;
|
}
|
triggerRecordMapper.create(entity, nodeModel, taskModel);
|
|
Map<String, Object> variableMap = this.getVariables(deploymentId, taskModel.getTaskKey());
|
this.complete(taskModel.getTaskId(), variableMap);
|
this.executeNode(model);
|
TriggerHolder.clear();
|
}
|
}
|
}
|
|
public Map<String, Object> getVariables(String deploymentId, String nodeCode) throws WorkFlowException {
|
OutgoingFlowsFo flowsFo = new OutgoingFlowsFo();
|
flowsFo.setDeploymentId(deploymentId);
|
flowsFo.setTaskKey(nodeCode);
|
List<String> outgoingFlows = flowAbleUrl.getOutgoingFlows(flowsFo);
|
Map<String, Object> variables = new HashMap<>();
|
for (String line : outgoingFlows) {
|
variables.put(line, true);
|
}
|
return variables;
|
}
|
|
public void complete(String id, Map<String, Object> variables) throws WorkFlowException {
|
CompleteFo fo = new CompleteFo();
|
fo.setTaskId(id);
|
fo.setVariables(variables);
|
flowAbleUrl.complete(fo);
|
}
|
|
public void executeNode(ExecuteModel model) throws WorkFlowException {
|
TemplateJsonEntity jsonEntity = model.getJsonEntity();
|
String deploymentId = jsonEntity.getFlowableId();
|
String instanceId = model.getInstanceId();
|
List<TemplateNodeEntity> nodeEntityList = model.getNodeEntityList();
|
TriggerTaskEntity triggerTask = model.getTriggerTask();
|
|
String groupId = model.getGroupId();
|
String taskId = model.getTaskId();
|
|
FlowableInstanceModel instance = flowAbleUrl.getInstance(instanceId);
|
if (null != instance && null != instance.getEndTime()) {
|
triggerRecordMapper.createEnd(triggerTask.getId());
|
triggerTask.setStatus(TaskStatusEnum.PASSED.getCode());
|
triggerTaskMapper.updateTriggerTask(triggerTask);
|
return;
|
}
|
List<FlowableTaskModel> taskModelList = flowAbleUrl.getCurrentTask(instanceId);
|
if (CollectionUtil.isNotEmpty(taskModelList)) {
|
// 统计执行节点的数量
|
int count = 0;
|
int executedCount = 0;
|
|
boolean multiple = taskModelList.size() > 1;
|
List<TriggerRecordEntity> recordList = triggerRecordMapper.getList(triggerTask.getId());
|
List<String> codeList = recordList.stream().map(TriggerRecordEntity::getNodeCode).collect(Collectors.toList());
|
|
List<String> nodeTypes = ImmutableList.of(NodeEnum.getData.getType(), NodeEnum.addData.getType(), NodeEnum.updateData.getType(), NodeEnum.deleteData.getType()
|
, NodeEnum.dataInterface.getType(), NodeEnum.message.getType(), NodeEnum.launchFlow.getType(), NodeEnum.schedule.getType());
|
|
for (FlowableTaskModel taskModel : taskModelList) {
|
// 任务流程的状态为终止，则结束
|
TriggerTaskEntity entity = triggerTaskMapper.selectById(triggerTask.getId());
|
if (null != entity && ObjectUtil.equals(entity.getStatus(), TaskStatusEnum.CANCEL.getCode())) {
|
return;
|
}
|
if (codeList.contains(taskModel.getTaskKey())) {
|
executedCount++;
|
continue;
|
}
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeCode(), taskModel.getTaskKey())).findFirst().orElse(null);
|
if (null != nodeEntity && nodeTypes.contains(nodeEntity.getNodeType())) {
|
NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
if (StringUtil.isNotBlank(groupId)) {
|
if (!ObjectUtil.equals(nodeModel.getGroupId(), groupId)) {
|
continue;
|
}
|
count++;
|
}
|
model.setNodeModel(nodeModel);
|
model.setCurrentNodeId(taskModel.getTaskId());
|
|
TriggerRecordEntity record = new TriggerRecordEntity();
|
record.setStartTime(new Date());
|
record.setNodeId(taskModel.getTaskId());
|
record.setNodeCode(taskModel.getTaskKey());
|
record.setNodeName(nodeModel.getNodeName());
|
record.setTriggerId(triggerTask.getId());
|
if (StringUtil.isNotEmpty(triggerTask.getTaskId())) {
|
record.setTaskId(triggerTask.getTaskId());
|
}
|
triggerRecordMapper.create(record);
|
|
NodeEnum node = NodeEnum.getNode(nodeEntity.getNodeType());
|
try {
|
switch (node) {
|
case getData:
|
List<Map<String, Object>> data = this.getData(model);
|
TriggerHolder.addData(nodeEntity.getNodeCode(), data);
|
break;
|
case addData:
|
this.addData(model);
|
break;
|
case updateData:
|
this.updateData(model);
|
break;
|
case deleteData:
|
this.deleteData(model);
|
break;
|
case message:
|
this.message(model);
|
break;
|
case launchFlow:
|
this.launchFlow(model);
|
break;
|
case dataInterface:
|
List<Map<String, Object>> maps = this.dataInterface(model);
|
//TriggerHolder.addData(nodeEntity.getNodeCode(), maps);
|
break;
|
case schedule:
|
this.createSchedule(model);
|
break;
|
}
|
} catch (Exception e) {
|
String msg = this.getErrMsg(e);
|
String errorMsg = msg;
|
if (e instanceof WorkFlowException) {
|
WorkFlowException workException = ((WorkFlowException) e);
|
errorMsg = workException.getDataMsg() != null ? workException.getDataMsg() : errorMsg;
|
}
|
record.setErrorTip(msg);
|
record.setErrorData(errorMsg);
|
record.setStatus(TriggerRecordEnum.EXCEPTION.getCode());
|
this.globalMsg(model, 2);
|
}
|
if (record.getStatus() == null) {
|
record.setStatus(TriggerRecordEnum.PASSED.getCode());
|
}
|
record.setEndTime(new Date());
|
triggerRecordMapper.updateById(record);
|
if (ObjectUtil.equals(record.getStatus(), TriggerRecordEnum.EXCEPTION.getCode())) {
|
if (!ObjectUtil.equals(triggerTask.getStatus(), TaskStatusEnum.EXCEPTION.getCode())) {
|
triggerTask.setStatus(TaskStatusEnum.EXCEPTION.getCode());
|
triggerTaskMapper.updateTriggerTask(triggerTask);
|
model.setTriggerTask(triggerTask);
|
}
|
if (multiple) {
|
continue;
|
} else {
|
throw new WorkFlowException(record.getErrorTip());
|
}
|
// triggerTask.setStatus(TaskStatusEnum.EXCEPTION.getCode());
|
// TriggerRecordHolder.addData(triggerTask, record);
|
// throw new WorkFlowException(record.getErrorTip());
|
}
|
if (StringUtil.isBlank(taskId)) {
|
Map<String, Object> variables = this.getVariables(deploymentId, taskModel.getTaskKey());
|
this.complete(taskModel.getTaskId(), variables);
|
} else {
|
// 嵌入的任务流程，最后的执行节点不能通过，否则退回会有问题
|
NextOrPrevFo fo = new NextOrPrevFo();
|
fo.setDeploymentId(deploymentId);
|
fo.setTaskKey(taskModel.getTaskKey());
|
List<FlowableNodeModel> next = flowAbleUrl.getNext(fo);
|
if (CollectionUtil.isNotEmpty(next)) {
|
Map<String, Object> variables = this.getVariables(deploymentId, taskModel.getTaskKey());
|
this.complete(taskModel.getTaskId(), variables);
|
}
|
}
|
}
|
}
|
if (executedCount == taskModelList.size()) {
|
return;
|
}
|
// 嵌入的任务流程可能存在多个，需要区分组别
|
if (StringUtil.isNotBlank(groupId) && count == 0) {
|
return;
|
}
|
this.executeNode(model);
|
}
|
}
|
|
private String getErrMsg(Exception e) {
|
ActionResult result = new ActionResult();
|
result.setCode(400);
|
result.setMsg(e.getMessage());
|
return JsonUtil.getObjectToString(result);
|
}
|
|
// -----------------------------------------------------------------------------
|
// 获取数据
|
public List<Map<String, Object>> getData(ExecuteModel model) throws WorkFlowException {
|
List<Map<String, Object>> dataList = new ArrayList<>();
|
|
NodeModel nodeModel = model.getNodeModel();
|
Integer formType = nodeModel.getFormType();
|
|
switch (formType) {
|
case 1:
|
case 2:
|
List<Map<String, Object>> list = this.getDataList(nodeModel, new HashMap<>(), new ArrayList<>());
|
dataList.addAll(list);
|
break;
|
case 3:
|
List<ActionResult> resultList = this.interfaceTemplateJson(model, new HashMap<>());
|
List<String> errList = new ArrayList<>();
|
for (ActionResult result : resultList) {
|
if (!ObjectUtil.equals(result.getCode(), 200)) {
|
errList.add(result.getMsg());
|
continue;
|
}
|
if (result.getData() instanceof List) {
|
List<Map<String, Object>> maps = this.castListMap(result.getData());
|
if (CollectionUtil.isNotEmpty(maps)) {
|
dataList.addAll(maps);
|
}
|
}
|
}
|
if (CollectionUtil.isNotEmpty(errList)) {
|
throw new WorkFlowException(errList.get(0));
|
}
|
break;
|
case 4:
|
List<Map<String, Object>> data = this.getDataList(nodeModel, new HashMap<>(), new ArrayList<>(), true);
|
String subTable = nodeModel.getSubTable();
|
for (Map<String, Object> map : data) {
|
Object obj = map.get(subTable);
|
if (null != obj) {
|
List<Map<String, Object>> mapList = this.castListMap(obj);
|
List<Map<String, Object>> resList = new ArrayList<>();
|
for (Map<String, Object> objectMap : mapList) {
|
Map<String, Object> resMap = new HashMap<>();
|
for (String key : objectMap.keySet()) {
|
if (ObjectUtil.equals(key, FlowFormConstant.ID)) {
|
resMap.put(key, objectMap.get(key));
|
} else {
|
resMap.put(subTable + "-" + key, objectMap.get(key));
|
}
|
}
|
resMap.put(FlowNature.SUB_TABLE, subTable);
|
resList.add(resMap);
|
}
|
dataList.addAll(resList);
|
}
|
}
|
break;
|
}
|
for (Map<String, Object> map : dataList) {
|
map.put(DataInterfaceVarConst.FORM_ID, map.get(FlowFormConstant.ID));
|
}
|
return dataList;
|
}
|
|
public List<Map<String, Object>> castListMap(Object obj) {
|
return this.castListMap(obj, String.class, Object.class);
|
}
|
|
// 对象转Map类型的List
|
public <K, V> List<Map<K, V>> castListMap(Object obj, Class<K> kClazz, Class<V> vClazz) {
|
List<Map<K, V>> result = new ArrayList<>();
|
if (obj instanceof List<?>) {
|
for (Object o : (List<?>) obj) {
|
if (o instanceof Map<?, ?>) {
|
Map<K, V> map = new HashMap<>(16);
|
for (Map.Entry<?, ?> entry : ((Map<?, ?>) o).entrySet()) {
|
map.put(kClazz.cast(entry.getKey()), vClazz.cast(entry.getValue()));
|
}
|
result.add(map);
|
}
|
}
|
}
|
return result;
|
}
|
|
// 接口获取数据
|
public List<ActionResult> interfaceTemplateJson(ExecuteModel executeModel, Map<String, Object> data) throws WorkFlowException {
|
UserInfo userInfo = executeModel.getUserInfo();
|
NodeModel nodeModel = executeModel.getNodeModel();
|
TaskEntity taskEntity = executeModel.getTaskEntity();
|
String globalParameter = taskEntity.getGlobalParameter();
|
Map<String, Object> parameterData = StringUtil.isNotEmpty(globalParameter) ? JsonUtil.stringToMap(globalParameter) : new HashMap<>();
|
String interId = nodeModel.getFormId();
|
List<IntegrateTplModel> templateJson = nodeModel.getTemplateJson();
|
boolean isGetData = ObjectUtil.equals(nodeModel.getType(), NodeEnum.getData.getType());
|
if (isGetData) {
|
templateJson = nodeModel.getInterfaceTemplateJson();
|
}
|
Map<String, String> parameterMap = new HashMap<>();
|
Set<String> msg = new HashSet<>();
|
Map<String, List<Map<String, Object>>> allData = TriggerHolder.getData();
|
String dataSourceForm = nodeModel.getDataSourceForm();
|
List<Map<String, Object>> maps = allData.get(dataSourceForm);
|
List<ActionResult> resultList = new ArrayList<>();
|
if (StringUtil.isBlank(dataSourceForm)) {
|
maps = new ArrayList<>();
|
maps.add(new HashMap<>());
|
}
|
if (CollectionUtil.isNotEmpty(maps)) {
|
List<String> paramList = ImmutableList.of(
|
DataInterfaceVarConst.USER,
|
DataInterfaceVarConst.USERANDSUB,
|
DataInterfaceVarConst.USERANDPROGENY,
|
DataInterfaceVarConst.ORG,
|
DataInterfaceVarConst.ORGANDSUB,
|
DataInterfaceVarConst.ORGANIZEANDPROGENY,
|
DataInterfaceVarConst.POSITIONID,
|
DataInterfaceVarConst.POSITIONANDSUB,
|
DataInterfaceVarConst.POSITIONANDPROGENY);
|
Map<String, String> paramDataMap = serviceUtil.getSystemFieldValue();
|
for (Map<String, Object> map : maps) {
|
Map<String, Object> tempMap = new HashMap<>(data);
|
tempMap.putAll(map);
|
for (IntegrateTplModel tpl : templateJson) {
|
String fieldId = tpl.getField();
|
Boolean required = tpl.getRequired();
|
Integer sourceType = tpl.getSourceType();
|
String relationField = tpl.getRelationField();
|
Map<String, Object> dataMap = new HashMap<>(tempMap);
|
String[] split = relationField.split("\\|");
|
String dataValue;
|
if (isGetData) {
|
dataValue = this.getFieldValue(relationField, FieldEnum.Field.getCode(), allData);
|
} else {
|
dataValue = this.getStrData(dataMap, split[0]);
|
}
|
if (DataInterfaceVarConst.FORM_ID.equals(relationField)) {
|
dataValue = String.valueOf(dataMap.get(FlowFormConstant.ID));
|
} else if (paramList.contains(relationField)) {
|
List<String> dataList = new ArrayList<>();
|
String value = paramDataMap.get(relationField);
|
if (StringUtil.isNotEmpty(value)) {
|
try {
|
List<String> list = JsonUtil.getJsonToList(value, String.class);
|
dataList.addAll(list);
|
} catch (Exception e) {
|
dataList.add(value);
|
}
|
}
|
dataValue = String.join(",",dataList);
|
}
|
String dataFieldValue = split[0];
|
String parameterValue = parameterData.get(relationField) != null ? String.valueOf(parameterData.get(relationField)) : null;
|
String dataJson = !ObjectUtil.equals(tpl.getSourceType(), FieldEnum.Custom.getCode()) ? Objects.equals(FieldEnum.Global.getCode(), sourceType) ? parameterValue : dataValue : dataFieldValue;
|
String[] model = StringUtil.isNotEmpty(split[0]) ? split[0].split("-") : new String[]{};
|
if (model.length > 1) {
|
Object dataList = dataMap.get(model[0]);
|
if (dataList instanceof List) {
|
List<Map<String, Object>> listAll = (List<Map<String, Object>>) dataList;
|
List<Object> dataListAll = new ArrayList<>();
|
for (Map<String, Object> objectMap : listAll) {
|
dataListAll.add(objectMap.get(model[1] + FlowNature.FORM_FIELD_SUFFIX));
|
}
|
if (required && ObjectUtil.isEmpty(dataListAll)) {
|
msg.add(fieldId);
|
}
|
dataJson = String.valueOf(dataListAll);
|
} else {
|
// 子表数据的处理
|
String oneData = this.getStrData(dataMap, split[0]);
|
dataJson = oneData;
|
}
|
}
|
if (required && ObjectUtil.isEmpty(dataJson)) {
|
msg.add(fieldId);
|
}
|
parameterMap.put(fieldId, dataJson);
|
}
|
this.errRequiredMsg(msg);
|
ActionResult result = serviceUtil.infoToId(interId, parameterMap);
|
if (!ObjectUtil.equals(result.getCode(), 200)) {
|
resultList.add(result);
|
return resultList;
|
}
|
if (result.getData() instanceof Map) {
|
Map<String, Object> dataMap = (Map<String, Object>) result.getData();
|
Integer code = (Integer) dataMap.get("code");
|
if (ObjectUtil.equals(code, 400)) {
|
ActionResult ar = new ActionResult<>();
|
ar.setCode(code);
|
ar.setMsg((String) dataMap.get("msg"));
|
resultList.add(ar);
|
return resultList;
|
}
|
}
|
resultList.add(result);
|
}
|
}
|
return resultList;
|
}
|
|
private void errRequiredMsg(Set<String> msg) throws WorkFlowException {
|
if (!msg.isEmpty()) {
|
throw new WorkFlowException(new ArrayList<>(msg).get(0) + MsgCode.VS015.get());
|
}
|
}
|
|
public List<Map<String, Object>> getDataList(NodeModel nodeModel, Map<String, Object> data, List<String> dataId) {
|
return this.getDataList(nodeModel, data, dataId, false);
|
}
|
|
private List<Map<String, Object>> getDataList(NodeModel nodeModel, Map<String, Object> data, List<String> dataId, Boolean isSub) {
|
boolean idDelete = Objects.equals(nodeModel.getType(), NodeEnum.deleteData.getType());
|
String formId = nodeModel.getFormId();
|
List<SuperQueryJsonModel> ruleList = JsonUtil.getJsonToList(nodeModel.getRuleList(), SuperQueryJsonModel.class);
|
String ruleMatchLogic = nodeModel.getRuleMatchLogic();
|
String flowId = "";
|
boolean isFlow = false;
|
if (ObjectUtil.equals(nodeModel.getFormType(), 2)) {
|
isFlow = true;
|
flowId = formId;
|
TemplateEntity template = templateMapper.selectById(flowId);
|
if (null != template) {
|
List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(template.getFlowId());
|
TemplateNodeEntity startNode = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.start.getType())).findFirst().orElse(null);
|
if (null != startNode) {
|
formId = startNode.getFormId();
|
}
|
}
|
}
|
VisualdevEntity visualdevEntity = serviceUtil.getReleaseInfo(formId);
|
if (Objects.equals(visualdevEntity.getType(), 2)) {
|
return new ArrayList<>();
|
}
|
|
// 条件选择
|
for (SuperQueryJsonModel superQueryJsonModel : ruleList) {
|
List<FieLdsModel> groups = superQueryJsonModel.getGroups();
|
for (FieLdsModel fieLdsModel : groups) {
|
if (ObjectUtil.equals(fieLdsModel.getFieldValueType(), "1")) {
|
// 字段名 | 节点编码
|
if (null != fieLdsModel.getFieldValue()) {
|
String[] split = fieLdsModel.getFieldValue().split("\\|");
|
if (split.length > 1) {
|
if (CollectionUtil.isNotEmpty(data)) {
|
String obj = this.getStrData(data, split[0]);
|
if (null != obj) {
|
fieLdsModel.setFieldValue(obj);
|
}
|
} else {
|
Map<String, List<Map<String, Object>>> allData = TriggerHolder.getData();
|
List<Map<String, Object>> maps = allData.get(split[1]);
|
if (CollectionUtil.isNotEmpty(maps)) {
|
Map<String, Object> map = maps.get(0);
|
String oneData = this.getStrData(map, split[0]);
|
fieLdsModel.setFieldValue(oneData);
|
}
|
}
|
}
|
}
|
} else {
|
boolean valueType = "1".equals(fieLdsModel.getFieldValueType());
|
String fieldValue = data.get(fieLdsModel.getFieldValue()) != null ? String.valueOf(data.get(fieLdsModel.getFieldValue())) : null;
|
if (DataInterfaceVarConst.FORM_ID.equals(fieLdsModel.getFieldValue())) {
|
fieldValue = String.valueOf(data.get(FlowFormConstant.ID));
|
}
|
fieLdsModel.setFieldValue(valueType ? fieldValue : fieLdsModel.getFieldValue());
|
}
|
}
|
}
|
|
SuperJsonModel superJsonModel = new SuperJsonModel();
|
superJsonModel.setConditionList(ruleList);
|
superJsonModel.setMatchLogic(StringUtil.isNotEmpty(ruleMatchLogic) ? ruleMatchLogic : superJsonModel.getMatchLogic());
|
PaginationModel paginationModel = new PaginationModel();
|
paginationModel.setDataType("1");
|
paginationModel.setSuperQueryJson(ruleList.size() > 0 ? JsonUtil.getObjectToString(superJsonModel) : "");
|
String sidx = this.handleSort(nodeModel.getSortList());
|
paginationModel.setSidx(sidx);
|
|
VisualDevJsonModel visualJsonModel = this.getVisualJsonModel(visualdevEntity);
|
List<String> idAll = new ArrayList<>();
|
List<String> idList = new ArrayList<>();
|
List<Map<String, Object>> dataList = new ArrayList<>();
|
try {
|
if (ruleList.size() > 0) {
|
visualJsonModel.setSuperQuery(superJsonModel);
|
}
|
if (isFlow) {
|
List<String> flowVersionIds = templateJsonMapper.getListByTemplateIds(ImmutableList.of(flowId)).stream().map(TemplateJsonEntity::getId).collect(Collectors.toList());
|
visualJsonModel.setFlowVersionIds(flowVersionIds);
|
visualJsonModel.setEnableFlow(flowVersionIds.size() > 0);
|
}
|
dataList.addAll(serviceUtil.getListWithTableList(visualJsonModel, paginationModel, UserProvider.getUser()));
|
if (isSub) {
|
return dataList;
|
}
|
idList.addAll(dataList.stream().map(t -> String.valueOf(t.get(FlowFormConstant.ID))).collect(Collectors.toList()));
|
} catch (Exception e) {
|
}
|
List<String> intersection = idList.stream().filter(item -> dataId.contains(item)).collect(Collectors.toList());
|
if (dataId.size() > 0) {
|
idAll.addAll(intersection);
|
} else {
|
idAll.addAll(idList);
|
}
|
List<Map<String, Object>> result = new ArrayList<>();
|
for (String id : idAll) {
|
List<Map<String, Object>> collect = dataList.stream().filter(t -> Objects.equals(String.valueOf(t.get(FlowFormConstant.ID)), id)).collect(Collectors.toList());
|
for (Map<String, Object> map : collect) {
|
boolean isAdd = true;
|
if (isFlow && !idDelete) {
|
TaskEntity infoSubmit = taskMapper.getInfoSubmit(String.valueOf(map.get(FlowFormConstant.FLOWTASKID)), TaskEntity::getEndTime);
|
isAdd = infoSubmit != null && infoSubmit.getEndTime() != null;
|
}
|
if (isAdd) {
|
result.add(map);
|
}
|
}
|
}
|
return result;
|
}
|
|
public VisualDevJsonModel getVisualJsonModel(VisualdevEntity entity) {
|
VisualDevJsonModel jsonModel = new VisualDevJsonModel();
|
if (entity == null) {
|
return jsonModel;
|
}
|
if (entity.getColumnData() != null) {
|
jsonModel.setColumnData(JsonUtil.getJsonToBean(entity.getColumnData(), ColumnDataModel.class));
|
}
|
if (entity.getAppColumnData() != null) {
|
jsonModel.setAppColumnData(JsonUtil.getJsonToBean(entity.getAppColumnData(), ColumnDataModel.class));
|
}
|
FormDataModel formDataModel = JsonUtil.getJsonToBean(entity.getFormData(), FormDataModel.class);
|
jsonModel.setFormData(formDataModel);
|
if (!VisualWebTypeEnum.DATA_VIEW.getType().equals(entity.getWebType())) {
|
jsonModel.setFormListModels(JsonUtil.getJsonToList(formDataModel.getFields(), FieLdsModel.class));
|
}
|
jsonModel.setVisualTables(JsonUtil.getJsonToList(entity.getVisualTables(), TableModel.class));
|
jsonModel.setId(entity.getId());
|
jsonModel.setDbLinkId(entity.getDbLinkId());
|
jsonModel.setFullName(entity.getFullName());
|
jsonModel.setType(entity.getType());
|
jsonModel.setWebType(entity.getWebType());
|
return jsonModel;
|
}
|
|
private String handleSort(List<SortModel> sortList) {
|
List<String> list = new ArrayList<>();
|
for (SortModel sortModel : sortList) {
|
String field = sortModel.getField();
|
String sortType = sortModel.getSortType();
|
if (!ObjectUtil.equals(sortType, "asc")) {
|
field = "-" + field;
|
}
|
list.add(field);
|
}
|
return String.join(",", list);
|
}
|
|
public String getStrData(Map<String, Object> map, String key) {
|
Object oneData = flowUtil.getOneData(map, key);
|
if (null != oneData) {
|
if (oneData instanceof String) {
|
return oneData.toString();
|
} else {
|
return JsonUtil.getObjectToString(oneData);
|
}
|
}
|
return null;
|
}
|
|
// 数据接口 --------------------------
|
public List<Map<String, Object>> dataInterface(ExecuteModel model) throws WorkFlowException {
|
List<Map<String, Object>> dataList = new ArrayList<>();
|
List<ActionResult> resultList = this.interfaceTemplateJson(model, new HashMap<>());
|
List<String> errList = new ArrayList<>();
|
for (ActionResult result : resultList) {
|
if (!ObjectUtil.equals(result.getCode(), 200)) {
|
errList.add(result.getMsg());
|
continue;
|
}
|
if (result.getData() instanceof List) {
|
List<Map<String, Object>> maps = this.castListMap(result.getData());
|
if (CollectionUtil.isNotEmpty(maps)) {
|
dataList.addAll(maps);
|
}
|
}
|
}
|
if (CollectionUtil.isNotEmpty(errList)) {
|
throw new WorkFlowException(errList.get(0));
|
}
|
return dataList;
|
}
|
|
// 消息 -----------------------------
|
public void message(ExecuteModel model) throws WorkFlowException {
|
NodeModel nodeModel = model.getNodeModel();
|
if (null != nodeModel) {
|
String msgId = nodeModel.getMsgId();
|
List<IntegrateTplModel> templateJson = nodeModel.getMsgTemplateJson();
|
UserInfo userInfo = model.getUserInfo();
|
Map<String, List<Map<String, Object>>> allData = TriggerHolder.getData();
|
Map<String, Object> parameterMap = this.templateJson(templateJson, allData, userInfo);
|
|
List<String> userIds = this.getUserList(nodeModel.getMsgUserIds(), nodeModel.getMsgUserIdsSourceType(), allData);
|
this.message(msgId, userIds, parameterMap, userInfo);
|
}
|
}
|
|
private void message(String msgId, List<String> userIdList, Map<String, Object> parameterMap, UserInfo userInfo) throws WorkFlowException {
|
List<SentMessageForm> formList = new ArrayList<>();
|
SentMessageForm sentMessageForm = new SentMessageForm();
|
sentMessageForm.setUserInfo(userInfo);
|
sentMessageForm.setTemplateId(msgId);
|
sentMessageForm.setToUserIds(userIdList);
|
sentMessageForm.setParameterMap(parameterMap);
|
sentMessageForm.setType(3);
|
sentMessageForm.setContentMsg(new HashMap<>());
|
sentMessageForm.setId(msgId);
|
sentMessageForm.setSysMessage(true);
|
formList.add(sentMessageForm);
|
List<String> errList = serviceUtil.sendDelegateMsg(formList);
|
if (CollectionUtil.isNotEmpty(errList)) {
|
throw new WorkFlowException(errList.get(0));
|
}
|
}
|
|
private Map<String, Object> templateJson(List<IntegrateTplModel> templateJson, Map<String, List<Map<String, Object>>> data, UserInfo userInfo) throws WorkFlowException {
|
Map<String, Object> parameterMap = new HashMap<>();
|
Set<String> msg = new HashSet<>();
|
|
for (IntegrateTplModel tplModel : templateJson) {
|
List<IntegrateParamModel> paramJson = tplModel.getParamJson();
|
for (IntegrateParamModel paramModel : paramJson) {
|
String field = paramModel.getField();
|
String relationField = paramModel.getRelationField() == null ? "" : paramModel.getRelationField();
|
if (ObjectUtil.equals(paramModel.getSourceType(), FieldEnum.Custom.getCode())) {
|
// 参数来源为自定义
|
parameterMap.put(paramModel.getMsgTemplateId() + field, relationField);
|
continue;
|
}
|
Boolean required = paramModel.getRequired();
|
String[] split = relationField.split("\\|");
|
if (split.length < 2) {
|
continue;
|
}
|
List<Map<String, Object>> mapList = data.get(split[1]);
|
Map<String, Object> map = CollectionUtil.isNotEmpty(mapList) ? mapList.get(0) : new HashMap<>();
|
if (map == null) {
|
map = new HashMap<>();
|
}
|
String dataValue = "";
|
if (DataInterfaceVarConst.FORM_ID.equals(split[0])) {
|
dataValue = map.get(FlowFormConstant.ID) != null ? String.valueOf(map.get(FlowFormConstant.ID)) : "";
|
} else {
|
if (map.get(split[0]) != null) {
|
dataValue = String.valueOf(map.get(split[0]));
|
}
|
}
|
if (required && ObjectUtil.isEmpty(dataValue)) {
|
msg.add(field);
|
}
|
parameterMap.put(paramModel.getMsgTemplateId() + field, dataValue);
|
}
|
Map<String, String> paramMap = ImmutableMap.of(FlowConstant.CREATORUSERNAME, userInfo.getUserName(), FlowConstant.SENDTIME, DateUtil.getNow().substring(11));
|
for (String key : paramMap.keySet()) {
|
parameterMap.put(tplModel.getId() + key, paramMap.get(key));
|
}
|
}
|
this.errRequiredMsg(msg);
|
return parameterMap;
|
}
|
|
// 新增数据 -------------------
|
public void addData(ExecuteModel model) throws Exception {
|
NodeModel nodeModel = model.getNodeModel();
|
if (null == nodeModel) {
|
return;
|
}
|
String formId = nodeModel.getFormId();
|
List<TemplateJsonModel> transferList = nodeModel.getTransferList();
|
String dataSourceForm = nodeModel.getDataSourceForm();
|
List<SuperQueryJsonModel> ruleList = nodeModel.getRuleList();
|
|
VisualdevEntity visualdevEntity = serviceUtil.getReleaseInfo(formId);
|
if (StringUtil.isBlank(dataSourceForm)) {
|
// 数据源没有数据时，将字段设置中的自定义添加到数据中
|
transferList = transferList.stream().filter(e -> ObjectUtil.equals(e.getSourceType(), 2)).collect(Collectors.toList());
|
Map<String, Object> data = new HashMap<>();
|
for (TemplateJsonModel TemplateJsonModel : transferList) {
|
data.put(TemplateJsonModel.getTargetField(), TemplateJsonModel.getSourceValue());
|
}
|
if (CollectionUtil.isNotEmpty(data)) {
|
serviceUtil.visualCreate(visualdevEntity, data);
|
}
|
return;
|
}
|
|
// 数据源的数据
|
Map<String, List<Map<String, Object>>> allData = TriggerHolder.getData();
|
List<Map<String, Object>> maps = allData.get(dataSourceForm) != null ? allData.get(dataSourceForm) : new ArrayList<>();
|
|
for (Map<String, Object> map : maps) {
|
List<Map<String, Object>> dataList = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(ruleList)) {
|
dataList = this.getDataList(nodeModel, map, new ArrayList<>());
|
}
|
if (dataList.isEmpty()) {
|
List<Map<String, Object>> list = this.handleAddData(map, transferList);
|
if (CollectionUtil.isNotEmpty(list)) {
|
for (Map<String, Object> saveData : list) {
|
serviceUtil.visualCreate(visualdevEntity, saveData);
|
}
|
}
|
}
|
}
|
}
|
|
public List<Map<String, Object>> handleAddData(Map<String, Object> data, List<TemplateJsonModel> transferList) {
|
return this.handleData(data, new ArrayList<>(), transferList);
|
}
|
|
// 将后缀为_jnpfId的值赋给原字段
|
public Map<String, Object> setData(Map<String, Object> data) {
|
data = CollectionUtil.isNotEmpty(data) ? data : new HashMap<>();
|
for (String key : data.keySet()) {
|
Object o = data.get(key);
|
Object o1 = data.get(key + FlowNature.FORM_FIELD_SUFFIX);
|
if (o != null && o1 != null) {
|
data.put(key, o1);
|
}
|
if (o != null && key.toLowerCase().startsWith(JnpfKeyConsts.CHILD_TABLE_PREFIX)) {
|
// 处理子表
|
if (o instanceof List) {
|
List<Map<String, Object>> subList = (List<Map<String, Object>>) o;
|
for (Map<String, Object> map : subList) {
|
this.setData(map);
|
}
|
}
|
}
|
}
|
return data;
|
}
|
|
/**
|
* 字段设置
|
*
|
*/
|
public List<Map<String, Object>> handleData(Map<String, Object> data, List<Map<String, Object>> dataList, List<TemplateJsonModel> transferList) {
|
boolean isAdd = CollectionUtil.isEmpty(dataList);
|
List<Map<String, Object>> list = new ArrayList<>(dataList);
|
Map<String, Object> oldData = new HashMap<>(data != null ? data : new HashMap<>());
|
|
int max = 1;
|
for (TemplateJsonModel TemplateJsonModel : transferList) {
|
Integer sourceType = TemplateJsonModel.getSourceType();
|
String sourceValue = TemplateJsonModel.getSourceValue();
|
String targetField = TemplateJsonModel.getTargetField();
|
if (ObjectUtil.equals(sourceType, FieldEnum.Field.getCode())) {
|
String[] sourceFieldList = sourceValue.split("-");
|
String[] targetFieldList = targetField.split("-");
|
if (sourceFieldList.length > 1 && targetFieldList.length == 1) {
|
if (oldData.get(sourceFieldList[0]) instanceof List) {
|
List<Map<String, Object>> parentList = (List<Map<String, Object>>) oldData.get(sourceFieldList[0]);
|
if (parentList.size() > max) {
|
max = parentList.size();
|
}
|
}
|
}
|
}
|
}
|
|
// 更新或新增的数据条数 小于 结果的最大数
|
int size = dataList.size();
|
if (size < max) {
|
for (int i = 0; i < max - size; i++) {
|
list.add(new HashMap<>());
|
}
|
}
|
|
if (isAdd) {
|
for (TemplateJsonModel TemplateJsonModel : transferList) {
|
Integer sourceType = TemplateJsonModel.getSourceType();
|
String sourceValue = TemplateJsonModel.getSourceValue();
|
String targetField = TemplateJsonModel.getTargetField();
|
if (ObjectUtil.equals(sourceType, FieldEnum.Field.getCode())) {
|
String[] sourceFieldList = sourceValue.split("-");
|
String[] targetFieldList = targetField.split("-");
|
if (sourceFieldList.length > 1) {
|
// 目标数据 大于 源数据 补差集
|
if (targetFieldList.length > 1) {
|
int diff = 0;
|
// 源数据
|
if (oldData.get(sourceFieldList[0]) instanceof List) {
|
List<Map<String, Object>> sourceList = (List<Map<String, Object>>) oldData.get(sourceFieldList[0]);
|
diff = sourceList.size();
|
}
|
for (Map<String, Object> map : list) {
|
if (map.get(targetFieldList[0]) instanceof List) {
|
List<Map<String, Object>> targetList = (List<Map<String, Object>>) map.get(targetFieldList[0]);
|
int max1 = targetList.size() - diff;
|
for (int i = 0; i < max1; i++) {
|
targetList.add(new HashMap<>());
|
}
|
} else {
|
List<Map<String, Object>> childList = new ArrayList<>();
|
for (int i = 0; i < diff; i++) {
|
childList.add(new HashMap<>());
|
}
|
map.put(targetFieldList[0], childList);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
// for (Map<String, Object> map : list) {
|
// this.setData(map);
|
// }
|
|
for (TemplateJsonModel TemplateJsonModel : transferList) {
|
Integer sourceType = TemplateJsonModel.getSourceType();
|
String[] split = TemplateJsonModel.getSourceValue().split("\\|");
|
String sourceValue = split.length > 0 ? split[0] : TemplateJsonModel.getSourceValue();
|
|
boolean isData = ObjectUtil.equals(sourceType, FieldEnum.Custom.getCode());
|
String[] sourceFieldList = isData ? new String[]{sourceValue} : sourceValue.split("-");
|
|
Object o = flowUtil.getOneData(data, sourceValue);
|
String targetField = TemplateJsonModel.getTargetField();
|
String[] targetFieldList = targetField.split("-");
|
Object childData = isData ? sourceValue : DataInterfaceVarConst.FORM_ID.equals(sourceValue)
|
? data.get(FlowFormConstant.ID) : o;
|
|
// 目标字段为子表
|
if (targetFieldList.length > 1) {
|
if (sourceFieldList.length > 1) {
|
// 来源是子表、目标是子表
|
if (oldData.get(sourceFieldList[0]) instanceof List) {
|
// 源数据
|
List<Map<String, Object>> parentList = (List<Map<String, Object>>) oldData.get(sourceFieldList[0]);
|
|
for (int i = 0; i < list.size(); i++) {
|
Map<String, Object> targetMap = list.get(i);
|
List<Map<String, Object>> childList = (List<Map<String, Object>>) targetMap.get(targetFieldList[0]);
|
if (CollectionUtil.isNotEmpty(childList)) {
|
for (int j = 0; j < parentList.size(); j++) {
|
Map<String, Object> sourceMap = parentList.get(j);
|
// this.setData(sourceMap);
|
if (childList.size() > j) {
|
Map<String, Object> map = childList.get(j);
|
Object oneData = flowUtil.getOneData(sourceMap, sourceFieldList[1]);
|
map.put(targetFieldList[1], oneData);
|
}
|
}
|
targetMap.put(targetFieldList[0], childList);
|
}
|
}
|
} else if (oldData.get(FlowNature.SUB_TABLE) != null) {
|
// this.setData(oldData);
|
for (Map<String, Object> map : list) {
|
Object obj = flowUtil.getOneData(oldData, split[0]);
|
if (map.get(targetFieldList[0]) instanceof List) {
|
List<Map<String, Object>> childList = (List<Map<String, Object>>) map.get(targetFieldList[0]);
|
if (CollectionUtil.isEmpty(childList)) {
|
childList.add(new HashMap<>());
|
}
|
for (Map<String, Object> objectMap : childList) {
|
objectMap.put(targetFieldList[1], obj);
|
}
|
map.put(targetFieldList[0], childList);
|
}
|
}
|
}
|
} else {
|
// 来源不是子表、目标是子表
|
for (Map<String, Object> map : list) {
|
if (null == map.get(targetFieldList[0])) {
|
List<Map<String, Object>> childList = new ArrayList<>();
|
Map<String, Object> child = new HashMap<>();
|
child.put(targetFieldList[1], childData);
|
childList.add(child);
|
map.put(targetFieldList[0], childList);
|
continue;
|
}
|
if (map.get(targetFieldList[0]) instanceof List) {
|
// 目标子表数据进行赋值
|
List<Map<String, Object>> childList = (List<Map<String, Object>>) map.get(targetFieldList[0]);
|
for (Map<String, Object> childMap : childList) {
|
childMap.put(targetFieldList[1], childData);
|
}
|
}
|
}
|
}
|
} else {
|
if (sourceFieldList.length > 1) {
|
// 来源是子表、目标不是子表
|
if (oldData.get(sourceFieldList[0]) instanceof List) {
|
List<Map<String, Object>> parentList = (List<Map<String, Object>>) oldData.get(sourceFieldList[0]);
|
// 新增时，一一对应；更新时，取子表第一条数据
|
if (isAdd) {
|
for (int i = 0; i < parentList.size(); i++) {
|
if (list.size() > i) {
|
Map<String, Object> parentMap = parentList.get(i);
|
// this.setData(parentMap);
|
Map<String, Object> map = list.get(i);
|
Object oneData = flowUtil.getOneData(parentMap, sourceFieldList[1]);
|
map.put(targetField, oneData);
|
}
|
}
|
} else {
|
if (CollectionUtil.isNotEmpty(parentList)) {
|
Map<String, Object> parentMap = parentList.get(0);
|
// this.setData(parentMap);
|
for (Map<String, Object> map : list) {
|
Object oneData = flowUtil.getOneData(parentMap, sourceFieldList[1]);
|
map.put(targetField, oneData);
|
}
|
}
|
}
|
} else if (oldData.get(FlowNature.SUB_TABLE) != null) {
|
for (Map<String, Object> map : list) {
|
Object obj = flowUtil.getOneData(oldData, split[0]);
|
map.put(targetFieldList[0], obj);
|
}
|
}
|
} else {
|
// 来源不是子表、目标不是子表
|
for (Map<String, Object> map : list) {
|
map.put(targetField, childData);
|
}
|
}
|
}
|
}
|
return list;
|
}
|
|
// 更新数据 -------------------------------
|
public void updateData(ExecuteModel model) throws Exception {
|
NodeModel nodeModel = model.getNodeModel();
|
String formId = nodeModel.getFormId();
|
VisualdevEntity visualdevEntity = serviceUtil.getReleaseInfo(formId);
|
String dataSourceForm = nodeModel.getDataSourceForm();
|
List<TemplateJsonModel> transferList = nodeModel.getTransferList();
|
|
// 没有可修改的数据时，向对应表单中新增一条数据
|
boolean unFoundRule = nodeModel.getUnFoundRule();
|
|
Map<String, List<Map<String, Object>>> allData = TriggerHolder.getData();
|
List<Map<String, Object>> maps = allData.get(dataSourceForm);
|
|
// 数据源可以不选，不选则直接更新目标表单的某些数据
|
if (StringUtil.isBlank(dataSourceForm)) {
|
transferList = transferList.stream().filter(e -> ObjectUtil.equals(e.getSourceType(), 2)).collect(Collectors.toList());
|
Map<String, Object> map = new HashMap<>();
|
for (TemplateJsonModel TemplateJsonModel : transferList) {
|
map.put(TemplateJsonModel.getTargetField(), TemplateJsonModel.getSourceValue());
|
}
|
maps = new ArrayList<>();
|
maps.add(map);
|
}
|
|
// 更新数据
|
if (CollectionUtil.isNotEmpty(maps)) {
|
for (Map<String, Object> map : maps) {
|
List<Map<String, Object>> tempList = this.getDataList(nodeModel, map, new ArrayList<>());
|
for (Map<String, Object> tempMap : tempList) {
|
this.setData(tempMap);
|
}
|
List<Map<String, Object>> list = this.handleData(map, tempList, transferList);
|
if (CollectionUtil.isNotEmpty(list)) {
|
for (Map<String, Object> data : list) {
|
if (null != data.get(FlowFormConstant.ID)) {
|
String id = data.get(FlowFormConstant.ID).toString();
|
serviceUtil.visualUpdate(visualdevEntity, data, id);
|
} else {
|
if (unFoundRule) {
|
serviceUtil.visualCreate(visualdevEntity, data);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
// 删除数据 -------------------------------
|
public void deleteData(ExecuteModel model) throws Exception {
|
NodeModel nodeModel = model.getNodeModel();
|
Integer deleteType = nodeModel.getDeleteType();
|
|
String formId = nodeModel.getFormId();
|
VisualdevEntity visualdevEntity = serviceUtil.getReleaseInfo(formId);
|
|
// 直接删除表
|
if (ObjectUtil.equals(deleteType, 0)) {
|
Integer tableType = nodeModel.getTableType();
|
if (ObjectUtil.equals(tableType, 0)) {
|
// 删除主表
|
List<Map<String, Object>> dataList = this.getDataList(nodeModel, new HashMap<>(), new ArrayList<>());
|
if (CollectionUtil.isNotEmpty(dataList)) {
|
serviceUtil.visualDelete(visualdevEntity, dataList);
|
}
|
} else {
|
// 删除子表
|
// List<Map<String, Object>> mapList = this.getDataList(nodeModel, new HashMap<>(), new ArrayList<>(), true);
|
FlowFormDataModel formDataModel = new FlowFormDataModel();
|
formDataModel.setTableName(nodeModel.getSubTable());
|
formDataModel.setFormId(nodeModel.getFormId());
|
formDataModel.setRuleMatchLogic(nodeModel.getRuleMatchLogic());
|
List<SuperQueryJsonModel> ruleList = nodeModel.getRuleList();
|
List<Map<String, Object>> list = JsonUtil.getJsonToListMap(JsonUtil.getObjectToString(ruleList));
|
formDataModel.setRuleList(list);
|
serviceUtil.deleteSubTable(formDataModel);
|
}
|
} else {
|
// 按节点删除
|
Integer condition = nodeModel.getDeleteCondition();
|
String dataSourceForm = nodeModel.getDataSourceForm();
|
|
Map<String, List<Map<String, Object>>> allData = TriggerHolder.getData();
|
List<Map<String, Object>> maps = allData.get(dataSourceForm) != null ? allData.get(dataSourceForm) : new ArrayList<>();
|
|
// 获取条件过滤的目标数据
|
List<Map<String, Object>> dataList = new ArrayList<>();
|
for (Map<String, Object> map : maps) {
|
List<Map<String, Object>> data = this.getDataList(nodeModel, map, new ArrayList<>());
|
dataList.addAll(data);
|
}
|
|
// 全部目标数据
|
nodeModel.setRuleList(new ArrayList<>());
|
List<Map<String, Object>> targetData = this.getDataList(nodeModel, new HashMap<>(), new ArrayList<>());
|
|
List<Map<String, Object>> intersection = new ArrayList<>();
|
List<Map<String, Object>> differentSet = new ArrayList<>();
|
|
if (ObjectUtil.equals(condition, 1)) {
|
// 存在，删除交集
|
intersection = dataList;
|
if (CollectionUtil.isNotEmpty(intersection)) {
|
serviceUtil.visualDelete(visualdevEntity, intersection);
|
}
|
} else {
|
// 不存在，删除差集
|
for (Map<String, Object> map : targetData) {
|
String sourceId = map.get(FlowFormConstant.ID).toString();
|
for (Map<String, Object> data : dataList) {
|
String targetId = data.get(FlowFormConstant.ID).toString();
|
if (!ObjectUtil.equals(sourceId, targetId)) {
|
differentSet.add(map);
|
}
|
}
|
}
|
if (CollectionUtil.isNotEmpty(differentSet)) {
|
serviceUtil.visualDelete(visualdevEntity, differentSet);
|
}
|
}
|
}
|
}
|
|
// 发起审批 -------------------------------
|
public void launchFlow(ExecuteModel model) throws Exception {
|
NodeModel nodeModel = model.getNodeModel();
|
String flowId = nodeModel.getFlowId();
|
List<TemplateJsonModel> transferList = nodeModel.getTransferList();
|
|
TemplateEntity template = templateMapper.selectById(flowId);
|
if (null == template) {
|
return;
|
}
|
if (!ObjectUtil.equals(template.getStatus(), TemplateStatueEnum.up.getCode())) {
|
throw new WorkFlowException(MsgCode.WF140.get());
|
}
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(template.getFlowId());
|
List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(jsonEntity.getId());
|
Map<String, NodeModel> nodes = new HashMap<>();
|
for (TemplateNodeEntity node : nodeEntityList) {
|
nodes.put(node.getNodeCode(), JsonUtil.getJsonToBean(node.getNodeJson(), NodeModel.class));
|
}
|
FlowMethod method = new FlowMethod();
|
method.setDeploymentId(jsonEntity.getFlowableId());
|
TemplateNodeEntity startNode = nodeEntityList.stream()
|
.filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(new TemplateNodeEntity());
|
if (flowUtil.checkBranch(startNode)) {
|
throw new WorkFlowException(MsgCode.WF147.get());
|
}
|
method.setNodeCode(startNode.getNodeCode());
|
method.setNodes(nodes);
|
method.setNodeEntityList(nodeEntityList);
|
Map<String, Boolean> resMap = conditionUtil.handleCondition(method);
|
// 判断条件、候选人
|
try {
|
conditionUtil.checkCondition(resMap, nodes);
|
} catch (WorkFlowException e) {
|
throw new WorkFlowException(MsgCode.WF133.get());
|
}
|
method.setNextSubFlow(true);
|
List<NodeModel> nextApprover = flowUtil.getNextApprover(method);
|
if (!flowUtil.checkNextCandidates(nextApprover)) {
|
throw new WorkFlowException(MsgCode.WF134.get());
|
}
|
|
// 数据源数据
|
String dataSourceForm = nodeModel.getDataSourceForm();
|
Map<String, List<Map<String, Object>>> allData = TriggerHolder.getData();
|
List<Map<String, Object>> maps = allData.get(dataSourceForm) != null ? allData.get(dataSourceForm) : new ArrayList<>();
|
|
List<Map<String, Object>> mapList = new ArrayList<>();
|
|
for (Map<String, Object> map : maps) {
|
List<Map<String, Object>> list = this.handleAddData(map, transferList);
|
mapList.addAll(list);
|
}
|
// 不选数据源的处理
|
if (StringUtil.isEmpty(dataSourceForm)) {
|
transferList = transferList.stream().filter(e -> ObjectUtil.equals(e.getSourceType(), FieldEnum.Custom.getCode())).collect(Collectors.toList());
|
Map<String, Object> map = new HashMap<>();
|
for (TemplateJsonModel TemplateJsonModel : transferList) {
|
map.put(TemplateJsonModel.getTargetField(), TemplateJsonModel.getSourceValue());
|
}
|
mapList = new ArrayList<>();
|
mapList.add(map);
|
}
|
if (CollectionUtil.isEmpty(mapList)) {
|
return;
|
}
|
Set<String> userListAll = new HashSet<>();
|
if (OperatorEnum.Nominator.getCode().equals(nodeModel.getAssigneeType())) {
|
userListAll.addAll(serviceUtil.getUserListAll(nodeModel.getInitiator()));
|
} else {
|
//表单数据用户
|
for (Map<String, Object> map : maps) {
|
Object data = flowUtil.getOneData(map, nodeModel.getFormField());
|
userListAll.addAll(flowUtil.getUserId(data));
|
}
|
}
|
|
// 判断流程权限
|
FlowFormModel formIdAndFlowId = flowUtil.getFormIdAndFlowId(new ArrayList<>(userListAll), flowId);
|
List<UserEntity> userList = serviceUtil.getUserName(nodeModel.getHasPermission() ? formIdAndFlowId.getUserId() : formIdAndFlowId.getUserIdAll(), true);
|
if (CollectionUtil.isEmpty(userList)) {
|
throw new WorkFlowException(MsgCode.WF136.get());
|
}
|
for (UserEntity user : userList) {
|
UserInfo userInfo = new UserInfo();
|
userInfo.setUserId(user.getId());
|
userInfo.setUserName(user.getRealName());
|
|
FlowModel flowModel = new FlowModel();
|
flowModel.setUserInfo(userInfo);
|
flowModel.setFlowId(flowId);
|
flowModel.setStatus(TaskStatusEnum.RUNNING.getCode());
|
flowModel.setDeploymentId(jsonEntity.getFlowableId());
|
flowModel.setNodeEntityList(nodeEntityList);
|
for (Map<String, Object> map : mapList) {
|
flowModel.setFormData(map);
|
if (flowUtil.checkNextError(flowModel, nextApprover, false, false) != 0) {
|
throw new WorkFlowException(MsgCode.WF135.get());
|
}
|
batchSaveOrSubmit(flowModel);
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
if (taskEntity.getRejectDataId() == null) {
|
autoAudit(flowModel);
|
handleEvent();
|
}
|
handleTaskStatus();
|
}
|
}
|
}
|
|
// 创建日程 --------------------------
|
public void createSchedule(ExecuteModel model) throws WorkFlowException {
|
ScheduleNewCrForm fo = new ScheduleNewCrForm();
|
NodeModel nodeModel = model.getNodeModel();
|
|
Map<String, List<Map<String, Object>>> allData = TriggerHolder.getData();
|
|
List<String> list = ImmutableList.of(nodeModel.getCreatorUserId());
|
List<String> creatorUserIds = this.getUserList(list, nodeModel.getCreatorUserIdSourceType(), allData);
|
if (CollectionUtil.isEmpty(creatorUserIds)) {
|
throw new WorkFlowException("找不到创建人");
|
}
|
|
Integer titleSourceType = nodeModel.getTitleSourceType();
|
String title = this.getFieldValue(nodeModel.getTitle(), titleSourceType, allData);
|
fo.setTitle(title);
|
|
String contents = this.getFieldValue(nodeModel.getContents(), nodeModel.getContentsSourceType(), allData);
|
fo.setContent(contents);
|
|
String startDay = this.getFieldValue(nodeModel.getStartDay(), nodeModel.getStartDaySourceType(), allData);
|
if (StringUtil.isBlank(startDay)) {
|
throw new WorkFlowException("开始时间不能为空");
|
}
|
fo.setStartDay(Long.valueOf(StringUtil.isBlank(startDay) ? new Date().getTime() + "" : startDay));
|
fo.setStartTime(nodeModel.getStartTime());
|
|
String endDay = this.getFieldValue(nodeModel.getEndDay(), nodeModel.getEndDaySourceType(), allData);
|
|
if (ObjectUtil.equals(nodeModel.getDuration(), -1) || ObjectUtil.equals(nodeModel.getAllDay(), 1)) {
|
if (StringUtil.isBlank(endDay)) {
|
throw new WorkFlowException("结束时间不能为空");
|
}
|
}
|
fo.setEndDay(Long.valueOf(StringUtil.isBlank(endDay) ? new Date().getTime() + "" : endDay));
|
fo.setEndTime(nodeModel.getEndTime());
|
String category = nodeModel.getCategory();
|
fo.setCategory(StringUtil.isNotEmpty(category) ? category : "391233231405462789");
|
|
fo.setDuration(nodeModel.getDuration());
|
fo.setAllDay(nodeModel.getAllDay());
|
fo.setFiles(nodeModel.getFiles());
|
|
List<String> value = this.getUserList(nodeModel.getToUserIds(), nodeModel.getToUserIdsSourceType(), allData);
|
fo.setToUserIds(value);
|
fo.setColor(nodeModel.getColor());
|
fo.setReminderType(nodeModel.getReminderType());
|
fo.setReminderTime(nodeModel.getReminderTime());
|
fo.setSend(nodeModel.getSend());
|
fo.setSendName(nodeModel.getSendName());
|
fo.setRepetition(nodeModel.getRepetition());
|
fo.setRepeatTime(nodeModel.getRepeatTime());
|
|
for (String creatorUserId : creatorUserIds) {
|
ScheduleNewCrForm jsonToBean = JsonUtil.getJsonToBean(fo, ScheduleNewCrForm.class);
|
jsonToBean.setCreatorUserId(creatorUserId);
|
serviceUtil.createSchedule(jsonToBean);
|
}
|
}
|
|
public String getFieldValue(String value, Integer sourceType, Map<String, List<Map<String, Object>>> allData) {
|
if (ObjectUtil.equals(sourceType, FieldEnum.Field.getCode())) {
|
String[] split = value.split("\\|");
|
if (split.length > 1) {
|
List<Map<String, Object>> data = allData.get(split[1]);
|
if (CollectionUtil.isNotEmpty(data)) {
|
Map<String, Object> map = data.get(0);
|
if (ObjectUtil.equals(split[0], DataInterfaceVarConst.FORM_ID)) {
|
value = map.get(FlowFormConstant.ID) + "";
|
} else {
|
value = this.getStrData(map, split[0]);
|
}
|
return value;
|
}
|
}
|
return null;
|
}
|
return value;
|
}
|
|
public List<String> getUserList(List<String> value, Integer sourceType, Map<String, List<Map<String, Object>>> allData) {
|
if (ObjectUtil.equals(sourceType, FieldEnum.Field.getCode()) && CollectionUtil.isNotEmpty(value)) {
|
List<String> userIdList = new ArrayList<>();
|
String str = value.get(0);
|
String[] split = str.split("\\|");
|
if (split.length > 1) {
|
List<Map<String, Object>> dataList = allData.get(split[1]);
|
if (ObjectUtil.isNotEmpty(dataList)) {
|
Object obj = flowUtil.getOneData(dataList.get(0), split[0]);
|
userIdList.addAll(flowUtil.getUserId(obj));
|
}
|
}
|
List<String> ids = serviceUtil.getUserName(userIdList, true).stream().map(UserEntity::getId).collect(Collectors.toList());
|
return ids;
|
}
|
return value == null ? new ArrayList<>() : serviceUtil.getUserListAll(value);
|
}
|
|
// webhook触发--------------------------------------------
|
public void handleWebhookTrigger(String id, String tenantId, Map<String, Object> body) throws Exception {
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(id);
|
if (null == jsonEntity) {
|
throw new WorkFlowException(MsgCode.VS016.get());
|
}
|
if (!ObjectUtil.equals(jsonEntity.getState(), 1)) {
|
throw new WorkFlowException("版本未启用");
|
}
|
List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(jsonEntity.getId());
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.webhookTrigger.getType())).findFirst().orElse(null);
|
if (null != nodeEntity) {
|
NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
List<Map<String, Object>> dataList = new ArrayList<>();
|
Map<String, Object> map = new HashMap<>();
|
List<FieLdsModel> formFieldList = nodeModel.getFormFieldList();
|
for (FieLdsModel fieLdsModel : formFieldList) {
|
map.put(fieLdsModel.getId(), body.get(fieLdsModel.getId()));
|
}
|
dataList.add(map);
|
String token = AuthUtil.loginTempUser(jsonEntity.getCreatorUserId(), tenantId);
|
UserInfo userInfo = UserProvider.getUser(token);
|
UserProvider.setLoginUser(userInfo);
|
UserProvider.setLocalLoginUser(userInfo);
|
ExecuteModel model = new ExecuteModel();
|
model.setFlowId(jsonEntity.getId());
|
model.setDataList(dataList);
|
model.setUserInfo(userInfo);
|
this.execute(model);
|
}
|
}
|
|
// 通知触发---------------------------------------------------------
|
|
// @DSTransactional
|
public void msgTrigger(TemplateNodeEntity triggerNode, UserInfo userInfo) throws Exception {
|
String flowId = triggerNode.getFlowId();
|
ExecuteModel model = new ExecuteModel();
|
model.setFlowId(flowId);
|
model.setUserInfo(userInfo);
|
this.execute(model);
|
}
|
|
// 获取触发节点之后的获取数据节点的数据
|
public List<Map<String, Object>> getDataListAfterTriggerNode(String flowId, String triggerNode, List<TemplateNodeEntity> nodeEntityList, UserInfo userInfo) throws WorkFlowException {
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(flowId);
|
NextOrPrevFo fo = new NextOrPrevFo();
|
fo.setDeploymentId(jsonEntity.getFlowableId());
|
fo.setTaskKey(triggerNode);
|
List<FlowableNodeModel> next = flowAbleUrl.getNext(fo);
|
if (CollectionUtil.isEmpty(next)) {
|
return new ArrayList<>();
|
}
|
String nodeCode = next.get(0).getId();
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream().filter(e -> ObjectUtil.equals(e.getNodeCode(), nodeCode)).findFirst().orElse(null);
|
ExecuteModel executeModel = new ExecuteModel();
|
executeModel.setNodeModel(JsonUtil.getJsonToBean(nodeEntity, NodeModel.class));
|
executeModel.setUserInfo(userInfo);
|
List<Map<String, Object>> dataList = this.getData(executeModel);
|
return dataList;
|
}
|
|
// 全局属性配置的消息通知，mark 1.开始执行 2.执行失败
|
public void globalMsg(ExecuteModel model, Integer mark) throws WorkFlowException {
|
TriggerTaskEntity triggerTask = model.getTriggerTask();
|
UserInfo userInfo = model.getUserInfo();
|
List<TemplateNodeEntity> nodeEntityList = model.getNodeEntityList();
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.global.getType())).findFirst().orElse(null);
|
if (null == nodeEntity) {
|
return;
|
}
|
NodeModel global = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
|
String code = ObjectUtil.equals(mark, 1) ? "PZXTJC002" : "PZXTJC001";
|
MsgConfig msgConfig;
|
if (ObjectUtil.equals(mark, 1)) {
|
msgConfig = global.getStartMsgConfig();
|
} else {
|
msgConfig = global.getFailMsgConfig();
|
}
|
Integer on = msgConfig.getOn();
|
boolean acquiesce = ObjectUtil.equals(on, 3);
|
String msgId = ObjectUtil.equals(on, 0) ? "" : acquiesce ? code : msgConfig.getMsgId();
|
|
List<String> msgUserType = global.getMsgUserType();
|
List<String> msgUserIds = global.getMsgUserIds();
|
|
Set<String> userIdList = new HashSet<>();
|
for (String type : msgUserType) {
|
switch (type) {
|
case "1":
|
userIdList.add(triggerTask.getCreatorUserId());
|
break;
|
case "2":
|
userIdList.add(serviceUtil.getAdmin());
|
break;
|
case "3":
|
List<String> userList = serviceUtil.getUserListAll(msgUserIds);
|
userIdList.addAll(userList);
|
break;
|
}
|
}
|
|
Map<String, Object> dataMap = ImmutableMap.of(FlowConstant.TITLE, triggerTask.getFullName(), FlowConstant.CREATORUSERNAME, "");
|
|
List<SendConfigJson> templateJson = msgConfig.getTemplateJson();
|
List<IntegrateTplModel> jsonToList = JsonUtil.getJsonToList(templateJson, IntegrateTplModel.class);
|
|
if (StringUtil.isNotEmpty(msgId) && CollectionUtil.isNotEmpty(userIdList)) {
|
Map<String, Object> map = acquiesce ? dataMap : this.templateJson(jsonToList, new HashMap<>(), userInfo);
|
try {
|
this.message(msgId, new ArrayList<>(userIdList), map, userInfo);
|
} catch (WorkFlowException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
}
|
