Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmEngineServiceImpl.java

@@ -5,7 +5,6 @@
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
import com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant;
@@ -18,13 +17,11 @@
import com.vci.ubcs.code.mapper.CodeWupinMapper;
import com.vci.ubcs.code.mapper.CommonsMapper;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.util.ClientBusinessObject;
import com.vci.ubcs.code.vo.CodeKeyAttrRepeatVO;
import com.vci.ubcs.code.vo.pagemodel.UITableFieldVO;
import com.vci.ubcs.code.vo.pagemodel.UITablePageVO;
import com.vci.ubcs.code.vo.pagemodel.*;
import com.vci.ubcs.omd.constant.BtmTypeLcStatusConstant;
import com.vci.ubcs.omd.entity.BtmTypeAttribute;
import com.vci.ubcs.omd.cache.EnumCache;
import com.vci.ubcs.omd.feign.*;
import com.vci.ubcs.omd.utils.VciOmdUtil;
@@ -37,7 +34,6 @@
import com.vci.ubcs.starter.revision.model.TreeQueryObject;
import com.vci.ubcs.starter.revision.model.TreeWrapperOptions;
import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
import com.vci.ubcs.starter.util.UBCSSqlKeyword;
import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
import com.vci.ubcs.starter.web.constant.RegExpConstant;
import com.vci.ubcs.starter.web.enumpck.BooleanEnum;
@@ -54,16 +50,12 @@
import com.vci.ubcs.system.user.feign.IUserClient;
import net.logstash.logback.encoder.org.apache.commons.lang3.StringUtils;
import oracle.sql.TIMESTAMP;
import org.apache.commons.collections4.MapUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.core.cache.utils.CacheUtil;
import org.springblade.core.launch.constant.AppConstant;
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.DateUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.core.tool.utils.StringPool;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
@@ -82,6 +74,7 @@
import java.time.ZonedDateTime;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.FrameWorkLangCodeConstant.DATA_OID_NOT_EXIST;
@@ -122,7 +115,7 @@
   @Resource
   ISysClient iSysClient;
   /**
    * 系统的服务
    * 密级服务
    */
   @Resource
   private IWebSecretClient secretService;
@@ -341,14 +334,6 @@
   public void changeStatus(BaseModelDTO baseModelDTO) {
      VciBaseUtil.alertNotNull(baseModelDTO, "数据信息", baseModelDTO.getOid(), "主键", baseModelDTO.getBtmname(), "业务类型", baseModelDTO.getLcStatus(), "目标状态");
      List<String> oids = VciBaseUtil.str2List(baseModelDTO.getOid());
//      List<ClientBusinessObject> cboList = boService.selectCBOByOidCollection(oids, baseModelDTO.getBtmname());
      // TODO 插个点 业务类型完成后需要修改
      QueryWrapper<BtmTypeVO> wrapper = new QueryWrapper<>();
      wrapper.eq("BTMNAME",baseModelDTO.getBtmname());
      wrapper.in("OID",oids);
      // TODO 待完善
      //插个点 业务类型完成后需要修改
//      QueryWrapper<BtmTypeVO> wrapper = new QueryWrapper<>();
      List<BaseModel> baseModels = new ArrayList<>();
      baseModels = selectByTypeAndOid(baseModelDTO.getBtmname(), baseModelDTO.getOid());
      if(baseModels.size() == 0){
@@ -368,15 +353,7 @@
      // 回收需要业务数据删除
      if (CodeDefaultLC.TASK_BACK.getValue().equals(baseModelDTO.getLcStatus())) {
         R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(baseModelDTO.getBtmname()));
//         String referTable = listR.getData().get(0).getTableName();
         commonsMapper.deleteByTaleAndOid(listR.getData().get(0).getTableName(),VciBaseUtil.toInSql(baseModelDTO.getOid()));
         // BatchCBO batchCBO = new BatchCBO();
         // batchCBO.getDeleteCbos().addAll(cboList);

         // TODO 待完善
         //btmTypeClient.deleteBatchIds(cboList);

         //boService.persistenceBatch(batchCBO);
      } else {
         for (BaseModel baseModel : baseModels) {
            baseModel.setLcStatus(baseModelDTO.getLcStatus());
@@ -439,11 +416,11 @@
      List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList);


      List<String> charList = new ArrayList<>();
      for (BaseModel baseModel : cboList) {
         charList.add(baseModel.getId());
      }
      batchSaveSelectChar(templateVO, charList);
//      List<String> charList = new ArrayList<>();
//      for (BaseModel baseModel : cboList) {
//         charList.add(baseModel.getId());
//      }
      batchSaveSelectChar(templateVO, cboList);
      return codeList.size() > 0 ? codeList.get(0) : "";
//      return null;
   }
@@ -667,7 +644,7 @@
         } else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
            sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
         }
         sql[0] += " and islastR = '1' and islastV = '1' ";
         sql[0] += " and lastR = '1' and lastV = '1' ";
//         if (boService.queryCountBySql(sql[0], new HashMap<>()) > 0) {
         if (Integer.parseInt(commonsMapper.selectById(sql[0]).get(0)) > 0) {
            String ruleInfoMsg = keyRuleVO == null ? "" : "查询规则：去除空格--{0},忽略大小写--{1},忽略全半角--{2},忽略全部空格--{3}";
@@ -879,7 +856,6 @@
      }
      try {
         String keyPrefix = BTM_INIT_CACHE.concat(StringPool.COLON).concat(AuthUtil.getTenantId()).concat(StringPool.COLON);
//         String finalBtmName = btmName;
         Cache.ValueWrapper valueWrapper = CacheUtil.getCache(keyPrefix).get(keyPrefix.concat(String.valueOf(btmName)));
         if(valueWrapper == null){
            CacheUtil.getCache(keyPrefix).put(keyPrefix.concat(String.valueOf(btmName)), createBaseModel(btmName));
@@ -890,69 +866,9 @@
         logger.error("创建业务类型对象",e);
         throw new VciBaseException("initBtmError",new String[]{btmName});
      }
//      String userName = AuthUtil.getUser().getUserName();
//      CodeWupin wupinEntity = new CodeWupin();
//      wupinEntity.setOid(VciBaseUtil.getPk());
////      bo.setRevisionid((new ObjectUtility()).getNewObjectID36());
////      bo.setNameoid((new ObjectUtility()).getNewObjectID36());
//      wupinEntity.setBtmname(btmName);
//      wupinEntity.setLastR(String.valueOf(1));
//      wupinEntity.setFirstR(String.valueOf(1));
//      wupinEntity.setFirstV(String.valueOf(1));
//      wupinEntity.setLastV(String.valueOf(1));
//      wupinEntity.setCreator(userName);
//      wupinEntity.setCreateTime(new Date());
//      wupinEntity.setLastModifier(userName);
//      wupinEntity.setLastModifyTime(new Date());
//      wupinEntity.setRevisionRule("numberversionrule");
//      wupinEntity.setVersionRule("0");
////      if(StringUtils.isNotBlank(btmTypeVO.getRevisionruleid())){
//         //
////         OsRevisionRuleVO revisionRuleVO = revisionRuleService.getRevisionRuleById(btmTypeVO.getRevisionruleid());
//      wupinEntity.setRevisionValue("1");
////      }
//
//      wupinEntity.setRevisionSeq(1);
//      wupinEntity.setVersionSeq(1);
//      //插个点，需要问勇哥版本问题，展示默认为1
//      wupinEntity.setVersionValue("1");
//      wupinEntity.setLctid("wupinLC");
//      wupinEntity.setLcStatus("Editing");
//      wupinEntity.setId("");
//      wupinEntity.setName("");
//      wupinEntity.setDescription("");
//      wupinEntity.setOwner(userName);
//      wupinEntity.setCheckinby(userName);
//      wupinEntity.setCopyFromVersion("");
//      wupinEntity.setMaterialtype(1001);
//      wupinEntity.setCaigouwl("true");
//      wupinEntity.setShifoupihaoguanli("true");
//      wupinEntity.setKucunwl("true");
//      wupinEntity.setXiaoshouwl("false");
//      wupinEntity.setPassing("true");

//      this.initTypeAttributeValue(wupinEntity,btmTypeVO);
//      return wupinEntity;


//      return cbo;
   }

   /**
    * 是否为修改忽略的属性
    * @param attrName 属性的名字
    * @return true 表示应该忽略
    */
   @Override
   public boolean checkUnAttrUnEdit(String attrName){
      return  (VciQueryWrapperForDO.OID_FIELD.equalsIgnoreCase(attrName)
         ||"ts".equalsIgnoreCase(attrName)
         || "lastmodifier".equalsIgnoreCase(attrName)
         || "lastmodifytime".equalsIgnoreCase(attrName)
         || "createtime".equalsIgnoreCase(attrName)
         || "checkintime".equalsIgnoreCase(attrName)
         ||"checkouttime".equalsIgnoreCase(attrName));
   }


   /**
    * 保存可输可选的信息
@@ -962,7 +878,7 @@
    */
   @Override
   public void batchSaveSelectChar(CodeClassifyTemplateVO templateVO, /*List<ClientBusinessObject> cboList*/
                           List<String> cboList) {
                           List<BaseModel> cboList) {
      if (templateVO != null && !CollectionUtils.isEmpty(cboList)) {
         //是异步的，所以直接循环
         List<CodeClassifyTemplateAttrVO> selectAttrVOs = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getLibraryIdentification())).collect(Collectors.toList());
@@ -970,13 +886,26 @@
         if (!CollectionUtils.isEmpty(selectAttrVOs)) {
//            SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
            selectAttrVOs.parallelStream().forEach(attrVO -> {
               List<String> valuesList = cboList;
//               cboList.parallelStream().forEach(cbo -> {
               List<String> valuesList = new ArrayList<>();
               cboList.parallelStream().forEach(cbo -> {
//                  String value = cbo.get.getAttributeValue(attrVO.getId());
//                  if (StringUtils.isNotBlank(value)) {
//                     valuesList.add(value);
//                  }
//               });

                  //将bean转为map,mybatis统一处理
                  Map<String,String> map = null;

//                  baseModels.stream().forEach(model-> {
                  try {
                     map = VciBaseUtil.convertBean2Map(cbo);
                  } catch (Exception e) {
                     throw new VciBaseException("类型转换错误：" + e.getMessage());
                  }
//                  });

                  String value = map.get(attrVO.getId());
                  if (StringUtils.isNotBlank(value)) {
                     valuesList.add(value);
                  }
               });
               if (!CollectionUtils.isEmpty(valuesList)) {
                  for (String s : valuesList) {
                     DictBiz dictBiz = new DictBiz();
@@ -1797,25 +1726,46 @@
            String field = UBCSSqlKeyword.getColumn(key, "_like");
            if (referFieldMap.containsKey(field)) {
               //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
               return referFieldMap.get(field) + SPACE + "LIKE" + SPACE + "concat(%,"+"concat('" + value + "'" + SPACE+",%)";
               return referFieldMap.get(field) + SPACE + "LIKE" + SPACE + "concat(%,"+"concat(" + value + ",%)" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + " <= " + getStringValueInWhere(field, value, attrVOMap);
               return (field.contains(".") ? "" : "t.") + field + SPACE + "LIKE " + "concat(%,"+"concat(" + getStringValueInWhere(field, value, attrVOMap) + ",%)" + SPACE;
            }
         } else if (key.endsWith("_notequal")) {
            qw.ne(UBCSSqlKeyword.getColumn(key, "_notequal"), v);
            String field = UBCSSqlKeyword.getColumn(key, "_notequal");
            if (referFieldMap.containsKey(field)) {
               //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
               return referFieldMap.get(field) + SPACE + " != '" + value + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + " != " + getStringValueInWhere(field, value, attrVOMap);
            }
         } else if (key.endsWith("_likeleft")) {
            qw.likeLeft(UBCSSqlKeyword.getColumn(key, "_likeleft"), v);
            String field = UBCSSqlKeyword.getColumn(key, "_likeleft");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "LIKE" + SPACE + "concat(%,"+value+")" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "LIKE " + "concat(%,"+getStringValueInWhere(field, value, attrVOMap)+")" + SPACE;
            }
         } else if (key.endsWith("_likeright")) {
            qw.likeRight(UBCSSqlKeyword.getColumn(key, "_likeright"), v);
            String field = UBCSSqlKeyword.getColumn(key, "_likeright");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "LIKE" + SPACE + "concat("+value+",%)" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "LIKE " + "concat("+getStringValueInWhere(field, value, attrVOMap)+",%)" + SPACE;
            }
         } else if (key.endsWith("_notlike")) {
            qw.notLike(UBCSSqlKeyword.getColumn(key, "_notlike"), v);
            String field = UBCSSqlKeyword.getColumn(key, "_notlike");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "NO LIKE" + SPACE + "concat(%,concat("+value+",%)" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "NO LIKE " + "concat(%,concat"+getStringValueInWhere(field, value, attrVOMap)+",%)" + SPACE;
            }
         } else if (key.endsWith("_ge")) {
            String field = UBCSSqlKeyword.getColumn(key, "_ge");
            if (referFieldMap.containsKey(field)) {
               //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
               return referFieldMap.get(field) + SPACE + " >= '" + value + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + " >= " + getStringValueInWhere(value, field, attrVOMap);
               return (field.contains(".") ? "" : "t.") + field + SPACE + " >= '" + getStringValueInWhere(value, field, attrVOMap) + "'" + SPACE;
            }
         } else if (key.endsWith("_le")) {
            //说明是<=的。我们需要先获取一下
@@ -1824,32 +1774,83 @@
               //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
               return referFieldMap.get(field) + SPACE + " <= '" + value + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + " <= " + getStringValueInWhere(field, value, attrVOMap);
               return (field.contains(".") ? "" : "t.") + field + SPACE + " <= '" + getStringValueInWhere(field, value, attrVOMap) + "'" + SPACE;
            }
         } else if (key.endsWith("_gt")) {
            qw.gt(UBCSSqlKeyword.getColumn(key, "_gt"), v);
            String field = UBCSSqlKeyword.getColumn(key, "_gt");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "> '" + value + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "> '" + getStringValueInWhere(field, value, attrVOMap) + "'" + SPACE;
            }
         } else if (key.endsWith("_lt")) {
            qw.lt(UBCSSqlKeyword.getColumn(key, "_lt"), v);
            String field = UBCSSqlKeyword.getColumn(key, "_lt");
            if (referFieldMap.containsKey(field)) {
               //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
               return referFieldMap.get(field) + SPACE + "< '" + value + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "< '" + getStringValueInWhere(field, value, attrVOMap) + "'" + SPACE;
            }
         } else if (key.endsWith("_datege")) {
            qw.ge(UBCSSqlKeyword.getColumn(key, "_datege"), DateUtil.parse(String.valueOf(v), "yyyy-MM-dd HH:mm:ss"));
            String field = UBCSSqlKeyword.getColumn(key, "_datege");
            if (referFieldMap.containsKey(field)) {
               //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
               return referFieldMap.get(field) + SPACE + ">= '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + ">= '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            }
         } else if (key.endsWith("_dategt")) {
            qw.gt(UBCSSqlKeyword.getColumn(key, "_dategt"), DateUtil.parse(String.valueOf(v), "yyyy-MM-dd HH:mm:ss"));
            String field = UBCSSqlKeyword.getColumn(key, "_dategt");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "> '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "> '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            }
         } else if (key.endsWith("_dateequal")) {
            qw.eq(UBCSSqlKeyword.getColumn(key, "_dateequal"), DateUtil.parse(String.valueOf(v), "yyyy-MM-dd HH:mm:ss"));
            String field = UBCSSqlKeyword.getColumn(key, "_dateequal");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "= '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "= '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            }
         } else if (key.endsWith("_datele")) {
            qw.le(UBCSSqlKeyword.getColumn(key, "_datele"), DateUtil.parse(String.valueOf(v), "yyyy-MM-dd HH:mm:ss"));
            String field = UBCSSqlKeyword.getColumn(key, "_datele");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "<= '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "<= '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            }
         } else if (key.endsWith("_datelt")) {
            qw.lt(UBCSSqlKeyword.getColumn(key, "_datelt"), DateUtil.parse(String.valueOf(v), "yyyy-MM-dd HH:mm:ss"));
            String field = UBCSSqlKeyword.getColumn(key, "_datelt");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "< '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "< '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE;
            }
         } else if (key.endsWith("_null")) {
            qw.isNull(UBCSSqlKeyword.getColumn(key, "_null"));
            String field = UBCSSqlKeyword.getColumn(key, "_null");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "IS NULL" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "IS NULL" + SPACE;
            }
         } else if (key.endsWith("_notnull")) {
            qw.isNotNull(UBCSSqlKeyword.getColumn(key, "_notnull"));
            String field = UBCSSqlKeyword.getColumn(key, "_null");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "IS NOT NULL" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "IS NOT NULL" + SPACE;
            }
         } else {
            qw.eq(UBCSSqlKeyword.getColumn(key, "_equal"), v);
            String field = UBCSSqlKeyword.getColumn(key, "_dateequal");
            if (referFieldMap.containsKey(field)) {
               return referFieldMap.get(field) + SPACE + "= '" + value + "'" + SPACE;
            } else {
               return (field.contains(".") ? "" : "t.") + field + SPACE + "= '" + getStringValueInWhere(field, value, attrVOMap)+ "'" + SPACE;
            }
         }

      }*/

      if (key.endsWith("_begin")) {
         //说明是>=的。我们需要先获取一下
         String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
@@ -2069,12 +2070,15 @@
//      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
      //找业务类型，然后使用主键去获取数据库里的数据
//      List<ClientBusinessObject> cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), WebUtil.getOidQuery(orderDTO.getOid()));
      List<BaseModel> cbos = selectByTypeAndOid(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), orderDTO.getOid());

      QueryWrapper<CodeWupin> btmWrapper = new QueryWrapper<>();
      btmWrapper.eq("OID",orderDTO.getOid());
      CodeWupin cbo = codeWupinMapper.selectOne(btmWrapper);

      if (CollectionUtils.isEmpty(cbos)) {
         throw new VciBaseException(DATA_OID_NOT_EXIST);
      }
//      QueryWrapper<CodeWupin> btmWrapper = new QueryWrapper<>();
//      btmWrapper.eq("OID",orderDTO.getOid());
//      CodeWupin cbo = codeWupinMapper.selectOne(btmWrapper);
      BaseModel cbo = cbos.get(0);
//      CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
//      CodeRuleVO ruleVO = ruleService.getObjectHasSecByOid(orderDTO.getCodeRuleOid());

@@ -2112,7 +2116,7 @@
      cbo.setDescription(orderDTO.getDescription());
      cbo.setName(orderDTO.getName());
      try {
         cbo.setDescription(orderDTO.getDescription());
         cbo.setDescription( StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
         cbo.setName(orderDTO.getName());
////         cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
//         cbo.setAttributeValue("name", orderDTO.getName());
@@ -2120,8 +2124,9 @@
         e.printStackTrace();
      }
      cbo.setLastModifyTime(new Date());
      cbo.setLastModifier(AuthUtil.getUser().getUserName());
      codeWupinMapper.updateById(cbo);
      cbo.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
      updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), Collections.singletonList(cbo));
//      codeWupinMapper.updateById(cbo);
//
//      List<CodeWupinEntity> cboList = new ArrayList<>();
//
@@ -2147,7 +2152,8 @@
//      List<ClientBusinessObject> cboList = new ArrayList<>();
//      cboList.add(cbo);
//      boService.persistenceBatch(batchCBO);
      batchSaveSelectChar(templateVO, Arrays.asList(cbo.getId()));
      batchSaveSelectChar(templateVO, Collections.singletonList(cbo));
//      batchSaveSelectChar(templateVO, Arrays.asList(cbo.getId()));
   }

   /**
@@ -2315,67 +2321,77 @@
    */
   @Override
   public R batchUpdateCode(List<CodeOrderDTO> orderDTOList) {
//      VciBaseUtil.alertNotNull(orderDTOList,"编码申请相关的属性内容");
//      orderDTOList.forEach(orderDTO -> {
//         VciBaseUtil.alertNotNull(orderDTO, "编码申请相关的属性的内容都为空", orderDTO.getOid(), "数据主键",
//            orderDTO.getCodeClassifyOid(), "主题库分类的主键");
//      });
//      Map<String, CodeOrderDTO> orderDTOMap = orderDTOList.stream().filter(orderDTO -> orderDTO != null && StringUtils.isNotBlank(orderDTO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
//      List<ClientBusinessObject> updateList = new ArrayList<>();
//      // 应该都是一个分类下的业务数据，找第一条的就行
//      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTOList.get(0).getCodeClassifyOid());
      VciBaseUtil.alertNotNull(orderDTOList,"编码申请相关的属性内容");
      orderDTOList.forEach(orderDTO -> {
         VciBaseUtil.alertNotNull(orderDTO, "编码申请相关的属性的内容都为空", orderDTO.getOid(), "数据主键",
            orderDTO.getCodeClassifyOid(), "主题库分类的主键");
      });
      Map<String, CodeOrderDTO> orderDTOMap = orderDTOList.stream().filter(orderDTO -> orderDTO != null && StringUtils.isNotBlank(orderDTO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
      List<BaseModel> updateList = new ArrayList<>();
      // 应该都是一个分类下的业务数据，找第一条的就行
      CodeClassifyFullInfoBO topClassifyFullInfo = classifyService.getClassifyFullInfo(orderDTOList.get(0).getCodeClassifyOid());
//      Map<String,String> cboOidMap = new HashMap<>();
//      if (CollectionUtils.isEmpty(orderDTOMap.keySet())){
//         throw new VciBaseException(DATA_OID_NOT_EXIST);
//      }
      if (CollectionUtils.isEmpty(orderDTOMap.keySet())){
         throw new VciBaseException(DATA_OID_NOT_EXIST);
      }

      List<BaseModel> cboList = selectByTypeAndOid(topClassifyFullInfo.getTopClassifyVO().getBtmtypeid(), VciBaseUtil.array2String(orderDTOMap.keySet().toArray(new String[0])));
//      cboOidMap.put("oid",QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(orderDTOMap.keySet().toArray(new String[0])) + ")");
//      List<ClientBusinessObject> cboList = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), cboOidMap);
//      if (CollectionUtils.isEmpty(cboList)){
//         throw new VciBaseException(DATA_OID_NOT_EXIST);
//      }
      if (CollectionUtils.isEmpty(cboList)){
         throw new VciBaseException(DATA_OID_NOT_EXIST);
      }
//      BatchCBO batchCBO = new BatchCBO();
//      CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid());
//      Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
//      orderDTOMap.keySet().stream().forEach(oid -> {
//         CodeOrderDTO orderDTO = orderDTOMap.get(oid);
//         ClientBusinessObject cbo = cboMap.get(oid);
//         if (!cbo.getTs().contains(VciDateUtil.date2Str(orderDTO.getTs(), VciDateUtil.DateTimeFormat))) {
//            throw new VciBaseException("数据不是最新的，可能他人已经修改，请刷新后再试");
//         }
//         if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
//            throw new VciBaseException("数据不是{0}的状态，不允许修改", new String[]{CodeDefaultLC.EDITING.getText()});
//         }
//         //1. 判断必输项
//         CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
//         checkRequiredAttrOnOrder(templateVO, orderDTO);
//         //2.先注入，再组合，最后校验
//         switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
//         //3.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
//         switchComponentAttrOnOrder(templateVO, orderDTO);
//         //4.校验规则
//         checkVerifyOnOrder(templateVO, orderDTO);
//         //5.判断关键属性
//         checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
//         //6.校验枚举的内容是否正确
//         checkEnumOnOrder(templateVO, orderDTO);
//         //7.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
//         switchDateAttrOnOrder(templateVO, orderDTO);
//         //默认的内容不能变，所以只需要拷贝自定义的相关属性即可
//         copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
//         //企业码和集团码的不修改
//         cbo.setDescription(orderDTO.getDescription());
//         cbo.setName(orderDTO.getName());
      Map<String, BaseModel> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
      orderDTOMap.keySet().stream().forEach(oid -> {
         CodeOrderDTO orderDTO = orderDTOMap.get(oid);
         CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
         CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid());
         BaseModel cbo = cboMap.get(oid);
         String code=cbo.getId();
         if (!cbo.getTs().toString().contains(orderDTO.getTs().toString())) {
            throw new VciBaseException("数据不是最新的，可能他人已经修改，请刷新后再试");
         }
         if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
            throw new VciBaseException("数据不是{0}的状态，不允许修改", new String[]{CodeDefaultLC.EDITING.getText()});
         }
         //1. 判断必输项
         CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
         checkRequiredAttrOnOrder(templateVO, orderDTO);
         //2.先注入，再组合，最后校验
         switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
         //3.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
         switchComponentAttrOnOrder(templateVO, orderDTO);
         //4.校验规则
         checkVerifyOnOrder(templateVO, orderDTO);
         //5.判断关键属性
         checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
         //6.校验枚举的内容是否正确
         checkEnumOnOrder(templateVO, orderDTO);
         //7.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
         switchDateAttrOnOrder(templateVO, orderDTO);
         //默认的内容不能变，所以只需要拷贝自定义的相关属性即可
         copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
         //企业码和集团码的不修改
         cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
         cbo.setName(orderDTO.getName());
//         try {
//            cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
//            cbo.setAttributeValue("id",code);
         cbo.setId(code);
         cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
//            cbo.setAttributeValueWithNoCheck("description", StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
//            cbo.setAttributeValue("name", orderDTO.getName());
         cbo.setName(orderDTO.getName());
//         } catch (VCIError e) {
//            e.printStackTrace();
//         }
//         batchCBO.getUpdateCbos().add(cbo);
//         updateList.add(cbo);
//      });
         updateList.add(cbo);
         batchSaveSelectChar(firstTemplateVO, cboList);
      });
//      boService.persistenceBatch(batchCBO);
//      batchSaveSelectChar(firstTemplateVO, cboList);
      updateBatchByBaseModel(topClassifyFullInfo.getTopClassifyVO().getBtmtypeid(),updateList);
      return R.success("操作成功！");
   }

@@ -2458,64 +2474,76 @@
    */
   @Override
   public void upSaveCode(CodeOrderDTO orderDTO) {
      VciBaseUtil.alertNotNull(orderDTO, "编码数据所在业务类名称", orderDTO.getBtmname());
      String btmName=orderDTO.getBtmname();
      //找业务类型，然后使用主键去获取数据库里的数据
      List<BaseModel> cbos = selectByTypeAndOid(btmName, orderDTO.getCopyFromVersion());
      if (CollectionUtils.isEmpty(cbos)) {
         throw new VciBaseException(DATA_OID_NOT_EXIST);
      }
      BaseModel oldCbo = cbos.get(0);

      if (!CodeDefaultLC.RELEASED.getValue().equalsIgnoreCase(oldCbo.getLcStatus())) {
         throw new VciBaseException("数据不是{0}的状态，不允许数据更改", new String[]{CodeDefaultLC.RELEASED.getText()});
      }

      //根据数据获取分类oid
      String codeClassifyOid=oldCbo.getData().get(CODE_CLASSIFY_OID_FIELD.toUpperCase());
      orderDTO.setCodeClassifyOid(codeClassifyOid);
      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
      CodeClassifyTemplateVO templateVO= this.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
      orderDTO.setTemplateOid(templateVO.getOid());
      VciBaseUtil.alertNotNull(orderDTO, "编码申请相关的属性的内容为空", orderDTO.getCopyFromVersion(), "原始数据的主键",
         orderDTO.getCodeClassifyOid(), "主题库分类的主键");
      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
      //找业务类型，然后使用主键去获取数据库里的数据
//      List<ClientBusinessObject> cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), WebUtil.getOidQuery(orderDTO.getCopyFromVersion()));
//      if (CollectionUtils.isEmpty(cbos)) {
//         throw new VciBaseException(DATA_OID_NOT_EXIST);
//      }
//      ClientBusinessObject oldCbo = cbos.get(0);
//      if (!CodeDefaultLC.RELEASED.getValue().equalsIgnoreCase(oldCbo.getLcStatus())) {
//         throw new VciBaseException("数据不是{0}的状态，不允许数据更改", new String[]{CodeDefaultLC.RELEASED.getText()});
//      }
//      //需要升版

      //需要升版
//      ClientBusinessObjectOperation cboOperation = new ClientBusinessObjectOperation();
//      ClientBusinessObject cbo = null;
      BaseModel cbo = null;
//      try {
//         //cbo = cboOperation.createBusinessObjectVersion(oldCbo,VciBaseUtil.getCurrentUserId());
//         cbo = cboOperation.reviseBusinessObject(oldCbo, "");
      cbo = reviseBusinessObject(oldCbo);
//      } catch (VCIError e) {
//         throw new VciBaseException("初始化相关的内容出现了错误", new String[0], e);
//      }
//      //1. 判断必输项
//      CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
//      checkRequiredAttrOnOrder(templateVO, orderDTO);
//      //2.先注入，再组合，最后校验
//      switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
//      //3.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
//      switchComponentAttrOnOrder(templateVO, orderDTO);
//      //4.校验规则
//      checkVerifyOnOrder(templateVO, orderDTO);
//      //5.判断关键属性
//      checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
//      //6.校验枚举的内容是否正确
//      checkEnumOnOrder(templateVO, orderDTO);
//      //7.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
//      switchDateAttrOnOrder(templateVO, orderDTO);
//      //默认的内容不能变，所以只需要拷贝自定义的相关属性即可
//      copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
//      //企业码和集团码的不修改
//      cbo.setDescription(orderDTO.getDescription());
//      cbo.setName(orderDTO.getName());
      //1. 判断必输项
      //CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
      checkRequiredAttrOnOrder(templateVO, orderDTO);
      //2.先注入，再组合，最后校验
      switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
      //3.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
      switchComponentAttrOnOrder(templateVO, orderDTO);
      //4.校验规则
      checkVerifyOnOrder(templateVO, orderDTO);
      //5.判断关键属性
      checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
      //6.校验枚举的内容是否正确
      checkEnumOnOrder(templateVO, orderDTO);
      //7.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
      switchDateAttrOnOrder(templateVO, orderDTO);
      //默认的内容不能变，所以只需要拷贝自定义的相关属性即可
      copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
      //企业码和集团码的不修改
      cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
      cbo.setName(orderDTO.getName());
//      try {
//         cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
//         cbo.setAttributeValue("name", orderDTO.getName());
      cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
//      cbo.setAttributeValueWithNoCheck("description", StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
      cbo.setName(orderDTO.getName());
//      } catch (VCIError e) {
//         e.printStackTrace();
//      }
//      //数据的时候，编码是不变的
//      cbo.setCreateTime(DateUtils.convert2String(new Date(Long.parseLong(cbo.getCreateTime())), "yyyy-MM-dd HH:mm:ss"));
//      cbo.setLastModifyTime(DateUtils.convert2String(new Date(Long.parseLong(cbo.getLastModifyTime())), "yyyy-MM-dd HH:mm:ss"));
      //数据的时候，编码是不变的
      cbo.setCreateTime(cbo.getCreateTime());
      cbo.setLastModifyTime(cbo.getLastModifyTime());
//      List<ClientBusinessObject> cboList = new ArrayList<>();
//      cboList.add(cbo);
//      try {
      try {
//         cboOperation.saveRevisionBuinessObject(cbo);
//      } catch (VCIError vciError) {
//         throw new VciBaseException("数据更改保存出错了", new String[0], vciError);
//      }
//      batchSaveSelectChar(templateVO, cboList);
         insertBatchByType(cbo.getBtmname(), Collections.singletonList(cbo));
      } catch (Exception vciError) {
         throw new VciBaseException("数据更改保存出错了", new String[0], vciError);
      }
      batchSaveSelectChar(templateVO, Collections.singletonList(cbo));
   }

   /**
@@ -3425,6 +3453,7 @@
      return revisionModelUtil.doList2Trees(codeClassifies, treeWrapperOptions, null);
   }


   private String getTableName(String refertype){
      if ("codeclassify".equals(refertype)){
         return "pl_code_classify";
@@ -3438,4 +3467,45 @@

      return "pl_code_"+refertype.trim().toLowerCase();
   }

   public BaseModel reviseBusinessObject(BaseModel fromBo) {
      BaseModel toBo = new BaseModel();
//      Map<String,String> data = new HashMap<>();
//      toBo.getData().put(data);
      toBo.setOid(VciBaseUtil.getPk());
      toBo.setRevisionOid(VciBaseUtil.getPk());
      toBo.setNameOid(fromBo.getNameOid());
      toBo.setBtmname(fromBo.getBtmname());
      toBo.setLastR(String.valueOf(1));
      toBo.setFirstR(String.valueOf(0));
      toBo.setFirstV(String.valueOf(1));
      toBo.setLastV(String.valueOf(1));
      toBo.setCreator(String.valueOf(AuthUtil.getUser().getUserId()));
      toBo.setCreateTime(new Date());
      toBo.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
      toBo.setLastModifyTime(new Date());
      toBo.setRevisionRule(fromBo.getRevisionRule());
      toBo.setVersionRule(fromBo.getVersionRule());
//      RevisionValueObject rvObj = this.getNextRevision(fromBo.getBtmName(), fromBo.getNameoid(), item.revRuleName, item.revInput, revisionVal);
      R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(fromBo.getBtmname()));
      Map<String, Object> nextRevision = commonsMapper.getNextRevision(listR.getData().get(0).getTableName(), fromBo.getNameOid());
      toBo.setRevisionSeq(Integer.parseInt(nextRevision.get("REVISIONSEQ").toString()));
      toBo.setRevisionValue(nextRevision.get("REVISIONVAL").toString());
//      VersionValueObject versionObj = this.getVersionValue(item.verRuleName);
      toBo.setVersionSeq(Integer.valueOf(nextRevision.get("VERSIONSEQ").toString()));
      toBo.setVersionValue(nextRevision.get("VERSIONVAL").toString());
      toBo.setLctid(fromBo.getLctid());
      toBo.setLcStatus("Editing");
      toBo.setId(fromBo.getId());
      toBo.setName(fromBo.getName());
      toBo.setDescription(fromBo.getDescription());
      toBo.setOwner(String.valueOf(AuthUtil.getUser().getUserId()));
//      toBo.setCheckinBy(String.valueOf(AuthUtil.getUser().getUserId()));
      toBo.setCopyFromVersion(fromBo.getOid());
      toBo.getData().putAll(fromBo.getData());
      toBo.getData().put("CHECKINBY",String.valueOf(AuthUtil.getUser().getUserId()));
//      this.initRevisionTypeAttributeValue(fromBo, toBo);
      return toBo;

   }
}