package jnpf.flowable.service.impl;
|
|
import cn.hutool.core.collection.CollUtil;
|
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.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.github.yulichang.toolkit.JoinWrappers;
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
import com.google.common.collect.ImmutableList;
|
import com.google.common.collect.ImmutableMap;
|
import jnpf.base.UserInfo;
|
import jnpf.base.entity.DictionaryDataEntity;
|
import jnpf.base.entity.SystemEntity;
|
import jnpf.base.entity.VisualdevEntity;
|
import jnpf.base.model.module.ModuleModel;
|
import jnpf.base.service.SuperServiceImpl;
|
import jnpf.constant.JnpfConst;
|
import jnpf.constant.MsgCode;
|
import jnpf.exception.WorkFlowException;
|
import jnpf.flowable.entity.*;
|
import jnpf.flowable.enums.*;
|
import jnpf.flowable.mapper.*;
|
import jnpf.flowable.model.candidates.*;
|
import jnpf.flowable.model.flowable.FlowAbleUrl;
|
import jnpf.flowable.model.message.FlowMsgModel;
|
import jnpf.flowable.model.monitor.MonitorVo;
|
import jnpf.flowable.model.operator.OperatorVo;
|
import jnpf.flowable.model.record.NodeRecordModel;
|
import jnpf.flowable.model.task.*;
|
import jnpf.flowable.model.template.BeforeInfoVo;
|
import jnpf.flowable.model.templatejson.TemplateJsonInfoVO;
|
import jnpf.flowable.model.templatenode.ButtonModel;
|
import jnpf.flowable.model.templatenode.TaskNodeModel;
|
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
|
import jnpf.flowable.model.util.FlowNature;
|
import jnpf.flowable.service.RejectDataService;
|
import jnpf.flowable.service.TaskService;
|
import jnpf.flowable.util.*;
|
import jnpf.permission.entity.UserEntity;
|
import jnpf.permission.model.authorize.AuthorizeVO;
|
import jnpf.util.*;
|
import jnpf.util.context.RequestContext;
|
import lombok.RequiredArgsConstructor;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.stereotype.Service;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 类的描述
|
*
|
* @author JNPF@YinMai Info. Co., Ltd
|
* @version 5.0.x
|
* @since 2024/4/17 15:09
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class TaskServiceImpl extends SuperServiceImpl<TaskMapper, TaskEntity> implements TaskService {
|
|
|
private final FlowAbleUrl flowAbleUrl;
|
|
private final ServiceUtil serviceUtil;
|
|
private final OperatorUtil operatorUtil;
|
|
private final NodeUtil nodeUtil;
|
|
private final MsgUtil msgUtil;
|
|
private final ButtonUtil buttonUtil;
|
|
private final RecordUtil recordUtil;
|
|
private final FlowUtil flowUtil;
|
|
private final TaskUtil taskUtil;
|
|
|
private final TemplateMapper templateMapper;
|
|
private final TemplateJsonMapper templateJsonMapper;
|
|
private final TemplateNodeMapper templateNodeMapper;
|
|
private final LaunchUserMapper launchUserMapper;
|
|
private final CandidatesMapper candidatesMapper;
|
|
private final OperatorMapper operatorMapper;
|
|
private final RecordMapper recordMapper;
|
|
private final CirculateMapper circulateMapper;
|
|
private final RejectDataService rejectDataService;
|
|
private final NodeRecordMapper nodeRecordMapper;
|
|
private final TaskLineMapper taskLineMapper;
|
|
private final RevokeMapper revokeMapper;
|
|
private final EventLogMapper eventLogMapper;
|
|
private final TemplateUseNumMapper templateUseNumMapper;
|
|
private final TriggerLaunchflowMapper triggerLaunchflowMapper;
|
|
@Override
|
public TaskEntity getInfoSubmit(String id, SFunction<TaskEntity, ?>... columns) {
|
return this.baseMapper.getInfoSubmit(id, columns);
|
}
|
|
@Override
|
public List<TaskEntity> getInfosSubmit(String[] ids, SFunction<TaskEntity, ?>... columns) {
|
return this.baseMapper.getInfosSubmit(ids, columns);
|
}
|
|
@Override
|
public List<TaskVo> getList(TaskPagination pagination) {
|
String userId = UserProvider.getUser().getUserId();
|
List<Integer> templateStatusList = ImmutableList.of(TemplateStatueEnum.UP.getCode(), TemplateStatueEnum.DOWN_CONTINUE.getCode());
|
List<Integer> taskStatusList = ImmutableList.of(TaskStatusEnum.TO_BE_SUBMIT.getCode(),
|
TaskStatusEnum.RUNNING.getCode(), TaskStatusEnum.PAUSED.getCode(),
|
TaskStatusEnum.BACKED.getCode(), TaskStatusEnum.RECALL.getCode());
|
MPJLambdaWrapper<TaskEntity> queryWrapper = JoinWrappers.lambda(TaskEntity.class)
|
.select(TaskEntity::getId, TaskEntity::getFullName, TaskEntity::getStartTime,
|
TaskEntity::getCurrentNodeName, TaskEntity::getFlowName, TaskEntity::getFlowType,
|
TaskEntity::getFlowVersion, TaskEntity::getParentId, TaskEntity::getStatus,
|
TaskEntity::getFlowCategory, TaskEntity::getFlowCode, TaskEntity::getFlowId,
|
TaskEntity::getInstanceId, TaskEntity::getTemplateId
|
)
|
.selectAs(TaskEntity::getDelegateUserId, TaskVo::getDelegateUser)
|
.selectAs(TaskEntity::getUrgent, TaskVo::getFlowUrgent)
|
.selectAs(TemplateEntity::getSystemId, TaskVo::getSystemName)
|
.selectAs(TaskEntity::getCreatorUserId, TaskVo::getCreatorUser)
|
.leftJoin(TemplateEntity.class, TemplateEntity::getId, TaskEntity::getTemplateId)
|
.and(e -> e.in(TemplateEntity::getStatus, templateStatusList)
|
.or(t -> t.eq(TemplateEntity::getStatus, TemplateStatueEnum.DOWN_HIDDEN.getCode()).notIn(TaskEntity::getStatus, taskStatusList))
|
)
|
.ne(TaskEntity::getStatus, TaskStatusEnum.WAITING.getCode());
|
|
List<DelegateEntity> delegateList = flowUtil.getByToUserId(userId, 0);
|
queryWrapper.and(t -> {
|
t.eq(TaskEntity::getCreatorUserId, userId);
|
for (DelegateEntity delegate : delegateList) {
|
if (StringUtil.isNotEmpty(delegate.getFlowId())) {
|
String[] flowIds = delegate.getFlowId().split(",");
|
t.or(tw -> tw.in(TaskEntity::getTemplateId, flowIds)
|
.eq(TaskEntity::getCreatorUserId, delegate.getUserId()).eq(TaskEntity::getDelegateUserId, userId)
|
.between(TaskEntity::getStartTime, delegate.getStartTime(), delegate.getEndTime())
|
);
|
} else {
|
t.or().eq(TaskEntity::getCreatorUserId, delegate.getUserId()).eq(TaskEntity::getDelegateUserId, userId)
|
.between(TaskEntity::getStartTime, delegate.getStartTime(), delegate.getEndTime());
|
}
|
}
|
});
|
|
//关键字（流程名称、流程编码）
|
String keyWord = pagination.getKeyword();
|
if (ObjectUtil.isNotEmpty(keyWord)) {
|
queryWrapper.and(t -> t.like(TaskEntity::getEnCode, keyWord).or().like(TaskEntity::getFullName, keyWord));
|
}
|
//日期范围（近7天、近1月、近3月、自定义）
|
if (ObjectUtil.isNotEmpty(pagination.getStartTime()) && ObjectUtil.isNotEmpty(pagination.getEndTime())) {
|
queryWrapper.between(TaskEntity::getStartTime, new Date(pagination.getStartTime()), new Date(pagination.getEndTime()));
|
}
|
//所属流程
|
String templateId = pagination.getTemplateId();
|
if (ObjectUtil.isNotEmpty(templateId)) {
|
queryWrapper.eq(TaskEntity::getTemplateId, templateId);
|
}
|
//流程状态
|
Integer status = pagination.getStatus();
|
if (ObjectUtil.isNotEmpty(status)) {
|
if (status.equals(0)) {// 待提交
|
List<Integer> list = ImmutableList.of(TaskStatusEnum.TO_BE_SUBMIT.getCode(), TaskStatusEnum.BACKED.getCode()
|
, TaskStatusEnum.RECALL.getCode());
|
queryWrapper.in(TaskEntity::getStatus, list);
|
} else if (status.equals(1)) { // 进行中
|
List<Integer> list = ImmutableList.of(TaskStatusEnum.RUNNING.getCode(), TaskStatusEnum.PAUSED.getCode());
|
queryWrapper.in(TaskEntity::getStatus, list);
|
} else { // 已完成
|
List<Integer> list = ImmutableList.of(TaskStatusEnum.PASSED.getCode(), TaskStatusEnum.REJECTED.getCode(),
|
TaskStatusEnum.CANCEL.getCode(), TaskStatusEnum.REVOKED.getCode());
|
queryWrapper.in(TaskEntity::getStatus, list);
|
}
|
}
|
//紧急程度
|
Integer flowUrgent = pagination.getFlowUrgent();
|
if (ObjectUtil.isNotEmpty(flowUrgent)) {
|
queryWrapper.eq(TaskEntity::getUrgent, flowUrgent);
|
}
|
//所属分类
|
String flowCategory = pagination.getFlowCategory();
|
if (ObjectUtil.isNotEmpty(flowCategory)) {
|
queryWrapper.eq(TaskEntity::getFlowCategory, flowCategory);
|
}
|
//应用主键
|
String systemId = pagination.getSystemId();
|
if (ObjectUtil.isNotEmpty(systemId)) {
|
queryWrapper.eq(TemplateEntity::getSystemId, systemId);
|
}
|
//排序
|
queryWrapper.orderByAsc(TaskEntity::getStatus).orderByDesc(TaskEntity::getStartTime);
|
Page<TaskVo> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize());
|
IPage<TaskVo> taskEntityPage = this.selectJoinListPage(page, TaskVo.class, queryWrapper);
|
|
return pagination.setData(taskEntityPage.getRecords(), page.getTotal());
|
}
|
|
@Override
|
public List<MonitorVo> getMonitorList(TaskPagination pagination) {
|
return this.baseMapper.getMonitorList(pagination);
|
}
|
|
@Override
|
public TaskEntity getInfo(String id) throws WorkFlowException {
|
return this.baseMapper.getInfo(id);
|
}
|
|
// 发起、审批详情
|
@Override
|
public BeforeInfoVo getInfo(String id, FlowModel fo) throws WorkFlowException {
|
BeforeInfoVo vo = new BeforeInfoVo();
|
TemplateJsonInfoVO jsonInfoVO = null;
|
TemplateEntity template = null;
|
|
if (!StringUtils.equals(FlowNature.PARENT_ID, id)) {
|
TaskEntity taskEntity = this.getById(id);
|
if (null != taskEntity) {
|
jsonInfoVO = flowUtil.getInfoVo(taskEntity.getFlowId());
|
template = templateMapper.getInfo(taskEntity.getTemplateId());
|
}
|
vo.setLineKeyList(taskLineMapper.getLineKeyList(id));
|
}
|
if (null == jsonInfoVO) {
|
template = null == template ? templateMapper.getInfo(fo.getFlowId()) : template;
|
jsonInfoVO = flowUtil.getInfoVo(template.getFlowId());
|
}
|
fo.setTemplateEntity(template);
|
vo.setFlowInfo(jsonInfoVO);
|
fo.setDeploymentId(jsonInfoVO.getFlowableId());
|
|
// 节点
|
List<TemplateNodeEntity> nodeEntities = templateNodeMapper.getList(jsonInfoVO.getFlowId());
|
|
TemplateNodeEntity nodeEntity = null;
|
OperatorEntity operatorEntity = new OperatorEntity();
|
RecordEntity recordEntity = new RecordEntity();
|
Map<String, Object> map = new HashMap<>();
|
Map<String, Object> draft = new HashMap<>();
|
String operatorId = ObjectUtil.isNotEmpty(fo.getOperatorId()) ? fo.getOperatorId() : "";
|
OpTypeEnum type = OpTypeEnum.getType(fo.getOpType());
|
switch (type) {
|
case LAUNCH_CREATE:
|
case SIGN:// 待签
|
case TODO:// 待办
|
case DOING:// 在办
|
OperatorEntity operator = operatorMapper.getInfo(operatorId);
|
if (null != operator) {
|
nodeEntity = nodeEntities.stream()
|
.filter(e -> StringUtils.equals(operator.getNodeCode(), e.getNodeCode())).findFirst().orElse(null);
|
operatorEntity = operator;
|
}
|
break;
|
case DONE:// 已办
|
RecordEntity recordMapperInfo = recordMapper.getInfo(operatorId);
|
if (null != recordMapperInfo) {
|
nodeEntity = nodeEntities.stream()
|
.filter(e -> StringUtils.equals(recordMapperInfo.getNodeCode(), e.getNodeCode()) && !Objects.equals(NodeEnum.OUTSIDE.getType(), e.getNodeType())).findFirst().orElse(null);
|
if (StringUtils.isNotBlank(recordMapperInfo.getOperatorId())) {
|
OperatorEntity op = operatorMapper.selectById(recordMapperInfo.getOperatorId());
|
if (null != op) {
|
operatorEntity = op;
|
}
|
}
|
recordEntity = recordMapperInfo;
|
}
|
break;
|
case CIRCULATE:// 抄送
|
CirculateEntity circulateEntity = circulateMapper.selectById(operatorId);
|
if (null != circulateEntity) {
|
nodeEntity = nodeEntities.stream()
|
.filter(e -> StringUtils.equals(circulateEntity.getNodeCode(), e.getNodeCode())).findFirst().orElse(null);
|
circulateEntity.setCirculateRead(1);
|
circulateMapper.updateById(circulateEntity);
|
if (StringUtils.isNotBlank(circulateEntity.getOperatorId())) {
|
OperatorEntity ope = operatorMapper.selectById(circulateEntity.getOperatorId());
|
if (null != ope) {
|
operatorEntity = ope;
|
}
|
}
|
}
|
break;
|
default:
|
break;
|
}
|
//发起流程添加使用次数
|
if (Objects.equals(fo.getIsFlow(), 1)) {
|
templateUseNumMapper.insertOrUpdateUseNum(fo.getFlowId());
|
}
|
|
if (null == nodeEntity) {
|
// 默认获取开始节点
|
nodeEntity = nodeEntities.stream()
|
.filter(e -> StringUtils.equals(NodeEnum.START.getType(), e.getNodeType())).findFirst().orElse(null);
|
}
|
if (null == nodeEntity) {
|
throw new WorkFlowException(MsgCode.WF076.get());
|
}
|
if (OpTypeEnum.DOING.equals(type) && null != operatorEntity.getDraftData()) {
|
Map<String, Object> draftData = JsonUtil.stringToMap(operatorEntity.getDraftData());
|
draftData.forEach((k, v) -> {
|
if (ObjectUtil.isNotEmpty(v) && !Objects.equals(TableFeildsEnum.VERSION.getField(), k)) {
|
map.put(k, v);
|
}
|
});
|
draft.putAll(draftData);
|
}
|
|
String formId = nodeEntity.getFormId();
|
NodeModel currentNode = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
vo.setFormOperates(currentNode.getFormOperates());
|
// 表单数据
|
if (!StringUtils.equals(FlowNature.PARENT_ID, id)) {
|
Map<String, Object> formData = serviceUtil.infoData(formId, id);
|
vo.setFormData(formData);
|
fo.setFormData(formData);
|
formData.putAll(map);
|
draft.putAll(formData);
|
|
String flowTaskID = Objects.nonNull(formData.get(FlowFormConstant.FLOWTASKID)) ? formData.get(FlowFormConstant.FLOWTASKID).toString() : "";
|
id = StringUtils.isNotBlank(flowTaskID) ? flowTaskID : id;
|
TaskEntity taskEntity = this.getById(id);
|
if (null != taskEntity) {
|
TaskVo taskVo = JsonUtil.getJsonToBean(taskEntity, TaskVo.class);
|
taskVo.setFlowUrgent(taskEntity.getUrgent());
|
UserEntity user = serviceUtil.getUserInfo(taskEntity.getCreatorUserId());
|
taskVo.setCreatorUser(user.getRealName());
|
taskVo.setHeadIcon(UploaderUtil.uploaderImg(user.getHeadIcon()));
|
String flowCategory = taskEntity.getFlowCategory();
|
// 分类名称
|
List<String> categoryIds = ImmutableList.of(flowCategory);
|
List<DictionaryDataEntity> dictionName = serviceUtil.getDictionName(categoryIds);
|
taskVo.setFlowCategory(dictionName.stream().map(DictionaryDataEntity::getFullName).collect(Collectors.joining(",")));
|
|
vo.setTaskInfo(taskVo);
|
fo.setTaskEntity(taskEntity);
|
|
// 流转记录
|
List<RecordEntity> records = recordMapper.getList(taskEntity.getId());
|
vo.setRecordList(recordUtil.getRecordList(records, nodeEntities));
|
|
FlowModel flowModel = new FlowModel();
|
flowModel.setFormData(formData);
|
flowModel.setDeploymentId(fo.getDeploymentId());
|
flowModel.setTaskEntity(taskEntity);
|
flowModel.setNodeEntityList(nodeEntities);
|
flowModel.setNodeEntity(nodeEntity);
|
flowModel.setOpType(fo.getOpType());
|
flowModel.setRecordEntity(recordEntity);
|
// 节点
|
List<TaskNodeModel> nodeList = nodeUtil.getNodeList(flowModel);
|
vo.setNodeList(nodeList);
|
fo.setNodeList(nodeList);
|
|
vo.setFlowInfo(jsonInfoVO);
|
Map<String, Object> nodeProperties = jsonInfoVO.getFlowNodes().get(nodeEntity.getNodeCode());
|
nodeUtil.setFlowFile(currentNode, taskEntity, nodeProperties);
|
vo.setNodeProperties(nodeProperties);
|
|
vo.setProgressList(!Objects.equals(type, OpTypeEnum.MONITOR) ? recordUtil.getProgressList(flowModel) : new ArrayList<>());
|
}
|
}
|
// 判断按钮
|
fo.setOperatorEntity(operatorEntity);
|
fo.setNodeEntity(nodeEntity);
|
fo.setRecordEntity(recordEntity);
|
fo.setNodeEntityList(nodeEntities);
|
fo.setFlowId(jsonInfoVO.getFlowId());
|
ButtonModel model = buttonUtil.handleButton(fo);
|
vo.setBtnInfo(model);
|
RevokeEntity revokeEntity = revokeMapper.getRevokeTask(id);
|
if (null != revokeEntity) {
|
Map<String, Object> revokeMap = JsonUtil.stringToMap(revokeEntity.getFormData());
|
vo.setFormData(revokeMap);
|
VisualdevEntity formInfo = new VisualdevEntity();
|
formInfo.setEnCode(FlowNature.REVOKE_FORM_CODE);
|
formInfo.setType(2);
|
vo.setFormInfo(formInfo);
|
TaskVo taskInfo = vo.getTaskInfo();
|
if (null != taskInfo) {
|
taskInfo.setIsRevokeTask(true);
|
}
|
} else {
|
vo.setFormData(draft);
|
// 获取表单
|
if (null != formId) {
|
VisualdevEntity formInfo = serviceUtil.getFormInfo(formId);
|
vo.setFormInfo(formInfo);
|
}
|
}
|
return vo;
|
}
|
|
@Override
|
public CandidateCheckVo checkCandidates(String id, CandidateCheckFo fo) throws WorkFlowException {
|
return operatorUtil.checkCandidates(id, fo);
|
}
|
|
@Override
|
public List<CandidateUserVo> getCandidateUser(String id, CandidateCheckFo fo) throws WorkFlowException {
|
TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(fo.getFlowId());
|
if (null == jsonEntity) {
|
TemplateEntity template = templateMapper.getInfo(fo.getFlowId());
|
jsonEntity = templateJsonMapper.getInfo(template.getFlowId());
|
}
|
List<TemplateNodeEntity> nodeEntities = templateNodeMapper.getList(jsonEntity.getId());
|
|
Map<String, NodeModel> nodes = new HashMap<>();
|
for (TemplateNodeEntity nodeEntity : nodeEntities) {
|
nodes.put(nodeEntity.getNodeCode(), JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class));
|
}
|
NodeModel nodeModel = nodes.get(fo.getNodeCode());
|
if (null == nodeModel) {
|
throw new WorkFlowException(MsgCode.WF076.get());
|
}
|
|
// 获取候选人
|
CandidateCheckVo candidateCheckVo = checkCandidates(id, fo);
|
List<CandidateListModel> list = candidateCheckVo.getList();
|
Map<String, List<CandidateListModel>> nodeMap = list.stream().collect(Collectors.groupingBy(CandidateListModel::getNodeCode));
|
List<CandidateListModel> candidateList = nodeMap.get(fo.getNodeCode()) != null ? nodeMap.get(fo.getNodeCode()) : new ArrayList<>();
|
List<String> userIds = new ArrayList<>();
|
for (CandidateListModel model : candidateList) {
|
userIds.addAll(model.getSelectIdList());
|
}
|
|
// 候选人范围过滤
|
UserInfo userInfo = UserProvider.getUser();
|
UserEntity userEntity = serviceUtil.getUserInfo(userInfo.getUserId());
|
OperatorEntity operator = operatorMapper.selectById(id);
|
if (null != operator) {
|
userEntity = serviceUtil.getUserInfo(operator.getHandleId());
|
} else {
|
if (StringUtils.isNotBlank(fo.getDelegateUser())) {
|
userEntity = serviceUtil.getUserInfo(fo.getDelegateUser());
|
}
|
}
|
LaunchUserEntity flowUser = new LaunchUserEntity();
|
flowUtil.launchUser(flowUser, userEntity);
|
flowUtil.rule(userIds, flowUser, nodeModel.getExtraRule());
|
|
return operatorUtil.getUserModelByUserIds(userIds, fo);
|
}
|
|
@DSTransactional
|
@Override
|
public void batchSaveOrSubmit(FlowModel flowModel) throws WorkFlowException {
|
operatorUtil.batchSaveOrSubmit(flowModel);
|
}
|
|
// 提交或暂存
|
@Override
|
public void saveOrSubmit(FlowModel flowModel) throws WorkFlowException {
|
operatorUtil.saveOrSubmit(flowModel);
|
}
|
|
// 发起撤回
|
@DSTransactional
|
@Override
|
public void recall(String id, FlowModel flowModel) throws WorkFlowException {
|
flowUtil.setFlowModel(id, flowModel);
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
operatorUtil.checkTemplateHide(taskEntity.getTemplateId());
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
if (CollUtil.isEmpty(nodeEntityList)) {
|
throw new WorkFlowException(MsgCode.WF076.get());
|
}
|
operatorUtil.addTask(ImmutableList.of(taskEntity.getId()));
|
// 开始节点
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> StringUtils.equals(NodeEnum.START.getType(), e.getNodeType())).findFirst().orElse(null);
|
if (null == nodeEntity) {
|
throw new WorkFlowException(MsgCode.WF076.get());
|
}
|
NodeModel start = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
|
|
flowModel.setNodeEntity(nodeEntity);
|
flowModel.setIsException(true);
|
if (!buttonUtil.checkRecall(flowModel)) {
|
throw new WorkFlowException(MsgCode.WF077.get());
|
}
|
// 删除子流程(判断方法中，存在异步 或 同步子流程已提交 则不允许撤回)
|
operatorUtil.deleteSubflow(taskEntity.getId(), null);
|
// 删除外部节点
|
eventLogMapper.delete(taskEntity.getId(), null);
|
// 记录
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setType(RecordEnum.RECALL.getCode());
|
flowMethod.setFlowModel(flowModel);
|
OperatorEntity operatorEntity = new OperatorEntity();
|
operatorEntity.setNodeCode(nodeEntity.getNodeCode());
|
operatorEntity.setNodeName(start.getNodeName());
|
operatorEntity.setTaskId(taskEntity.getId());
|
operatorEntity.setHandleId(taskEntity.getCreatorUserId());
|
operatorEntity.setHandleTime(new Date());
|
flowMethod.setOperatorEntity(operatorEntity);
|
recordMapper.createRecord(flowMethod);
|
|
// 节点记录
|
NodeRecordModel nodeRecordModel = new NodeRecordModel();
|
nodeRecordModel.setTaskId(taskEntity.getId());
|
nodeRecordModel.setNodeCode(nodeEntity.getNodeCode());
|
nodeRecordModel.setNodeStatus(NodeStateEnum.RECALL.getCode());
|
nodeRecordMapper.update(nodeRecordModel);
|
|
// 删除经办
|
QueryWrapper<OperatorEntity> wrapper = new QueryWrapper<>();
|
wrapper.lambda().eq(OperatorEntity::getTaskId, taskEntity.getId());
|
operatorMapper.delete(wrapper);
|
|
// 删除候选人
|
candidatesMapper.deleteByCodes(taskEntity.getId(), null);
|
|
// 删除发起人
|
launchUserMapper.delete(taskEntity.getId());
|
|
//删除同步流程
|
List<TriggerLaunchflowEntity> triggerLaunchList = operatorUtil.getLaunchFlowList(taskEntity.getId());
|
triggerLaunchflowMapper.deleteByIds(triggerLaunchList);
|
|
// 删除引擎实例
|
flowAbleUrl.deleteInstance(taskEntity.getInstanceId(), "retract");
|
|
// 变更任务状态
|
UpdateWrapper<TaskEntity> updateWrapper = new UpdateWrapper<>();
|
updateWrapper.lambda().eq(TaskEntity::getId, taskEntity.getId())
|
.set(TaskEntity::getInstanceId, null)
|
.set(TaskEntity::getRejectDataId, null)
|
.set(TaskEntity::getCurrentNodeName, FlowNature.START_NAME)
|
.set(TaskEntity::getCurrentNodeCode, FlowNature.START_CODE)
|
.set(TaskEntity::getStatus, TaskStatusEnum.RECALL.getCode());
|
this.update(updateWrapper);
|
if (taskEntity.getRejectDataId() != null) {
|
rejectDataService.removeById(taskEntity.getRejectDataId());
|
}
|
}
|
|
// 催办
|
@Override
|
public boolean press(String id) throws WorkFlowException {
|
FlowModel flowModel = new FlowModel();
|
flowUtil.setFlowModel(id, flowModel);
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
|
// 消息
|
QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(OperatorEntity::getTaskId, id).eq(OperatorEntity::getCompletion, FlowNature.NORMAL)
|
.ne(OperatorEntity::getStatus, OperatorStateEnum.FUTILITY.getCode())
|
.isNull(OperatorEntity::getHandleStatus).isNotNull(OperatorEntity::getDuedate);
|
List<OperatorEntity> operatorList = operatorMapper.selectList(queryWrapper);
|
if (operatorList.isEmpty()) {
|
return false;
|
}
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setUserInfo(flowModel.getUserInfo());
|
flowMsgModel.setTaskEntity(taskEntity);
|
flowMsgModel.setOperatorList(operatorList);
|
flowMsgModel.setPress(true);
|
msgUtil.message(flowMsgModel);
|
return true;
|
}
|
|
@DSTransactional
|
@Override
|
public void revoke(String id, FlowModel flowModel) throws WorkFlowException {
|
flowUtil.setFlowModel(id, flowModel);
|
TaskEntity taskEntity = flowModel.getTaskEntity();
|
if (!TaskStatusEnum.PASSED.getCode().equals(taskEntity.getStatus())) {
|
throw new WorkFlowException(MsgCode.WF078.get());
|
}
|
// 处理撤销表单的数据
|
operatorUtil.submitOfRevoke(flowModel);
|
}
|
|
@DSTransactional
|
@Override
|
public List<TaskEntity> delete(String id) throws WorkFlowException {
|
List<TaskEntity> taskList = taskUtil.delete(ImmutableList.of(id), false);
|
operatorUtil.deleteFormData(taskList);
|
return taskList;
|
}
|
|
@DSTransactional
|
@Override
|
public void deleteBatch(List<String> ids) throws WorkFlowException {
|
List<TaskEntity> taskList = taskUtil.delete(ids, true);
|
operatorUtil.deleteFormData(taskList);
|
|
List<String> instanceIds = taskList.stream()
|
.filter(t -> TaskStatusEnum.RUNNING.getCode().equals(t.getStatus()) || TaskStatusEnum.CANCEL.getCode().equals(t.getStatus()))
|
.map(TaskEntity::getInstanceId).distinct().collect(Collectors.toList());
|
if (CollUtil.isNotEmpty(instanceIds)) {
|
for (String instanceId : instanceIds) {
|
flowAbleUrl.deleteInstance(instanceId, "monitor");
|
}
|
}
|
}
|
|
@Override
|
public void deleTaskAll(List<String> idList, List<String> idAll) {
|
this.baseMapper.deleTaskAll(idList, idAll);
|
}
|
|
// 终止与挂起的区别，就是能否在列表中查询到，撤销中不允许终止等操作
|
@DSTransactional
|
@Override
|
public void cancel(String id, FlowModel flowModel, boolean isCancel) throws WorkFlowException {
|
operatorUtil.cancel(id, flowModel, isCancel);
|
}
|
|
@Override
|
public boolean checkAsync(String id) {
|
return this.baseMapper.checkAsync(id);
|
}
|
|
// isSuspend: true 挂起、false 恢复
|
@DSTransactional
|
@Override
|
public void pause(String id, FlowModel flowModel, Boolean isSuspend) throws WorkFlowException {
|
List<String> idList = new ArrayList<>();
|
idList.add(id);
|
|
boolean pause = false;
|
|
// 暂停的选项，0.全部 1：仅主流程，同时暂停同步子流程
|
if (Boolean.TRUE.equals(isSuspend)) {
|
pause = flowModel.getPause() == 1;
|
} else {
|
TaskEntity taskEntity = this.getInfo(id);
|
if (ObjectUtil.equals(taskEntity.getIsRestore(), FlowNature.NOT_RESTORE)) {
|
throw new WorkFlowException("无法恢复");
|
}
|
List<TaskEntity> childList = this.baseMapper.getChildList(id, TaskEntity::getId, TaskEntity::getIsRestore);
|
// 存在 0（能恢复的），就只恢复 1（不能恢复的，即同步的）
|
pause = childList.stream().anyMatch(e -> ObjectUtil.equals(e.getIsRestore(), FlowNature.RESTORE));
|
}
|
String userId = UserProvider.getLoginUserId();
|
|
this.baseMapper.getChildList(id, pause, idList);
|
|
List<TaskEntity> orderStaList = this.baseMapper.getOrderStaList(idList);
|
|
this.pause(orderStaList, isSuspend, id);
|
|
for (TaskEntity entity : orderStaList) {
|
// 记录
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setFlowModel(flowModel);
|
flowMethod.setType(Boolean.TRUE.equals(isSuspend) ? RecordEnum.PAUSE.getCode() : RecordEnum.REBOOT.getCode());
|
OperatorEntity operatorEntity = new OperatorEntity();
|
operatorEntity.setNodeCode(StringUtils.isNotBlank(entity.getCurrentNodeCode()) ? entity.getCurrentNodeCode() : FlowNature.START_CODE);
|
operatorEntity.setNodeName(StringUtils.isNotBlank(entity.getCurrentNodeName()) ? entity.getCurrentNodeName() : FlowNature.START_NAME);
|
operatorEntity.setTaskId(entity.getId());
|
operatorEntity.setHandleId(userId);
|
flowMethod.setOperatorEntity(operatorEntity);
|
recordMapper.createRecord(flowMethod);
|
operatorUtil.addTask(ImmutableList.of(entity.getId()));
|
}
|
|
}
|
|
public List<OperatorEntity> pause(List<TaskEntity> orderStaList, boolean isSuspend, String id) {
|
List<OperatorEntity> operatorList = new ArrayList<>();
|
for (TaskEntity taskEntity : orderStaList) {
|
if (isSuspend) {
|
// 暂停
|
if (!ObjectUtil.equals(taskEntity.getStatus(), TaskStatusEnum.PAUSED.getCode())) {
|
taskEntity.setHisStatus(taskEntity.getStatus());
|
taskEntity.setStatus(TaskStatusEnum.PAUSED.getCode());
|
}
|
taskEntity.setIsRestore(ObjectUtil.equals(taskEntity.getId(), id) ? FlowNature.RESTORE : FlowNature.NOT_RESTORE);
|
this.updateById(taskEntity);
|
} else {
|
// 恢复
|
taskEntity.setStatus(taskEntity.getHisStatus());
|
taskEntity.setHisStatus(TaskStatusEnum.PAUSED.getCode());
|
taskEntity.setIsRestore(FlowNature.RESTORE);
|
this.updateById(taskEntity);
|
}
|
// 过滤作废的经办
|
List<OperatorEntity> list = operatorMapper.getList(taskEntity.getId()).stream()
|
.filter(e -> !e.getStatus().equals(OperatorStateEnum.FUTILITY.getCode())).collect(Collectors.toList());
|
operatorList.addAll(list);
|
}
|
return operatorList;
|
}
|
|
@DSTransactional
|
@Override
|
public void assign(String id, FlowModel flowModel) throws WorkFlowException {
|
flowUtil.setFlowModel(id, flowModel);
|
TaskEntity entity = flowModel.getTaskEntity();
|
flowUtil.isSuspend(entity);
|
flowUtil.isCancel(entity);
|
|
String handleId = flowModel.getUserInfo() == null ? UserProvider.getLoginUserId() : flowModel.getUserInfo().getUserId();
|
|
List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
|
|
// 作废原先的经办、生成指派的经办
|
OperatorEntity operator = operatorUtil.handleAssign(flowModel);
|
List<OperatorEntity> list = new ArrayList<>();
|
list.add(operator);
|
|
String nodeCode = flowModel.getNodeCode();
|
NodeModel nodeModel = flowModel.getNodes().get(nodeCode);
|
Boolean autoTransfer = flowModel.getAutoTransferFlag();
|
boolean isProcessing = ObjectUtil.equals(nodeModel.getType(), NodeEnum.PROCESSING.getType());
|
if (Boolean.TRUE.equals(autoTransfer)) {
|
flowModel.setHandleOpinion(isProcessing ? "系统转办" : "系统转审");
|
}
|
|
//指派逐级审批失效
|
if (StringUtil.isNotEmpty(nodeCode)) {
|
launchUserMapper.delete(operator.getTaskId(), ImmutableList.of(nodeCode));
|
}
|
|
// 记录
|
FlowMethod flowMethod = new FlowMethod();
|
flowMethod.setFlowModel(flowModel);
|
Integer transferType = isProcessing ? RecordEnum.TRANSFER_PROCESSING.getCode() : RecordEnum.TRANSFER.getCode();
|
flowMethod.setType(Boolean.TRUE.equals(autoTransfer) ? transferType : RecordEnum.ASSIGN.getCode());
|
OperatorEntity operatorEntity = new OperatorEntity();
|
operatorEntity.setId(operator.getId());
|
operatorEntity.setNodeCode(nodeCode);
|
operatorEntity.setNodeId(operator.getNodeId());
|
operatorEntity.setNodeName(nodeModel.getNodeName());
|
operatorEntity.setTaskId(entity.getId());
|
operatorEntity.setHandleId(Boolean.TRUE.equals(autoTransfer) ? FlowNature.SYSTEM_CODE : handleId);
|
flowMethod.setOperatorEntity(operatorEntity);
|
List<String> userIds = ImmutableList.of(flowModel.getHandleIds());
|
flowMethod.setUserId(String.join(",", userIds));
|
recordMapper.createRecord(flowMethod);
|
|
// 消息
|
FlowMsgModel flowMsgModel = new FlowMsgModel();
|
flowMsgModel.setNodeList(nodeEntityList);
|
flowMsgModel.setUserInfo(flowModel.getUserInfo());
|
flowMsgModel.setTaskEntity(entity);
|
flowMsgModel.setOperatorList(list);
|
if (Boolean.TRUE.equals(flowModel.getAutoTransferFlag())) {
|
flowMsgModel.setTransfer(true);
|
} else {
|
flowMsgModel.setAssign(true);
|
}
|
msgUtil.message(flowMsgModel);
|
|
operatorUtil.addOperatorList(list, flowModel);
|
}
|
|
@Override
|
public TaskUserListModel getTaskUserList(String taskId) {
|
return flowUtil.getTaskUserList(taskId);
|
}
|
|
@Override
|
public List<BeforeInfoVo> subFlowInfo(FlowModel flowModel) throws WorkFlowException {
|
List<BeforeInfoVo> list = new ArrayList<>();
|
List<TaskEntity> entityList = this.baseMapper.subFlowInfo(flowModel);
|
if (CollUtil.isNotEmpty(entityList)) {
|
for (TaskEntity entity : entityList) {
|
FlowModel model = new FlowModel();
|
model.setFlowId(entity.getFlowId());
|
BeforeInfoVo info = this.getInfo(entity.getId(), model);
|
list.add(info);
|
}
|
}
|
return list;
|
}
|
|
// 消息跳转流程时，校验以及返回opType
|
@Override
|
public String checkInfo(String id) throws WorkFlowException {
|
CirculateEntity circulate = circulateMapper.selectById(id);
|
if (null != circulate) {
|
return OpTypeEnum.CIRCULATE.getType();
|
}
|
OperatorEntity operator = operatorMapper.getInfo(id);
|
if (null == operator) {
|
throw new WorkFlowException(MsgCode.FA001.get());
|
}
|
if (operator.getStatus().equals(OperatorStateEnum.FUTILITY.getCode())) {
|
throw new WorkFlowException("该流程无权限查看");
|
}
|
|
TaskEntity taskEntity = this.getById(operator.getTaskId());
|
if (null == taskEntity) {
|
throw new WorkFlowException(MsgCode.FA001.get());
|
}
|
if (TaskStatusEnum.CANCEL.getCode().equals(taskEntity.getStatus())) {
|
throw new WorkFlowException(MsgCode.WF041.get());
|
}
|
if (TaskStatusEnum.RECALL.getCode().equals(taskEntity.getStatus())) {
|
throw new WorkFlowException(MsgCode.WF042.get());
|
}
|
operatorUtil.checkTemplateHide(taskEntity.getTemplateId());
|
|
String handleId = operator.getHandleId();
|
String userId = UserProvider.getLoginUserId();
|
List<String> delegateList = flowUtil.getToUser(handleId, taskEntity.getFlowId());
|
delegateList.add(handleId);
|
if (!delegateList.contains(userId)) {
|
throw new WorkFlowException(MsgCode.FA021.get());
|
}
|
|
String opType = OpTypeEnum.LAUNCH_DETAIL.getType();
|
if (null == operator.getSignTime() && null == operator.getStartHandleTime() && null == operator.getHandleStatus()) {
|
opType = OpTypeEnum.SIGN.getType();
|
}
|
if (null != operator.getSignTime() && null == operator.getStartHandleTime() && null == operator.getHandleStatus()) {
|
opType = OpTypeEnum.TODO.getType();
|
}
|
if (null != operator.getSignTime() && null != operator.getStartHandleTime() && null == operator.getHandleStatus()) {
|
opType = OpTypeEnum.DOING.getType();
|
}
|
if (null != operator.getHandleStatus() || operator.getCompletion().equals(FlowNature.ACTION)) {
|
opType = OpTypeEnum.CIRCULATE.getType();
|
}
|
return opType;
|
}
|
|
@Override
|
public void updateIsFile(String taskId) throws WorkFlowException {
|
TaskEntity taskEntity = this.getInfo(taskId);
|
if (null != taskEntity) {
|
taskEntity.setIsFile(1);
|
this.updateById(taskEntity);
|
}
|
}
|
|
// 获取发起表单
|
@Override
|
public ViewFormModel getStartForm(String taskId) throws WorkFlowException {
|
ViewFormModel model = new ViewFormModel();
|
TaskEntity taskEntity = this.getInfo(taskId);
|
List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(taskEntity.getFlowId());
|
TemplateNodeEntity nodeEntity = nodeEntityList.stream()
|
.filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.START.getType())).findFirst().orElse(null);
|
if (null != nodeEntity) {
|
String formId = nodeEntity.getFormId();
|
VisualdevEntity formInfo = serviceUtil.getFormInfo(formId);
|
model.setFormInfo(formInfo);
|
Map<String, Object> map = serviceUtil.infoData(formId, taskId);
|
model.setFormData(map);
|
}
|
return model;
|
}
|
|
@Override
|
public TaskTo getFlowTodoCount(TaskTo taskTo) {
|
TaskPagination pagination = new TaskPagination();
|
pagination.setDelegateType(true);
|
pagination.setPageSize(1L);
|
pagination.setCurrentPage(1L);
|
String appCode = RequestContext.getAppCode();
|
boolean isMainSystem = Objects.equals(JnpfConst.MAIN_SYSTEM_CODE, appCode);
|
SystemEntity systemEntity = serviceUtil.getInfoByEnCode(!isMainSystem ? appCode : JnpfConst.WORK_FLOW_CODE);
|
if (!isMainSystem) {
|
pagination.setSystemId(systemEntity.getId());
|
}
|
TaskTo vo = new TaskTo();
|
boolean isPc = RequestContext.isOrignPc();
|
String webType = isPc ? JnpfConst.WEB : JnpfConst.APP;
|
List<ModuleModel> moduleListAll = taskTo.getModuleList() != null ? taskTo.getModuleList() : new ArrayList<>();
|
List<ModuleModel> moduleList = moduleListAll.stream().
|
filter(e -> Objects.equals(e.getSystemId(), systemEntity.getId()) && Objects.equals(webType, e.getCategory()))
|
.collect(Collectors.toList());
|
Map<String, List<ModuleModel>> encodeMap = moduleList.stream().collect(Collectors.groupingBy(ModuleModel::getEnCode));
|
|
vo.setIsLaunch(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWLAUNCH)));
|
if (Boolean.TRUE.equals(vo.getIsLaunch())) {
|
getList(pagination);
|
vo.setFlowLaunch(pagination.getTotal());
|
}
|
|
vo.setIsToSign(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWSIGN)));
|
if (Boolean.TRUE.equals(vo.getIsToSign())) {
|
if (ObjectUtil.isNotEmpty(taskTo.getFlowToSignType())) {
|
pagination.setFlowCategory(String.join(",", taskTo.getFlowToSignType()));
|
}
|
pagination.setCategory(CategoryEnum.SIGN.getType());
|
flowUtil.getOperatorList(pagination);
|
vo.setFlowToSign(pagination.getTotal());
|
}
|
|
vo.setIsTodo(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWTODO)));
|
if (Boolean.TRUE.equals(vo.getIsTodo())) {
|
if (ObjectUtil.isNotEmpty(taskTo.getFlowTodoType())) {
|
pagination.setFlowCategory(String.join(",", taskTo.getFlowTodoType()));
|
}
|
pagination.setCategory(CategoryEnum.TODO.getType());
|
flowUtil.getOperatorList(pagination);
|
vo.setFlowTodo(pagination.getTotal());
|
}
|
|
vo.setIsDoing(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWDOING)));
|
if (Boolean.TRUE.equals(vo.getIsDoing())) {
|
if (ObjectUtil.isNotEmpty(taskTo.getFlowDoingType())) {
|
pagination.setFlowCategory(String.join(",", taskTo.getFlowDoingType()));
|
}
|
pagination.setCategory(CategoryEnum.DOING.getType());
|
flowUtil.getOperatorList(pagination);
|
vo.setFlowDoing(pagination.getTotal());
|
}
|
|
vo.setIsDone(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWDONE)));
|
if (Boolean.TRUE.equals(vo.getIsDone())) {
|
if (ObjectUtil.isNotEmpty(taskTo.getFlowDoneType())) {
|
pagination.setFlowCategory(String.join(",", taskTo.getFlowDoneType()));
|
}
|
flowUtil.getRecordList(pagination);
|
vo.setFlowDone(pagination.getTotal());
|
}
|
|
vo.setIsCirculate(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWCIRCULATE)));
|
if (Boolean.TRUE.equals(vo.getIsCirculate())) {
|
if (ObjectUtil.isNotEmpty(taskTo.getFlowCirculateType())) {
|
pagination.setFlowCategory(String.join(",", taskTo.getFlowCirculateType()));
|
}
|
circulateMapper.getList(pagination);
|
vo.setFlowCirculate(pagination.getTotal());
|
}
|
|
return vo;
|
}
|
|
@Override
|
public FlowTodoVO getFlowTodo(TaskPagination pagination) {
|
FlowTodoVO flowTodoVO = new FlowTodoVO();
|
String appCode = RequestContext.getAppCode();
|
String category = pagination.getCategory();
|
pagination.setSystemId(serviceUtil.getSystemCodeById(appCode));
|
if (Objects.equals(JnpfConst.MAIN_SYSTEM_CODE, appCode)) {
|
appCode = JnpfConst.WORK_FLOW_CODE;
|
}
|
boolean isPc = RequestContext.isOrignPc();
|
String webType = isPc ? JnpfConst.WEB : JnpfConst.APP;
|
SystemEntity systemEntity = serviceUtil.getInfoByEnCode(appCode);
|
AuthorizeVO authorize = serviceUtil.getAuthorizeByUser();
|
List<ModuleModel> moduleList = authorize.getModuleList().stream().
|
filter(e -> Objects.equals(e.getSystemId(), systemEntity.getId()) && Objects.equals(webType, e.getCategory()))
|
.collect(Collectors.toList());
|
Map<String, List<ModuleModel>> encodeMap = moduleList.stream().collect(Collectors.groupingBy(ModuleModel::getEnCode));
|
Map<String, String> flowType = ImmutableMap.of(
|
CategoryEnum.SIGN.getType(), JnpfConst.WORK_FLOWSIGN,
|
CategoryEnum.TODO.getType(), JnpfConst.WORK_FLOWTODO,
|
CategoryEnum.DOING.getType(), JnpfConst.WORK_FLOWDOING
|
);
|
String module = flowType.get(category);
|
flowTodoVO.setIsAuthorize(ObjectUtil.isNotEmpty(encodeMap.get(module)));
|
if (Boolean.TRUE.equals(flowTodoVO.getIsAuthorize())) {
|
List<OperatorVo> waitList = flowUtil.getOperatorList(pagination);
|
List<TaskFlowTodoVO> list = new ArrayList<>();
|
for (OperatorVo operatorVo : waitList) {
|
TaskFlowTodoVO vo = JsonUtil.getJsonToBean(operatorVo, TaskFlowTodoVO.class);
|
vo.setTaskNodeId(operatorVo.getNodeCode());
|
vo.setTaskOperatorId(operatorVo.getId());
|
vo.setType(2);
|
list.add(vo);
|
}
|
flowTodoVO.setList(list);
|
}
|
return flowTodoVO;
|
}
|
}
|
