Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/service/impl/BtmTypeServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,624 @@
package com.vci.ubcs.omd.service.impl;

import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.nacos.api.exception.NacosException;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.omd.constant.BtmTypeFieldConstant;
import com.vci.ubcs.omd.dto.BtmAndLinkTypeDdlDTO;
import com.vci.ubcs.omd.repeater.DomainRepeater;
import com.vci.ubcs.omd.service.IBtmTypeAttributeService;
import com.vci.ubcs.omd.service.IModifyAttributeService;
import com.vci.ubcs.omd.wrapper.BtmTypeAttributeWrapper;
import com.vci.ubcs.omd.wrapper.BtmTypeWrapper;
import com.vci.ubcs.omd.wrapper.ModifyAttributeWrapper;
import com.vci.ubcs.starter.web.constant.OmdRegExpConstant;
import com.vci.ubcs.omd.dto.BtmTypeDTO;
import com.vci.ubcs.omd.dto.BtmTypeLinkAttributesDTO;
import com.vci.ubcs.omd.entity.BtmType;
import com.vci.ubcs.omd.entity.BtmTypeAttribute;
import com.vci.ubcs.omd.entity.ModifyAttributeInfo;
import com.vci.ubcs.omd.mapper.BtmTypeMapper;
import com.vci.ubcs.omd.service.IBtmTypeService;
import com.vci.ubcs.omd.vo.BtmTypeVO;
import com.vci.ubcs.omd.vo.BtmTypeAttributeVO;
import com.vci.ubcs.omd.vo.LinkTypeVO;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import com.vci.ubcs.starter.web.util.VciDateUtil;
import org.springblade.core.log.exception.ServiceException;
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.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
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/4/23
 */
@Service
public class BtmTypeServiceImpl extends ServiceImpl<BtmTypeMapper, BtmType> implements IBtmTypeService {

   /**
    * äº‹åŠ¡ç®¡ç†
    */
   @Autowired
   private DataSourceTransactionManager dataSourceTransactionManager;

   /**
    * ä¸šåŠ¡ç±»åž‹å…³è”属性服务
    */
   @Autowired
   private IBtmTypeAttributeService btmTypeAttributeService;

   /**
    * å­—段修改信息的服务
    */
   @Autowired
   private IModifyAttributeService modifyAttributeService;

   /**
    * è¡¨åå‰ç¼€
    */
   public static final String PL = "PL";

   /**
    * è®¾ç½®å¹³å°æœ¬èº«çš„业务类型
    *
    * @param platformBtmType å¹³å°æœ¬èº«çš„业务类型
    */
   @Override
   public void setPlatformBtmType(Collection<String> platformBtmType) {

   }

   /**
    * æ ¹æ®ä¸»é”®èŽ·å–业务类型
    *
    * @param pkBtmType ä¸šåŠ¡ç±»åž‹ä¸»é”®
    * @return ä¸šåŠ¡ç±»åž‹ï¼Œå¦‚果不存在会返回null
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public BtmTypeVO getBtmTypeByOid(String pkBtmType) throws ServiceException {
      Func.requireNotNull(pkBtmType,"业务类型主键不能为空");
      BtmTypeVO btmTypeVO = BtmTypeWrapper.build().entityVO(baseMapper.selectOne(Wrappers.<BtmType>query().lambda().eq(BtmType::getOid, pkBtmType)));
      btmTypeVO.setAttributes(btmTypeAttributeService.getAttributeByBtmTypeOid(pkBtmType));
      return btmTypeVO;
   }

   /**
    * æ ¹æ®ä¸»é”®æ‰¹é‡èŽ·å–业务类型
    *
    * @param pkBtmTypes ä¸šåŠ¡ç±»åž‹ä¸»é”®ï¼Œç”¨é€—号分隔
    * @return ä¸šåŠ¡ç±»åž‹åˆ—表，如果有不存在的不会返回，全部不存在的则返回空列表
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public List<BtmTypeVO> listBtmTypeByOids(String pkBtmTypes) throws ServiceException {
      VciBaseUtil.alertNotNull(pkBtmTypes, "业务类型的主键");
      List<String> pkList = new ArrayList<>();
      Collections.addAll(pkList, pkBtmTypes.split(","));
      return listBtmTypeByOidCollection(pkList);
   }

   /**
    * æ‰¹é‡æ ¹æ®ä¸»é”®èŽ·å–业务类型
    *
    * @param pkBtmTypeCollection ä¸šåŠ¡ç±»åž‹ä¸»é”®é›†åˆ
    * @return ä¸šåŠ¡ç±»åž‹åˆ—表，如果有不存在的不会返回，全部不存在的则返回空列表
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public List<BtmTypeVO> listBtmTypeByOidCollection(Collection<String> pkBtmTypeCollection) throws ServiceException {
      if (!CollectionUtils.isEmpty(pkBtmTypeCollection)) {
         List<BtmType> btmTypeDOList = listBtmTypeDOByOidCollection(pkBtmTypeCollection);
         if (!CollectionUtils.isEmpty(btmTypeDOList)) {
            return BtmTypeWrapper.build().listEntityVO(btmTypeDOList);
         }
      }
      return null;
   }

   /**
    * æ ¹æ®è‹±æ–‡åç§°èŽ·å–业务类型
    *
    * @param id è‹±æ–‡åç§°
    * @return ä¸šåŠ¡ç±»åž‹ï¼Œå¦‚果不存在会返回null
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public BtmTypeVO getBtmTypeById(String id) throws ServiceException {
      VciBaseUtil.alertNotNull(id, "业务类型的英文名称");
      List<BtmTypeVO> btmTypeVOList = listBtmTypeByIds(id);
      if (!CollectionUtils.isEmpty(btmTypeVOList)) {
         return btmTypeVOList.get(0);
      }
      return null;
   }

   /**
    * æ ¹æ®è‹±æ–‡åç§°æ‰¹é‡èŽ·å–业务类型
    *
    * @param ids è‹±æ–‡åç§°ï¼Œä½¿ç”¨é€—号分隔
    * @return ä¸šåŠ¡ç±»åž‹åˆ—表，如果有不存在的不会返回，全部不存在的则返回空列表
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public List<BtmTypeVO> listBtmTypeByIds(String ids) throws ServiceException {
      Func.requireNotNull(ids,"英文名称不能为空");
      return listBtmTypeByIdCollection(Func.toStrList(",",ids));
   }

   /**
    * æ ¹æ®è‹±æ–‡åç§°é›†åˆæ‰¹é‡èŽ·å–业务类型
    *
    * @param idCollection è‹±æ–‡åç§°é›†åˆ
    * @return ä¸šåŠ¡ç±»åž‹åˆ—表，如果有不存在的不会返回，全部不存在的则返回空列表
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public List<BtmTypeVO> listBtmTypeByIdCollection(Collection<String> idCollection) throws ServiceException {
      return CollectionUtils.isEmpty(idCollection) ?  null : BtmTypeWrapper.build().listEntityVO(baseMapper.selectList(Wrappers.<BtmType>query().lambda().in(BtmType::getId,idCollection)));
   }

   /**
    * æ ¹æ®è‹±æ–‡åç§°é›†åˆæ‰¹é‡èŽ·å–业务类型的数据对象
    *
    * @param idCollection è‹±æ–‡åç§°é›†åˆ
    * @return ä¸šåŠ¡ç±»åž‹åˆ—表，如果有不存在的不会返回，全部不存在的则返回空列表
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public List<BtmType> listBtmTypeDOByIdCollection(Collection<String> idCollection) throws ServiceException {
      return CollectionUtils.isEmpty(idCollection) ? null : baseMapper.selectList(Wrappers.<BtmType>query().lambda().in(BtmType::getId, idCollection));
   }

   /**
    * æ ¹æ®ä¸»é”®é›†åˆæ‰¹é‡èŽ·å–业务类型的数据对象
    *
    * @param oidCollection ä¸»é”®
    * @return ä¸šåŠ¡ç±»åž‹åˆ—表，如果有不存在的不会返回，全部不存在的则返回空列表
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public List<BtmType> listBtmTypeDOByOidCollection(Collection<String> oidCollection) throws ServiceException {
      if (!CollectionUtils.isEmpty(oidCollection)) {
         return baseMapper.selectList(Wrappers.<BtmType>query().lambda().in(BtmType::getOid, oidCollection));
      }
      return null;
   }

   /**
    * æ ¹æ®ä¸šåŠ¡ç±»åž‹ä¸»é”®èŽ·å–中文名称
    *
    * @param oid ä¸šåŠ¡ç±»åž‹ä¸»é”®ï¼Œå¤šä¸ªä½¿ç”¨é€—号分隔
    * @return ä¸­æ–‡åç§°ï¼Œå¦‚果不存在会返回null;多个会以逗号分隔
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public String getNameByOid(String oid) throws ServiceException {
      return Objects.requireNonNull(baseMapper.selectOne(Wrappers.<BtmType>query().lambda().eq(BtmType::getOid,oid))).getName();
   }

   /**
    * æ ¹æ®ä¸šåŠ¡ç±»åž‹è‹±æ–‡åç§°èŽ·å–中文名称
    *
    * @param id ä¸šåŠ¡ç±»åž‹è‹±æ–‡åç§°
    * @return ä¸­æ–‡åç§°ï¼Œå¦‚果不存在会返回null;多个会以逗号分隔
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public String getNameById(String id) throws ServiceException {
      return Objects.requireNonNull(baseMapper.selectOne(Wrappers.<BtmType>query().lambda().eq(BtmType::getId,id))).getName();
   }

   /**
    * æ ¹æ®ä¸šåŠ¡ç±»åž‹ä¸»é”®èŽ·å–关联的所有属性对象
    *
    * @param oid ä¸šåŠ¡ç±»åž‹ä¸»é”®
    * @return æ‰€æœ‰çš„属性对象，包括系统属性
    * @throws ServiceException ä¸šåŠ¡ç±»åž‹ä¸å­˜åœ¨ï¼Œå‚数为空或查询出错时会抛出错误
    */
   @Override
   public List<BtmTypeAttributeVO> listHasAttributesByOid(String oid) throws ServiceException {
      return null;
   }

   /**
    * æ ¹æ®ä¸šåŠ¡ç±»åž‹è‹±æ–‡åç§°èŽ·å–关联的所有属性对象
    *
    * @param id ä¸šåŠ¡ç±»åž‹è‹±æ–‡åç§°
    * @return æ‰€æœ‰çš„属性对象，包括系统内置属性
    * @throws ServiceException ä¸šåŠ¡ç±»åž‹ä¸å­˜åœ¨ï¼Œå‚数为空或者查询出错时会抛出异常
    */
   @Override
   public List<BtmTypeAttributeVO> listHasAttributeById(String id) throws ServiceException {
      VciBaseUtil.alertNotNull(id,"业务类型英文名称");
      List<String> ids = Func.toStrList(",", id);
      Map<String, List<BtmTypeAttributeVO>> attributeMap = batchListHasAttributesByIdCollection(ids);
      if (!CollectionUtils.isEmpty(attributeMap)) {
         List<BtmTypeAttributeVO> attributeVOList = new ArrayList<>();
         attributeMap.forEach((k, v) -> {
            attributeVOList.addAll(v);
         });
         return attributeVOList;
      }
      return null;
   }

   /**
    * æ ¹æ®ä¸šåŠ¡ç±»åž‹ä¸»é”®èŽ·å–关联的所有属性对象
    *
    * @param oidCollection ä¸šåŠ¡ç±»åž‹ä¸»é”®é›†åˆ
    * @return æ‰€æœ‰çš„属性对象，包括系统内置属性，key是业务类型主键，value是包含的属性
    * @throws ServiceException ä¸šåŠ¡ç±»åž‹ä¸å­˜åœ¨ï¼Œå‚数为空或者查询出错时会抛出异常
    */
   @Override
   public Map<String, List<BtmTypeAttributeVO>> batchListHasAttributesByOidCollection(Collection<String> oidCollection) throws ServiceException {
      return btmTypeAttributeService.batchListHasAttributesByBtmTypeOidCollection(oidCollection).stream().collect(Collectors.groupingBy(BtmTypeAttributeVO::getPkBtmType));
   }

   /**
    * æ ¹æ®ä¸šåŠ¡ç±»åž‹è‹±æ–‡åç§°èŽ·å–关联的所有属性对象
    *
    * @param idCollection ä¸šåŠ¡ç±»åž‹è‹±æ–‡åç§°é›†åˆ
    * @return æ‰€æœ‰çš„属性对象，包括系统内置属性，key是业务类型主键，value是包含的属性
    * @throws ServiceException ä¸šåŠ¡ç±»åž‹ä¸å­˜åœ¨ï¼Œå‚数为空或者查询出错时会抛出异常
    */
   @Override
   public Map<String, List<BtmTypeAttributeVO>> batchListHasAttributesByIdCollection(Collection<String> idCollection) throws ServiceException {
      List<String> btmTypeOidList = baseMapper.selectList(Wrappers.<BtmType>query().lambda().in(BtmType::getId, idCollection)).stream().map(BtmType::getOid).collect(Collectors.toList());
      return btmTypeAttributeService.batchListHasAttributesByBtmTypeOidCollection(btmTypeOidList).stream().collect(Collectors.groupingBy(BtmTypeAttributeVO::getPkBtmType));
   }

   /**
    * èŽ·å–使用业务类型的链接类型
    *
    * @param pkBtmType ä¸šåŠ¡ç±»åž‹ä¸»é”®
    * @return å¼•ç”¨çš„链接类型
    * @throws ServiceException å‚数为空或者查询出错时会抛出异常
    */
   @Override
   public List<LinkTypeVO> listLinkTypeForUsedBtmType(String pkBtmType) throws ServiceException {
      return null;
   }

   /**
    * æ ¡éªŒä¸šåŠ¡ç±»åž‹æ˜¯å¦è¢«å¼•ç”¨
    *
    * @param pkBtmType ä¸šåŠ¡ç±»åž‹çš„主键
    * @return true表示被引用， false表示没有被引用
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public boolean checkBtmTypeUsed(String pkBtmType) throws ServiceException {
      VciBaseUtil.alertNotNull(pkBtmType, "业务类型主键");
      return checkBtmTypeUseds(VciBaseUtil.str2List(pkBtmType));
   }

   /**
    * æ ¡éªŒä¸šåŠ¡ç±»åž‹æ˜¯å¦è¢«å¼•ç”¨
    *
    * @param oidCollection ä¸šåŠ¡ç±»åž‹çš„主键集合
    * @return true表示被引用， false表示没有被引用
    * @throws ServiceException å‚数为空或者查询出错时会抛出错误
    */
   @Override
   public boolean checkBtmTypeUseds(Collection<String> oidCollection) throws ServiceException {
      VciBaseUtil.alertCollectionNotNull("校验是否引用的业务类型对象的主键", oidCollection);
      //检查链接类型
      //因为链接类型中fromBtmType和toBtmType都是逗号分隔的，所以直接查询所有的链接类型中的使用的业务类型名称
      List<BtmType> btmTypeDOList = listBtmTypeDOByOidCollection(oidCollection);
      if (CollectionUtils.isEmpty(btmTypeDOList)) {
         return false;
      }
      /*Set<String> usedBtmTypeSet = linkTypeServiceI.listUsedBtmType();
      if (btmTypeDOList.stream().anyMatch(s -> usedBtmTypeSet.contains(s.getId().trim().toLowerCase()))) {
         return true;
      }*/
      return false;
   }

   /**
    * æ·»åŠ é»˜è®¤çš„字段
    * @param attributes å­—段集
    * @param fieldMap é»˜è®¤å­—段集
    * @return æ·»åŠ åŽçš„字段集
    */
   private List<BtmTypeLinkAttributesDTO> addAttributeByFieldMap(List<BtmTypeLinkAttributesDTO> attributes, Map<String, String> fieldMap) {
      Map<String, BtmTypeLinkAttributesDTO> existFieldMap = attributes.stream().collect(Collectors.toMap(BtmTypeLinkAttributesDTO::getId, t -> t, (o1, o2) -> o1));
      fieldMap.forEach((k,v) -> {
         if (!existFieldMap.containsKey(k)){
            BtmTypeLinkAttributesDTO attr = new BtmTypeLinkAttributesDTO();
            attr.setId(k);
            attr.setAttrDataType(VciFieldTypeEnum.VTString.name());
            attr.setAttributeLength(50);
            attr.setNullableFlag(false);
            attr.setDescription(v);
            attributes.add(attr);
         }
      });
      return attributes;
   }

   /**
    * æ£€æŸ¥ä¸šåŠ¡ç±»åž‹çš„属性是否和数据库中相同
    *
    * @param btmTypeVO ä¸šåŠ¡ç±»åž‹çš„显示对象
    */
   private void checkTableSame(BtmTypeVO btmTypeVO) {
      List<BtmTypeVO> btmTypeVOList = new ArrayList<>();
      btmTypeVOList.add(btmTypeVO);
      BtmAndLinkTypeDdlDTO ddlDTO = new BtmAndLinkTypeDdlDTO();
      ddlDTO.setBtmTypeList(btmTypeVOList);
      try {
         // å°†ä»¥å‰çš„checkDifferent和reflexDifferent结合了
         R result = DomainRepeater.checkDifferent(ddlDTO,btmTypeVO.getDomain());
         if (result.isSuccess()){
            List<ModifyAttributeInfo> infoList = new ArrayList<>();
            Object data = result.getData();
            if (data instanceof List){
               List dataList = (List) data;
               dataList.forEach(s -> {
                  if (s instanceof ModifyAttributeInfo){
                     ModifyAttributeInfo info = (ModifyAttributeInfo) s;
                     infoList.add(info);
                  }
               });
               modifyAttributeService.saveBatch(ModifyAttributeWrapper.build().listEntityBeforeSave(infoList));
            }
         }
      } catch (NacosException e) {
         if (log.isDebugEnabled()) {
            log.error("保存【修改属性】数据", e);
         }
         throw new RuntimeException(e);
      }
//      modifyAttributeServiceI.finishModify(modifyAttributeInfoList);
   }

   /**
    * æ·»åŠ å±žæ€§åˆ°ä¸šåŠ¡ç±»åž‹ä¸­
    *
    * @param btmTypeDTO ä¸šåŠ¡ç±»åž‹çš„数据传输对象
    */
   private List<BtmTypeAttributeVO> addAttributeForBtm(BtmTypeDTO btmTypeDTO) throws VciBaseException{
      List<BtmTypeLinkAttributesDTO> attributesDTOList = btmTypeDTO.getAttributes();
      return btmTypeAttributeService.checkAndInsert(btmTypeDTO.getOid(),attributesDTOList,AuthUtil.getUserAccount(),new Date());
   }

   /**
    * åˆ é™¤ä¸šåŠ¡ç±»åž‹
    *
    * @param btmTypeVO       ä¸šåŠ¡ç±»åž‹æ˜¾ç¤ºå¯¹è±¡
    * @param autoDeleteTable è‡ªåŠ¨åˆ é™¤è¡¨æ ¼
    * @throws ServiceException å¦‚果业务类型被引用，或者删除出错时会抛出异常
    */
   @Override
   public void delete(BtmTypeVO btmTypeVO, boolean autoDeleteTable) throws ServiceException {

   }

   /**
    * æ‰¹é‡åˆ é™¤ä¸šåŠ¡ç±»åž‹
    *
    * @param btmTypeVOList   è¦åˆ é™¤çš„业务类型显示对象列表
    * @param autoDeleteTable è‡ªåŠ¨åˆ é™¤è¡¨æ ¼
    * @throws ServiceException å¦‚果业务类型被引用，或者删除出错时会抛出异常
    */
   @Override
   public void batchDelete(List<BtmTypeVO> btmTypeVOList, boolean autoDeleteTable) throws ServiceException {

   }

   /**
    * æ£€æŸ¥ä¸šåŠ¡ç±»åž‹ä¸Žæ•°æ®åº“表是否一致
    *
    * @param pkBtmType ä¸šåŠ¡ç±»åž‹ä¸»é”®
    * @return ä¸åŒçš„属性信息
    * @throws ServiceException å‚数为空或者查询出错时会抛出异常
    */
   @Override
   public List<ModifyAttributeInfo> checkDbTableSame(String pkBtmType) throws ServiceException {
      return null;
   }

   /**
    * èŽ·å–数据库表，支持业务类型和视图
    *
    * @param id ä¸šåŠ¡ç±»åž‹çš„名称
    * @return æ•°æ®åº“表的名称
    * @throws ServiceException å‚数为空的时候会抛出异常
    */
   @Override
   public String getTableName(String id,String domain) throws ServiceException {
      VciBaseUtil.alertNotNull(id,"业务类型英文名称",domain,"领域名称");
      if (domain.contains("ubcs-")){
         domain = domain.split("ubcs-")[1];
      }else {
         throw new VciBaseException("领域名称不符合规则");
      }
      return PL + StringPool.UNDERSCORE + domain + StringPool.UNDERSCORE + id;
   }

   /**
    * æ–°å¢žæˆ–修改业务类型
    *
    * @param btmTypeDTO ä¸šåŠ¡ç±»åž‹é¡µé¢ä¼ è¾“对象
    * @return æ‰§è¡Œç»“æžœ
    */
   @Override
   public R submit(BtmTypeDTO btmTypeDTO, boolean autoCreateTable) {
      TransactionStatus transaction = null;
      DefaultTransactionDefinition def = null;
      if (autoCreateTable) {
         def = new DefaultTransactionDefinition();
         def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
         // äº‹ç‰©éš”离级别，开启新事务，这样会比较安全些。
         transaction = dataSourceTransactionManager.getTransaction(def);
         // èŽ·å¾—事务状态
      }
      checkBtmTypeBeforeSave(btmTypeDTO);
      BtmType btmTypeDO = Optional.ofNullable(BeanUtil.copy(btmTypeDTO, BtmType.class)).orElseGet(BtmType::new);
      List<BtmTypeLinkAttributesDTO> attributes = btmTypeDTO.getAttributes();
      List<BtmTypeAttributeVO> afterAttributes;
      if (StringUtils.isBlank(btmTypeDO.getOid())){
         btmTypeDO = BtmTypeWrapper.build().entityBeforeInsert(btmTypeDO);
         if (StringUtils.isBlank(btmTypeDO.getTableName())) {
            btmTypeDO.setTableName(getTableName(btmTypeDO.getId(),btmTypeDO.getDomain()));
         }
         // æ·»åŠ å±žæ€§
         afterAttributes = addAttributeForBtm(btmTypeDTO);
         baseMapper.insert(btmTypeDO);
      }else {
         BtmTypeVO btmTypeByOid = getBtmTypeByOid(btmTypeDO.getOid());
         List<BtmTypeAttributeVO> beforeAttributes = btmTypeByOid.getAttributes();
         // å¤„理属性，多余的删除，不存在的添加
         afterAttributes = updateAttributeForBtm(btmTypeByOid.getOid(),beforeAttributes, attributes);
      }
      BtmTypeVO btmTypeVO = BtmTypeWrapper.build().entityVO(btmTypeDO);
      btmTypeVO.setAttributes(afterAttributes);
      try {
         if (autoCreateTable) {
            checkTableSame(btmTypeVO);
            R result = DomainRepeater.submitBtmType(btmTypeDTO.getDomain(), btmTypeVO);
            if (result.isSuccess()){
               List<ModifyAttributeInfo> infoList = new ArrayList<>();
               Object data = result.getData();
               if (data instanceof List){
                  List dataList = (List) data;
                  dataList.forEach(s -> {
                     if (s instanceof ModifyAttributeInfo){
                        ModifyAttributeInfo info = (ModifyAttributeInfo) s;
                        infoList.add(info);
                     }
                  });
                  modifyAttributeService.saveBatch(ModifyAttributeWrapper.build().listEntityBeforeSave(infoList));
               }
               dataSourceTransactionManager.commit(transaction);
            }else {
               dataSourceTransactionManager.rollback(transaction);
            }
         }
      } catch (Throwable e) {
         if (autoCreateTable) {
            dataSourceTransactionManager.rollback(transaction);
         }
      }
      return R.data(btmTypeVO);
   }

   /**
    * æ›´æ–°ä¸šåŠ¡ç±»åž‹çš„属性
    * @param oid é€æ¸
    * @param beforeAttr æ›´æ–°å‰çš„属性
    * @param afterAttr æ›´æ–°åŽçš„属性
    */
   private List<BtmTypeAttributeVO> updateAttributeForBtm(String oid, List<BtmTypeAttributeVO> beforeAttr, List<BtmTypeLinkAttributesDTO> afterAttr) {
      List<BtmTypeAttributeVO> deleteList = beforeAttr.stream().filter(before -> afterAttr.stream().noneMatch(after -> StringUtils.equals(before.getId(), after.getId()))).collect(Collectors.toList());
      List<BtmTypeLinkAttributesDTO> addList = afterAttr.stream().filter(after -> beforeAttr.stream().noneMatch(before -> StringUtils.equals(before.getId(), after.getId()))).collect(Collectors.toList());
      List<BtmTypeLinkAttributesDTO> modifyList = new ArrayList<>();
      Map<String, BtmTypeAttributeVO> beforeAttrMap = beforeAttr.stream().collect(Collectors.toMap(BtmTypeAttributeVO::getId, t -> t, (o1, o2) -> o1));
      Map<String, BtmTypeLinkAttributesDTO> afterAttrMap = afterAttr.stream().collect(Collectors.toMap(BtmTypeLinkAttributesDTO::getId, t -> t, (o1, o2) -> o1));
      afterAttrMap.forEach((k,v) -> {
         if (beforeAttrMap.containsKey(k)){
            modifyList.add(v);
         }
      });
      btmTypeAttributeService.checkAndRemove(deleteList.stream().map(BtmTypeAttributeVO::getOid).collect(Collectors.toList()));
      List<BtmTypeAttributeVO> voListAdd = btmTypeAttributeService.checkAndInsert(oid, addList, AuthUtil.getUserAccount(), new Date());
      List<BtmTypeAttributeVO> voListUpdate = btmTypeAttributeService.checkAndUpdate(oid, modifyList, AuthUtil.getUserAccount(), new Date());
      List<BtmTypeAttributeVO> returnList = new ArrayList<>();
      returnList.addAll(Objects.requireNonNull(voListAdd));
      returnList.addAll(Objects.requireNonNull(voListUpdate));
      return returnList;
   }

   /**
    * æ£€æŸ¥ä¸šåŠ¡ç±»åž‹ç¬¦åˆè§„范
    * @param btmTypeDTO ä¸šåŠ¡ç±»åž‹é¡µé¢ä¼ è¾“对象
    */
   private void checkBtmTypeBeforeSave(BtmTypeDTO btmTypeDTO) {
      VciBaseUtil.alertNotNull(btmTypeDTO, "要添加的业务类型", btmTypeDTO.getId(), "业务类型的英文名称", btmTypeDTO.getName(), "业务类型中文名称");
      if (btmTypeDTO.isViewFlag() && (StringUtils.isBlank(btmTypeDTO.getViewCreateSql())
         || StringUtils.isBlank(btmTypeDTO.getTableName()))) {
         throw new VciBaseException("如果当前是业务类型是视图的时候，请必须输入视图的创建语句和视图名称");
      }
      if (!btmTypeDTO.isViewFlag()) {
         VciBaseUtil.alertCollectionNotNull("属性", btmTypeDTO.getAttributes());
      }
      if (!btmTypeDTO.getId().matches(OmdRegExpConstant.LETTER)) {
         throw new VciBaseException("业务类型英文名称只能是纯英文，目前为{0}", new Object[]{btmTypeDTO.getId()});
      }
      if (btmTypeDTO.getId().length() > 24) {
         throw new VciBaseException("业务类型英文名称不能超过18，目前长度为{0}", new Object[]{btmTypeDTO.getId().length()});
      }
      List<BtmType> btmTypeDOList = listBtmTypeDOByIdCollection(VciBaseUtil.str2List(btmTypeDTO.getId()));
      if (!CollectionUtils.isEmpty(btmTypeDOList) && btmTypeDOList.size() > 0) {
         BtmType existBtmType = btmTypeDOList.get(0);
         throw new VciBaseException("业务类型英文名称已经存在（不区分大小写），这个英文名称对应的中文名称为{0},创建人{1},创建时间{2}"
            , new Object[]{existBtmType.getName(), existBtmType.getCreator(), VciDateUtil.date2Str(existBtmType.getCreateTime(), VciDateUtil.DateFormat)});
      }
      if (btmTypeDTO.isRevisionFlag()){
         // éœ€è¦æŽ§åˆ¶ç‰ˆæœ¬
         // æ£€æŸ¥ä½¿ç”¨çš„版本规则是否存在
//            if (StringUtils.isNotBlank(btmTypeDTO.getRevisionRuleId())) {
//               if (revisionRuleServiceI.checkRevisionRuleExist(btmTypeDTO.getRevisionRuleId())) {
//                  throw new VciBaseException("版本规则{0}[{1}]在系统中不存在，请先查证",
//                     new Object[]{btmTypeDTO.getRevisionRuleId(), btmTypeDTO.getRevisionRuleName()});
//               }
//            }
         btmTypeDTO.setAttributes(addAttributeByFieldMap(btmTypeDTO.getAttributes(),BtmTypeFieldConstant.REVISION_MANAGE_FIELD_MAP));
      }
      if (btmTypeDTO.isLifeCycleFlag()){
         // éœ€è¦æŽ§åˆ¶ç”Ÿå‘½å‘¨æœŸ
         //检查使用的生命周期是否存在
//            if (StringUtils.isNotBlank(btmTypeDTO.getLifeCycleId())
//               && !FrameWorkLcStatusConstant.EMTYPE_LIFE_CYCLE.equalsIgnoreCase(btmTypeDTO.getLifeCycleId())) {
//               if (lifeCycleServiceI.checkLifeCycleExist(btmTypeDTO.getLifeCycleId())) {
//                  throw new VciBaseException("生命周期{0}[{1}]在系统中不存在，请先查证",
//                     new Object[]{btmTypeDTO.getLifeCycleId(), btmTypeDTO.getLifeCycleName()});
//               }
//            }
//            if (StringUtils.isNotBlank(btmTypeDTO.getSubLifeCycleId())) {
//               if (lifeCycleServiceI.checkLifeCycleExist(btmTypeDTO.getSubLifeCycleId())) {
//                  throw new VciBaseException("备用生命周期{0}[{1}]中其中有某些在系统中不存在，请先查证",
//                     new Object[]{btmTypeDTO.getSubLifeCycleId(), btmTypeDTO.getSubLifeCycleName()});
//               }
//            }
         btmTypeDTO.setAttributes(addAttributeByFieldMap(btmTypeDTO.getAttributes(),BtmTypeFieldConstant.LIFECYCLE_MANAGE_FIELD_MAP));
      }
      if (btmTypeDTO.isSecretFlag()){
         // éœ€è¦æŽ§åˆ¶å¯†çº§
         btmTypeDTO.setAttributes(addAttributeByFieldMap(btmTypeDTO.getAttributes(),BtmTypeFieldConstant.SECRET_MANAGE_FIELD_MAP));
      }
      if (StringUtils.isBlank(btmTypeDTO.getOid())) {
         btmTypeDTO.setOid(VciBaseUtil.getPk());
      }
   }
   @Override
   public boolean deleteLogic(@NotEmpty List<Long> ids) {
      return false;
   }

   @Override
   public boolean changeStatus(@NotEmpty List<Long> ids, Integer status) {
      return false;
   }
}