package com.vci.ubcs.omd.service.impl;
|
|
import com.alibaba.cloud.commons.lang.StringUtils;
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import com.alibaba.nacos.api.exception.NacosException;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.vci.ubcs.omd.constant.BtmTypeConstant;
|
import com.vci.ubcs.omd.dto.BtmAndLinkTypeDdlDTO;
|
import com.vci.ubcs.omd.dto.TableAddColumnDTO;
|
import com.vci.ubcs.omd.dto.TableCheckDTO;
|
import com.vci.ubcs.omd.dto.TableCheckResultDTO;
|
import com.vci.ubcs.omd.entity.BtmType;
|
import com.vci.ubcs.omd.entity.LinkType;
|
import com.vci.ubcs.omd.entity.LinkTypeAttribute;
|
import com.vci.ubcs.omd.entity.ModifyAttributeInfo;
|
import com.vci.ubcs.omd.mapper.LinkTypeMapper;
|
import com.vci.ubcs.omd.repeater.DomainRepeater;
|
import com.vci.ubcs.omd.service.*;
|
import com.vci.ubcs.omd.vo.*;
|
import com.vci.ubcs.omd.wrapper.LinkTypeAttributeWrapper;
|
import com.vci.ubcs.omd.wrapper.LinkTypeWrapper;
|
import com.vci.ubcs.starter.exception.VciBaseException;
|
import com.vci.ubcs.starter.web.constant.RegExpConstant;
|
import com.vci.ubcs.starter.web.pagemodel.PageHelper;
|
import com.vci.ubcs.starter.web.util.VciBaseUtil;
|
import com.vci.ubcs.starter.web.util.VciDateUtil;
|
import org.springblade.core.launch.constant.AppConstant;
|
import org.springblade.core.mp.support.Condition;
|
import org.springblade.core.mp.support.Query;
|
import org.springblade.core.secure.utils.AuthUtil;
|
import org.springblade.core.tool.api.R;
|
import org.springblade.core.tool.utils.BeanUtil;
|
import org.springblade.core.tool.utils.Func;
|
import org.springblade.core.tool.utils.StringPool;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.cglib.beans.BeanMap;
|
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.TransactionDefinition;
|
import org.springframework.transaction.TransactionStatus;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.support.DefaultTransactionDefinition;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.validation.constraints.NotEmpty;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* Description: 链接类型的服务
|
*
|
* @author LiHang
|
* @date 2023/5/24
|
*/
|
@Service
|
public class LinkTypeServiceImpl extends ServiceImpl<LinkTypeMapper, LinkType> implements ILinkTypeService {
|
/**
|
* 链接类型关联属性的服务
|
*/
|
@Autowired
|
private ILinkTypeAttributeService linkTypeAttributeService;
|
|
/**
|
* 业务类型服务
|
*/
|
@Autowired
|
private IBtmTypeService btmTypeService;
|
|
/**
|
* 属性的服务
|
*/
|
@Autowired
|
private IAttributeService attributeService;
|
|
/**
|
* 事务
|
*/
|
@Autowired
|
private DataSourceTransactionManager dataSourceTransactionManager;
|
|
/**
|
* 更改的属性信息服务
|
*/
|
@Autowired
|
private IModifyAttributeService modifyAttributeService;
|
|
/**
|
* 表名前缀
|
*/
|
public static final String PL = "PLLT";
|
|
|
/**
|
* 获取链接类型列表
|
*
|
* @param conditionMap 查询条件
|
* @param pageHelper 分页信息和排序信息，默认使用id排序
|
* @return 链接类型对象列表
|
* @throws VciBaseException 查询出错时会抛出异常
|
*/
|
@Override
|
public IPage<LinkTypeVO> listLinkType(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
|
if (conditionMap == null){
|
conditionMap = new HashMap<>(16);
|
}
|
if (pageHelper == null) {
|
pageHelper = new PageHelper(-1);
|
}
|
LinkType queryObj = new LinkType();
|
BeanMap.create(queryObj).putAll(conditionMap);
|
Query query = new Query();
|
query.setCurrent(pageHelper.getPage());
|
query.setSize(pageHelper.getLimit());
|
|
return LinkTypeWrapper.build().pageVO(baseMapper.selectPage(Condition.getPage(query),Condition.getQueryWrapper(queryObj).lambda().orderByAsc(LinkType::getId)));
|
}
|
|
/**
|
* 根据主键获取链接类型
|
*
|
* @param pkLinkType 链接类型主键
|
* @return 链接类型，如果不存在会返回null
|
* @throws VciBaseException 参数为空或者查询出错时会抛出错误
|
*/
|
@Override
|
public LinkTypeVO getLinkTypeByOid(String pkLinkType) throws VciBaseException {
|
VciBaseUtil.alertNotNull(pkLinkType,"链接类型的主键");
|
List<LinkTypeVO> linkTypeVOList = listLinkTypeByOids(pkLinkType);
|
if(!CollectionUtils.isEmpty(linkTypeVOList)){
|
return linkTypeVOList.get(0);
|
}
|
return null;
|
}
|
|
/**
|
* 根据主键批量获取链接类型
|
*
|
* @param pkLinkTypes 链接类型主键，用逗号分隔
|
* @return 链接类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
|
* @throws VciBaseException 参数为空或者查询出错时会抛出错误
|
*/
|
@Override
|
public List<LinkTypeVO> listLinkTypeByOids(String pkLinkTypes) throws VciBaseException {
|
VciBaseUtil.alertNotNull(pkLinkTypes,"链接类型的主键");
|
List<String> pkList = Func.toStrList(",",pkLinkTypes);
|
return listLinkTypeByOidCollection(pkList);
|
}
|
|
/**
|
* 批量根据主键获取链接类型
|
*
|
* @param pkLinkTypeCollection 链接类型主键集合
|
* @return 链接类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
|
* @throws VciBaseException 参数为空或者查询出错时会抛出错误
|
*/
|
@Override
|
public List<LinkTypeVO> listLinkTypeByOidCollection(Collection<String> pkLinkTypeCollection) throws VciBaseException {
|
if(!CollectionUtils.isEmpty(pkLinkTypeCollection)){
|
List<LinkType> linkTypeDOList = listLinkTypeDOByOidCollection(pkLinkTypeCollection);
|
if(!CollectionUtils.isEmpty(linkTypeDOList)) {
|
Map<String,List<LinkTypeAttributeVO>> pkLinkTypeAndAttributeMap = linkTypeAttributeService.batchGetAttributesNoDefault(linkTypeDOList);
|
return LinkTypeWrapper.build().listEntityVO(linkTypeDOList,pkLinkTypeAndAttributeMap);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 根据主键集合批量获取数据对象
|
* @param oidCollection 主键集合
|
* @return 业务类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
|
* @throws VciBaseException 参数为空或者查询出错时会抛出错误
|
*/
|
private List<LinkType> listLinkTypeDOByOidCollection(Collection<String> oidCollection) throws VciBaseException {
|
if(!CollectionUtils.isEmpty(oidCollection)){
|
List<LinkType> linkTypeDOList = new ArrayList<>();
|
Collection<Collection<String>> pksCollections = VciBaseUtil.switchCollectionForOracleIn(oidCollection);
|
if(CollectionUtils.isEmpty(pksCollections)) {
|
return linkTypeDOList;
|
}
|
pksCollections.forEach(s -> {
|
List<LinkType> linkTypeDOS = baseMapper.selectList(Wrappers.<LinkType>query().lambda().in(LinkType::getOid, s));
|
if(!CollectionUtils.isEmpty(linkTypeDOS)){
|
linkTypeDOList.addAll(linkTypeDOS);
|
}
|
});
|
return linkTypeDOList;
|
}
|
return null;
|
}
|
|
/**
|
* 根据英文名称获取链接类型
|
*
|
* @param id 英文名称
|
* @return 链接类型，如果不存在会返回null
|
* @throws VciBaseException
|
*/
|
@Override
|
public LinkTypeVO getLinkTypeById(String id) throws VciBaseException {
|
VciBaseUtil.alertNotNull(id,"链接类型的英文名称");
|
List<LinkTypeVO> linkTypeVOList = listLinkTypeByIds(id);
|
if(CollectionUtils.isEmpty(linkTypeVOList)){
|
return null;
|
}
|
return linkTypeVOList.get(0);
|
}
|
|
/**
|
* 根据英文名称批量获取链接类型
|
*
|
* @param ids 英文名称，使用逗号分隔
|
* @return 链接类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
|
* @throws VciBaseException 参数为空或者查询出错时会抛出错误
|
*/
|
@Override
|
public List<LinkTypeVO> listLinkTypeByIds(String ids) throws VciBaseException {
|
VciBaseUtil.alertNotNull(ids,"链接类型的英文名称");
|
List<String> idList = Func.toStrList(",",ids);
|
return listLinkTypeByIdCollection(idList);
|
}
|
|
/**
|
* 根据英文名称集合批量获取链接类型
|
*
|
* @param linkTypeIdCollection 英文名称集合，使用逗号分隔
|
* @return 链接类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
|
* @throws VciBaseException 参数为空或者查询出错时会抛出错误
|
*/
|
@Override
|
public List<LinkTypeVO> listLinkTypeByIdCollection(Collection<String> linkTypeIdCollection) throws VciBaseException {
|
if(!CollectionUtils.isEmpty(linkTypeIdCollection)){
|
List<LinkType> linkTypeDOList = listLinkTypeDOByIdCollection(linkTypeIdCollection);
|
if(!CollectionUtils.isEmpty(linkTypeDOList)) {
|
Map<String,List<LinkTypeAttributeVO>> pkLinkTypeAndAttributeMap = linkTypeAttributeService.batchGetAttributesNoDefault(linkTypeDOList);
|
return LinkTypeWrapper.build().listEntityVO(linkTypeDOList, pkLinkTypeAndAttributeMap);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 根据主键集合批量获取数据对象
|
* @param idCollection 英文名称集合
|
* @return 业务类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
|
* @throws VciBaseException 参数为空或者查询出错时会抛出错误
|
*/
|
private List<LinkType> listLinkTypeDOByIdCollection(Collection<String> idCollection) throws VciBaseException {
|
if(!CollectionUtils.isEmpty(idCollection)){
|
List<LinkType> linkTypeDOList = new ArrayList<>();
|
Collection<Collection<String>> pksCollections = VciBaseUtil.switchCollectionForOracleIn(idCollection);
|
if(!CollectionUtils.isEmpty(pksCollections)) {
|
pksCollections.forEach(s -> {
|
List<LinkType> linkTypeDOS = baseMapper.selectList(Wrappers.<LinkType>query().lambda().in(LinkType::getId,s));
|
if(!CollectionUtils.isEmpty(linkTypeDOS)){
|
linkTypeDOList.addAll(linkTypeDOS);
|
}
|
});
|
}
|
return linkTypeDOList;
|
}
|
return null;
|
}
|
|
/**
|
* 获取链接类型的指定属性
|
*
|
* @param id 链接类型的英文名称
|
* @param attributeIdCollection 属性的集合，如果为空则获取全部
|
* @return 属性的显示对象
|
*/
|
@Override
|
public List<LinkTypeAttributeVO> listAttributeVOByIdsForLink(String id, Collection<String> attributeIdCollection) {
|
//一个表里不会有1000个属性
|
if(attributeIdCollection == null){
|
attributeIdCollection = new ArrayList<>();
|
}
|
List<LinkTypeAttribute> attributeDOList = linkTypeAttributeService.list(Wrappers.<LinkTypeAttribute>query().lambda().in(LinkTypeAttribute::getId,attributeIdCollection));
|
return LinkTypeAttributeWrapper.build().listEntityVO(attributeDOList);
|
}
|
|
/**
|
* 根据链接类型主键获取中文名称
|
*
|
* @param oid 链接类型主键
|
* @return 中文名称，如果不存在会返回null;多个会以逗号分隔
|
* @throws VciBaseException 参数为空或者查询出错时会抛出错误
|
*/
|
@Override
|
public String getNameByOid(String oid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oid,"链接类型主键");
|
return baseMapper.selectOne(Wrappers.<LinkType>query().lambda().eq(LinkType::getOid,oid)).getName();
|
}
|
|
/**
|
* 根据链接类型英文名称获取中文名称
|
*
|
* @param id 链接类型英文名称
|
* @return 中文名称，如果不存在会返回null;多个会以逗号分隔
|
* @throws VciBaseException 参数为空或者查询出错时会抛出错误
|
*/
|
@Override
|
public String getNameById(String id) throws VciBaseException {
|
VciBaseUtil.alertNotNull(id,"链接类型英文名称");
|
return baseMapper.selectOne(Wrappers.<LinkType>query().lambda().eq(LinkType::getId,id)).getName();
|
}
|
|
/**
|
* 根据业务类型主键获取包含的属性数据对象
|
* @param oidCollection 主键集合
|
* @return 属性数据对象
|
*/
|
private List<LinkTypeAttribute> listHasAttributeDOByOidCollection(Collection<String> oidCollection){
|
VciBaseUtil.alertNotNull("业务类型主键",oidCollection);
|
Collection<Collection<String>> oidCollections = VciBaseUtil.switchCollectionForOracleIn(oidCollection);
|
List<LinkTypeAttribute> attributeDOList = new ArrayList<>();
|
for(Collection<String> oids : oidCollections){
|
List<LinkTypeAttribute> attributeDOs = linkTypeAttributeService.list(Wrappers.<LinkTypeAttribute>query().lambda().in(LinkTypeAttribute::getPkLinkType,oids));
|
if(!CollectionUtils.isEmpty(attributeDOs)){
|
attributeDOList.addAll(attributeDOs);
|
}
|
}
|
return attributeDOList;
|
}
|
|
/**
|
* 添加链接类型
|
*
|
* @param linkTypeVO 链接类型显示对象（和DTO共用）
|
* @return 添加后的链接类型
|
* @throws VciBaseException 添加出错的时候会抛出异常
|
*/
|
@Override
|
public LinkTypeVO addSave(LinkTypeVO linkTypeVO) throws VciBaseException {
|
return addSave(linkTypeVO,true);
|
}
|
|
/**
|
* 添加链接类型
|
*
|
* @param linkTypeVO 链接类型显示对象（和DTO共用）
|
* @param autoCreateTable 自动创建表格
|
* @return 添加后的链接类型
|
* @throws VciBaseException 添加出错的时候会抛出异常
|
*/
|
@Override
|
@Transactional
|
public LinkTypeVO addSave(LinkTypeVO linkTypeVO, boolean autoCreateTable) throws VciBaseException {
|
TransactionStatus transaction = null;
|
if(autoCreateTable) {
|
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
|
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
|
// 事物隔离级别，开启新事务，这样会比较安全些。
|
transaction = dataSourceTransactionManager.getTransaction(def);
|
// 获得事务状态
|
}
|
try {
|
VciBaseUtil.alertNotNull(linkTypeVO, "要添加的链接类型",
|
linkTypeVO.getId(), "链接类型的英文名称", linkTypeVO.getName(), "链接类型中文名称",
|
linkTypeVO.getFromBtmType(),"from端的业务类型",linkTypeVO.getFromBtmTypeName(),"from端的业务类型的名称",
|
linkTypeVO.getToBtmType(),"to端的业务类型",linkTypeVO.getToBtmType(),"to端的业务类型的名称");
|
if (!linkTypeVO.getId().matches(RegExpConstant.LETTER)) {
|
throw new VciBaseException("链接类型英文名称只能是纯英文，目前为{0}", new Object[]{linkTypeVO.getId()});
|
}
|
if (linkTypeVO.getId().length() > 24) {
|
throw new VciBaseException("链接类型英文名称不能超过18，目前长度为{0}", new Object[]{linkTypeVO.getId().length()});
|
}
|
List<LinkType> linkTypeDOList = listLinkTypeDOByIdCollection(VciBaseUtil.str2List(linkTypeVO.getId()));
|
if (!CollectionUtils.isEmpty(linkTypeDOList) && linkTypeDOList.size() > 0) {
|
LinkType existLinkType= linkTypeDOList.get(0);
|
throw new VciBaseException("链接类型英文名称已经存在（不区分大小写），这个英文名称对应的中文名称为{0},创建人{1},创建时间{2}"
|
, new Object[]{existLinkType.getName(), existLinkType.getCreator(), VciDateUtil.date2Str(existLinkType.getCreateTime(), VciDateUtil.DateFormat)});
|
}
|
//检查使用的业务类型是否存在
|
Set<String> usedBtmTypeSet = new HashSet<>();
|
Collections.addAll(usedBtmTypeSet,linkTypeVO.getFromBtmType().split(","));
|
Collections.addAll(usedBtmTypeSet,linkTypeVO.getToBtmType().split(","));
|
|
List<BtmType> btmTypeDOList = btmTypeService.listBtmTypeDOByIdCollection(usedBtmTypeSet);
|
if(CollectionUtils.isEmpty(btmTypeDOList)){
|
throw new VciBaseException("链接类型使用的业务类型全部不存在，请查证");
|
}
|
Set<String> existBtmTypeIdSet = btmTypeDOList.stream().collect(Collectors.toMap(s -> s.getId().trim().toLowerCase(), t -> t)).keySet();
|
String unExistBtmTypeId = usedBtmTypeSet.stream().filter(s -> !existBtmTypeIdSet.contains(s.toLowerCase().trim())).collect(Collectors.joining(","));
|
if(StringUtils.isNotBlank(unExistBtmTypeId)){
|
throw new VciBaseException("链接类型使用的业务类型{0}不存在，请查证",new Object[]{unExistBtmTypeId});
|
}
|
|
if (StringUtils.isBlank(linkTypeVO.getOid())) {
|
linkTypeVO.setOid(VciBaseUtil.getPk());
|
}
|
LinkType linkTypeDO = new LinkType();
|
BeanUtil.copy(linkTypeVO, linkTypeDO);
|
if (StringUtils.isBlank(linkTypeDO.getTableName())){
|
linkTypeDO.setTableName(getTableName(linkTypeDO.getId(),linkTypeDO.getBizDomain()));
|
}
|
String creator = AuthUtil.getUserAccount();
|
Date now = new Date();
|
LinkTypeWrapper.build().setBeforeInsert(linkTypeDO,creator,now);
|
|
//处理属性
|
List<LinkTypeAttributeVO> attributeVOList = addAttributeForLink(linkTypeVO.getAttributes(), linkTypeDO.getOid(), creator, now);
|
|
baseMapper.insert(linkTypeDO);
|
if(autoCreateTable) {
|
LinkTypeVO typeVO = LinkTypeWrapper.build().entityVO(linkTypeDO);
|
typeVO.setAttributes(attributeVOList);
|
List<LinkTypeAttributeVO> attributes = typeVO.getAttributes();
|
attributes.addAll(linkTypeAttributeService.getDefaultAttributes(typeVO));
|
typeVO.setAttributes(attributes);
|
R r = DomainRepeater.submitLinkType(typeVO.getBizDomain(), typeVO);
|
if (!r.isSuccess()){
|
dataSourceTransactionManager.rollback(transaction);
|
}else {
|
dataSourceTransactionManager.commit(transaction);
|
}
|
}
|
}catch (VciBaseException e){
|
if(autoCreateTable) {
|
dataSourceTransactionManager.rollback(transaction);
|
}
|
throw e;
|
}catch (Throwable e){
|
if(autoCreateTable) {
|
dataSourceTransactionManager.rollback(transaction);
|
}
|
throw e;
|
}
|
/*if(autoCreateTable) {
|
checkTableSame(linkTypeVO);
|
}*/
|
return linkTypeVO;
|
}
|
|
/**
|
* 为链接类型添加属性
|
* @param attributesVOList 属性的显示对象列表
|
* @param pkLinkType 链接类型的主键
|
* @param creator 创建人
|
* @param now 当前时间
|
*/
|
private List<LinkTypeAttributeVO> addAttributeForLink(List<LinkTypeAttributeVO> attributesVOList,String pkLinkType,String creator,Date now){
|
List<LinkTypeAttribute> linkTypeAttributeDOList = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(attributesVOList)) {
|
List<String> attributeIdList = new ArrayList<>();
|
attributesVOList.forEach(s -> {
|
linkTypeAttributeService.checkAttribute(s);
|
linkTypeAttributeDOList.add(LinkTypeAttributeWrapper.build().copyVO2DO(s, pkLinkType, creator, now));
|
attributeIdList.add(s.getId().toLowerCase().trim());
|
});
|
//检查属性是否都存在
|
attributeService.checkAttributeExists(attributeIdList);
|
linkTypeAttributeService.saveOrUpdateBatch(linkTypeAttributeDOList,10000);
|
return LinkTypeAttributeWrapper.build().listEntityVO(linkTypeAttributeDOList);
|
}
|
return null;
|
}
|
|
/**
|
* 检查链接类型的属性是否和数据库中相同
|
* @param linkTypeVO 链接类型的显示对象
|
*/
|
private void checkTableSame(LinkTypeVO linkTypeVO){
|
List<LinkTypeVO> linkTypeVOList = new ArrayList<>();
|
linkTypeVOList.add(linkTypeVO);
|
BtmAndLinkTypeDdlDTO btmAndLinkTypeDdlDTO = new BtmAndLinkTypeDdlDTO();
|
btmAndLinkTypeDdlDTO.setLinkTypeList(linkTypeVOList);
|
List<ModifyAttributeInfo> modifyAttributeInfoDOList = new ArrayList<>();
|
try {
|
R result = DomainRepeater.checkDifferent(btmAndLinkTypeDdlDTO, AppConstant.APPLICATION_NAME_CODE);
|
if (result.isSuccess()){
|
Object dataList = result.getData();
|
if (dataList instanceof List){
|
((List<?>) dataList).forEach(data -> {
|
JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(data));
|
modifyAttributeInfoDOList.add(BeanUtil.copy(jsonObject,ModifyAttributeInfo.class));
|
});
|
}
|
}
|
} catch (NacosException e) {
|
throw new RuntimeException(e);
|
}
|
if (!CollectionUtils.isEmpty(modifyAttributeInfoDOList)) {
|
modifyAttributeService.saveOrUpdateBatch(modifyAttributeInfoDOList);
|
modifyAttributeService.finishModify(modifyAttributeInfoDOList);
|
}
|
}
|
|
/**
|
* 修改链接类型
|
*
|
* @param linkTypeVO 链接类型显示对象（和DTO共用）
|
* @return 修改后的链接类型
|
* @throws VciBaseException 修改出错的时候会抛出异常
|
*/
|
@Override
|
public LinkTypeVO editSave(LinkTypeVO linkTypeVO) throws VciBaseException {
|
return editSave(linkTypeVO,true);
|
}
|
|
/**
|
* 修改链接类型
|
*
|
* @param linkTypeVO 链接类型显示对象（和DTO共用）
|
* @param autoCreateTable 自动创建表格
|
* @return 修改后的链接类型
|
* @throws VciBaseException 修改出错的时候会抛出异常
|
*/
|
@Override
|
public LinkTypeVO editSave(LinkTypeVO linkTypeVO, boolean autoCreateTable) throws VciBaseException {
|
TransactionStatus transaction = null;
|
if(autoCreateTable) {
|
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
|
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
|
// 事物隔离级别，开启新事务，这样会比较安全些。
|
transaction = dataSourceTransactionManager.getTransaction(def);
|
// 获得事务状态
|
}
|
try{
|
VciBaseUtil.alertNotNull(linkTypeVO, "要修改的链接类型", linkTypeVO.getOid(),"链接类型的主键",
|
linkTypeVO.getId(), "链接类型的英文名称", linkTypeVO.getName(), "链接类型中文名称");
|
if (!linkTypeVO.getId().matches(RegExpConstant.LETTER)) {
|
throw new VciBaseException("链接类型英文名称只能是纯英文，目前为{0}", new Object[]{linkTypeVO.getId()});
|
}
|
if (linkTypeVO.getId().length() > 24) {
|
throw new VciBaseException("链接类型英文名称不能超过18，目前长度为{0}", new Object[]{linkTypeVO.getId().length()});
|
}
|
List<LinkType> linkTypeDOList = listLinkTypeDOByIdCollection(VciBaseUtil.str2List(linkTypeVO.getId()));
|
if (CollectionUtils.isEmpty(linkTypeDOList)) {
|
throw new VciBaseException("这个链接类型{0}[{1}]在系统中不存在。或者请检查您是否修改了链接类型的英文名称（系统不允许修改英文名称，只可以修改英文名称字母的大小写）"
|
,new Object[]{linkTypeVO.getId(),linkTypeVO.getName()});
|
}
|
LinkType linkTypeDO = linkTypeDOList.get(0);
|
|
//检查使用的业务类型是否存在
|
Set<String> usedBtmTypeSet = new HashSet<>();
|
Collections.addAll(usedBtmTypeSet,linkTypeVO.getFromBtmType().split(","));
|
Collections.addAll(usedBtmTypeSet,linkTypeVO.getToBtmType().split(","));
|
|
List<BtmType> btmTypeDOList = btmTypeService.listBtmTypeDOByIdCollection(usedBtmTypeSet);
|
if(CollectionUtils.isEmpty(btmTypeDOList)){
|
throw new VciBaseException("链接类型使用的业务类型全部不存在，请查证");
|
}
|
Set<String> existBtmTypeIdSet = btmTypeDOList.stream().collect(Collectors.toMap(s -> s.getId().trim().toLowerCase(), t -> t)).keySet();
|
String unExistBtmTypeId = usedBtmTypeSet.stream().filter(s -> !existBtmTypeIdSet.contains(s.toLowerCase().trim())).collect(Collectors.joining(","));
|
if(StringUtils.isNotBlank(unExistBtmTypeId)){
|
throw new VciBaseException("链接类型使用的业务类型{0}不存在，请查证",new Object[]{unExistBtmTypeId});
|
}
|
String creator = AuthUtil.getUserAccount();
|
Date now = new Date();
|
linkTypeDO = LinkTypeWrapper.build().setBeforeUpdate(linkTypeDO,creator,now);
|
//处理属性
|
LinkTypeWrapper.build().copyLinkTypeVO2DO(linkTypeVO,linkTypeDO,creator,new Date());
|
|
//先查询这个链接类型包含多少属性
|
List<LinkTypeAttribute> hasAttributeList = linkTypeAttributeService.list(Wrappers.<LinkTypeAttribute>query().lambda().in(LinkTypeAttribute::getPkLinkType,Func.toStrList(",",linkTypeVO.getOid())));
|
//处理属性
|
addAttributeForLink(linkTypeVO.getAttributes(),linkTypeDO.getOid(),creator,now);
|
|
if(!CollectionUtils.isEmpty(hasAttributeList)){
|
//有属性的时候直接删除后再添加
|
linkTypeAttributeService.batchDeleteByOids(hasAttributeList.stream().map(s->s.getOid()).collect(Collectors.toList()));
|
}
|
saveOrUpdate(linkTypeDO);
|
if(autoCreateTable) {
|
List<LinkTypeAttributeVO> defaultAttributes = linkTypeAttributeService.getDefaultAttributes(linkTypeVO);
|
List<LinkTypeAttributeVO> attributes = linkTypeVO.getAttributes();
|
attributes.addAll(defaultAttributes);
|
linkTypeVO.setAttributes(attributes);
|
BtmAndLinkTypeDdlDTO ddlDTO = new BtmAndLinkTypeDdlDTO();
|
DomainRepeater.checkDifferent(ddlDTO,linkTypeVO.getBizDomain());
|
dataSourceTransactionManager.commit(transaction);
|
}
|
} catch (Throwable e){
|
if(autoCreateTable) {
|
dataSourceTransactionManager.rollback(transaction);
|
}
|
throw new VciBaseException(e.getMessage());
|
}
|
/*if(autoCreateTable) {
|
checkTableSame(linkTypeVO);
|
}*/
|
return linkTypeVO;
|
}
|
|
/**
|
* 删除链接类型
|
*
|
* @param linkTypeVO 链接类型显示对象
|
* @throws VciBaseException 如果链接类型被引用，或者删除出错时会抛出异常
|
*/
|
@Override
|
public void delete(LinkTypeVO linkTypeVO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(linkTypeVO,"要删除的链接类型",linkTypeVO.getOid(),"要删除的链接类型的主键");
|
List<LinkTypeVO> linkTypeVOList = new ArrayList<>();
|
linkTypeVOList.add(linkTypeVO);
|
batchDelete(linkTypeVOList);
|
}
|
|
/**
|
* 批量删除链接类型
|
*
|
* @param linkTypeVOList 要删除的链接类型显示对象列表
|
* @throws VciBaseException 如果链接类型被引用，或者删除出错时会抛出异常
|
*/
|
@Override
|
public void batchDelete(List<LinkTypeVO> linkTypeVOList) throws VciBaseException {
|
VciBaseUtil.alertNotNull("要删除的链接类型",linkTypeVOList);
|
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
|
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
|
// 事物隔离级别，开启新事务，这样会比较安全些。
|
TransactionStatus transaction= dataSourceTransactionManager.getTransaction(def);
|
// 获得事务状态
|
List<LinkType> linkTypeDOList = null;
|
try {
|
List<String> oidList = linkTypeVOList.stream().map(LinkTypeVO::getOid).collect(Collectors.toList());
|
linkTypeDOList = listLinkTypeDOByOidCollection(oidList);
|
//需要判断表格是否存在数据，
|
if (CollectionUtils.isEmpty(linkTypeDOList)) {
|
throw new VciBaseException("要删除的链接类型对象未在系统中找到");
|
}
|
List<TableCheckDTO> checkList = linkTypeDOList.stream().map(linkType -> {
|
TableCheckDTO tableCheckDTO = new TableCheckDTO();
|
tableCheckDTO.setBtmName(linkType.getId());
|
tableCheckDTO.setTableName(getTableName(linkType.getId(),linkType.getBizDomain()));
|
tableCheckDTO.setCheckTableHasData(true);
|
tableCheckDTO.setNeedDelete(true);
|
tableCheckDTO.setDomain(linkType.getBizDomain());
|
return tableCheckDTO;
|
}).collect(Collectors.toList());
|
R result = DomainRepeater.checkTableHasDataByTableNameThenDrop(checkList);
|
if (result.isSuccess()){
|
JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(result.getData()));
|
TableCheckResultDTO tableCheckResult = BeanUtil.copy(jsonObject, TableCheckResultDTO.class);
|
if (tableCheckResult == null){
|
throw new VciBaseException("调用DDL服务失败");
|
}
|
List<String> successOidList = linkTypeDOList.stream().filter(s -> Optional.ofNullable(tableCheckResult.getSuccessList()).orElseGet(ArrayList::new).stream().anyMatch(r -> StringUtils.equals(s.getId(), r.getBtmName())))
|
.map(LinkType::getOid).collect(Collectors.toList());
|
if (!CollectionUtils.isEmpty(successOidList)) {
|
//删除属性
|
List<LinkTypeAttribute> hasAttributesList = listHasAttributeDOByOidCollection(successOidList);
|
List<String> attributeOidList = hasAttributesList.stream().map(LinkTypeAttribute::getOid).collect(Collectors.toList());
|
Collection<Collection<String>> attributeOidCollections = VciBaseUtil.switchCollectionForOracleIn(attributeOidList);
|
for (Collection<String> attrOidCollection : attributeOidCollections) {
|
linkTypeAttributeService.batchDeleteByOids(new ArrayList<>(attrOidCollection));
|
}
|
|
//删除链接类型
|
Collection<Collection<String>> oidCollections = VciBaseUtil.switchCollectionForOracleIn(successOidList);
|
for (Collection<String> oids : oidCollections) {
|
baseMapper.delete(Wrappers.<LinkType>query().lambda().in(LinkType::getOid, oids));
|
}
|
}
|
if (!CollectionUtils.isEmpty(tableCheckResult.getFailList())){
|
throw new VciBaseException("链接类型:" + tableCheckResult.getFailList().stream().map(TableCheckDTO::getBtmName).collect(Collectors.joining("],[")) + "存在数据不能删除");
|
}
|
}else {
|
throw new VciBaseException("没有找到DDL服务");
|
}
|
dataSourceTransactionManager.commit(transaction);
|
} catch (NacosException e) {
|
dataSourceTransactionManager.rollback(transaction);
|
throw new RuntimeException(e);
|
} catch (Throwable e){
|
dataSourceTransactionManager.rollback(transaction);
|
throw e;
|
}
|
|
}
|
|
/**
|
* 为链接类型添加属性对象
|
*
|
* @param attributeVO 属性显示对象
|
* @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
|
*/
|
@Override
|
public void addSaveAttribute(LinkTypeAttributeVO attributeVO,String tableName,String serviceName) throws VciBaseException {
|
addSaveAttribute(attributeVO,tableName,true,serviceName);
|
}
|
|
/**
|
* 为链接类型添加属性对象
|
*
|
* @param attributeVO 属性显示对象
|
* @param autoAdd2Table 是否自动添加到表格中
|
* @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
|
*/
|
@Override
|
public void addSaveAttribute(LinkTypeAttributeVO attributeVO,String tableName, boolean autoAdd2Table,String serviceName) throws VciBaseException {
|
TransactionStatus transaction = null;
|
if(autoAdd2Table) {
|
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
|
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
|
// 事物隔离级别，开启新事务，这样会比较安全些。
|
transaction = dataSourceTransactionManager.getTransaction(def);
|
}
|
try {
|
linkTypeAttributeService.checkAttribute(attributeVO);
|
LinkTypeAttribute attributeDO = new LinkTypeAttribute();
|
if (StringUtils.isBlank(attributeVO.getOid())) {
|
attributeVO.setOid(VciBaseUtil.getPk());
|
}
|
attributeVO.setPkLinkType(attributeVO.getPkLinkType());
|
attributeVO.setCreator(AuthUtil.getUserAccount());
|
attributeVO.setCreateTime(new Date());
|
attributeVO.setOwner(attributeVO.getCreator());
|
attributeVO.setBtmName(BtmTypeConstant.LINK_TYPE_ATTRIBUTE);
|
attributeVO.setTs(attributeDO.getCreateTime());
|
//查询链接类型是否存在
|
checkLinkTypeExist(attributeVO.getPkLinkType());
|
BeanUtil.copy(attributeVO, attributeDO);
|
|
linkTypeAttributeService.saveOrUpdate(attributeDO);
|
if (autoAdd2Table) {
|
//执行添加属性列
|
List<LinkTypeAttributeVO> attributeVOList = new ArrayList<>();
|
attributeVOList.add(attributeVO);
|
if (autoAdd2Table) {
|
TableAddColumnDTO addColumnDTO = new TableAddColumnDTO();
|
addColumnDTO.setTableName(tableName);
|
addColumnDTO.setLinkTypeAttributeVOList(attributeVOList);
|
R result = DomainRepeater.addColumnForTable(addColumnDTO, serviceName);
|
if (result.isSuccess()) {
|
dataSourceTransactionManager.commit(transaction);
|
} else {
|
dataSourceTransactionManager.rollback(transaction);
|
|
}
|
}
|
}
|
}catch (NacosException e){
|
if(autoAdd2Table) {
|
dataSourceTransactionManager.rollback(transaction);
|
}
|
throw new RuntimeException(e);
|
}catch (Throwable e){
|
if(autoAdd2Table) {
|
dataSourceTransactionManager.rollback(transaction);
|
}
|
throw e;
|
}
|
}
|
|
/**
|
* 检查某个主键的链接类型是否存在
|
*
|
* @param pkLinkType 链接类型主键
|
* @return true表示存在，false表示不存在
|
* @throws VciBaseException 查询出错或者参数为空的时候抛出异常
|
*/
|
@Override
|
public boolean checkLinkTypeExist(String pkLinkType) throws VciBaseException {
|
VciBaseUtil.alertNotNull(pkLinkType,"要校验是否存在的链接类型主键为空");
|
String name = getNameByOid(pkLinkType);
|
if(StringUtils.isBlank(name)){
|
return false;
|
}else{
|
return true;
|
}
|
}
|
|
/**
|
* 为链接类型修改属性对象
|
*
|
* @param attributeVO 属性显示对象
|
* @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
|
*/
|
@Override
|
public void editSaveAttribute(LinkTypeAttributeVO attributeVO,String tableName,String domain) throws VciBaseException {
|
editSaveAttribute(attributeVO,tableName,domain,true);
|
}
|
|
/**
|
* 为链接类型修改属性对象
|
*
|
* @param attributeVO 属性显示对象
|
* @param autoEdit2Table 是否自动修改到表格
|
* @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
|
*/
|
@Override
|
public void editSaveAttribute(LinkTypeAttributeVO attributeVO,String tableName,String domain, boolean autoEdit2Table) throws VciBaseException {
|
TransactionStatus transaction = null;
|
if(autoEdit2Table) {
|
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
|
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
|
// 事物隔离级别，开启新事务，这样会比较安全些。
|
transaction = dataSourceTransactionManager.getTransaction(def);
|
}
|
try {
|
VciBaseUtil.alertNotNull(attributeVO.getOid(), "使用属性的主键");
|
linkTypeAttributeService.checkAttribute(attributeVO);
|
LinkType linkTypeDO = baseMapper.selectOne(Wrappers.<LinkType>query().lambda().eq(LinkType::getOid, attributeVO.getPkLinkType()));
|
if (linkTypeDO == null || StringUtils.isBlank(linkTypeDO.getOid())) {
|
throw new VciBaseException("要修改的属性关联的链接类型不存在");
|
}
|
LinkTypeAttribute attributeDO = linkTypeAttributeService.selectByPrimaryKey(attributeVO.getOid());
|
String creator = AuthUtil.getUserAccount();
|
Date now = new Date();
|
BeanUtil.copy(attributeVO, attributeDO);
|
attributeDO.setPkLinkType(linkTypeDO.getOid());
|
attributeDO.setLastModifier(creator);
|
attributeDO.setLastModifyTime(now);
|
attributeDO.setTs(now);
|
|
attributeVO.setLastModifier(creator);
|
attributeVO.setLastModifyTime(now);
|
attributeVO.setTs(now);
|
linkTypeAttributeService.saveOrUpdate(attributeDO);
|
if (autoEdit2Table) {
|
BtmAndLinkTypeDdlDTO ddlDTO = new BtmAndLinkTypeDdlDTO();
|
LinkTypeVO linkTypeVO = LinkTypeWrapper.build().entityVO(linkTypeDO);
|
ddlDTO.setLinkTypeList(Collections.singletonList(linkTypeVO));
|
DomainRepeater.checkDifferent(ddlDTO,domain);
|
dataSourceTransactionManager.commit(transaction);
|
}
|
}catch (NacosException e){
|
if(autoEdit2Table) {
|
dataSourceTransactionManager.rollback(transaction);
|
}
|
throw new RuntimeException(e);
|
}catch (Throwable e){
|
if(autoEdit2Table) {
|
dataSourceTransactionManager.rollback(transaction);
|
}
|
throw e;
|
}
|
}
|
|
/**
|
* 获取链接类型的数据库表名称
|
*
|
* @param id 链接类型的英文名称
|
* @param domain 领域值
|
* @return 数据库表名称
|
*/
|
@Override
|
public String getTableName(String id,String domain) {
|
VciBaseUtil.alertNotNull(id,"业务类型英文名称",domain,"领域名称");
|
if (domain.contains("ubcs-")){
|
domain = domain.split("ubcs-")[1];
|
}else {
|
throw new VciBaseException("领域名称不符合规则");
|
}
|
return PL + StringPool.UNDERSCORE + domain.toUpperCase(Locale.ROOT) + StringPool.UNDERSCORE + id.toUpperCase(Locale.ROOT);
|
}
|
|
/**
|
* 获取所有使用的业务类型的英文名称，转换为小写
|
*
|
* @return 英文名称英文小写
|
*/
|
@Override
|
public Set<String> listUsedBtmType() {
|
List<LinkType> allLinkTypeDOList = baseMapper.selectList(Wrappers.query());
|
Set<String> btmTypeSet = new HashSet<>();
|
if(!CollectionUtils.isEmpty(allLinkTypeDOList)){
|
allLinkTypeDOList.stream().forEach( s -> {
|
Collections.addAll(btmTypeSet,s.getFromBtmType().split(","));
|
Collections.addAll(btmTypeSet,s.getToBtmType().split(","));
|
});
|
}
|
return btmTypeSet;
|
}
|
|
/**
|
* 按domain分组，查询链接类型属性结构
|
*
|
* @return 查询结果
|
*/
|
@Override
|
public List<BtmTreeVO> treeDomain() {
|
try {
|
Map<String, String> domain = Optional.ofNullable(DomainRepeater.getDomain()).orElseGet(ArrayList::new).stream().collect(Collectors.toMap(DomainVO::getValue, DomainVO::getLabel));
|
List<LinkTypeVO> vos = LinkTypeWrapper.build().listEntityVO(baseMapper.selectAll(), null);
|
if (CollectionUtils.isEmpty(vos)){
|
return new ArrayList<>();
|
}
|
Map<String, List<LinkTypeVO>> domainMap = Optional.ofNullable(vos).orElseGet(ArrayList::new).stream().collect(Collectors.groupingBy(LinkTypeVO::getBizDomain));
|
List<BtmTreeVO> treeList = new ArrayList<>();
|
domainMap.forEach((k,v)-> {
|
if (domain.containsKey(k)){
|
String label = domain.get(k);
|
BtmTreeVO parent = new BtmTreeVO();
|
parent.setName(label);
|
parent.setId(k);
|
parent.setLevel(1);
|
parent.setLabel(label);
|
parent.setChildList(v.stream().map(s -> {
|
BtmTreeVO child = new BtmTreeVO();
|
child.setOid(s.getOid());
|
child.setLabel(s.getId() + (s.getName() == null ? "" : "(" + s.getName() + ")"));
|
child.setId(s.getId());
|
child.setName(s.getName());
|
child.setLevel(2);
|
return child;
|
}).collect(Collectors.toList()));
|
treeList.add(parent);
|
}
|
});
|
return treeList;
|
} catch (NacosException e) {
|
throw new RuntimeException(e);
|
}
|
}
|
|
@Override
|
public boolean deleteLogic(@NotEmpty List<Long> ids) {
|
return false;
|
}
|
|
@Override
|
public boolean changeStatus(@NotEmpty List<Long> ids, Integer status) {
|
return false;
|
}
|
|
/**
|
* 获取链接类型，只有默认字段
|
*
|
* @param linkTypeId 链接类型id
|
* @return 默认字段属性
|
*/
|
@Override
|
public LinkTypeVO getLinkTypeDefaultAttrById(String linkTypeId) {
|
LinkTypeVO vo = getLinkTypeById(linkTypeId);
|
List<LinkTypeAttributeVO> attributes = linkTypeAttributeService.getDefaultAttributes(vo);
|
vo.setAttributes(attributes);
|
return vo;
|
}
|
|
/**
|
* 获取链接类型，有所有的字段
|
*
|
* @param linkTypeId 链接类型id
|
* @return 所有字段
|
*/
|
@Override
|
public LinkTypeVO getLinkTypeAllAttrById(String linkTypeId) {
|
LinkTypeVO vo = getLinkTypeById(linkTypeId);
|
List<LinkTypeAttributeVO> attributes = linkTypeAttributeService.getAllAttributes(vo);
|
vo.setAttributes(attributes);
|
return vo;
|
}
|
|
/**
|
* 获取链接类型，有所有的字段
|
*
|
* @param linkTypeOid 链接类型主键
|
* @return 所有字段
|
*/
|
@Override
|
public LinkTypeVO getLinkTypeAllAttrByOid(String linkTypeOid) {
|
LinkTypeVO vo = getLinkTypeByOid(linkTypeOid);
|
List<LinkTypeAttributeVO> attributes = linkTypeAttributeService.getAllAttributes(vo);
|
vo.setAttributes(attributes);
|
return vo;
|
}
|
}
|
