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 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 nodeEntityList = flowModel.getNodeEntityList(); Map nodes = flowModel.getNodes(); NodeModel global = nodes.get(NodeEnum.global.getType()); List operatorEntities = new ArrayList<>(); // 生成经办，获取之前同意的经办，再次生成经办 List operatorList = operatorMapper.getList(taskId) .stream().filter(e -> ObjectUtil.equals(e.getHandleStatus(), FlowNature.AuditCompletion) && !ObjectUtil.equals(e.getStatus(), OperatorStateEnum.Futility.getCode())).collect(Collectors.toList()); List taskModelList = flowAbleUrl.getCurrentTask(instanceId); // 原来的当前节点 List srcCurrentList = StringUtil.isNotEmpty(taskEntity.getCurrentNodeCode()) ? Arrays.stream(taskEntity.getCurrentNodeCode().split(",")).collect(Collectors.toList()) : new ArrayList<>(); updateCurrentNode(taskModelList, nodes, taskEntity); List 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 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 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 delegateList = flowUtil.getByToUserId(UserProvider.getLoginUserId()); List handleId = new ArrayList<>(); Map 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 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 createOperator(FlowMethod flowMethod) { List userIds = flowMethod.getUserIds(); NodeModel nodeModel = flowMethod.getNodeModel(); FlowModel flowModel = flowMethod.getFlowModel(); List 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 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 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 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 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 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 list, NodeModel nodeModel, LaunchUserEntity launchUser) { if (null != launchUser) { String positionId = launchUser.getPositionId(); List positionList = Arrays.asList(positionId.split(",")); String organizeId = launchUser.getOrganizeId(); List 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 circulateList = flowMethod.getCirculateList(); TemplateNodeEntity nodeEntity = flowMethod.getNodeEntity(); TaskEntity taskEntity = flowMethod.getTaskEntity(); List nodeEntityList = flowMethod.getNodeEntityList(); List 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 queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId).eq(OperatorEntity::getParentId, operator.getId()) .eq(OperatorEntity::getStatus, OperatorStateEnum.Assist.getCode()); List 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 queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId) .isNull(OperatorEntity::getHandleStatus); if (StringUtil.isNotEmpty(nodeCode)) { queryWrapper.lambda().eq(OperatorEntity::getNodeCode, nodeCode); } List 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 list = new ArrayList<>(); this.getAddSignChildren(parentId, list); if (CollectionUtil.isNotEmpty(list)) { operatorMapper.updateById(list); } } // 撤回复原 public void recallRestore(OperatorEntity operator, String nodeId, List userIds) { QueryWrapper 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 list = operatorMapper.selectList(queryWrapper); if (CollectionUtil.isEmpty(list)) { return; } List 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 wrapper = new UpdateWrapper<>(); List 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 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 getAddSignChildren(String operatorId, List list) { list = null == list ? new ArrayList<>() : list; List 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 conditions = autoAuditRule.getConditions(); flowMethod.setConditions(conditions); flowMethod.setMatchLogic(autoAuditRule.getMatchLogic()); if (conditionUtil.hasCondition(flowMethod)) { return 1; } } AutoAuditRule autoRejectRule = nodeModel.getAutoRejectRule(); if (null != autoRejectRule) { List 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 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 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 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 nextModels = flowAbleUrl.getNext(nextOrPrevFo); List 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 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 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 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 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 list = operatorMapper.selectList(queryWrapper); boolean result = checkStep(list, nodeModel, launchUser); if (!result) { String positionId = launchUser.getPositionId() != null ? launchUser.getPositionId() : ""; List positionList = Arrays.asList(positionId.split(",")); String organizeId = launchUser.getOrganizeId() != null ? launchUser.getOrganizeId() : ""; List 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 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 branchList = candidatesMapper.getBranch(operator.getTaskId(), operator.getNodeCode()); Map 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 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 systemList = SystemAuditHolder.getAll(); if (CollectionUtil.isNotEmpty(systemList)) { List jsonToList = JsonUtil.getJsonToList(systemList, SystemAuditModel.class); SystemAuditHolder.clear(); Map 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 nodeEntityList = flowModel.getNodeEntityList(); String deploymentId = flowModel.getDeploymentId(); if (null == entity.getSignTime()) { entity.setSignTime(new Date()); } // 自动提交规则 AutoSubmitConfig autoSubmitConfig = global.getAutoSubmitConfig(); // 相邻节点审批人重复 if (autoSubmitConfig.getAdjacentNodeApproverRepeated()) { // 获取上一级节点编码 List nodeCodeList = new ArrayList<>(); flowUtil.prevNodeList(deploymentId, entity.getNodeCode(), nodeEntityList, nodeCodeList); if (CollectionUtil.isNotEmpty(nodeCodeList)) { QueryWrapper 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 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 getChildList(String id) { QueryWrapper 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 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 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 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 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 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 getReduceUsers(List todoList, Pagination pagination) { List ids = todoList.stream().map(OperatorEntity::getHandleId).collect(Collectors.toList()); return getUserModel(ids, pagination); } // 处理退回数据，当前的经办通过计算比例后进入该方法，无需变更状态 public void handleRejectData(FlowModel flowModel) throws WorkFlowException { List nodeEntityList = flowModel.getNodeEntityList(); OperatorEntity operatorEntity = flowModel.getOperatorEntity(); TaskEntity taskEntity = flowModel.getTaskEntity(); String currentNodeCode = taskEntity.getCurrentNodeCode(); // 待提交（即未发起）重新发起，需要获取当前节点 String instanceId = taskEntity.getInstanceId(); if (instanceId != null) { List taskModelList = flowAbleUrl.getCurrentTask(instanceId); List 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 srcOperatorList = JsonUtil.getJsonToList(operatorJson, OperatorEntity.class); // 获取被退回的节点编码，用于表单值传递 List nodeCodes = srcOperatorList.stream().sorted(Comparator.comparing(OperatorEntity::getCreatorTime)) .map(OperatorEntity::getNodeCode).distinct().collect(Collectors.toList()); List 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 sourceList = StringUtil.isNotEmpty(currentNodeCode) ? Arrays.stream(currentNodeCode.split(",")).collect(Collectors.toList()) : new ArrayList<>(); List targetList = StringUtil.isNotEmpty(srcCurrentNodeCode) ? Arrays.stream(srcCurrentNodeCode.split(",")).collect(Collectors.toList()) : new ArrayList<>(); List source = sourceList.stream().filter(e -> !targetList.contains(e)).collect(Collectors.toList()); List target = targetList.stream().filter(e -> !sourceList.contains(e)).collect(Collectors.toList()); fo.setSource(source); fo.setTarget(target); flowAbleUrl.jump(fo); // 跳转后，获取当前的节点信息，更新经办 List 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 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 getByNodeCode(String taskId, String nodeCode) { QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId) .eq(OperatorEntity::getNodeCode, nodeCode) .ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode()); List 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 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 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 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 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 circulateList = circulateList(flowMethod); flowMethod.setCirculateList(circulateList); if (endFlag) { flowMethod.setIsRevoke(true); handleEndTask(flowMethod); revokeMapper.deleteRevoke(taskEntity.getId()); return; } // 判断撤销经办的比例 QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().eq(OperatorEntity::getTaskId, operator.getTaskId()).eq(OperatorEntity::getNodeCode, operator.getNodeCode()) .ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode()); List 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 nodeEntityList = flowModel.getNodeEntityList(); Map> 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 subNodeEntityList = templateNodeMapper.getList(jsonEntity.getId()); Map 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 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 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 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 queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskEntity.getId()) .in(OperatorEntity::getNodeCode, nodeCodeList).isNotNull(OperatorEntity::getHandleStatus) .orderByDesc(OperatorEntity::getHandleTime); List 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 resMap = new HashMap<>(); Map> allData = FlowContextHolder.getAllData(); Map 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 userIds = flowUtil.userListAll(flowMethod); List 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 subTaskData = new ArrayList<>(); UserInfo userInfo = flowModel.getUserInfo(); Map taskMap = new HashMap<>(); for (UserEntity user : userList) { flag++; FlowModel model = new FlowModel(); model.setSubCode(nodeCode); model.setParentId(taskEntity.getId()); model.setDeploymentId(jsonEntity.getFlowableId()); Map 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 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 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 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 operatorEntities = handleOperator(flowModel); List 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 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 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 nodes = flowModel.getNodes(); NodeModel global = nodes.get(NodeEnum.global.getType()); List 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> map = operatorList.stream().collect(Collectors.groupingBy(OperatorEntity::getNodeCode)); List handleIds = operatorList.stream().map(OperatorEntity::getHandleId).distinct().collect(Collectors.toList()); List 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 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 resMap = conditionUtil.handleCondition(flowMethod); try { conditionUtil.checkCondition(resMap, nodes); } catch (WorkFlowException e) { continue; } List nextApprover; boolean mark = true; try { nextApprover = flowUtil.getNextApprover(flowMethod); } catch (WorkFlowException e) { nextApprover = null; mark = false; } if (!mark) { continue; } List 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 sourceList = Arrays.stream(taskEntity.getCurrentNodeCode().split(",")).collect(Collectors.toList()); fo.setSource(sourceList); List 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 nodeRecords = nodeRecordMapper.getNodeRecord(taskEntity.getId()); List nodeIds = nodeRecords.stream().map(NodeRecordEntity::getNodeId).filter(StringUtil::isNotBlank).collect(Collectors.toList()); // 更新经办关联的flowable的任务id List operatorList = operatorMapper.getList(taskEntity.getId()); List updateList = new ArrayList<>(); // 更新记录关联的flowable的任务id List recordList = recordMapper.getList(taskEntity.getId()); List updateRecordList = new ArrayList<>(); //外部节点 List eventLogList = eventLogMapper.getList(taskEntity.getId()); List 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 list = operatorList.stream() .filter(e -> e.getNodeCode().equals(model.getTaskKey())).collect(Collectors.toList()); list.forEach(e -> e.setNodeId(model.getTaskId())); updateList.addAll(list); // 记录修改 List collect = recordList.stream() .filter(e -> e.getNodeCode().equals(model.getTaskKey())).collect(Collectors.toList()); collect.forEach(e -> e.setNodeId(model.getTaskId())); updateRecordList.addAll(collect); //外部节点 List 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 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 ids, List resList, Boolean flag) throws WorkFlowException { QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().in(OperatorEntity::getId, ids); List list = operatorMapper.selectList(queryWrapper); List taskIds = list.stream().map(OperatorEntity::getTaskId).collect(Collectors.toList()); List 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 flowIds = taskEntityList.stream().map(TaskEntity::getFlowId).collect(Collectors.toList()); List 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 ids, List resList, Integer batchType) throws WorkFlowException { QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().in(OperatorEntity::getId, ids); List list = operatorMapper.selectList(queryWrapper); List 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 ids, List resList) throws WorkFlowException { QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().in(OperatorEntity::getId, ids); List list = operatorMapper.selectList(queryWrapper); List taskIds = list.stream().map(OperatorEntity::getTaskId).collect(Collectors.toList()); List 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 queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId) .isNull(OperatorEntity::getHandleStatus); List 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 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 operatorListAll = FlowOperatorHolder.getOperatorList(); for (FlowOperatorModel model : operatorListAll) { List list = model.getList() != null ? model.getList() : new ArrayList<>(); Map> allData = model.getAllData(); Map> taskMap = list.stream().collect(Collectors.groupingBy(OperatorEntity::getTaskId)); for (String taskId : taskMap.keySet()) { List operatorList = taskMap.get(taskId) != null ? taskMap.get(taskId) : new ArrayList<>(); Map> operatorMap = operatorList.stream().collect(Collectors.groupingBy(OperatorEntity::getNodeCode)); for (String nodeCode : operatorMap.keySet()) { List operator = operatorMap.get(nodeCode) != null ? operatorMap.get(nodeCode) : new ArrayList<>(); if (operator.isEmpty()) { continue; } FlowModel flowModel = JsonUtil.getJsonToBean(model.getFlowModel(), FlowModel.class); Map 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 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 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 taskIdList) { FlowStatusHolder.addTaskIdList(taskIdList); } //删除流程id public void addDelTask(String taskId, String flowId) { FlowStatusHolder.addDelTaskIdList(taskId, flowId); } public List getList(String taskId, List nodeCodes) { if (StringUtil.isEmpty(taskId)) { return new ArrayList<>(); } QueryWrapper 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 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 queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().eq(OperatorEntity::getNodeId, operator.getNodeId()) .eq(OperatorEntity::getHandleId, nextHandleId); List deleteList = operatorMapper.selectList(queryWrapper); if (CollectionUtil.isNotEmpty(deleteList)) { operatorMapper.deleteByIds(deleteList); } } } public void deleteStepOperator(OperatorEntity operator) { if (operator != null) { QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().eq(OperatorEntity::getTaskId, operator.getTaskId()); List list = operatorMapper.selectList(queryWrapper); List 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 nodes = flowModel.getNodes(); List 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 formData = flowModel.getFormData(); List systemList = SystemAuditHolder.getAll(); // 存在同步 boolean isAsync = false; List approveNode = new ArrayList<>(); Map 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 outgoingFlows = flowAbleUrl.getOutgoingFlows(flowsFo); Map variables = new HashMap<>(); for (String line : outgoingFlows) { variables.put(line, true); } if (ObjectUtil.equals(action, 3)) { List 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 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 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 operatorList = new ArrayList<>(); List 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> 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 list) throws Exception { for (ExecuteAsyncModel asyncModel : list) { FlowModel flowModel = asyncModel.getFlowModel(); ExecuteModel model = asyncModel.getModel(); Boolean sync = asyncModel.getSync(); List operatorList = asyncModel.getOperatorList(); List systemList = asyncModel.getSystemList(); List subTaskList = asyncModel.getSubTaskList(); this.execute(model, sync, operatorList, subTaskList, systemList, flowModel); } } public void execute(ExecuteModel model, Boolean isAsync, List operatorList, List subTaskList, List 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 delTaskMap = FlowStatusHolder.getDelTaskMap(); for (String taskId : delTaskMap.keySet()) { String flowId = delTaskMap.get(taskId); if (StringUtil.isEmpty(flowId)) { continue; } List flowIdList = ImmutableList.of(flowId); List list = templateNodeMapper.getList(flowIdList, null); Set formIds = list.stream().map(TemplateNodeEntity::getFormId).collect(Collectors.toSet()); FlowStateModel model = new FlowStateModel(new ArrayList<>(formIds), taskId, 0); serviceUtil.saveState(model); } List taskIdList = FlowStatusHolder.getTaskList(); if (!taskIdList.isEmpty()) { List taskList = taskMapper.getInfosSubmit(taskIdList.toArray(new String[0]), TaskEntity::getId, TaskEntity::getStatus, TaskEntity::getFlowId); List flowIdList = taskList.stream().map(TaskEntity::getFlowId).collect(Collectors.toList()); List list = templateNodeMapper.getList(flowIdList, null); for (TaskEntity task : taskList) { String id = task.getId(); String flowId = task.getFlowId(); Integer status = task.getStatus(); Set 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 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 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 outsideData(FlowModel flowModel, List templateJsonModelList, Map> allData, String resultNodeCode, String eventId) throws WorkFlowException { TaskEntity taskEntity = flowModel.getTaskEntity(); List 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 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 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 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 dataMap = new HashMap<>(formData); dataMap.putAll(parameterData); FlowModel parameterModel = new FlowModel(); parameterModel.setFormData(dataMap); parameterModel.setRecordEntity(record); parameterModel.setTaskEntity(taskEntity); Map 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 idList = ImmutableList.of(id); List taskList = new ArrayList<>(); // 递归获取子流程 for (String taskId : idList) { List childAllList = taskMapper.getChildAllList(taskId); taskList.addAll(taskMapper.getOrderStaList(childAllList)); } List 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 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 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 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 wrapper = new QueryWrapper<>(); wrapper.lambda().in(TaskEntity::getParentId, task.getId()); List 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 taskModelList, Map nodes, TaskEntity taskEntity) { List currentNodeList = new ArrayList<>(); List currentNodeNameList = new ArrayList<>(); List 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 circulateList = flowMethod.getCirculateList(); FlowModel flowModel = flowMethod.getFlowModel(); TaskEntity taskEntity = flowModel.getTaskEntity(); List 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 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 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 formData) throws WorkFlowException { this.getGlobalParam(taskEntity, nodeModel, global, formData); taskMapper.updateById(taskEntity); } public void getGlobalParam(TaskEntity taskEntity, NodeModel nodeModel, NodeModel global, Map formData) throws WorkFlowException { List paramModelList = global.getGlobalParameterList(); if (CollectionUtil.isEmpty(paramModelList)) { return; } formData = formData == null ? new HashMap<>() : formData; List 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 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 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 improperSort(List userIds, NodeModel nodeModel) { List list = new ArrayList<>(); List sortList = nodeModel.getApproversSortList(); if (sortList.isEmpty()) { return userIds; } for (String id : sortList) { List 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 nodeEntityList = flowModel.getNodeEntityList(); String instanceId = taskEntity.getInstanceId(); boolean flag; FlowableInstanceModel instance = flowAbleUrl.getInstance(instanceId); if (null != instance && null != instance.getEndTime()) { flag = true; } else { List 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 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 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 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 subNodeList = templateNodeMapper.getList(template.getFlowId()); Map 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 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 wrapper = new QueryWrapper<>(); wrapper.lambda().eq(TaskEntity::getParentId, taskEntity.getParentId()) .eq(TaskEntity::getSubCode, subCode); List subList = taskMapper.selectList(wrapper); // 未审批集合 List 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 nodes = model.getNodes(); Map 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 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 nodeCodeList = new ArrayList<>(); flowUtil.prevNodeList(flowModel.getDeploymentId(), subCode, parentNodeList, nodeCodeList); if (CollectionUtil.isNotEmpty(nodeCodeList)) { List list = getList(parentTask.getId(), nodeCodeList); if (CollectionUtil.isNotEmpty(list)) { model.setOperatorEntity(list.get(0)); } } completeNode(flowMethod); } } // 删除子流程（退回时若是重新审批） public void deleteSubflow(String taskId, List nodeCodeList) { QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().eq(TaskEntity::getParentId, taskId); if (CollectionUtil.isNotEmpty(nodeCodeList)) { queryWrapper.lambda().in(TaskEntity::getSubCode, nodeCodeList); } List list = taskMapper.selectList(queryWrapper); if (CollectionUtil.isNotEmpty(list)) { List idList = list.stream().map(TaskEntity::getId).distinct().collect(Collectors.toList()); List idAll = new ArrayList<>(); taskMapper.deleTaskAll(idList, idAll); List 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 userIdAll, UserEntity flowUser, int rule) { if (flowUser != null) { String userId = flowUser.getId(); //附加条件 switch (ExtraRuleEnum.getByCode(rule)) { case role: List roleId = serviceUtil.getRoleObjectId(ImmutableList.of(userId)).stream().map(RoleRelationEntity::getRoleId).collect(Collectors.toList()); List userIdList = serviceUtil.getListByRoleId(roleId).stream().map(RoleRelationEntity::getObjectId).collect(Collectors.toList()); List 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 userRelationList = serviceUtil.getListByUserIdAll(ImmutableList.of(userId)); List objectIdList = new ArrayList<>(); List idList = userRelationList.stream().filter(e -> ObjectUtil.equals(e.getObjectType(), type)) .map(UserRelationEntity::getObjectId).collect(Collectors.toList()); if (Objects.equals(ExtraRuleEnum.organize.getCode(), rule)) { List positionList = serviceUtil.getPosList(idList); List organizeList = positionList.stream().map(PositionEntity::getOrganizeId).collect(Collectors.toList()); List 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 userIds = serviceUtil.getListByObjectIdAll(objectIdList).stream().map(UserRelationEntity::getUserId) .filter(e -> !ObjectUtil.equals(e, userId)).collect(Collectors.toList()); userIdAll.addAll(userIds); break; } } } //封装用户对象 public List getUserModel(List ids, Pagination pagination) { List userIds = serviceUtil.getUserListAll(ids); List userList = serviceUtil.getUserName(userIds, pagination); pagination.setTotal(pagination.getTotal()); List userIdList = userList.stream().map(UserEntity::getId).collect(Collectors.toList()); List userRelationList = serviceUtil.getListByUserIdAll(userIdList); Map> userMap = userRelationList.stream() .filter(t -> PermissionConst.POSITION.equals(t.getObjectType())).collect(Collectors.groupingBy(UserRelationEntity::getUserId)); List 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 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 organizeIdTree = new ArrayList<>(Arrays.asList(organize.getOrganizeIdTree().split(","))); List 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 positionIdTree = new ArrayList<>(Arrays.asList(position.getPositionIdTree().split(","))); List 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 dataTransfer(FlowMethod flowMethod) throws WorkFlowException { List nodeEntityList = flowMethod.getNodeEntityList(); FlowModel flowModel = flowMethod.getFlowModel(); Map 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 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 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 taskList) throws Exception { if (taskList.isEmpty()) { return; } List nodeEntityList = new ArrayList<>(); List flowIds = taskList.stream().map(TaskEntity::getFlowId).collect(Collectors.toList()); if (!flowIds.isEmpty()) { nodeEntityList = templateNodeMapper.getList(flowIds, null); } for (TaskEntity taskEntity : taskList) { List 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 getNextList(String deploymentId, String nodeCode, Map nodes, List nextList) throws WorkFlowException { nextList = nextList != null ? nextList : new ArrayList<>(); NextOrPrevFo fo = new NextOrPrevFo(); fo.setDeploymentId(deploymentId); fo.setTaskKey(nodeCode); List nextModels = flowAbleUrl.getNext(fo); for (FlowableNodeModel next : nextModels) { NodeModel nodeModel = nodes.get(next.getId()); if (null != nodeModel) { // 子流程往下递归 List 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 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 userIds = flowModel.getUserIds(); List> 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 nodeEntityList = templateNodeMapper.getList(jsonEntity.getId()); Map 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 resMap = conditionUtil.handleCondition(method); // 判断条件、候选人 try { conditionUtil.checkCondition(resMap, nodes); } catch (WorkFlowException e) { throw new WorkFlowException(MsgCode.WF133.get()); } method.setNextSubFlow(true); List nextApprover = flowUtil.getNextApprover(method); if (!flowUtil.checkNextCandidates(nextApprover)) { throw new WorkFlowException(MsgCode.WF134.get()); } String flowId = jsonEntity.getId(); // 判断流程权限 List userListAll = serviceUtil.getUserListAll(userIds); FlowFormModel formIdAndFlowId = flowUtil.getFormIdAndFlowId(userListAll, templateId); List 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 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> allData = FlowContextHolder.getAllData(); Map>> formOperates = FlowContextHolder.getFormOperates(); List writeIdList = FlowContextHolder.getWriteIdList(); for (String idAll : writeIdList) { String[] idList = idAll.split(JnpfConst.SIDE_MARK); List> operates = formOperates.get(idAll); Map 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 branchList = flowModel.getBranchList(); //taskUtil.checkLaunchPermission(userInfo.getUserId(), templateEntity); // 获取节点 List nodeEntityList = templateNodeMapper.getList(jsonEntity.getId()); if (CollectionUtil.isEmpty(nodeEntityList)) { throw new WorkFlowException(MsgCode.WF076.get()); } Map 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 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 resMap = new HashMap<>(); if (branchList.isEmpty()) { resMap.putAll(conditionUtil.handleCondition(flowMethod)); // 全是false，说明没有分支可走 conditionUtil.checkCondition(resMap, nodes); } else { // 选择分支的处理 resMap.putAll(conditionUtil.getForBranch(flowMethod, branchList)); } // 引擎启动的变量 Map 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 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 handleOperator(FlowModel flowModel) throws Exception { TaskEntity taskEntity = flowModel.getTaskEntity(); List nodeEntityList = flowModel.getNodeEntityList(); Map nodes = flowModel.getNodes(); Map formData = flowModel.getFormData(); String instanceId = taskEntity.getInstanceId(); String deploymentId = flowModel.getDeploymentId(); NodeModel global = nodes.get(NodeEnum.global.getType()); OperatorEntity operatorEntity = flowModel.getOperatorEntity(); // 最终要返回一个所有节点下的审批人的集合 List list = new ArrayList<>(); // 原来的当前节点 List srcCurrentList = StringUtil.isNotEmpty(taskEntity.getCurrentNodeCode()) ? Arrays.stream(taskEntity.getCurrentNodeCode().split(",")).collect(Collectors.toList()) : new ArrayList<>(); // 获取引擎当前任务 List taskModelList = flowAbleUrl.getCurrentTask(instanceId); if (CollectionUtil.isEmpty(taskModelList)) { return list; } updateCurrentNode(taskModelList, nodes, taskEntity); List types = ImmutableList.of(NodeEnum.subFlow.getType(), NodeEnum.approver.getType(), NodeEnum.processing.getType(), NodeEnum.outside.getType()); List 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 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 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> outsideOptions = nodeModel.getOutsideOptions(); String resultNodeCode = flowUtil.resultNodeCode(flowMethod); List 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 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 nextApprover; boolean mark = true; try { nextApprover = flowUtil.getNextApprover(flowMethod); } catch (WorkFlowException e) { nextApprover = null; mark = false; } Map 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 userIds = flowUtil.userListAll(flowMethod); // 获取正常的用户 List users = serviceUtil.getUserName(userIds, true); // 全局异常处理 if (users.isEmpty()) { // 自动通过 Integer pass = flowMethod.getPass(); if (pass > 0) { // 自动审批 要判断候选人等 boolean mark = true; List nextApprover; try { nextApprover = flowUtil.getNextApprover(flowMethod); } catch (WorkFlowException e) { // 异常节点（默认通过）下条件不满足、候选人，走admin兜底方案 nextApprover = null; mark = false; } Map 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 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 list = new ArrayList<>(); String flowId = fo.getFlowId(); String nodeCode = null; Map 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 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 launchPermission = serviceUtil.getPermission(fo.getDelegateUser()); if (ObjectUtil.equals(template.getVisibleType(), FlowNature.Authority) && !launchPermission.contains(template.getId())) { throw new WorkFlowException(MsgCode.WF129.get()); } } List nodeEntities = templateNodeMapper.getList(jsonEntity.getId()); Map 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 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 nextModels = flowAbleUrl.getNext(nextOrPrevFo); List 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 typeList = ImmutableList.of(NodeEnum.eventTrigger.getType(), NodeEnum.timeTrigger.getType(), NodeEnum.noticeTrigger.getType(), NodeEnum.webhookTrigger.getType(), NodeEnum.trigger.getType()); List connectList = global.getConnectList(); List 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 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 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 assignList = nodeModel.getAssignList().stream().filter(t -> t.getNodeId().equals(currentNode.getNodeCode())).collect(Collectors.toList()); Map 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 nextTypeList = ImmutableList.of(NodeEnum.subFlow.getType()); if (nextTypeList.contains(nodeModel.getType())) { // 判断子流程、外部节点，获取审批节点 jsonToBean.setNodeCode(nodeModel.getNodeId()); jsonToBean.setNextSubFlow(true); List nextApprover = flowUtil.getNextApprover(jsonToBean); for (NodeModel node : nextApprover) { List 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 candidates = candidatesMapper.getList(taskId, model.getNodeCode()); String candidateStr = candidates.stream().map(CandidatesEntity::getCandidates).collect(Collectors.joining(",")); if (StringUtil.isNotEmpty(candidateStr)) { List selected = new ArrayList<>(); List userIds = Arrays.stream(candidateStr.split(",")).distinct().collect(Collectors.toList()); List 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 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 userIds = flowUtil.userListAll(flowMethod); List 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 circulateList(FlowMethod flowMethod) throws WorkFlowException { FlowModel flowModel = flowMethod.getFlowModel(); List circulateList = new ArrayList<>(); TaskEntity task = flowMethod.getTaskEntity(); OperatorEntity operator = flowMethod.getOperatorEntity(); TemplateNodeEntity nodeEntity = flowMethod.getNodeEntity(); NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class); List 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 dataAll = flowUtil.createOrUpdate(flowMethod); Object data = dataAll.get(nodeModel.getCopyFormField() + FlowNature.FORM_FIELD_SUFFIX); if (data != null) { List 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 id = new ArrayList<>(); for (String s : list) { id.add(s.split("--")[0]); } List listByObjectIdAll = serviceUtil.getListByObjectIdAll(id); List userList = serviceUtil.getUserListAll(list); List userPosition = listByObjectIdAll.stream().map(UserRelationEntity::getUserId).collect(Collectors.toList()); List 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 userList = serviceUtil.getUserName(userIdAll, true); List 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 getCirculateList(List list){ List vos = new ArrayList<>(); if (CollectionUtil.isNotEmpty(list)) { List 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 getTriggerDataModel(TriggerDataFo fo) { String modelId = fo.getModelId(); Integer trigger = fo.getTrigger(); List dataId = fo.getDataId(); List> dataMap = fo.getDataMap(); List updateFields = fo.getUpdateFields(); List res = new ArrayList<>(); Map 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> 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 updateFields) { List updateFieldList = nodeModel.getUpdateFieldList(); if (CollectionUtil.isEmpty(updateFieldList)) { return false; } if (ObjectUtil.equals(nodeModel.getType(), NodeEnum.eventTrigger.getType()) && ObjectUtil.equals(trigger, 2)) { // 任意字段发生修改，结果集合为空 说明指定字段（updateFieldList）不存在发生修改的字段（updateFields）中 List list = updateFieldList.stream().filter(updateFields::contains).collect(Collectors.toList()); return CollectionUtil.isEmpty(list); } return false; } public Map getTriggerNode(String formId, Integer trigger) { QueryWrapper queryWrapper = new QueryWrapper<>(); List typeList = ImmutableList.of(NodeEnum.eventTrigger.getType()); queryWrapper.lambda().in(TemplateNodeEntity::getNodeType, typeList) .eq(TemplateNodeEntity::getFormId, formId); List nodeEntityList = templateNodeMapper.selectList(queryWrapper); List 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 filterFlowIds = new ArrayList<>(); if (CollectionUtil.isNotEmpty(flowIds)) { QueryWrapper wrapper = new QueryWrapper<>(); wrapper.lambda().in(TemplateEntity::getFlowId, flowIds).eq(TemplateEntity::getType, FlowNature.Quest); List templateList = templateMapper.selectList(wrapper); filterFlowIds = templateList.stream().map(TemplateEntity::getFlowId).collect(Collectors.toList()); } // Map Map 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 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 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> 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> 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> 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 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 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 taskModelList = flowAbleUrl.getCurrentTask(instanceId); // 触发节点 List 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 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 variableMap = this.getVariables(deploymentId, taskModel.getTaskKey()); this.complete(taskModel.getTaskId(), variableMap); this.executeNode(model); TriggerHolder.clear(); } } } public Map getVariables(String deploymentId, String nodeCode) throws WorkFlowException { OutgoingFlowsFo flowsFo = new OutgoingFlowsFo(); flowsFo.setDeploymentId(deploymentId); flowsFo.setTaskKey(nodeCode); List outgoingFlows = flowAbleUrl.getOutgoingFlows(flowsFo); Map variables = new HashMap<>(); for (String line : outgoingFlows) { variables.put(line, true); } return variables; } public void complete(String id, Map 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 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 taskModelList = flowAbleUrl.getCurrentTask(instanceId); if (CollectionUtil.isNotEmpty(taskModelList)) { // 统计执行节点的数量 int count = 0; int executedCount = 0; boolean multiple = taskModelList.size() > 1; List recordList = triggerRecordMapper.getList(triggerTask.getId()); List codeList = recordList.stream().map(TriggerRecordEntity::getNodeCode).collect(Collectors.toList()); List 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> 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> 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 variables = this.getVariables(deploymentId, taskModel.getTaskKey()); this.complete(taskModel.getTaskId(), variables); } else { // 嵌入的任务流程，最后的执行节点不能通过，否则退回会有问题 NextOrPrevFo fo = new NextOrPrevFo(); fo.setDeploymentId(deploymentId); fo.setTaskKey(taskModel.getTaskKey()); List next = flowAbleUrl.getNext(fo); if (CollectionUtil.isNotEmpty(next)) { Map 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> getData(ExecuteModel model) throws WorkFlowException { List> dataList = new ArrayList<>(); NodeModel nodeModel = model.getNodeModel(); Integer formType = nodeModel.getFormType(); switch (formType) { case 1: case 2: List> list = this.getDataList(nodeModel, new HashMap<>(), new ArrayList<>()); dataList.addAll(list); break; case 3: List resultList = this.interfaceTemplateJson(model, new HashMap<>()); List errList = new ArrayList<>(); for (ActionResult result : resultList) { if (!ObjectUtil.equals(result.getCode(), 200)) { errList.add(result.getMsg()); continue; } if (result.getData() instanceof List) { List> 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> data = this.getDataList(nodeModel, new HashMap<>(), new ArrayList<>(), true); String subTable = nodeModel.getSubTable(); for (Map map : data) { Object obj = map.get(subTable); if (null != obj) { List> mapList = this.castListMap(obj); List> resList = new ArrayList<>(); for (Map objectMap : mapList) { Map 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 map : dataList) { map.put(DataInterfaceVarConst.FORM_ID, map.get(FlowFormConstant.ID)); } return dataList; } public List> castListMap(Object obj) { return this.castListMap(obj, String.class, Object.class); } // 对象转Map类型的List public List> castListMap(Object obj, Class kClazz, Class vClazz) { List> result = new ArrayList<>(); if (obj instanceof List) { for (Object o : (List) obj) { if (o instanceof Map) { Map 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 interfaceTemplateJson(ExecuteModel executeModel, Map data) throws WorkFlowException { UserInfo userInfo = executeModel.getUserInfo(); NodeModel nodeModel = executeModel.getNodeModel(); TaskEntity taskEntity = executeModel.getTaskEntity(); String globalParameter = taskEntity.getGlobalParameter(); Map parameterData = StringUtil.isNotEmpty(globalParameter) ? JsonUtil.stringToMap(globalParameter) : new HashMap<>(); String interId = nodeModel.getFormId(); List templateJson = nodeModel.getTemplateJson(); boolean isGetData = ObjectUtil.equals(nodeModel.getType(), NodeEnum.getData.getType()); if (isGetData) { templateJson = nodeModel.getInterfaceTemplateJson(); } Map parameterMap = new HashMap<>(); Set msg = new HashSet<>(); Map>> allData = TriggerHolder.getData(); String dataSourceForm = nodeModel.getDataSourceForm(); List> maps = allData.get(dataSourceForm); List resultList = new ArrayList<>(); if (StringUtil.isBlank(dataSourceForm)) { maps = new ArrayList<>(); maps.add(new HashMap<>()); } if (CollectionUtil.isNotEmpty(maps)) { List paramList = ImmutableList.of( DataInterfaceVarConst.USER, DataInterfaceVarConst.USERANDSUB, DataInterfaceVarConst.USERANDPROGENY, DataInterfaceVarConst.ORG, DataInterfaceVarConst.ORGANDSUB, DataInterfaceVarConst.ORGANIZEANDPROGENY, DataInterfaceVarConst.POSITIONID, DataInterfaceVarConst.POSITIONANDSUB, DataInterfaceVarConst.POSITIONANDPROGENY); Map paramDataMap = serviceUtil.getSystemFieldValue(); for (Map map : maps) { Map 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 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 dataList = new ArrayList<>(); String value = paramDataMap.get(relationField); if (StringUtil.isNotEmpty(value)) { try { List 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> listAll = (List>) dataList; List dataListAll = new ArrayList<>(); for (Map 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 dataMap = (Map) 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 msg) throws WorkFlowException { if (!msg.isEmpty()) { throw new WorkFlowException(new ArrayList<>(msg).get(0) + MsgCode.VS015.get()); } } public List> getDataList(NodeModel nodeModel, Map data, List dataId) { return this.getDataList(nodeModel, data, dataId, false); } private List> getDataList(NodeModel nodeModel, Map data, List dataId, Boolean isSub) { boolean idDelete = Objects.equals(nodeModel.getType(), NodeEnum.deleteData.getType()); String formId = nodeModel.getFormId(); List 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 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 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>> allData = TriggerHolder.getData(); List> maps = allData.get(split[1]); if (CollectionUtil.isNotEmpty(maps)) { Map 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 idAll = new ArrayList<>(); List idList = new ArrayList<>(); List> dataList = new ArrayList<>(); try { if (ruleList.size() > 0) { visualJsonModel.setSuperQuery(superJsonModel); } if (isFlow) { List 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 intersection = idList.stream().filter(item -> dataId.contains(item)).collect(Collectors.toList()); if (dataId.size() > 0) { idAll.addAll(intersection); } else { idAll.addAll(idList); } List> result = new ArrayList<>(); for (String id : idAll) { List> collect = dataList.stream().filter(t -> Objects.equals(String.valueOf(t.get(FlowFormConstant.ID)), id)).collect(Collectors.toList()); for (Map 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 sortList) { List 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 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> dataInterface(ExecuteModel model) throws WorkFlowException { List> dataList = new ArrayList<>(); List resultList = this.interfaceTemplateJson(model, new HashMap<>()); List errList = new ArrayList<>(); for (ActionResult result : resultList) { if (!ObjectUtil.equals(result.getCode(), 200)) { errList.add(result.getMsg()); continue; } if (result.getData() instanceof List) { List> 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 templateJson = nodeModel.getMsgTemplateJson(); UserInfo userInfo = model.getUserInfo(); Map>> allData = TriggerHolder.getData(); Map parameterMap = this.templateJson(templateJson, allData, userInfo); List userIds = this.getUserList(nodeModel.getMsgUserIds(), nodeModel.getMsgUserIdsSourceType(), allData); this.message(msgId, userIds, parameterMap, userInfo); } } private void message(String msgId, List userIdList, Map parameterMap, UserInfo userInfo) throws WorkFlowException { List 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 errList = serviceUtil.sendDelegateMsg(formList); if (CollectionUtil.isNotEmpty(errList)) { throw new WorkFlowException(errList.get(0)); } } private Map templateJson(List templateJson, Map>> data, UserInfo userInfo) throws WorkFlowException { Map parameterMap = new HashMap<>(); Set msg = new HashSet<>(); for (IntegrateTplModel tplModel : templateJson) { List 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> mapList = data.get(split[1]); Map 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 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 transferList = nodeModel.getTransferList(); String dataSourceForm = nodeModel.getDataSourceForm(); List 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 data = new HashMap<>(); for (TemplateJsonModel TemplateJsonModel : transferList) { data.put(TemplateJsonModel.getTargetField(), TemplateJsonModel.getSourceValue()); } if (CollectionUtil.isNotEmpty(data)) { serviceUtil.visualCreate(visualdevEntity, data); } return; } // 数据源的数据 Map>> allData = TriggerHolder.getData(); List> maps = allData.get(dataSourceForm) != null ? allData.get(dataSourceForm) : new ArrayList<>(); for (Map map : maps) { List> dataList = new ArrayList<>(); if (CollectionUtil.isNotEmpty(ruleList)) { dataList = this.getDataList(nodeModel, map, new ArrayList<>()); } if (dataList.isEmpty()) { List> list = this.handleAddData(map, transferList); if (CollectionUtil.isNotEmpty(list)) { for (Map saveData : list) { serviceUtil.visualCreate(visualdevEntity, saveData); } } } } } public List> handleAddData(Map data, List transferList) { return this.handleData(data, new ArrayList<>(), transferList); } // 将后缀为_jnpfId的值赋给原字段 public Map setData(Map 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> subList = (List>) o; for (Map map : subList) { this.setData(map); } } } } return data; } /** * 字段设置 * */ public List> handleData(Map data, List> dataList, List transferList) { boolean isAdd = CollectionUtil.isEmpty(dataList); List> list = new ArrayList<>(dataList); Map 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> parentList = (List>) 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> sourceList = (List>) oldData.get(sourceFieldList[0]); diff = sourceList.size(); } for (Map map : list) { if (map.get(targetFieldList[0]) instanceof List) { List> targetList = (List>) map.get(targetFieldList[0]); int max1 = targetList.size() - diff; for (int i = 0; i < max1; i++) { targetList.add(new HashMap<>()); } } else { List> childList = new ArrayList<>(); for (int i = 0; i < diff; i++) { childList.add(new HashMap<>()); } map.put(targetFieldList[0], childList); } } } } } } } // for (Map 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> parentList = (List>) oldData.get(sourceFieldList[0]); for (int i = 0; i < list.size(); i++) { Map targetMap = list.get(i); List> childList = (List>) targetMap.get(targetFieldList[0]); if (CollectionUtil.isNotEmpty(childList)) { for (int j = 0; j < parentList.size(); j++) { Map sourceMap = parentList.get(j); // this.setData(sourceMap); if (childList.size() > j) { Map 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 map : list) { Object obj = flowUtil.getOneData(oldData, split[0]); if (map.get(targetFieldList[0]) instanceof List) { List> childList = (List>) map.get(targetFieldList[0]); if (CollectionUtil.isEmpty(childList)) { childList.add(new HashMap<>()); } for (Map objectMap : childList) { objectMap.put(targetFieldList[1], obj); } map.put(targetFieldList[0], childList); } } } } else { // 来源不是子表、目标是子表 for (Map map : list) { if (null == map.get(targetFieldList[0])) { List> childList = new ArrayList<>(); Map 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> childList = (List>) map.get(targetFieldList[0]); for (Map childMap : childList) { childMap.put(targetFieldList[1], childData); } } } } } else { if (sourceFieldList.length > 1) { // 来源是子表、目标不是子表 if (oldData.get(sourceFieldList[0]) instanceof List) { List> parentList = (List>) oldData.get(sourceFieldList[0]); // 新增时，一一对应；更新时，取子表第一条数据 if (isAdd) { for (int i = 0; i < parentList.size(); i++) { if (list.size() > i) { Map parentMap = parentList.get(i); // this.setData(parentMap); Map map = list.get(i); Object oneData = flowUtil.getOneData(parentMap, sourceFieldList[1]); map.put(targetField, oneData); } } } else { if (CollectionUtil.isNotEmpty(parentList)) { Map parentMap = parentList.get(0); // this.setData(parentMap); for (Map map : list) { Object oneData = flowUtil.getOneData(parentMap, sourceFieldList[1]); map.put(targetField, oneData); } } } } else if (oldData.get(FlowNature.SUB_TABLE) != null) { for (Map map : list) { Object obj = flowUtil.getOneData(oldData, split[0]); map.put(targetFieldList[0], obj); } } } else { // 来源不是子表、目标不是子表 for (Map 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 transferList = nodeModel.getTransferList(); // 没有可修改的数据时，向对应表单中新增一条数据 boolean unFoundRule = nodeModel.getUnFoundRule(); Map>> allData = TriggerHolder.getData(); List> maps = allData.get(dataSourceForm); // 数据源可以不选，不选则直接更新目标表单的某些数据 if (StringUtil.isBlank(dataSourceForm)) { transferList = transferList.stream().filter(e -> ObjectUtil.equals(e.getSourceType(), 2)).collect(Collectors.toList()); Map 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 map : maps) { List> tempList = this.getDataList(nodeModel, map, new ArrayList<>()); for (Map tempMap : tempList) { this.setData(tempMap); } List> list = this.handleData(map, tempList, transferList); if (CollectionUtil.isNotEmpty(list)) { for (Map 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> dataList = this.getDataList(nodeModel, new HashMap<>(), new ArrayList<>()); if (CollectionUtil.isNotEmpty(dataList)) { serviceUtil.visualDelete(visualdevEntity, dataList); } } else { // 删除子表 // List> 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 ruleList = nodeModel.getRuleList(); List> list = JsonUtil.getJsonToListMap(JsonUtil.getObjectToString(ruleList)); formDataModel.setRuleList(list); serviceUtil.deleteSubTable(formDataModel); } } else { // 按节点删除 Integer condition = nodeModel.getDeleteCondition(); String dataSourceForm = nodeModel.getDataSourceForm(); Map>> allData = TriggerHolder.getData(); List> maps = allData.get(dataSourceForm) != null ? allData.get(dataSourceForm) : new ArrayList<>(); // 获取条件过滤的目标数据 List> dataList = new ArrayList<>(); for (Map map : maps) { List> data = this.getDataList(nodeModel, map, new ArrayList<>()); dataList.addAll(data); } // 全部目标数据 nodeModel.setRuleList(new ArrayList<>()); List> targetData = this.getDataList(nodeModel, new HashMap<>(), new ArrayList<>()); List> intersection = new ArrayList<>(); List> differentSet = new ArrayList<>(); if (ObjectUtil.equals(condition, 1)) { // 存在，删除交集 intersection = dataList; if (CollectionUtil.isNotEmpty(intersection)) { serviceUtil.visualDelete(visualdevEntity, intersection); } } else { // 不存在，删除差集 for (Map map : targetData) { String sourceId = map.get(FlowFormConstant.ID).toString(); for (Map 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 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 nodeEntityList = templateNodeMapper.getList(jsonEntity.getId()); Map 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 resMap = conditionUtil.handleCondition(method); // 判断条件、候选人 try { conditionUtil.checkCondition(resMap, nodes); } catch (WorkFlowException e) { throw new WorkFlowException(MsgCode.WF133.get()); } method.setNextSubFlow(true); List nextApprover = flowUtil.getNextApprover(method); if (!flowUtil.checkNextCandidates(nextApprover)) { throw new WorkFlowException(MsgCode.WF134.get()); } // 数据源数据 String dataSourceForm = nodeModel.getDataSourceForm(); Map>> allData = TriggerHolder.getData(); List> maps = allData.get(dataSourceForm) != null ? allData.get(dataSourceForm) : new ArrayList<>(); List> mapList = new ArrayList<>(); for (Map map : maps) { List> 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 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 userListAll = new HashSet<>(); if (OperatorEnum.Nominator.getCode().equals(nodeModel.getAssigneeType())) { userListAll.addAll(serviceUtil.getUserListAll(nodeModel.getInitiator())); } else { //表单数据用户 for (Map map : maps) { Object data = flowUtil.getOneData(map, nodeModel.getFormField()); userListAll.addAll(flowUtil.getUserId(data)); } } // 判断流程权限 FlowFormModel formIdAndFlowId = flowUtil.getFormIdAndFlowId(new ArrayList<>(userListAll), flowId); List 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 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>> allData = TriggerHolder.getData(); List list = ImmutableList.of(nodeModel.getCreatorUserId()); List 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 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>> allData) { if (ObjectUtil.equals(sourceType, FieldEnum.Field.getCode())) { String[] split = value.split("\\|"); if (split.length > 1) { List> data = allData.get(split[1]); if (CollectionUtil.isNotEmpty(data)) { Map 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 getUserList(List value, Integer sourceType, Map>> allData) { if (ObjectUtil.equals(sourceType, FieldEnum.Field.getCode()) && CollectionUtil.isNotEmpty(value)) { List userIdList = new ArrayList<>(); String str = value.get(0); String[] split = str.split("\\|"); if (split.length > 1) { List> dataList = allData.get(split[1]); if (ObjectUtil.isNotEmpty(dataList)) { Object obj = flowUtil.getOneData(dataList.get(0), split[0]); userIdList.addAll(flowUtil.getUserId(obj)); } } List 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 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 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> dataList = new ArrayList<>(); Map map = new HashMap<>(); List 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> getDataListAfterTriggerNode(String flowId, String triggerNode, List nodeEntityList, UserInfo userInfo) throws WorkFlowException { TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(flowId); NextOrPrevFo fo = new NextOrPrevFo(); fo.setDeploymentId(jsonEntity.getFlowableId()); fo.setTaskKey(triggerNode); List 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> 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 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 msgUserType = global.getMsgUserType(); List msgUserIds = global.getMsgUserIds(); Set 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 userList = serviceUtil.getUserListAll(msgUserIds); userIdList.addAll(userList); break; } } Map dataMap = ImmutableMap.of(FlowConstant.TITLE, triggerTask.getFullName(), FlowConstant.CREATORUSERNAME, ""); List templateJson = msgConfig.getTemplateJson(); List jsonToList = JsonUtil.getJsonToList(templateJson, IntegrateTplModel.class); if (StringUtil.isNotEmpty(msgId) && CollectionUtil.isNotEmpty(userIdList)) { Map map = acquiesce ? dataMap : this.templateJson(jsonToList, new HashMap<>(), userInfo); try { this.message(msgId, new ArrayList<>(userIdList), map, userInfo); } catch (WorkFlowException e) { e.printStackTrace(); } } } }