package jnpf.workflow.flowable.service;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collection;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
import org.flowable.bpmn.model.BaseElement;
|
import org.flowable.bpmn.model.BpmnModel;
|
import org.flowable.bpmn.model.FlowElement;
|
import org.flowable.bpmn.model.Process;
|
import org.flowable.bpmn.model.SequenceFlow;
|
import org.flowable.bpmn.model.UserTask;
|
import org.flowable.engine.HistoryService;
|
import org.flowable.engine.ManagementService;
|
import org.flowable.engine.RepositoryService;
|
import org.flowable.engine.RuntimeService;
|
import org.flowable.engine.TaskService;
|
import org.flowable.engine.history.HistoricActivityInstance;
|
import org.flowable.engine.history.HistoricProcessInstance;
|
import org.flowable.engine.repository.ProcessDefinition;
|
import org.flowable.engine.runtime.ProcessInstance;
|
import org.flowable.task.api.Task;
|
import org.flowable.task.api.TaskInfo;
|
import org.flowable.task.api.history.HistoricTaskInstance;
|
import org.flowable.variable.api.history.HistoricVariableInstance;
|
import org.springframework.stereotype.Service;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.core.util.StrUtil;
|
import jnpf.workflow.common.exception.BizException;
|
import jnpf.workflow.common.exception.ResultCode;
|
import jnpf.workflow.common.model.fo.CompensateFo;
|
import jnpf.workflow.common.model.fo.FlowTargetTaskFo;
|
import jnpf.workflow.common.model.fo.InfoModel;
|
import jnpf.workflow.common.model.fo.InstanceStartFo;
|
import jnpf.workflow.common.model.fo.JumpFo;
|
import jnpf.workflow.common.model.fo.MoveMultiToSingleFo;
|
import jnpf.workflow.common.model.fo.MoveSingleToMultiFo;
|
import jnpf.workflow.common.model.fo.TaskAfterFo;
|
import jnpf.workflow.common.model.fo.TaskBackFo;
|
import jnpf.workflow.common.model.fo.TaskCompleteFo;
|
import jnpf.workflow.common.model.fo.TaskNextFo;
|
import jnpf.workflow.common.model.fo.TaskOutgoingFo;
|
import jnpf.workflow.common.model.fo.TaskPrevFo;
|
import jnpf.workflow.common.model.vo.FlowVo;
|
import jnpf.workflow.common.model.vo.HistoricNodeVo;
|
import jnpf.workflow.common.model.vo.InstanceVo;
|
import jnpf.workflow.common.model.vo.NodeElementVo;
|
import jnpf.workflow.common.model.vo.TaskVo;
|
import jnpf.workflow.common.service.IInstanceService;
|
import jnpf.workflow.common.service.ITaskService;
|
import jnpf.workflow.flowable.cmd.JumpCmd;
|
import jnpf.workflow.flowable.util.FlowableUtil;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
|
@Slf4j
|
@Service
|
@RequiredArgsConstructor
|
public class TaskServiceImpl implements ITaskService {
|
|
private final TaskService taskService;
|
private final HistoryService historyService;
|
private final RuntimeService runtimeService;
|
private final RepositoryService repositoryService;
|
private final ManagementService managementService;
|
private final IInstanceService instanceService;
|
|
@Override
|
public List<TaskVo> getTask(String instanceId) {
|
List<Task> list = taskService.createTaskQuery().processInstanceId(instanceId).list();
|
List<TaskVo> vos = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(list)) {
|
for (Task task : list) {
|
TaskVo vo = new TaskVo();
|
vo.setTaskId(task.getId());
|
vo.setTaskName(task.getName());
|
vo.setTaskKey(task.getTaskDefinitionKey());
|
vo.setInstanceId(task.getProcessInstanceId());
|
vos.add(vo);
|
}
|
}
|
return vos;
|
}
|
|
@Override
|
public boolean complete(TaskCompleteFo fo) {
|
Task task = taskService.createTaskQuery().taskId(fo.getTaskId()).singleResult();
|
if (null == task) {
|
throw new BizException(ResultCode.TASK_NOT_EXIST);
|
}
|
try {
|
if (CollectionUtil.isNotEmpty(fo.getVariables())) {
|
taskService.complete(fo.getTaskId(), fo.getVariables());
|
} else {
|
taskService.complete(fo.getTaskId());
|
}
|
return true;
|
} catch (Exception e) {
|
log.error(ResultCode.TASK_COMPLETE_ERROR.getMsg(), e);
|
return false;
|
}
|
}
|
|
@Override
|
public boolean moveSingleToMulti(MoveSingleToMultiFo fo) {
|
ProcessInstance instance = runtimeService.createProcessInstanceQuery().processInstanceId(fo.getInstanceId()).singleResult();
|
if (null == instance) {
|
throw new BizException(ResultCode.INSTANCE_NOT_EXIST);
|
}
|
try {
|
moveSingleActivityIdToActivityIds(fo.getInstanceId(), fo.getSourceKey(), fo.getTargetKeys());
|
return true;
|
} catch (Exception e) {
|
log.error(ResultCode.TASK_JUMP_ERROR.getMsg(), e);
|
return false;
|
}
|
}
|
|
public void moveSingleActivityIdToActivityIds(String processInstanceId, String activityId, List<String> activityIds) {
|
runtimeService.createChangeActivityStateBuilder()
|
.processInstanceId(processInstanceId)
|
.moveSingleActivityIdToActivityIds(activityId, activityIds)
|
.changeState();
|
}
|
|
@Override
|
public boolean moveMultiToSingle(MoveMultiToSingleFo fo) {
|
ProcessInstance instance = runtimeService.createProcessInstanceQuery().processInstanceId(fo.getInstanceId()).singleResult();
|
if (null == instance) {
|
throw new BizException(ResultCode.INSTANCE_NOT_EXIST);
|
}
|
try {
|
moveActivityIdsToSingleActivityId(fo.getInstanceId(), fo.getSourceKeys(), fo.getTargetKey());
|
return true;
|
} catch (Exception e) {
|
log.error(ResultCode.TASK_JUMP_ERROR.getMsg(), e);
|
return false;
|
}
|
}
|
|
public void moveActivityIdsToSingleActivityId(String processInstanceId, List<String> activityIds, String activityId) {
|
runtimeService.createChangeActivityStateBuilder()
|
.processInstanceId(processInstanceId)
|
.moveActivityIdsToSingleActivityId(activityIds, activityId)
|
.changeState();
|
}
|
|
@Override
|
public boolean jump(JumpFo fo) {
|
ProcessInstance instance = runtimeService.createProcessInstanceQuery().processInstanceId(fo.getInstanceId()).singleResult();
|
if (null == instance) {
|
throw new BizException(ResultCode.INSTANCE_NOT_EXIST);
|
}
|
try {
|
BpmnModel bpmnModel = repositoryService.getBpmnModel(instance.getProcessDefinitionId());
|
JumpCmd jumpCmd = new JumpCmd(fo.getInstanceId(), fo.getSource(), fo.getTarget(), "custom jump", bpmnModel, runtimeService);
|
managementService.executeCommand(jumpCmd);
|
return true;
|
} catch (Exception e) {
|
log.error(ResultCode.TASK_JUMP_ERROR.getMsg(), e);
|
return false;
|
}
|
}
|
|
@Override
|
public List<String> getFallbacks(String taskId) {
|
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
|
if (null == task) {
|
throw new BizException(ResultCode.TASK_NOT_EXIST);
|
}
|
FlowElement source = getFlowElement(task.getProcessDefinitionId(), task.getTaskDefinitionKey());
|
List<String> list = FlowableUtil.getPassActs(source, null, null);
|
return list.stream().distinct().collect(Collectors.toList());
|
}
|
|
public FlowElement getFlowElement(String processDefinitionId, String taskDefinitionKey) {
|
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefinitionId).singleResult();
|
if (null == definition) {
|
throw new BizException(ResultCode.DEFINITION_NOT_EXIST);
|
}
|
Process process = repositoryService.getBpmnModel(definition.getId()).getProcesses().get(0);
|
Collection<FlowElement> elements = FlowableUtil.getAllElements(process.getFlowElements(), null);
|
FlowElement source = null;
|
if (null != elements && !elements.isEmpty()) {
|
for (FlowElement element : elements) {
|
if (!element.getId().equals(taskDefinitionKey)) {
|
continue;
|
}
|
source = element;
|
}
|
}
|
return source;
|
}
|
|
@Override
|
public List<String> back(TaskBackFo fo) {
|
String instanceId;
|
String definitionId;
|
Task task = taskService.createTaskQuery().taskId(fo.getTaskId()).singleResult();
|
if (null == task) {
|
HistoricTaskInstance historicTask = historyService.createHistoricTaskInstanceQuery().taskId(fo.getTaskId()).singleResult();
|
definitionId = historicTask.getProcessDefinitionId();
|
instanceId = historicTask.getProcessInstanceId();
|
} else {
|
definitionId = task.getProcessDefinitionId();
|
instanceId = task.getProcessInstanceId();
|
}
|
if (StrUtil.isNotBlank(fo.getTargetKey())) {
|
String[] split = fo.getTargetKey().split(",");
|
if (split.length == 0) {
|
throw new BizException("目标节点编码不能为空");
|
}
|
List<String> list = Arrays.asList(split);
|
return back(definitionId, instanceId, list);
|
}
|
return null;
|
}
|
|
public List<String> back(String definitionId, String instanceId, List<String> targetList) {
|
List<String> currentIds = new ArrayList<>();
|
for (String targetKey : targetList) {
|
FlowElement target = getFlowElement(definitionId, targetKey);
|
List<Task> runTaskList = taskService.createTaskQuery().processInstanceId(instanceId).list();
|
List<String> runTaskKeyList = runTaskList.stream().map(TaskInfo::getTaskDefinitionKey).collect(Collectors.toList());
|
List<UserTask> userTaskList = FlowableUtil.getChildUserTasks(target, runTaskKeyList, null, null);
|
List<String> collect = userTaskList.stream().map(BaseElement::getId).collect(Collectors.toList());
|
currentIds.addAll(collect);
|
}
|
currentIds = currentIds.stream().distinct().collect(Collectors.toList());
|
JumpFo jumpFo = new JumpFo();
|
jumpFo.setInstanceId(instanceId);
|
jumpFo.setSource(currentIds);
|
jumpFo.setTarget(targetList);
|
jump(jumpFo);
|
return currentIds;
|
}
|
|
@Override
|
public List<String> getPrevUserTask(TaskPrevFo fo) {
|
List<String> list;
|
if (StrUtil.isNotBlank(fo.getDeploymentId())) {
|
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().deploymentId(fo.getDeploymentId()).singleResult();
|
if (null == definition) {
|
throw new BizException(ResultCode.DEFINITION_NOT_EXIST);
|
}
|
FlowElement source = getFlowElement(definition.getId(), fo.getTaskKey());
|
list = FlowableUtil.getParentActs(source, null, null);
|
} else {
|
Task task = taskService.createTaskQuery().taskId(fo.getTaskId()).singleResult();
|
if (null == task) {
|
throw new BizException(ResultCode.TASK_NOT_EXIST);
|
}
|
FlowElement source = getFlowElement(task.getProcessDefinitionId(), task.getTaskDefinitionKey());
|
list = FlowableUtil.getParentActs(source, null, null);
|
}
|
return list;
|
}
|
|
@Override
|
public List<NodeElementVo> getNextUserTask(TaskNextFo fo) {
|
List<UserTask> nextUserTasks;
|
FlowElement source;
|
if (StrUtil.isNotBlank(fo.getDeploymentId())) {
|
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().deploymentId(fo.getDeploymentId()).singleResult();
|
if (null == definition) {
|
throw new BizException(ResultCode.DEFINITION_NOT_EXIST);
|
}
|
source = getFlowElement(definition.getId(), fo.getTaskKey());
|
nextUserTasks = FlowableUtil.getNextUserTasks(source, null, null);
|
} else {
|
HistoricTaskInstance taskInst = historyService.createHistoricTaskInstanceQuery().taskId(fo.getTaskId()).singleResult();
|
if (null == taskInst) {
|
throw new BizException(ResultCode.TASK_NOT_EXIST);
|
}
|
source = getFlowElement(taskInst.getProcessDefinitionId(), taskInst.getTaskDefinitionKey());
|
nextUserTasks = FlowableUtil.getNextUserTasks(source, null, null);
|
}
|
List<NodeElementVo> vos = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(nextUserTasks)) {
|
for (UserTask userTask : nextUserTasks) {
|
NodeElementVo vo = new NodeElementVo();
|
vo.setId(userTask.getId());
|
vo.setName(userTask.getName());
|
vo.setIncomingList(userTask.getIncomingFlows().stream().map(BaseElement::getId).collect(Collectors.toList()));
|
vo.setOutgoingList(userTask.getOutgoingFlows().stream().map(BaseElement::getId).collect(Collectors.toList()));
|
vos.add(vo);
|
}
|
}
|
return vos;
|
}
|
|
@Override
|
public List<String> getTaskKeyAfterFlow(FlowTargetTaskFo fo) {
|
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().deploymentId(fo.getDeploymentId()).singleResult();
|
if (null == definition) {
|
throw new BizException(ResultCode.DEFINITION_NOT_EXIST);
|
}
|
List<String> list = new ArrayList<>();
|
FlowElement source = getFlowElement(definition.getId(), fo.getFlowKey());
|
String taskKey = FlowableUtil.getTaskKeyAfterFlow(source);
|
list.add(taskKey);
|
return list;
|
}
|
|
@Override
|
public boolean retract(String taskId) {
|
HistoricTaskInstance taskInst = historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
|
if (null != taskInst) {
|
ProcessInstance procInst = runtimeService.createProcessInstanceQuery()
|
.processInstanceId(taskInst.getProcessInstanceId()).active().singleResult();
|
if (null != procInst) {
|
FlowElement source = getFlowElement(taskInst.getProcessDefinitionId(), taskInst.getTaskDefinitionKey());
|
List<UserTask> nextUserTasks = FlowableUtil.getNextUserTasks(source, null, null);
|
List<String> nextUserTaskKeys = nextUserTasks.stream().map(BaseElement::getId).collect(Collectors.toList());
|
List<Task> activateTasks = taskService.createTaskQuery().processInstanceId(taskInst.getProcessInstanceId()).list();
|
List<String> currentIds = new ArrayList<>();
|
for (Task task : activateTasks) {
|
if (!CollUtil.contains(nextUserTaskKeys, task.getTaskDefinitionKey())) {
|
continue;
|
}
|
currentIds.add(task.getTaskDefinitionKey());
|
}
|
moveActivityIdsToSingleActivityId(taskInst.getProcessInstanceId(), currentIds, taskInst.getTaskDefinitionKey());
|
return true;
|
}
|
}
|
return false;
|
}
|
|
@Override
|
public List<String> getOutgoingFlows(TaskOutgoingFo fo) {
|
if (StrUtil.isNotBlank(fo.getDeploymentId())) {
|
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().deploymentId(fo.getDeploymentId()).singleResult();
|
if (null == definition) {
|
throw new BizException(ResultCode.DEFINITION_NOT_EXIST);
|
}
|
return getOutgoingFlows(definition.getId(), fo.getTaskKey());
|
}
|
Task task = taskService.createTaskQuery().taskId(fo.getTaskId()).singleResult();
|
if (null == task) {
|
throw new BizException(ResultCode.TASK_NOT_EXIST);
|
}
|
return getOutgoingFlows(task.getProcessDefinitionId(), task.getTaskDefinitionKey());
|
}
|
|
public List<String> getOutgoingFlows(String processDefinitionId, String taskDefinitionKey) {
|
FlowElement source = getFlowElement(processDefinitionId, taskDefinitionKey);
|
List<SequenceFlow> flows = new ArrayList<>();
|
flows = FlowableUtil.getOutFlowsWithGateway(source, flows);
|
List<String> list = new ArrayList<>();
|
if (!flows.isEmpty()) {
|
for (SequenceFlow flow : flows) {
|
list.add(flow.getId());
|
}
|
}
|
return list.stream().distinct().collect(Collectors.toList());
|
}
|
|
@Override
|
public List<FlowVo> getOutgoing(TaskOutgoingFo fo) {
|
if (StrUtil.isNotBlank(fo.getDeploymentId())) {
|
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().deploymentId(fo.getDeploymentId()).singleResult();
|
if (null == definition) {
|
throw new BizException(ResultCode.DEFINITION_NOT_EXIST);
|
}
|
return getOutgoing(definition.getId(), fo.getTaskKey());
|
}
|
Task task = taskService.createTaskQuery().taskId(fo.getTaskId()).singleResult();
|
if (null == task) {
|
throw new BizException(ResultCode.TASK_NOT_EXIST);
|
}
|
return getOutgoing(task.getProcessDefinitionId(), task.getTaskDefinitionKey());
|
}
|
|
public List<FlowVo> getOutgoing(String processDefinitionId, String taskDefinitionKey) {
|
FlowElement source = getFlowElement(processDefinitionId, taskDefinitionKey);
|
return FlowableUtil.getOutFlows(source, null);
|
}
|
|
@Override
|
public List<String> getKeysOfFinished(String instanceId) {
|
ProcessInstance instance = runtimeService.createProcessInstanceQuery().processInstanceId(instanceId).singleResult();
|
if (null == instance) {
|
throw new BizException(ResultCode.INSTANCE_NOT_EXIST);
|
}
|
List<String> keysOfBefore = getKeysOfBefore(instance);
|
List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery()
|
.processInstanceId(instanceId).finished().list();
|
if (CollectionUtil.isNotEmpty(list)) {
|
List<String> keysOfFinished = list.stream()
|
.filter(e -> !"sequenceFlow".equals(e.getActivityType()))
|
.sorted(Comparator.comparing(HistoricActivityInstance::getStartTime))
|
.map(HistoricActivityInstance::getActivityId)
|
.distinct()
|
.collect(Collectors.toList());
|
if (CollectionUtil.isNotEmpty(keysOfBefore)) {
|
keysOfFinished.retainAll(keysOfBefore);
|
}
|
return keysOfFinished;
|
}
|
return null;
|
}
|
|
public List<String> getKeysOfBefore(ProcessInstance instance) {
|
List<String> res = new ArrayList<>();
|
List<Task> taskList = taskService.createTaskQuery().processInstanceId(instance.getId()).list();
|
if (CollectionUtil.isNotEmpty(taskList)) {
|
List<String> keys = taskList.stream().map(TaskInfo::getTaskDefinitionKey).collect(Collectors.toList());
|
for (String key : keys) {
|
FlowElement source = getFlowElement(instance.getProcessDefinitionId(), key);
|
List<String> list = FlowableUtil.getBefore(source, null, null);
|
res.addAll(list);
|
}
|
}
|
return res.stream().distinct().collect(Collectors.toList());
|
}
|
|
@Override
|
public List<String> getIncomingFlows(String taskId) {
|
HistoricTaskInstance taskInst = historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
|
if (null != taskInst) {
|
FlowElement source = getFlowElement(taskInst.getProcessDefinitionId(), taskInst.getTaskDefinitionKey());
|
List<SequenceFlow> flows = FlowableUtil.getElementIncomingFlows(source);
|
return flows.stream().map(BaseElement::getId).collect(Collectors.toList());
|
}
|
return null;
|
}
|
|
@Override
|
public List<String> getToBePass(String instanceId) {
|
List<String> list = new ArrayList<>();
|
List<Task> currentList = taskService.createTaskQuery().processInstanceId(instanceId).list();
|
if (CollectionUtil.isNotEmpty(currentList)) {
|
List<String> collect = currentList.stream().map(TaskInfo::getTaskDefinitionKey).collect(Collectors.toList());
|
for (Task task : currentList) {
|
FlowElement source = getFlowElement(task.getProcessDefinitionId(), task.getTaskDefinitionKey());
|
List<String> after = FlowableUtil.getAfter(source, null, null);
|
list.addAll(after);
|
}
|
list = list.stream().filter(e -> !collect.contains(e)).collect(Collectors.toList());
|
}
|
return list.stream().distinct().collect(Collectors.toList());
|
}
|
|
@Override
|
public List<String> getAfter(TaskAfterFo fo) {
|
String deploymentId = fo.getDeploymentId();
|
List<String> taskKeys = fo.getTaskKeys();
|
List<String> list = new ArrayList<>();
|
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().deploymentId(deploymentId).singleResult();
|
if (null == definition) {
|
throw new BizException(ResultCode.DEFINITION_NOT_EXIST);
|
}
|
for (String taskKey : taskKeys) {
|
FlowElement source = getFlowElement(definition.getId(), taskKey);
|
List<String> after = FlowableUtil.getAfter(source, null, null);
|
list.addAll(after);
|
}
|
return list.stream().distinct().collect(Collectors.toList());
|
}
|
|
@Override
|
public List<TaskVo> compensate(CompensateFo fo) {
|
String instanceId = fo.getInstanceId();
|
ProcessInstance instance = runtimeService.createProcessInstanceQuery().processInstanceId(instanceId).singleResult();
|
if (null == instance) {
|
HistoricProcessInstance historicInstance = historyService.createHistoricProcessInstanceQuery()
|
.processInstanceId(instanceId).singleResult();
|
Map<String, Object> variables = new HashMap<>();
|
List<HistoricVariableInstance> list = historyService.createHistoricVariableInstanceQuery()
|
.processInstanceId(instanceId).list();
|
for (HistoricVariableInstance var : list) {
|
variables.put(var.getVariableName(), var.getValue());
|
}
|
String deploymentId = historicInstance.getDeploymentId();
|
InstanceStartFo startFo = new InstanceStartFo();
|
startFo.setDeploymentId(deploymentId);
|
startFo.setVariables(variables);
|
InstanceVo instanceVo = instanceService.startById(startFo);
|
instanceId = instanceVo.getInstanceId();
|
}
|
List<String> sourceList = fo.getSource().stream().sorted().collect(Collectors.toList());
|
List<TaskVo> taskVoList = getTask(instanceId);
|
List<String> currentList = taskVoList.stream().map(TaskVo::getTaskKey).sorted().collect(Collectors.toList());
|
List<String> createList = sourceList.stream().filter(e -> !currentList.contains(e)).collect(Collectors.toList());
|
List<String> deleteList = currentList.stream().filter(e -> !sourceList.contains(e)).collect(Collectors.toList());
|
JumpFo jumpFo = new JumpFo();
|
jumpFo.setInstanceId(instanceId);
|
jumpFo.setSource(deleteList);
|
jumpFo.setTarget(createList);
|
jump(jumpFo);
|
List<TaskVo> vos = getTask(instanceId);
|
if (null != instance) {
|
vos.forEach(e -> e.setInstanceId(null));
|
}
|
return vos;
|
}
|
|
@Override
|
public List<HistoricNodeVo> getHistoric(String instanceId) {
|
Set<String> set = new HashSet<>();
|
set.add("userTask");
|
set.add("startEvent");
|
List<HistoricNodeVo> vos = getHistoricVos(instanceId, set);
|
return vos.stream().sorted(Comparator.comparing(HistoricNodeVo::getStartTime)).collect(Collectors.toList());
|
}
|
|
@Override
|
public List<String> getHistoricEnd(String instanceId) {
|
List<String> list = new ArrayList<>();
|
List<HistoricNodeVo> vos = getHistoricVos(instanceId, null);
|
if (CollectionUtil.isNotEmpty(vos)) {
|
list = vos.stream().map(HistoricNodeVo::getCode).distinct().collect(Collectors.toList());
|
}
|
return list;
|
}
|
|
public List<HistoricNodeVo> getHistoricVos(String instanceId, Set<String> set) {
|
List<HistoricNodeVo> vos = new ArrayList<>();
|
if (CollectionUtil.isEmpty(set)) {
|
set = new HashSet<>();
|
set.add("endEvent");
|
}
|
List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery()
|
.activityTypes(set).processInstanceId(instanceId).list();
|
if (CollectionUtil.isNotEmpty(list)) {
|
for (HistoricActivityInstance act : list) {
|
HistoricNodeVo vo = new HistoricNodeVo();
|
vo.setCode(act.getActivityId());
|
vo.setTaskId(act.getTaskId());
|
vo.setStartTime(act.getStartTime().getTime());
|
vos.add(vo);
|
}
|
}
|
return vos;
|
}
|
|
@Override
|
public NodeElementVo getElementInfo(InfoModel model) {
|
String deploymentId = model.getDeploymentId();
|
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().deploymentId(deploymentId).singleResult();
|
if (null == definition) {
|
throw new BizException(ResultCode.DEFINITION_NOT_EXIST);
|
}
|
String definitionId = definition.getId();
|
String key = model.getKey();
|
NodeElementVo vo = new NodeElementVo();
|
FlowElement source = getFlowElement(definitionId, key);
|
if (null != source) {
|
vo.setId(source.getId());
|
List<SequenceFlow> outgoingFlows = FlowableUtil.getElementOutgoingFlows(source);
|
vo.setOutgoingList(outgoingFlows.stream().map(BaseElement::getId).collect(Collectors.toList()));
|
List<SequenceFlow> incomingFlows = FlowableUtil.getElementIncomingFlows(source);
|
vo.setIncomingList(incomingFlows.stream().map(BaseElement::getId).collect(Collectors.toList()));
|
}
|
return vo;
|
}
|
}
|
