package com.vci.ubcs.omd.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.vci.ubcs.omd.constant.BtmTypeConstant;
|
import com.vci.ubcs.omd.dto.LifeCycleDTO;
|
import com.vci.ubcs.omd.dto.LifeCycleEdgeDTO;
|
import com.vci.ubcs.omd.dto.LifeCycleLineEventDTO;
|
import com.vci.ubcs.omd.dto.LifeCycleNodeDTO;
|
import com.vci.ubcs.omd.entity.LifeCycleEdge;
|
import com.vci.ubcs.omd.entity.LifeCycleLineEvent;
|
import com.vci.ubcs.omd.entity.LifeCycleNode;
|
import com.vci.ubcs.omd.entity.LifeCycleRule;
|
import com.vci.ubcs.omd.mapper.LifeCycleEdgeMapper;
|
import com.vci.ubcs.omd.mapper.LifeCycleLineEventMapper;
|
import com.vci.ubcs.omd.mapper.LifeCycleMapper;
|
import com.vci.ubcs.omd.mapper.LifeCycleNodeMapper;
|
import com.vci.ubcs.omd.repeater.DomainRepeater;
|
import com.vci.ubcs.omd.service.IBtmTypeService;
|
import com.vci.ubcs.omd.service.ILifeCycleService;
|
import com.vci.ubcs.omd.service.IStatusService;
|
import com.vci.ubcs.omd.vo.BtmTypeVO;
|
import com.vci.ubcs.omd.vo.LifeCycleVO;
|
import com.vci.ubcs.omd.vo.StatusVO;
|
import com.vci.ubcs.omd.wrapper.LifeCycleRuleWrapper;
|
import com.vci.ubcs.starter.enumpack.NewAppConstantEnum;
|
import com.vci.ubcs.starter.exception.VciBaseException;
|
import com.vci.ubcs.starter.web.constant.RegExpConstant;
|
import com.vci.ubcs.starter.web.util.BeanUtil;
|
import com.vci.ubcs.starter.web.util.VciBaseUtil;
|
import org.springblade.core.mp.support.Condition;
|
import org.springblade.core.mp.support.Query;
|
import org.springblade.core.secure.utils.AuthUtil;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.util.StringUtils;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
|
/**
|
* 生命周期的服务
|
* @author weidy
|
* @date 2023/6/20
|
*/
|
@Service
|
public class LifeCycleServiceImpl extends ServiceImpl<LifeCycleMapper, LifeCycleRule> implements ILifeCycleService{
|
|
/**
|
* 节点的数据层
|
*/
|
@Resource
|
private LifeCycleNodeMapper nodeMapper;
|
|
/**
|
* 连接线数据层
|
*/
|
@Resource
|
private LifeCycleEdgeMapper edgeMapper;
|
|
/**
|
* 状态
|
*/
|
@Autowired(required = false)
|
@Lazy
|
private IStatusService statusService;
|
|
/**
|
* 连接线的事件
|
*/
|
@Resource
|
private LifeCycleLineEventMapper lineEventMapper;
|
|
/**
|
* 业务类型的服务
|
*/
|
@Autowired(required = false)
|
@Lazy
|
private IBtmTypeService btmTypeService;
|
|
|
/**
|
* 获取生命周期列表
|
*
|
* @param conditionMap 查询条件
|
* @param query 分页
|
* @return 生命周期的显示对象
|
*/
|
@Override
|
public IPage<LifeCycleVO> listLife(Map<String, Object> conditionMap, Query query) {
|
return LifeCycleRuleWrapper.build().pageVO(baseMapper.selectPage(Condition.getPage(query),Condition.getQueryWrapper(conditionMap,LifeCycleRule.class).lambda().orderByAsc(LifeCycleRule::getId)));
|
}
|
|
/**
|
* 添加保存
|
*
|
* @param lifeCycleDTO 数据传输对象
|
* @return 添加后的显示对象
|
*/
|
@Override
|
@Transactional
|
public LifeCycleVO addSave(LifeCycleDTO lifeCycleDTO) {
|
VciBaseUtil.alertNotNull(lifeCycleDTO,"生命周期信息",lifeCycleDTO.getId(),"生命周期的编号",lifeCycleDTO.getName(),"生命周期名称",lifeCycleDTO.getNodes(),"生命周期的节点",lifeCycleDTO.getStartStatus(),"起始状态");
|
//先查询是否存在
|
QueryWrapper wrapper = new QueryWrapper(LifeCycleRule.class);
|
wrapper.eq("lower(id)",lifeCycleDTO.getId().toLowerCase(Locale.ROOT));
|
if(baseMapper.selectCount(wrapper)>0){
|
throw new VciBaseException("生命周期的编号不能重复");
|
}
|
String lifeOid = addLifeCycle(lifeCycleDTO);
|
return LifeCycleRuleWrapper.build().entityVO(baseMapper.selectById(lifeOid));
|
}
|
|
/**
|
* 添加生命周期
|
* @param lifeCycleDTO
|
* @return 主键
|
*/
|
private String addLifeCycle(LifeCycleDTO lifeCycleDTO){
|
//编号不能有特殊的内容
|
if(!lifeCycleDTO.getId().matches(RegExpConstant.LETTER)){
|
throw new VciBaseException("生命周期的编号只能是字母");
|
}
|
LifeCycleRule life = LifeCycleRuleWrapper.build().copyDTO2DO(lifeCycleDTO);
|
life.setOid(VciBaseUtil.getPk());
|
String creator = AuthUtil.getUserAccount();
|
Date now = new Date();
|
life.setBtmname(BtmTypeConstant.LIFE_CYCLE);
|
life.setOwner(creator);
|
life.setCreator(creator);
|
life.setCreateTime(now);
|
life.setLastModifier(creator);
|
life.setLastModifyTime(now);
|
life.setTs(now);
|
|
List<String> statusList = new ArrayList<>();
|
//处理节点
|
if(!CollectionUtils.isEmpty(lifeCycleDTO.getNodes())){
|
lifeCycleDTO.getNodes().stream().forEach(nodeDTO->{
|
addLifeCycleNode(nodeDTO,life.getOid(),creator,now);
|
statusList.add(nodeDTO.getId());
|
});
|
}
|
if(!statusList.contains(life.getStartStatus())){
|
throw new VciBaseException("起始状态不在生命周期的画布中");
|
}
|
//判断所有的节点在系统里都存在
|
List<String> existStatusIdList = statusService.listStatusByIdCollection(statusList).stream().map(StatusVO::getId).collect(Collectors.toList());
|
String unExistStatus = statusList.stream().filter(s -> !existStatusIdList.contains(s)).collect(Collectors.joining(","));
|
if(StringUtils.hasLength(unExistStatus)){
|
throw new VciBaseException(unExistStatus + "这些状态在状态池里不存在，不能添加到生命周期中");
|
}
|
//处理边界和连接线
|
if(!CollectionUtils.isEmpty(lifeCycleDTO.getEdges())){
|
lifeCycleDTO.getEdges().stream().forEach(edgeDTO->{
|
String edgeOid = addLifeCycleEdge(edgeDTO,statusList,life.getOid(),creator,now);
|
if(!CollectionUtils.isEmpty(edgeDTO.getEvents())){
|
//有事件
|
edgeDTO.getEvents().stream().forEach(eventDTO->{
|
addLifeCycleLineEvent(eventDTO,edgeOid,creator,now);
|
});
|
}
|
});
|
}
|
baseMapper.insert(life);
|
return life.getOid();
|
}
|
|
/**
|
* 添加生命周期的连接线上的事件
|
* @param eventDTO
|
* @param edgeOid
|
* @param creator
|
* @param now
|
*/
|
private void addLifeCycleLineEvent(LifeCycleLineEventDTO eventDTO,String edgeOid,String creator,Date now){
|
VciBaseUtil.alertNotNull(eventDTO.getBizDomain(),"所属领域",eventDTO.getEventFullName(),"事件的全路径");
|
NewAppConstantEnum[] values = NewAppConstantEnum.values();
|
Boolean fined = false;
|
for (int i = 0; i < values.length; i++) {
|
NewAppConstantEnum value = values[i];
|
if(value.getName().equalsIgnoreCase(eventDTO.getBizDomain())){
|
fined = true;
|
break;
|
}
|
}
|
if(!fined){
|
throw new VciBaseException(eventDTO.getBizDomain() + "这个领域还没有开放,请让开发人员在NewAppConstantEnum类中添加");
|
}
|
LifeCycleLineEvent event = org.springblade.core.tool.utils.BeanUtil.copy(eventDTO, LifeCycleLineEvent.class);
|
event.setOid(VciBaseUtil.getPk());
|
event.setPkLifeCycleEdge(edgeOid);
|
event.setBtmname(BtmTypeConstant.LIFE_CYCLE_LINE_EVENT);
|
event.setOwner(creator);
|
event.setCreator(creator);
|
event.setCreateTime(now);
|
event.setLastModifier(creator);
|
event.setLastModifyTime(now);
|
event.setTs(now);
|
lineEventMapper.insert(event);
|
}
|
|
/**
|
* 添加生命周期的节点
|
* @param nodeDTO
|
* @param lifeOid
|
* @param creator
|
* @param now
|
*/
|
private void addLifeCycleNode(LifeCycleNodeDTO nodeDTO,String lifeOid,String creator,Date now){
|
VciBaseUtil.alertNotNull(nodeDTO.getId(),"状态标识",nodeDTO.getName(),"状态名称");
|
LifeCycleNode node = org.springblade.core.tool.utils.BeanUtil.copy(nodeDTO, LifeCycleNode.class);
|
node.setOid(VciBaseUtil.getPk());
|
node.setLifeCycleOid(lifeOid);
|
node.setBtmname(BtmTypeConstant.LIFE_CYCLE_NODE);
|
node.setOwner(creator);
|
node.setCreator(creator);
|
node.setCreateTime(now);
|
node.setLastModifier(creator);
|
node.setLastModifyTime(now);
|
node.setTs(now);
|
nodeMapper.insert(node);
|
}
|
|
/**
|
* 添加生命周期的连接线
|
* @param edgeDTO
|
* @param statusList
|
* @param lifeOid
|
* @param creator
|
* @param now
|
* @return 连接线的主键
|
*/
|
private String addLifeCycleEdge(LifeCycleEdgeDTO edgeDTO,List<String> statusList,String lifeOid,String creator,Date now){
|
VciBaseUtil.alertNotNull(edgeDTO.getSource(),"来源状态",edgeDTO.getTarget(),"目标状态",edgeDTO.getName(),"连接线名称");
|
if(!statusList.contains(edgeDTO.getSource())
|
||!statusList.contains(edgeDTO.getTarget())){
|
throw new VciBaseException("数据错误，[" + edgeDTO.getName() + "]连接线上中使用的状态没有找到");
|
}
|
LifeCycleEdge edge = org.springblade.core.tool.utils.BeanUtil.copy(edgeDTO, LifeCycleEdge.class);
|
edge.setOid(VciBaseUtil.getPk());
|
edge.setLifeCycleOid(lifeOid);
|
edge.setBtmname(BtmTypeConstant.LIFE_CYCLE_EDGE);
|
edge.setOwner(creator);
|
edge.setCreator(creator);
|
edge.setCreateTime(now);
|
edge.setLastModifier(creator);
|
edge.setLastModifyTime(now);
|
edge.setTs(now);
|
edgeMapper.insert(edge);
|
return edge.getOid();
|
}
|
|
|
|
/**
|
* 批量添加内容
|
*
|
* @param lifeCycleDTOs 数据传输对象
|
* @return 添加后的显示对象
|
*/
|
@Override
|
@Transactional
|
public List<LifeCycleVO> batchAddSave(Collection<LifeCycleDTO> lifeCycleDTOs) {
|
VciBaseUtil.alertNotNull(lifeCycleDTOs,"生命周期的信息");
|
//先集体校验一下
|
if(lifeCycleDTOs.stream().anyMatch(s->!StringUtils.hasLength(s.getId()) || !StringUtils.hasLength(s.getName())
|
|| CollectionUtils.isEmpty(s.getNodes()) || !StringUtils.hasLength(s.getStartStatus()))){
|
throw new VciBaseException("生命周期的编号，名称，起始状态，包含的节点不能为空");
|
}
|
//统一校验重复
|
Map<String, List<LifeCycleDTO>> dtoMap = lifeCycleDTOs.stream().collect(Collectors.groupingBy(s->s.getId().toLowerCase(Locale.ROOT)));
|
dtoMap.forEach((id,dtos)->{
|
if(dtos.size()>1){
|
throw new VciBaseException("编号为【" + id + "】的生命周期重复");
|
}
|
});
|
VciBaseUtil.switchCollectionForOracleIn(dtoMap.keySet()).stream().forEach(
|
ids->{
|
QueryWrapper wrapper = new QueryWrapper(LifeCycleRule.class);
|
ids.stream().forEach(id->{
|
wrapper.eq("lower(id)",id);
|
wrapper.or();
|
});
|
wrapper.eq("1","2");
|
if(baseMapper.selectCount(wrapper)>0){
|
throw new VciBaseException("生命周期的编号不能重复");
|
}
|
}
|
);
|
//先循环处理下，因为现在当前用户没有处理为线程共享的，后面修改后，可以用并发流去处理
|
List<String> oidList = new ArrayList<>();
|
lifeCycleDTOs.stream().forEach(dto->{
|
oidList.add(addLifeCycle(dto));
|
});
|
return LifeCycleRuleWrapper.build().listEntityVO(listByIds(oidList));
|
}
|
|
/**
|
* 修改保存
|
*
|
* @param lifeCycleDTO 数据传输对象
|
* @return
|
*/
|
@Override
|
public LifeCycleVO editSave(LifeCycleDTO lifeCycleDTO) {
|
VciBaseUtil.alertNotNull(lifeCycleDTO,"生命周期信息",lifeCycleDTO.getId(),"生命周期的编号",lifeCycleDTO.getName(),"生命周期名称"
|
,lifeCycleDTO.getNodes(),"生命周期的节点",lifeCycleDTO.getStartStatus(),"起始状态",
|
lifeCycleDTO.getOid(),"主键");
|
LifeCycleRule rule = selectByOid(lifeCycleDTO.getOid());
|
//查询重复
|
QueryWrapper wrapper = new QueryWrapper(LifeCycleRule.class);
|
if(rule.getId().equals(lifeCycleDTO.getId())){
|
throw new VciBaseException("生命周期编号不能修改");
|
}
|
wrapper.eq("lower(id)",lifeCycleDTO.getId().toLowerCase(Locale.ROOT));
|
wrapper.ne("oid",lifeCycleDTO.getOid());
|
if(baseMapper.selectCount(wrapper)>0){
|
throw new VciBaseException("生命周期的编号不能重复");
|
}
|
editLifeCycle(lifeCycleDTO,rule);
|
return LifeCycleRuleWrapper.build().entityVO(getById(rule.getOid()));
|
}
|
|
/**
|
* 修改生命周期
|
* @param lifeCycleDTO
|
* @param life
|
*/
|
private void editLifeCycle(LifeCycleDTO lifeCycleDTO,LifeCycleRule life){
|
if(!lifeCycleDTO.getId().matches(RegExpConstant.LETTER)){
|
throw new VciBaseException("生命周期的编号只能是字母");
|
}
|
BeanUtil.convert(lifeCycleDTO,life);
|
String creator = AuthUtil.getUserAccount();
|
Date now = new Date();
|
life.setLastModifier(creator);
|
life.setLastModifyTime(now);
|
life.setTs(now);
|
|
//删除现在全部的数据，然后重新添加=
|
List<LifeCycleNode> nodeList = selectNodeByLifeOid(life.getOid());
|
List<LifeCycleEdge> edges = selectEdgeByLifeOid(life.getOid());
|
List<LifeCycleLineEvent> eventList = selectEventByEdgeOids(Optional.ofNullable(edges).orElseGet(ArrayList::new).stream().map(LifeCycleEdge::getOid).collect(Collectors.toList()));
|
if(!CollectionUtils.isEmpty(nodeList)){
|
nodeMapper.deleteBatchIds(nodeList.stream().map(LifeCycleNode::getOid).collect(Collectors.toList()));
|
}
|
if(!CollectionUtils.isEmpty(edges)){
|
edgeMapper.deleteBatchIds(edges.stream().map(LifeCycleEdge::getOid).collect(Collectors.toList()));
|
}
|
if(!CollectionUtils.isEmpty(eventList)){
|
lineEventMapper.deleteBatchIds(eventList.stream().map(LifeCycleLineEvent::getOid).collect(Collectors.toList()));
|
}
|
|
List<String> statusList = new ArrayList<>();
|
//处理节点
|
if(!CollectionUtils.isEmpty(lifeCycleDTO.getNodes())){
|
lifeCycleDTO.getNodes().stream().forEach(nodeDTO->{
|
addLifeCycleNode(nodeDTO,life.getOid(),creator,now);
|
statusList.add(nodeDTO.getId());
|
});
|
}
|
if(!statusList.contains(life.getStartStatus())){
|
throw new VciBaseException("起始状态不在生命周期的画布中");
|
}
|
//判断所有的节点在系统里都存在
|
List<String> existStatusIdList = statusService.listStatusByIdCollection(statusList).stream().map(StatusVO::getId).collect(Collectors.toList());
|
String unExistStatus = statusList.stream().filter(s -> !existStatusIdList.contains(s)).collect(Collectors.joining(","));
|
if(StringUtils.hasLength(unExistStatus)){
|
throw new VciBaseException(unExistStatus + "这些状态在状态池里不存在，不能添加到生命周期中");
|
}
|
//处理边界和连接线
|
if(!CollectionUtils.isEmpty(lifeCycleDTO.getEdges())){
|
lifeCycleDTO.getEdges().stream().forEach(edgeDTO->{
|
String edgeOid = addLifeCycleEdge(edgeDTO,statusList,life.getOid(),creator,now);
|
if(!CollectionUtils.isEmpty(edgeDTO.getEvents())){
|
//有事件
|
edgeDTO.getEvents().stream().forEach(eventDTO->{
|
addLifeCycleLineEvent(eventDTO,edgeOid,creator,now);
|
});
|
}
|
});
|
}
|
baseMapper.updateById(life);
|
|
}
|
|
/**
|
* 使用主键查询
|
* @param oid
|
* @return
|
*/
|
private LifeCycleRule selectByOid(String oid){
|
LifeCycleRule rule = null;
|
try {
|
rule = getById(oid);
|
}catch (Throwable e){
|
throw new VciBaseException("使用主键获取对象出错，这个数据可能不存在，或者数据重复了");
|
}
|
return rule;
|
}
|
|
/**
|
* 批量修改保存
|
*
|
* @param lifeCycleDTOs
|
* @return
|
*/
|
@Override
|
public List<LifeCycleVO> batchEditSave(Collection<LifeCycleDTO> lifeCycleDTOs) {
|
if(CollectionUtils.isEmpty(lifeCycleDTOs)){
|
return new ArrayList<>();
|
}
|
if(lifeCycleDTOs.stream().anyMatch(s->!StringUtils.hasLength(s.getId()) || !StringUtils.hasLength(s.getName())
|
|| CollectionUtils.isEmpty(s.getNodes()) || !StringUtils.hasLength(s.getStartStatus()))){
|
throw new VciBaseException("生命周期的编号，名称，起始状态，包含的节点不能为空");
|
}
|
//统一校验重复
|
Map<String, List<LifeCycleDTO>> dtoMap = lifeCycleDTOs.stream().collect(Collectors.groupingBy(s->s.getId().toLowerCase(Locale.ROOT)));
|
dtoMap.forEach((id,dtos)->{
|
if(dtos.size()>1){
|
throw new VciBaseException("编号为【" + id + "】的生命周期重复");
|
}
|
});
|
VciBaseUtil.switchCollectionForOracleIn(dtoMap.keySet()).stream().forEach(
|
ids->{
|
QueryWrapper wrapper = new QueryWrapper(LifeCycleRule.class);
|
ids.stream().forEach(id->{
|
wrapper.eq("lower(id)",id);
|
wrapper.ne("oid",dtoMap.get(id).get(0).getOid());
|
wrapper.or();
|
});
|
wrapper.eq("1","2");
|
if(baseMapper.selectCount(wrapper)>0){
|
throw new VciBaseException("生命周期的编号不能重复");
|
}
|
}
|
);
|
List<String> oidList = lifeCycleDTOs.stream().map(LifeCycleDTO::getOid).collect(Collectors.toList());
|
List<LifeCycleRule> rules = listByIds(oidList);
|
if(!CollectionUtils.isEmpty(rules)){
|
rules.stream().forEach(life->{
|
editLifeCycle(dtoMap.get(life.getId().toLowerCase(Locale.ROOT)).get(0),life);
|
});
|
}
|
return LifeCycleRuleWrapper.build().listEntityVO(listByIds(oidList));
|
}
|
|
/**
|
* 删除生命周期
|
*
|
* @param lifeCycleDTO 数据传输对象
|
*/
|
@Override
|
@Transactional
|
public void delete(LifeCycleDTO lifeCycleDTO) {
|
VciBaseUtil.alertNotNull(lifeCycleDTO,"数据传输对象",lifeCycleDTO.getOid(),"主键");
|
LifeCycleRule rule = selectByOid(lifeCycleDTO.getOid());
|
//检查被引用不能删除
|
Integer count = btmTypeService.countByLifeId(lifeCycleDTO.getId());
|
if(count !=null && count>0){
|
throw new VciBaseException("生命周期被使用，不能被删除");
|
}
|
//我们查询全部node和edge，然后一起删除
|
List<LifeCycleNode> nodeList = selectNodeByLifeOid(rule.getOid());
|
List<LifeCycleEdge> edges = selectEdgeByLifeOid(rule.getOid());
|
List<LifeCycleLineEvent> eventList = selectEventByEdgeOids(Optional.ofNullable(edges).orElseGet(ArrayList::new).stream().map(LifeCycleEdge::getOid).collect(Collectors.toList()));
|
if(!CollectionUtils.isEmpty(nodeList)){
|
nodeMapper.deleteBatchIds(nodeList.stream().map(LifeCycleNode::getOid).collect(Collectors.toList()));
|
}
|
if(!CollectionUtils.isEmpty(edges)){
|
edgeMapper.deleteBatchIds(edges.stream().map(LifeCycleEdge::getOid).collect(Collectors.toList()));
|
}
|
if(!CollectionUtils.isEmpty(eventList)){
|
lineEventMapper.deleteBatchIds(eventList.stream().map(LifeCycleLineEvent::getOid).collect(Collectors.toList()));
|
}
|
baseMapper.deleteById(rule);
|
}
|
|
/**
|
* 查询链接线
|
* @param lifeOid
|
* @return
|
*/
|
private List<LifeCycleEdge> selectEdgeByLifeOid(String lifeOid){
|
if(!StringUtils.hasLength(lifeOid)){
|
return new ArrayList<>();
|
}
|
LambdaQueryWrapper<LifeCycleEdge> query = new LambdaQueryWrapper<LifeCycleEdge>();
|
query.eq(LifeCycleEdge::getLifeCycleOid,lifeOid);
|
return edgeMapper.selectList(query);
|
}
|
|
|
/**
|
* 获取节点的信息
|
* @param lifeOids 生命周期的主键集合
|
* @return
|
*/
|
private List<LifeCycleEdge> selectEdgeByLifeOids(Collection<String> lifeOids){
|
if(!CollectionUtils.isEmpty(lifeOids)){
|
return new ArrayList<>();
|
}
|
List<LifeCycleEdge> edgeList = new ArrayList<>();
|
VciBaseUtil.switchCollectionForOracleIn(lifeOids).stream().forEach(lOids->{
|
LambdaQueryWrapper<LifeCycleEdge> query = new LambdaQueryWrapper<LifeCycleEdge>();
|
lOids.stream().forEach(lOid->{
|
query.eq(LifeCycleEdge::getLifeCycleOid,lOid);
|
query.or();
|
});
|
query.eq(LifeCycleEdge::getLifeCycleOid,"-1");
|
edgeList.addAll(edgeMapper.selectList(query));
|
});
|
return edgeList;
|
}
|
|
/**
|
* 查询链接线上的事件
|
* @param edgeOids
|
* @return
|
*/
|
private List<LifeCycleLineEvent> selectEventByEdgeOids(Collection<String> edgeOids){
|
if(CollectionUtils.isEmpty(edgeOids)){
|
return new ArrayList<>();
|
}
|
List<LifeCycleLineEvent> eventList = new ArrayList<>();
|
VciBaseUtil.switchCollectionForOracleIn(edgeOids).stream().forEach(edgeOidList->{
|
LambdaQueryWrapper<LifeCycleLineEvent> query = new LambdaQueryWrapper<LifeCycleLineEvent>();
|
edgeOidList.stream().forEach(edgeOid->{
|
query.eq(LifeCycleLineEvent::getPkLifeCycleEdge,edgeOid);
|
query.or();
|
});
|
query.eq(LifeCycleLineEvent::getPkLifeCycleEdge,"-1");
|
eventList.addAll(lineEventMapper.selectList(query));
|
});
|
return eventList;
|
}
|
|
|
/**
|
* 获取节点的信息
|
* @param lifeOid
|
* @return
|
*/
|
private List<LifeCycleNode> selectNodeByLifeOid(String lifeOid){
|
if(!StringUtils.hasLength(lifeOid)){
|
return new ArrayList<>();
|
}
|
LambdaQueryWrapper<LifeCycleNode> query = new LambdaQueryWrapper<LifeCycleNode>();
|
query.eq(LifeCycleNode::getLifeCycleOid,lifeOid);
|
return nodeMapper.selectList(query);
|
}
|
|
/**
|
* 获取节点的信息
|
* @param lifeOids 生命周期的主键集合
|
* @return
|
*/
|
private List<LifeCycleNode> selectNodeByLifeOids(Collection<String> lifeOids){
|
if(!CollectionUtils.isEmpty(lifeOids)){
|
return new ArrayList<>();
|
}
|
List<LifeCycleNode> nodeList = new ArrayList<>();
|
VciBaseUtil.switchCollectionForOracleIn(lifeOids).stream().forEach(lOids->{
|
LambdaQueryWrapper<LifeCycleNode> query = new LambdaQueryWrapper<LifeCycleNode>();
|
lOids.stream().forEach(lOid->{
|
query.eq(LifeCycleNode::getLifeCycleOid,lOid);
|
query.or();
|
});
|
query.eq(LifeCycleNode::getLifeCycleOid,"-1");
|
nodeList.addAll(nodeMapper.selectList(query));
|
});
|
return nodeList;
|
}
|
|
/**
|
* 批量删除生命周期
|
*
|
* @param lifeCycleDTOs 数据传输对象列表
|
*/
|
@Override
|
@Transactional
|
public void batchDelete(List<LifeCycleDTO> lifeCycleDTOs) {
|
VciBaseUtil.alertNotNull(lifeCycleDTOs,"生命周期的信息");
|
if(lifeCycleDTOs.stream().anyMatch(s->!StringUtils.hasLength(s.getOid()))){
|
throw new VciBaseException("生命周期的主键不能为空");
|
}
|
List<String> oidList = lifeCycleDTOs.stream().map(LifeCycleDTO::getOid).collect(Collectors.toList());
|
List<LifeCycleRule> lifeList = baseMapper.selectBatchIds(oidList);
|
//批量查询
|
String usedBtmTypeId = Optional.ofNullable(btmTypeService.selectByLifeIds(lifeList.stream().map(LifeCycleRule::getId).collect(Collectors.toList()))).orElseGet(ArrayList::new).stream().map(BtmTypeVO::getId).collect(Collectors.joining(","));
|
if(StringUtils.hasLength(usedBtmTypeId)){
|
throw new VciBaseException(usedBtmTypeId + "这些业务类型引用了生命周期，不能删除");
|
}
|
List<LifeCycleNode> nodeList = selectNodeByLifeOids(oidList);
|
List<LifeCycleEdge> edgeList = selectEdgeByLifeOids(oidList);
|
if(!CollectionUtils.isEmpty(nodeList)){
|
nodeMapper.deleteBatchIds(nodeList.stream().map(LifeCycleNode::getOid).collect(Collectors.toList()));
|
}
|
if(!CollectionUtils.isEmpty(edgeList)){
|
List<String> edgeOids = edgeList.stream().map(LifeCycleEdge::getOid).collect(Collectors.toList());
|
edgeMapper.deleteBatchIds(edgeOids);
|
List<LifeCycleLineEvent> eventList = selectEventByEdgeOids(edgeOids);
|
if(!CollectionUtils.isEmpty(eventList)){
|
lineEventMapper.deleteBatchIds(eventList.stream().map(LifeCycleLineEvent::getOid).collect(Collectors.toList()));
|
}
|
}
|
baseMapper.deleteBatchIds(oidList);
|
}
|
|
/**
|
* 显示引用范围
|
*
|
* @param lifeCycleDTO 生命周期的数据传输对象
|
* @return 业务类型
|
*/
|
@Override
|
public List<BtmTypeVO> listUses(LifeCycleDTO lifeCycleDTO) {
|
VciBaseUtil.alertNotNull(lifeCycleDTO,"数据传输对象",lifeCycleDTO.getOid(),"主键");
|
LifeCycleRule rule = selectByOid(lifeCycleDTO.getOid());
|
return btmTypeService.selectByLifeId(rule.getId());
|
}
|
}
|
