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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,1811 @@
package com.vci.ubcs.code.service.impl;
import com.alibaba.cloud.commons.lang.StringUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.entity.CodeAllCode;
import com.vci.ubcs.code.mapper.CodeAllCodeMapper;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
import com.vci.ubcs.starter.exception.VciBaseException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
//


/**
 * ä¸»æ•°æ®å¼•æ“ŽæœåŠ¡
 *
 * @author weidy
 * @date 2022-2-22
 */
@Slf4j
@Service
public class MdmEngineServiceImpl extends ServiceImpl<CodeAllCodeMapper, CodeAllCode> implements MdmEngineService {
//
//
//   /**
//    * åˆ†ç±»çš„服务
//    */
//   @Resource
//   private ICodeClassifyService classifyService;
//
//   /**
//    * å…³é”®å±žæ€§çš„配置
//    */
//   @Autowired
//   private ICodeKeyattrrepeatService keyRuleService;
//   /**
//    * æ—¥å¿—
//    */
//   private Logger logger = LoggerFactory.getLogger(getClass());
//
//   //   @Autowired
//   //   private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
//
   /**
    * æ¨¡æ¿çš„服务
    */
   @Autowired(required = false)
   private ICodeClassifyTemplateAttrService codeClassifyTemplateAttrService;

   /***
    * ç¼–码规则服务
    */
   @Autowired(required = false)
   private ICodeRuleService codeRuleService;
   /**
    * ä½¿ç”¨åˆ†ç±»çš„主键获取可以使用的模板对象
    *
    * @param codeClassifyOid åˆ†ç±»çš„主键
    * @return æ¨¡æ¿çš„显示对象
    */
   @Override
   public CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid) {
      return getUsedTemplateByClassifyOid(codeClassifyOid, true);
   }
//
   /**
    * ä½¿ç”¨åˆ†ç±»çš„主键获取可以使用的模板对象
    *
    * @param codeClassifyOid åˆ†ç±»çš„主键
    * @param hasAttr         åŒ…含属性
    * @return æ¨¡æ¿çš„显示对象
    */
   @Override
   public CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr) {
      List<CodeClassifyTemplateVO> templateVOs=new ArrayList<>();
      //templateVOs = codeClassifyTemplateAttrService.listReleaseTemplateByClassifyOid(codeClassifyOid, hasAttr);
      return templateVOs.get(templateVOs.size() - 1);
   }


   /**
    * ä½¿ç”¨åˆ†ç±»çš„全部信息获取编码规则
    *
    * @param fullInfoBO åˆ†ç±»çš„全部信息
    * @return è§„则的内容
    */
   @Override
   public CodeRuleVO getCodeRuleByClassifyFullInfo(CodeClassifyFullInfoBO fullInfoBO) {
      //往上找
      String codeRuleOid = "";
      if (StringUtils.isNotBlank(fullInfoBO.getCurrentClassifyVO().getCoderuleoid())) {
         codeRuleOid = fullInfoBO.getCurrentClassifyVO().getCoderuleoid();
      } else {
         if (CollectionUtils.isEmpty(fullInfoBO.getParentClassifyVOs())) {
            //说明已经是最高层级,
            throw new VciBaseException("当前主题库分类，以及它的所有的上级分类都没有设置编码规则");
         }
         List<CodeClassifyVO> parentClassifyVOList = fullInfoBO.getParentClassifyVOs().stream().sorted((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel())).collect(Collectors.toList());
         //从最高的level开始获取
         for (int i = 0; i < parentClassifyVOList.size(); i++) {
            CodeClassifyVO record = parentClassifyVOList.get(i);
            if (StringUtils.isNotBlank(record.getCoderuleoid())) {
               codeRuleOid = record.getCoderuleoid();
               break;
            }
         }
         if (StringUtils.isBlank(codeRuleOid)) {
            throw new VciBaseException("当前主题库分类，以及它的所有的上级分类都没有设置编码规则");
         }
      }
      return codeRuleService.getObjectHasSecByOid(codeRuleOid);
   }
//
//   /**
//    * èŽ·å–枚举的下拉选项
//    *
//    * @param attrVO æ¨¡æ¿å±žæ€§çš„对象
//    * @return ä¸‹æ‹‰é€‰é¡¹
//    */
//   @Override
//   public List<KeyValue> listComboboxItems(CodeClassifyTemplateAttrVO attrVO) {
//      List<KeyValue> comboboxKVs = null;
//      if (StringUtils.isNotBlank(attrVO.getEnumString())) {
//         comboboxKVs = JSONObject.parseArray(attrVO.getEnumString(), KeyValue.class);
//      } else {
////         comboboxKVs = enumService.getEnum(attrVO.getEnumid());
////          Dict dict = new Dict();
////         dict.setParentId(Long.valueOf(attrVO.getEnumid()));
//         R<List<DictBiz>> list = iDictBizClient.getList(attrVO.getEnumId());
//         if(list.isSuccess()){
//            for (DictBiz datum : list.getData()) {
//               KeyValue keyValue = new KeyValue();
//               keyValue.setKey(datum.getDictKey());
//               keyValue.setValue(datum.getDictValue());
//               comboboxKVs.add(keyValue);
//            }
//         }
//      }
//      return comboboxKVs;
//   }
//   /**
//    * ä¿®æ”¹çŠ¶æ€
//    *
//    * @param baseModelDTO æ•°æ®ä¼ è¾“对象
//    */
//   @Override
//   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());
//      //插个点 ä¸šåŠ¡ç±»åž‹å®ŒæˆåŽéœ€è¦ä¿®æ”¹
//      QueryWrapper<CodeOsbtmtypeEntity> wrapper = new QueryWrapper<>();
//      wrapper.eq("BTMNAME",baseModelDTO.getBtmname());
//      wrapper.in("OID",oids);
//      List<CodeOsbtmtypeEntity> cboList = codeOsbtmtypeMapper.selectList(wrapper);
//      //还需要修改allCode的生命周期
////      Map<String, String> conditionMap = new HashMap<>();
//      QueryWrapper<CodeAllCode> allCodeWrapper = new QueryWrapper<>();
//      allCodeWrapper.eq("createcodebtm",baseModelDTO.getBtmname());
//      allCodeWrapper.in("createcodeoid",oids);
////      conditionMap.put("createcodeoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
////      conditionMap.put("createcodebtm", baseModelDTO.getBtmname());
//      List<CodeAllCode> codeCbos = baseMapper.selectList(allCodeWrapper);
////      List<ClientBusinessObject> codeCbos = boService.queryCBO(MdmBtmTypeConstant.CODE_ALL_CODE, conditionMap);
//      // å›žæ”¶éœ€è¦ä¸šåŠ¡æ•°æ®åˆ é™¤
////      if (CodeDefaultLC.TASK_BACK.getValue().equals(baseModelDTO.getLcStatus())) {
//////         BatchCBO batchCBO = new BatchCBO();
//////         batchCBO.getDeleteCbos().addAll(cboList);
////         codeOsbtmtypeMapper.deleteBatchIds(cboList);
//////         boService.persistenceBatch(batchCBO);
////      } else {
////         lifeCycleService.transCboStatus(cboList, baseModelDTO.getLcStatus());
////      }
////      lifeCycleService.transCboStatus(codeCbos, baseModelDTO.getLcStatus());
//   }
//
//
//   /**
//    * ç”³è¯·å•ä¸€ç¼–码
//    *
//    * @param orderDTO ç”³è¯·çš„信息，需要包含属性的内容和码段相关的内容
//    * @return è¿”回编码的内容
//    */
//   @Override
//   public String addSaveCode(CodeOrderDTO orderDTO) {
//      VciBaseUtil.alertNotNull(orderDTO, "编码申请相关的属性和码段的内容都为空", orderDTO.getCodeClassifyOid(), "主题库分类的主键",
//         orderDTO.getTemplateOid(), "模板的主键", orderDTO.getCodeRuleOid(), "编码规则的主键");
//      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
//      CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
//      CodeRuleVO ruleVO = ruleService.getObjectHasSecByOid(orderDTO.getCodeRuleOid());
//      //1.判断规则中除了流水码段，是否有其他码段
//      checkSecValueOnOrder(ruleVO, orderDTO);
//      //2.判断必输项
//      checkRequiredAttrOnOrder(templateVO, orderDTO);
//      //3.先注入，再组合，最后校验
//      switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
//      //4.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
//      switchComponentAttrOnOrder(templateVO, orderDTO);
//      //5.校验规则
//      checkVerifyOnOrder(templateVO, orderDTO);
//      //6.关键属性
//      checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
//      //7.枚举转换
//      checkEnumOnOrder(templateVO, orderDTO);
//      //8.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
//      switchDateAttrOnOrder(templateVO, orderDTO);
//      //9.生成编码的信息
////      ClientBusinessObject cbo = boService.createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
////      CodeWupinEntity cbo = createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
//////      //默认的属性都不用从前端拷贝
//////      //设置编码需要的默认属性的内容
////      copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, false);
//////      //TODO:因为默认的属性都不拷贝，目前集团码叫name，并没有从DTO拷贝到cbo里。增加一个单独处理，以后再看要不要调整
////      cbo.setName(orderDTO.getName() == null ? "" : orderDTO.getName());
//////      //end -- modify by lihang @20220407
////      List<CodeWupinEntity> cboList = new ArrayList<>();
////
////      //备注
////      cbo.setDescription(orderDTO.getDescription());
////
////      cboList.add(cbo);
////      List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList);
////
////
////      List<String> charList = new ArrayList<>();
////      for (CodeWupinEntity wupinEntity : cboList) {
////         charList.add(wupinEntity.getId());
////      }
////      batchSaveSelectChar(templateVO, charList);
////      return codeList.size() > 0 ? codeList.get(0) : "";
//////      return null;
////   }
////
////   /**
////    * å¤„理分类注入的信息
////    *
////    * @param templateVO         æ¨¡æ¿çš„显示对象，必须要后模板的属性
////    * @param classifyFullInfoBO åˆ†ç±»çš„全路径
////    * @param orderDTO           ç¼–码申请的信息
////    */
////   private void switchClassifyLevelOnOrder(CodeClstemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO) {
////      Map<String,CodeClstempattrVO> classifyAttrVOMap = templateVO.getAttributes().stream().filter(
////         s -> StringUtils.isNotBlank(s.getClassifyinvokeattr()) && StringUtils.isNotBlank(s.getClassifyinvokelevel())
////      ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////      if (classifyFullInfoBO.getTopClassifyVO() == null) {
////         //需要重新查询一下，因为这个是指定的分类进来的
////
////      }
////      if (!CollectionUtils.isEmpty(classifyAttrVOMap)) {
////         classifyAttrVOMap.forEach((attrId, attrVO) -> {
////            //分类注入的编号或者名称，
////            //层级包含指定层和最小层
////            CodeClassifyVO classifyVO = null;
////            if (!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyinvokelevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyinvokelevel())) {
////               //指定了层级的
////               //注意，因为查询上级分类出来的层级是倒序的，即顶层节点是最大的值
////               List<CodeClassifyVO> classifyVOS = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
////               int level = VciBaseUtil.getInt(attrVO.getClassifyinvokelevel());
////               if (classifyVOS.size() >= level && level > 0) {
////                  classifyVO = classifyVOS.get(level - 1);
////               }
////            } else {
////               //当前的分类
////               classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
////            }
////            if (classifyVO == null) {
////               //说明层级有误
////               orderDTO.getData().put(attrId, "分类树上没有层级[" + attrVO.getClassifyinvokelevel() + "]");
////               // classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
////            } else {
////               Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
////               String value = classifyDataMap.getOrDefault(attrVO.getClassifyinvokeattr(), "");
////               orderDTO.getData().put(attrId, value);
////            }
////         });
////      }
////   }
////
////
////   /**
////    * åˆ¤æ–­ç¼–码的码段是否输入或者选择了码值
////    *
////    * @param ruleVO   è§„则的显示对象
////    * @param orderDTO ç¼–码申请的内容
////    */
////   @Override
////   public void checkSecValueOnOrder(CodeRuleVO ruleVO, CodeOrderDTO orderDTO) {
////      List<String> unSerialSecOidList = ruleVO.getSecVOList().stream().filter(
////         s -> !(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue().equalsIgnoreCase(s.getSecType())
////            || CodeSecTypeEnum.CODE_ATTR_SEC.getValue().equalsIgnoreCase(s.getSecType())
////            || CodeSecTypeEnum.CODE_DATE_SEC.getValue().equalsIgnoreCase(s.getSecType())
////            || CodeSecTypeEnum.CODE_LEVEL_SEC.getValue().equalsIgnoreCase(s.getSecType())
////            || VciBaseUtil.getBoolean(s.getNullableFlag()))
////      ).map(CodeBasicSecVO::getOid).collect(Collectors.toList());
////      if (!CollectionUtils.isEmpty(unSerialSecOidList)) {
////         if (CollectionUtils.isEmpty(orderDTO.getSecDTOList())) {
////            throw new VciBaseException("非流水码段(或者必输码段）必须要输入(或选择)码值");
////         }
////         if (orderDTO.getSecDTOList().stream().anyMatch(s -> !unSerialSecOidList.contains(s.getSecOid())
////            && StringUtils.isBlank(s.getSecValue()))) {
////            throw new VciBaseException("非流水码段(或者必输码段）必须要输入(或选择)码值");
////         }
////      }
////   }
////
////   /**
////    * æ ¡éªŒå±žæ€§æ˜¯å¦ä¸ºå¿…输
////    *
////    * @param templateVO æ¨¡æ¿çš„显示对象，需要包含模板属性
////    * @param orderDTO   ç¼–码申请的信息
////    */
////   private void checkRequiredAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////      Map<String, CodeClstempattrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(
////            s -> VciBaseUtil.getBoolean(s.getRequireflag()) && StringUtils.isBlank(s.getComponentrule())
////               && StringUtils.isBlank(s.getClassifyinvokeattr()))
////         .collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////      if (!CollectionUtils.isEmpty(requiredAttrMap)) {
////         requiredAttrMap.forEach((attrId, attrVO) -> {
////            //只有企业编码，状态，备注，模板主键，分类主键这几个是固定的，其余都是自行配置的
////            if (StringUtils.isBlank(getValueFromOrderDTO(orderDTO, attrId))) {
////               throw new VciBaseException("属性【{0}】必须要输入(选择)内容", new String[]{attrVO.getName()});
////            }
////         });
////      }
////   }
////
////   /**
////    * ä»Žç¼–码申请信息对象上获取某个属性的值
////    *
////    * @param orderDTO ç¼–码申请对象
////    * @param attrId   å±žæ€§çš„编号
////    * @return å€¼
////    */
////   private String getValueFromOrderDTO(CodeOrderDTO orderDTO, String attrId) {
////      attrId = attrId.toLowerCase(Locale.ROOT);
////      String value = null;
////      if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
////         value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
////      } else {
////         //说明是自行配置的
////         //前端必须要传递小写的属性
////         value = orderDTO.getData().getOrDefault(attrId, "");
////      }
////      return value;
////   }
////
////   /**
////    * è½¬æ¢ç»„合规则的值
////    *
////    * @param templateVO æ¨¡æ¿çš„显示对象，需要包含模板属性
////    * @param orderDTO   ç¼–码申请的信息
////    */
////   private void switchComponentAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////      Map<String, CodeClstempattrVO> compAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getComponentrule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////      if (!CollectionUtils.isEmpty(compAttrVOMap)) {
////         Map<String, String> dataMap = WebUtil.objectToMapString(orderDTO);
////
////         Map<String, String> dataLowMap = new HashMap<>();
////         if (!CollectionUtils.isEmpty(dataMap)) {
////            dataMap.forEach((key, value) -> {
////               dataLowMap.put(key.toLowerCase(Locale.ROOT), value);
////            });
////         }
////         dataLowMap.putAll(orderDTO.getData());
////         compAttrVOMap.forEach((attrId, attrVO) -> {
////            dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentrule()));
////         });
////         dataLowMap.forEach((key, value) -> {
////            setValueToOrderDTO(orderDTO, key, value);
////         });
////      }
////   }
////
////
////   /**
////    * è®¾ç½®æ–°çš„值到申请对象上
////    *
////    * @param orderDTO ç¼–码申请对象
////    * @param attrId   å±žæ€§çš„编号
////    * @param value    å€¼
////    */
////   private void setValueToOrderDTO(CodeOrderDTO orderDTO, String attrId, String value) {
////      attrId = attrId.toLowerCase(Locale.ROOT);
////      if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
////         WebUtil.setValueToField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO, value);
////      } else {
////         orderDTO.getData().put(attrId, value);
////      }
////   }
////
////   /**
////    * æ ¡éªŒæ­£åˆ™è¡¨è¾¾å¼æ˜¯å¦æ­£ç¡®
////    *
////    * @param templateVO æ¨¡æ¿çš„信息，必须包含属性的内容
////    * @param orderDTO   ç¼–码申请的相关的信息
////    */
////   private void checkVerifyOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////      Map<String, CodeClstempattrVO> verifyAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getVerifyrule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////      if (!CollectionUtils.isEmpty(verifyAttrVOMap)) {
////         verifyAttrVOMap.forEach((attrId, attrVO) -> {
////            String value = getValueFromOrderDTO(orderDTO, attrId);
////            if (StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyrule())) {
////               //校验正则表达式
////               throw new VciBaseException("属性[{0}]的值不符合校验规则的要求", new String[]{attrVO.getName()});
////            }
////         });
////      }
////   }
////
////   /**
////    * æ ¡éªŒå…³é”®å±žæ€§
////    *
////    * @param classifyFullInfo åˆ†ç±»çš„全部信息
////    * @param templateVO       æ¨¡æ¿çš„内容，必须包含模板属性
////    * @param orderDTO         ç¼–码申请的相关的信息
////    */
////   private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////      //先获取关键属性的规则，也利用继承的方式
////      CodeKeyattrrepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
////      //注意的是keyRuleVO可能为空，表示不使用规则控制
////      //获取所有的关键属性
////      Map<String, CodeClstempattrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyattrflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////      Map<String, String> conditionMap = new HashMap<>();
////      boolean trimAll = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
////      //全部去空的优先级大于去空
////      boolean trim = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
////      boolean ignoreCase = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
////      boolean ignoreWidth = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
////      ketAttrMap.forEach((attrId, attrVO) -> {
////         String value = getValueFromOrderDTO(orderDTO, attrId);
////         if (value == null) {
////            value = "";
////         }
////         wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
////      });
////
////      //没有限制分类，但是一个模板只可能在一个业务类型里面，所以直接查询这个业务类型即可
////
////      if (!CollectionUtils.isEmpty(conditionMap)) {
////         final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()) + " t where 1 = 1 "};
////         conditionMap.forEach((key, value) -> {
////            sql[0] += " and " + key + " = " + value;
////         });
////         if (StringUtils.isNotBlank(orderDTO.getOid())) {
////            //修改的时候，需要排除自己
////            sql[0] += " and oid != '" + orderDTO.getOid() + "'";
////         } else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
////            sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
////         }
////         sql[0] += " and islastR = '1' and islastV = '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}";
////            String[] objs = new String[]{trim ? "是" : "否", ignoreCase ? "是" : "否", ignoreWidth ? "是" : "否", trimAll ? "是" : "否"};
////            throw new VciBaseException("根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了。请修正!。" + ruleInfoMsg, objs);
////         }
////      }
////   }
////
////   /**
////    * å°è£…关键属性的查询语句
////    *
////    * @param value        å½“前的值
////    * @param keyRuleVO    å…³é”®å±žæ€§çš„控制规则，可以为空
////    * @param attrId       å±žæ€§çš„编号
////    * @param trim         æ˜¯å¦åŽ»é™¤ç©ºæ ¼
////    * @param ignoreCase   æ˜¯å¦ä¸åŒºåˆ†å¤§å°å†™
////    * @param ignoreWidth  æ˜¯å¦å¿½ç•¥å…¨åŠè§’
////    * @param trimAll      æ˜¯å¦å¿½ç•¥å…¨éƒ¨ç©ºæ ¼
////    * @param conditionMap æŸ¥è¯¢æ¡ä»¶
////    */
////   @Override
////   public void wrapperKeyAttrConditionMap(String value, CodeKeyattrrepeatVO keyRuleVO, String attrId,
////                                 boolean trim, boolean ignoreCase, boolean ignoreWidth,
////                                 boolean trimAll, Map<String, String> conditionMap) {
////      boolean ignoreSpace = trim || trimAll;
////      if (StringUtils.isBlank(value)) {
////         //为空的时候，不能用QueryOperation.ISNULL，平台不知道啥时候不处理这种了
////         conditionMap.put("t."+attrId, "null");
////      } else {
////         if (keyRuleVO != null) {
////            String queryKey = "";
////            String queryValue = "";
////
////            String temp = "";
////            if (ignoreCase && ignoreSpace && ignoreWidth) {
////               //忽略大小写，且去空，忽略全半角
////               temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte(%s)) " + (trimAll ? ",' ','')" : ")");
////            } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
////               //忽略大小写、去空、不忽略全半角
////               temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
////            } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
////               //忽略大小写、不去空、忽略全半角
////               temp = "UPPER(to_single_byte(%s))";
////            } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
////               //不忽略大小写、去空、忽略全半角
////               temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte(%s) " + (trimAll ? ",' ','')" : ")");
////            } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
////               //忽略大小写、不去空、不忽略全半角
////               temp = "UPPER(%s)";
////            } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
////               //不忽略大小写、不去空、忽略全半角
////               temp = "to_single_byte(%s)";
////            } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
////               //不忽略大小写、去空、不忽略全半角
////               temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
////            } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
////               //不忽略大小写、不去空、不忽略全半角
////               temp = "%s";
////            }
////            queryKey = String.format(temp, "t."+attrId);
////            queryValue = String.format(temp, "'" + (trim ? value.trim() : value) + "'");
////            conditionMap.put(queryKey, queryValue);
////         } else {
////            //为空的时候不代表不校验，只是不去除相关的信息
////            conditionMap.put("t."+attrId, value);
////         }
////      }
////   }
////
////   /**
////    * æ ¡éªŒæžšä¸¾çš„内容
////    *
////    * @param templateVO æ¨¡æ¿çš„显示对象，需要包含属性
////    * @param orderDTO   ç¼–码申请的信息
////    */
////   private void checkEnumOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////      //如果枚举可以修改，则不需要校验是否符合枚举的选项
////
////      Map<String, CodeClstempattrVO> enumAttrVOMap = templateVO.getAttributes().stream().filter(s -> (StringUtils.isNotBlank(s.getEnumstring()) || StringUtils.isNotBlank(s.getEnumid())) && !VciBaseUtil.getBoolean(s.getEnumeditflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////      if (!CollectionUtils.isEmpty(enumAttrVOMap)) {
////         enumAttrVOMap.forEach((attrId, attrVO) -> {
////            String value = getValueFromOrderDTO(orderDTO, attrId);
////            if (StringUtils.isNotBlank(value)) {
////               CodeClassifyTemplateAttrVO codeClassifyTemplateAttrVO = new CodeClassifyTemplateAttrVO();
////               BeanUtils.copyProperties(attrVO,codeClassifyTemplateAttrVO);
////               //有值才能校验
////               List<KeyValue> comboboxKVs = listComboboxItems(codeClassifyTemplateAttrVO);
////               if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
////                  throw new VciBaseException("属性【{0}】的值不符合枚举的要求", new String[]{attrVO.getName()});
////               }
////            }
////         });
////      }
////   }
////
////   /**
////    * è½¬æ¢æ—¶é—´çš„格式
////    *
////    * @param templateVO æ¨¡æ¿çš„显示对象，需要包含属性
////    * @param orderDTO   ç¼–码申请的信息
////    */
////   private void switchDateAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////      Map<String, CodeClstempattrVO> dateAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getCodedateformat())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////      if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
////         dateAttrVOMap.forEach((attrId, attrVO) -> {
////            String value = getValueFromOrderDTO(orderDTO, attrId);
////            if (StringUtils.isNotBlank(value)) {
////               DateConverter dateConverter = new DateConverter();
////               dateConverter.setAsText(value);
////               value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
////               setValueToOrderDTO(orderDTO, attrId, value);
////            }
////         });
////      }
////   }
////
////   /**
////    * æ‹·è´æ•°æ®åˆ°cbo对象上
////    *
////    * @param classifyFullInfo åˆ†ç±»çš„全部信息
////    * @param cbo              ä¸šåŠ¡æ•°æ®
////    * @param orderDTO         ç¼–码申请的信息
////    * @param templateVO       æ¨¡æ¿çš„显示对象
////    * @param edit             æ˜¯å¦ä¸ºä¿®æ”¹
////    */
////   private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, CodeWupinEntity cbo,
////                        CodeOrderDTO orderDTO, CodeClstemplateVO templateVO,
////                        boolean edit) {
////      String fullPath = "";
////      if (!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())) {
////         fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel())))
////            .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
////      } else {
////         fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
////      }
////
//////      BeanUtils.
////      BeanUtils.copyProperties(orderDTO.getData(),cbo);
////      cbo.setMaterialtype(Short.valueOf("1001"));
//////      orderDTO.getData().forEach((key, value) -> {
//////         if (!edit || (!checkUnAttrUnEdit(key) &&
//////            !VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
//////            try {
//////               cbo.setAttributeValue(key, value);
//////            } catch (Exception e) {
//////               logger.error("设置属性的值错误", e);
//////            }
//////         }
//////      });
////      try {
////
////         cbo.setCodeclsfid(classifyFullInfo.getCurrentClassifyVO().getOid());
////         cbo.setCodetemplateoid(templateVO.getOid());
////         cbo.setCodeclsfpath(fullPath);
//////         cbo.setMaterialclassify("model_type");
//////         cbo.setMaterialname(orderDTO.getData().get("materialname"));
//////         cbo.setShifoupihaoguanli("true");
//////         cbo.setKucunwl("true");
//////         cbo.setXiaoshouwl("false");
////         if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
////            //找生命周期的起始状态，插个点，看生命周期是否需要创建
////            if (StringUtils.isNotBlank(cbo.getLctid())) {
//////               OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctid());
//////               if (lifeCycleVO != null) {
//////                  cbo.setLcStatus("Editing");
////////                  cbo.setLcStatus(lifeCycleVO.getStartStatus());
//////               } else {
////                  cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
//////               }
////            } else {
////               cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
////            }
////
////         }
////
////         int secret = VciBaseUtil.getInt(cbo.getSecretGrade().toString());
////         //插个点，后续看密级服务是否可用
//////         if (secret == 0 || !secretService.checkDataSecret(secret)) {
////         if (secret == 0 ) {
////            Integer userSecret = VciBaseUtil.getCurrentUserSecret();
//////            cbo.setAttributeValue(SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
////            cbo.setSecretGrade(userSecret == null || userSecret == 0 ? UserSecretEnum.NONE.getValue() : userSecret);
////         }
////      } catch (Throwable e) {
////         logger.error("设置默认的属性的值错误", e);
////      }
////   }
////
////
////   /**
////    * åˆå§‹åŒ–业务类型
////    * --创建人默认为当前用户，如果需要修改，可以在获取后自行处理
////    * @param btmName ä¸šåŠ¡ç±»åž‹çš„名称，会自动变成小写
////    * @return CodeWupinEntity
////    * @throws VciBaseException åˆå§‹åŒ–出错的是会抛出异常
////    */
////   @Override
////   public CodeWupinEntity createCBOByBtmName(String btmName)
////      throws VciBaseException {
////      if(btmName!=null){
////         btmName = btmName.trim().toLowerCase();
////      }
////      String userid = AuthUtil.getUser().getUserName();
//////      if(!hasCreatedCbos.containsKey(btmName)){
//////         if(StringUtils.isEmpty(userid)){
//////            throw new VciBaseException(msgCodePrefix +"noHasUserid");
//////         }
//////         try {
//////            hasCreatedCbos.put(btmName, createBusinessObject(btmName));
//////         } catch (Exception e) {
//////            logger.error("创建业务类型对象",e);
//////            throw new VciBaseException(msgCodePrefix + "initBoError",new String[]{btmName});
//////         }
//////      }
//////      ClientBusinessObject cbo = cloneClientBusinessObject(hasCreatedCbos.get(btmName));
////
////      QueryWrapper<CodeOsbtmtypeEntity> btmWrapper = new QueryWrapper<>();
////      btmWrapper.eq("ID",btmName);
////      CodeOsbtmtypeEntity btmTypeVO = codeOsbtmtypeMapper.selectOne(btmWrapper);
//////      OsBtmTypeVO btmTypeVO = btmService.getBtmById(boName);
////      String userName = AuthUtil.getUser().getUserName();
////      CodeWupinEntity wupinEntity = new CodeWupinEntity();
////      wupinEntity.setOid(null);
//////      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(btmTypeVO.getRevisionruleid());
////      wupinEntity.setVersionRule(String.valueOf(btmTypeVO.getVersionRule()));
////      if(StringUtils.isNotBlank(btmTypeVO.getRevisionruleid())){
////         //插个点，需要问勇哥版本问题，展示默认为1
//////         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((short) 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 è¡¨ç¤ºåº”该忽略
////    */
////   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));
////   }
////
////   /**
////    * ä¿å­˜å¯è¾“可选的信息
////    *
////    * @param templateVO æ¨¡æ¿çš„对象
////    * @param cboList    æ•°æ®çš„内容
////    */
////   @Override
////   public void batchSaveSelectChar(CodeClstemplateVO templateVO, /*List<ClientBusinessObject> cboList*/
////                           List<String> cboList) {
////      if (templateVO != null && !CollectionUtils.isEmpty(cboList)) {
////         //是异步的，所以直接循环
////         List<CodeClstempattrVO> selectAttrVOs = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getLibraryidentification())).collect(Collectors.toList());
////
////         if (!CollectionUtils.isEmpty(selectAttrVOs)) {
//////            SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
////            selectAttrVOs.parallelStream().forEach(attrVO -> {
////               List<String> valuesList = cboList;
//////               cboList.parallelStream().forEach(cbo -> {
//////                  String value = cbo.get.getAttributeValue(attrVO.getId());
//////                  if (StringUtils.isNotBlank(value)) {
//////                     valuesList.add(value);
//////                  }
//////               });
////               if (!CollectionUtils.isEmpty(valuesList)) {
////                  for (String s : valuesList) {
////                     DictBiz dictBiz = new DictBiz();
////                     dictBiz.setCode(templateVO.getBtmTypeId());
////                     dictBiz.setDictKey(s);
////                     dictBiz.setDictValue(s);
////                     //从原来的charService（可输可选）更改为调用omd中的接口来实现
////                     iDictBizClient.getCheck(dictBiz);
////                  }
//////                  charService.saveBySameNamespaceAndFlag(templateVO.getBtmTypeId(), attrVO.getLibraryIdentification(), valuesList, sessionInfo);
////               }
////            });
////         }
////      }
////   }
////
////    @Override
////    public MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid) {
////      CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(templateOid);
////      MdmUIInfoVO uiInfoVO = new MdmUIInfoVO();
////      uiInfoVO.setTemplateVO(templateVO);
////      uiInfoVO.setFormDefineVO(wrapperFormDefineByTemplate(templateVO, codeClassifyOid));
////      wrapperResemble(templateVO, uiInfoVO);
////      return uiInfoVO;
////    }
////
////
////   /**
////    * æ¨¡æ¿å±žæ€§è½¬æ¢ä¸ºè¡¨å•å®šä¹‰çš„信息
////    *
////    * @param templateVO      æ¨¡æ¿çš„显示对象
////    * @param codeClassifyOid åˆ†ç±»çš„主键，为空的时候，获取模板所属的分类主键.用于产生分类注入
////    * @return è¡¨æ ¼çš„信息
////    */
////   private UIFormDefineVO wrapperFormDefineByTemplate(CodeClstemplateVO templateVO, String codeClassifyOid) {
////      UIFormDefineVO formDefineVO = new UIFormDefineVO();
////      formDefineVO.setOid(templateVO.getOid());
////      formDefineVO.setBtmType(templateVO.getBtmTypeId());
////      if (StringUtils.isBlank(codeClassifyOid)) {
////         codeClassifyOid = templateVO.getCodeClassifyOid();
////      }
////      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
////
////      List<UIFormItemVO> itemVOS = new ArrayList<>();
////      Map<String, List<CodeClstempattrVO>> attrGroupMap = templateVO.getAttributes().stream().
////         filter(s -> StringUtils.isNotBlank(s.getAttributegroup())).collect(Collectors.groupingBy(s -> s.getAttributegroup()));
////
////      templateVO.getAttributes().forEach(attrVO -> {
////         UIFormItemVO formItemVO = templateAttr2FormField(attrVO, templateVO.getBtmTypeId());
////         itemVOS.add(formItemVO);
////      });
////      //处理属性分组
////      if (!CollectionUtils.isEmpty(attrGroupMap)) {
////         //按照分组的属性排列，找到每一个分组的第一个属性
////         for (String key : attrGroupMap.keySet()) {
////            List<CodeClstempattrVO> value = attrGroupMap.get(key);
////            //找到这个分组的属性的第一个
////            CodeClstempattrVO attrVO = value.stream().sorted(((o1, o2) -> o1.getOrdernum().compareTo(o2.getOrdernum()))).findFirst().get();
////            //我们找到这个属性在最终的itemVOs里的位置
////            UIFormItemVO lineVO = new UIFormItemVO();
////            lineVO.setField(attrVO.getId() + "_line");
////            lineVO.setType("line");
////            lineVO.setText(key);
////            //找位置
////            for (int i = 0; i < itemVOS.size(); i++) {
////               UIFormItemVO record = itemVOS.get(i);
////               if (record.getField().equalsIgnoreCase(attrVO.getId())) {
////                  itemVOS.add(i, lineVO);
////                  break;
////               }
////            }
////         }
////      }
////
////      CodeOrderDTO orderDTO = new CodeOrderDTO();
////      switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
////      if (!CollectionUtils.isEmpty(orderDTO.getData())) {
////         orderDTO.getData().forEach((key, value) -> {
////            for (int i = 0; i < itemVOS.size(); i++) {
////               UIFormItemVO itemVO = itemVOS.get(i);
////               if (itemVO.getField().equalsIgnoreCase(key)) {
////                  itemVO.setDefaultValue(value);
////                  break;
////               }
////            }
////         });
////      }
////      formDefineVO.setItems(itemVOS);
////      //查询是否有分类注入的
////      return formDefineVO;
////   }
////   /**
////    * å±žæ€§ç±»åž‹ä¸Žjs中的字段类型的映射
////    */
////   private static Map<String, String> vciFieldTypeMap = new HashMap<String, String>() {{
////      put(VciFieldTypeEnum.VTString.name(), "text");
////      put(VciFieldTypeEnum.VTInteger.name(), "text");
////      put(VciFieldTypeEnum.VTLong.name(), "text");
////      put(VciFieldTypeEnum.VTDouble.name(), "text");
////      put(VciFieldTypeEnum.VTClob.name(), "text");
////      put(VciFieldTypeEnum.VTBoolean.name(), "truefalse");
////      put(VciFieldTypeEnum.VTDateTime.name(), "datetime");
////      put(VciFieldTypeEnum.VTDate.name(), "datetime");
////      put(VciFieldTypeEnum.VTTime.name(), "datetime");
////      put(VciFieldTypeEnum.VTFilePath.name(), "file");
////   }};
////
////   /**
////    * æ¨¡æ¿å±žæ€§è½¬æ¢ä¸ºè¡¨å•çš„字段
////    *
////    * @param attrVO  æ¨¡æ¿å±žæ€§
////    * @param btmType ä¸šåŠ¡ç±»åž‹
////    * @return è¡¨å•çš„字段
////    */
////   @Override
////   public UIFormItemVO templateAttr2FormField(CodeClstempattrVO attrVO, String btmType) {
////
////      UIFormItemVO itemVO = new UIFormItemVO();
////      if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
//////         attrVO.setEnumid(OsEnumServiceImpl.MY_DATA_SECRET);
////         attrVO.setEnumid(MY_DATA_SECRET);
////      }
////      itemVO.setField(attrVO.getId());
////      itemVO.setText(attrVO.getName());
////      itemVO.setType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
////      if (VciBaseUtil.getBoolean(attrVO.getTextareaflag())) {
////         itemVO.setType("textarea");
////      }
////      if (VciFieldTypeEnum.VTLong.name().equalsIgnoreCase(attrVO.getAttributedatatype())
////         || VciFieldTypeEnum.VTInteger.name().equalsIgnoreCase(attrVO.getAttributedatatype())
////         || VciFieldTypeEnum.VTDouble.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
////         itemVO.setVerify("number");
////      }
////      itemVO.setReadOnly(VciBaseUtil.getBoolean(attrVO.getReadonlyflag()));
////      itemVO.setKeyAttr(VciBaseUtil.getBoolean(attrVO.getKeyattrflag()));
////      itemVO.setRequired(VciBaseUtil.getBoolean(attrVO.getRequireflag()));
////      itemVO.setDefaultValue(attrVO.getDefaultvalue());
////      itemVO.setDateFormate(attrVO.getCodedateformat());
////      itemVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
////      itemVO.setVerify(attrVO.getVerifyrule());
////      itemVO.setPrefix(attrVO.getPrefixvalue());
////      itemVO.setSuffix(attrVO.getSuffixvalue());
////      itemVO.setTooltips(attrVO.getExplain());
////      itemVO.setSelectLibFlag(attrVO.getLibraryidentification());
////      //看看是否有枚举
////      if ((StringUtils.isNotBlank(attrVO.getEnumstring())
////         && !"[]".equalsIgnoreCase(attrVO.getEnumstring())) ||
////         StringUtils.isNotBlank(attrVO.getEnumid())) {
////         itemVO.setType("combox");
////         itemVO.setComboxKey(attrVO.getEnumid());
////         if (StringUtils.isNotBlank(attrVO.getEnumstring())) {
////            //指定的下拉框内容
////            itemVO.setData(JSONObject.parseArray(attrVO.getEnumstring(), KeyValue.class));
////            if (StringUtils.isBlank(attrVO.getEnumid())) {
////               itemVO.setComboxKey(itemVO.getField() + "_data");
////            }
////         }
////      }
////      //看是否有参照
////      if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferconfig())) {
////         itemVO.setType("refer");
////         itemVO.setShowField(itemVO.getField() + "name");
////         if (StringUtils.isNotBlank(attrVO.getReferconfig())) {
////            //配置的内容
////            itemVO.setReferConfig(JSONObject.parseObject(attrVO.getReferconfig(), UIFormReferVO.class));
////         } else {
////            UIFormReferVO formReferVO = new UIFormReferVO();
////            formReferVO.setType("default");
////            formReferVO.setReferType(attrVO.getReferbtmid());
////            itemVO.setReferConfig(formReferVO);
////         }
////      }
////
////      //如果是组合规则，分类注入的，显示为只读
////      if (StringUtils.isNotBlank(attrVO.getComponentrule())) {
////         itemVO.setReadOnly(true);
////         itemVO.setTooltips("本属性为组合规则");
////         itemVO.setRequired(false);
////      }
////      if (StringUtils.isNotBlank(attrVO.getClassifyinvokeattr())) {
////         itemVO.setReadOnly(!VciBaseUtil.getBoolean(attrVO.getClassifyinvokeeditflag()));
////         itemVO.setTooltips("本属性是分类注入");
////         itemVO.setRequired(false);
////      }
////
////      if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(itemVO.getField())) {
////         //是生命周期状态
////         itemVO.setType("combox");
////         itemVO.setComboxKey(btmType + LC_STATUS_SUBFIX);
////      }
////      return itemVO;
////   }
////
////
////   /**
////    * å°è£…相似项查询的列表
////    *
////    * @param templateVO æ¨¡æ¿çš„显示对象
////    * @param uiInfoVO   é¡µé¢çš„信息
////    */
////   private void wrapperResemble(CodeClstemplateVO templateVO, MdmUIInfoVO uiInfoVO) {
////      List<CodeClstempattrVO> resembleAttrList = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())
////         || VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).collect(Collectors.toList());
////      if (!CollectionUtils.isEmpty(resembleAttrList) && resembleAttrList.size() > 1) {
////         UITableDefineVO resembleTable = new UITableDefineVO();
////         resembleTable.setOid(templateVO.getOid());
////         resembleTable.setBtmType(templateVO.getBtmTypeId());
////         resembleTable.setDisplayQueryArea(false);
////         resembleTable.setPageVO(new UITablePageVO());
////         //处理所有的列，这个模板没有合并的表头的情况
////         List<UITableFieldVO> fieldVOList = new ArrayList<>();
////         resembleAttrList.forEach(attrVO -> {
////            UITableFieldVO tableFieldVO = templateAttr2TableField(attrVO,false);
////            tableFieldVO.setHidden(false);
////            fieldVOList.add(tableFieldVO);
////         });
////         List<List<UITableFieldVO>> cols = new ArrayList<>();
////         cols.add(fieldVOList);
////         resembleTable.setCols(cols);
////         uiInfoVO.setResembleTableVO(resembleTable);
////      }
////   }
////
////
////   /**
////    * æ¨¡æ¿å±žæ€§è½¬æ¢ä¸ºè¡¨æ ¼æ˜¾ç¤ºçš„配置
////    *
////    * @param attrVO æ¨¡æ¿å±žæ€§
////    * @param forEdit æ˜¯å¦æ˜¯ç¼–辑所需
////    * @return è¡¨æ ¼çš„字段
////    */
////   @Override
////   public UITableFieldVO templateAttr2TableField(CodeClstempattrVO attrVO,boolean forEdit) {
////      UITableFieldVO fieldVO = new UITableFieldVO();
////      if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
////         attrVO.setEnumid(MY_DATA_SECRET);
////      }
////      fieldVO.setField(attrVO.getId());
////      fieldVO.setTitle(attrVO.getName());
////      fieldVO.setFieldType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
////      fieldVO.setSort(true);
////      fieldVO.setSortField(fieldVO.getField());
////      fieldVO.setQueryField(fieldVO.getField());
////      if (forEdit){
////         fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
////      }else {
////         fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getTabledisplayflag()));
////      }
////      if (attrVO.getAttrtablewidth() != null && attrVO.getAttrtablewidth() > 0) {
////         fieldVO.setMinWidth(Integer.valueOf(attrVO.getAttrtablewidth()));
////         fieldVO.setWidth(Integer.valueOf(attrVO.getAttrtablewidth()));
////      }
////      //看看是否有枚举
////      if ((StringUtils.isNotBlank(attrVO.getEnumstring())
////         && !"[]".equalsIgnoreCase(attrVO.getEnumstring())) ||
////         StringUtils.isNotBlank(attrVO.getEnumid())) {
////         fieldVO.setFieldType("combox");
////         fieldVO.setField(fieldVO.getField() + "Text");
////         fieldVO.setComboxKey(attrVO.getEnumid());
////         if (StringUtils.isNotBlank(attrVO.getEnumstring())) {
////            //指定的下拉框内容
////            fieldVO.setData(JSONObject.parseArray(attrVO.getEnumstring(), KeyValue.class));
////            if (StringUtils.isBlank(attrVO.getEnumid())) {
////               fieldVO.setComboxKey(fieldVO.getField() + "_data");
////            }
////         }else {
////            List<KeyValue> osEnumItemVOList= enumService.getEnum(attrVO.getEnumid());
////            fieldVO.setData(osEnumItemVOList);
////         }
////      }
////      //看是否有参照
////      if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferconfig())) {
////         fieldVO.setFieldType("refer");
////         fieldVO.setQueryField(fieldVO.getField());
////         fieldVO.setField(fieldVO.getField() + "name");
////         fieldVO.setShowField(fieldVO.getField());
////         if (StringUtils.isNotBlank(attrVO.getReferconfig())) {
////            //配置的内容
////            fieldVO.setReferConfig(JSONObject.parseObject(attrVO.getReferconfig(), UIFormReferVO.class));
////         } else {
////            UIFormReferVO formReferVO = new UIFormReferVO();
////            formReferVO.setType("default");
////            formReferVO.setReferType(attrVO.getReferbtmid());
////            fieldVO.setReferConfig(formReferVO);
////         }
////      }
////      if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(fieldVO.getSortField())) {
////         fieldVO.setField("lcstatus_text");
////      }
////      Map<String, String> eventJsMap = new HashMap<>();
////      //超链接与模板是互斥
////      if (StringUtils.isNotBlank(attrVO.getTablehref())) {
////         String event = fieldVO.getSortField() + "_href";
////         eventJsMap.put(event, attrVO.getTablehref());
////         fieldVO.setTemplet("function(d){ return '<a class=\"layui-btn layui-btn-intable \" lay-event=\"" + event + "\">d." + fieldVO.getField() + "</a>';}");
////      }
////      if (StringUtils.isNotBlank(attrVO.getTabledisplayjs())) {
////         //直接写function(d){ return xxxxx;}
////         fieldVO.setTemplet(attrVO.getTabledisplayjs());
////      }
////      if (StringUtils.isBlank(fieldVO.getTemplet()) && VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
////         fieldVO.setTemplet("function(d){return $webUtil.formateBoolean(d." + fieldVO.getField() + ");}");
////      }
////      fieldVO.setOptionJsMap(eventJsMap);
////      fieldVO.setStyle(attrVO.getTabledisplaystyle());
////      //列表里不允许直接编辑
////      fieldVO.setDateFormate(attrVO.getCodedateformat());
////      return fieldVO;
////   }
////
////
////   /**
////    * ç›¸ä¼¼é¡¹æŸ¥è¯¢
////    *
////    * @param orderDTO ç¼–码的相关信息
////    * @return æ•°æ®åˆ—表
////    */
////   @Override
////   public DataGrid<Map<String, String>> resembleQuery(CodeOrderDTO orderDTO) {
////      VciBaseUtil.alertNotNull(orderDTO, "申请的信息", orderDTO.getCodeClassifyOid(), "分类主键", orderDTO.getTemplateOid(), "模板主键");
////      CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
////      CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
////      switchClassifyLevelOnOrder(templateVO, fullInfoBO, orderDTO);
////      switchDateAttrOnOrder(templateVO, orderDTO);
////      switchComponentAttrOnOrder(templateVO, orderDTO);
////      //需要获取是否有相似查询属性
////      Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
////      if (CollectionUtils.isEmpty(attrVOs)) {
////         //都没有属性，肯定不能查询了
////         return new DataGrid<>();
////      }
////      Map<String, String> conditionMap = new HashMap<>();
////      //我们首先获取有没有查询规则
////      CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
////      attrVOs.forEach((attrId, attrVO) -> {
////         String value = getValueFromOrderDTO(orderDTO, attrId);
////         if (value == null) {
////            value = "";
////         }
////         wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
////      });
////
////      //没有限制分类，但是一个模板只可能在一个业务类型里面，所以直接查询这个业务类型即可
////      if (!CollectionUtils.isEmpty(conditionMap)) {
////         Map<String, String> andConditionMap = new HashMap<>();
////         andConditionMap.put("islastr", "1");
////         andConditionMap.put("islastv", "1");
////         if (StringUtils.isNotBlank(orderDTO.getOid())) {
////            andConditionMap.put("oid", QueryOptionConstant.NOTEQUAL + orderDTO.getOid());
////         }
////         conditionMap.putAll(andConditionMap);
////         PageHelper pageHelper = new PageHelper(-1);
////         pageHelper.addDefaultDesc("id");
////         return queryGrid(fullInfoBO.getTopClassifyVO().getBtmtypeid(), templateVO, conditionMap, pageHelper);
////      }
////      return new DataGrid<>();
////   }
////
////   /**
////    * èŽ·å–使用的相似查询规则
////    *
////    * @param fullInfoBO        ç±»å…¨éƒ¨ä¿¡æ¯
////    * @param currentClassifyVO å½“前的分类
////    * @return è§„则，如果不存在会返回Null
////    */
////   @Override
////   public CodeResembleRuleVO getUseResembleRule(CodeClassifyFullInfoBO fullInfoBO, CodeClassifyVO currentClassifyVO) {
////      if (currentClassifyVO == null) {
////         return null;
////      }
////      if (currentClassifyVO != null && StringUtils.isNotBlank(currentClassifyVO.getCodeResembleRuleOid())) {
////         //说明已经存在
////         return resembleRuleService.getObjectByOid(currentClassifyVO.getCodeResembleRuleOid());
////      }
////      if (StringUtils.isBlank(currentClassifyVO.getParentcodeclassifyoid())) {
////         return null;
////      }
////      Map<String, CodeClassifyVO> classifyVOMap = fullInfoBO.getParentClassifyVOs().stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
////      return getUseResembleRule(fullInfoBO, classifyVOMap.getOrDefault(currentClassifyVO.getParentcodeclassifyoid(), null));
////   }
////
////   /**
////    * å°è£…相似项查询的查询条件的映射
////    *
////    * @param value          å€¼
////    * @param resembleRuleVO ç›¸ä¼¼é¡¹è§„则
////    * @param attrId         å±žæ€§çš„编号
////    * @param conditionMap   æŸ¥è¯¢æ¡ä»¶
////    */
////   @Override
////   public void wrapperResembleConditionMap(String value, CodeResembleRuleVO resembleRuleVO, String attrId, Map<String, String> conditionMap) {
////      boolean ignoreSpace = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorespaceflag()) || VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
////      if (StringUtils.isBlank(value)) {
////         //为空的时候就不查询它就是
////      } else {
////         String queryKey = "";
////         String queryValue = "";
////         boolean ignoreCase = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorecaseflag());
////         boolean ignoreWidth = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorewidthflag());
////         boolean trimAll = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
////         boolean trim = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
////         String temp = "";
////         if (ignoreCase && ignoreSpace && ignoreWidth) {
////            //忽略大小写，且去空，忽略全半角
////            temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte('%s')) " + (trimAll ? ",' ','')" : ")");
////         } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
////            //忽略大小写、去空、不忽略全半角
////            temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
////         } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
////            //忽略大小写、不去空、忽略全半角
////            temp = "UPPER(to_single_byte('%s'))";
////         } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
////            //不忽略大小写、去空、忽略全半角
////            temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte('%s') " + (trimAll ? ",' ','')" : ")");
////         } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
////            //忽略大小写、不去空、不忽略全半角
////            temp = "UPPER(%s)";
////         } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
////            //不忽略大小写、不去空、忽略全半角
////            temp = "to_single_byte('%s')";
////         } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
////            //不忽略大小写、去空、不忽略全半角
////            temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
////         } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
////            //不忽略大小写、不去空、不忽略全半角
////            temp = "%s";
////         }
////         if (StringUtils.isNotBlank(resembleRuleVO.getLinkCharacter())) {
////            List<String> chars = VciBaseUtil.str2List(resembleRuleVO.getLinkCharacter());
////            for (int i = 0; i < chars.size(); i++) {
////               String s = chars.get(i);
////               temp = "replace(" + temp + ",'" + s + "','')";
////            }
////         }
////         queryValue = String.format(temp, (trim ? value.trim() : value));
////         temp = temp.replace("to_single_byte('%s')","to_single_byte(%s)");
////         queryKey = String.format(temp, "t."+attrId);
////         conditionMap.put(queryKey, QueryOptionConstant.OR + queryValue);
////      }
////   }
////
////
////   /**
////    * æŸ¥è¯¢ç¼–码数据的列表
////    *
////    * @param btmType      ä¸šåŠ¡ç±»åž‹
////    * @param templateVO   æ¨¡æ¿çš„对象，需要包含模板的属性
////    * @param conditionMap æŸ¥è¯¢æ¡ä»¶
////    * @param pageHelper   åˆ†é¡µå¯¹è±¡
////    * @return æ•°æ®åˆ—表
////    */
////   @Override
////   public DataGrid<Map<String, String>> queryGrid(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
////      CodeTemplateAttrSqlBO sqlBO = getSqlByTemplateVO(btmType, templateVO, conditionMap, pageHelper);
//////      List<Map> maps = boService.queryByOnlySqlForMap(sqlBO.getSqlHasPage());
////      List<Map> maps = commonsMapper.selectBySql(sqlBO.getSqlHasPage());
////      DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
////      List<Map<String, String>> dataList = new ArrayList<>();
////      if (!CollectionUtils.isEmpty(maps)) {
////         maps.stream().forEach(map -> {
////            Map<String, String> data = new HashMap<>();
////            map.forEach((key, value) -> {
////               data.put(((String) key).toLowerCase(Locale.ROOT), (String) value);
////            });
////            dataList.add(data);
////         });
////      }
////      dataGrid.setData(dataList);
////      if (!CollectionUtils.isEmpty(dataList)) {
////         wrapperData(dataGrid.getData(), templateVO, sqlBO.getSelectFieldList(), false);
////         dataGrid.setTotal(Long.parseLong(commonsMapper.selectBySql(sqlBO.getSqlCount()).get(0).values().toArray()[0].toString()););
////      }
////      return dataGrid;
////   }
////
////
////   /**
////    * å°è£…查询出来的数据
////    *
////    * @param dataMap              æ•°æ®çš„映射
////    * @param templateVO           æ¨¡æ¿çš„属性
////    * @param onlySelectAttrIdList ä»…仅查询的属性字段
////    * @param form è¡¨å•é‡Œä½¿ç”¨
////    */
////   @Override
////   public void wrapperData(List<Map<String, String>> dataMap, CodeClassifyTemplateVO templateVO,
////                     Collection<String> onlySelectAttrIdList, boolean form) {
////      if (onlySelectAttrIdList == null) {
////         onlySelectAttrIdList = new ArrayList<>();
////      }
////      //先转换一下时间格式
////      List<String> finalOnlySelectAttrIdList = onlySelectAttrIdList.stream().collect(Collectors.toList());
////      List<CodeClassifyTemplateAttrVO> dateFormatAttrVOs = templateVO.getAttributes().stream().filter(
////         s -> StringUtils.isNotBlank(s.getCodeDateFormat()) &&
////            (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
////      ).collect(Collectors.toList());
////      //枚举的内容
////      List<CodeClassifyTemplateAttrVO> enumAttrVOs = templateVO.getAttributes().stream().filter(
////         s -> (StringUtils.isNotBlank(s.getEnumId()) || StringUtils.isNotBlank(s.getEnumString()))
////            &&
////            (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
////      ).collect(Collectors.toList());
////
////      List<String> userIds = new ArrayList<>();
////      dataMap.stream().forEach(data -> {
////         //处理时间
////         if (!form) {
////            //表单的时候只能用统一的时间格式
////            wrapperDateFormat(dateFormatAttrVOs, data);
////         }
////         //处理枚举
////         wrapperEnum(enumAttrVOs, data);
////         String lcstatus = data.get(VciQueryWrapperForDO.LC_STATUS_FIELD);
////         String copyFromVersion = data.getOrDefault(COPY_FROM_VERSION,"");
////         if ((CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus) || CodeDefaultLC.AUDITING.getValue().equalsIgnoreCase(lcstatus))
////            && StringUtils.isBlank(copyFromVersion)
////         ) {
////            data.put(VciQueryWrapperForDO.ID_FIELD, "******");
////         }
////         data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), CodeDefaultLC.getTextByValue(lcstatus));
////         if(CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus)
////            && StringUtils.isNotBlank(copyFromVersion)){
////            data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), "修改中");
////         }
////         if (data.containsKey("creator")) {
////            userIds.add(data.get("creator"));
////         }
////         if (data.containsKey("lastmodifier")) {
////            userIds.add(data.get("lastmodifier"));
////         }
////      });
////      if (!CollectionUtils.isEmpty(userIds)) {
////         Map<String, SmUserVO> userVOMap = Optional.ofNullable(userQueryService.listUserByUserIds(userIds)).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////         dataMap.stream().forEach(data -> {
////            String creator = data.getOrDefault("creator", null);
////            if (StringUtils.isNotBlank(creator) && userVOMap.containsKey(creator.toLowerCase(Locale.ROOT))) {
////               data.put("creator", creator + "(" + userVOMap.get(creator.toLowerCase(Locale.ROOT)).getName() + ")");
////            }
////            String lastmodifier = data.getOrDefault("lastmodifier", null);
////            if (StringUtils.isNotBlank(lastmodifier) && userVOMap.containsKey(lastmodifier.toLowerCase(Locale.ROOT))) {
////               data.put("lastmodifier", lastmodifier + "(" + userVOMap.get(lastmodifier.toLowerCase(Locale.ROOT)).getName() + ")");
////            }
////         });
////      }
////   }
////
////
////   /**
////    * å¤„理时间格式
////    *
////    * @param dateFormatAttrVOs æ—¶é—´æ ¼å¼çš„属性
////    * @param data              å½“前行数据
////    */
////   private void wrapperDateFormat(Collection<CodeClassifyTemplateAttrVO> dateFormatAttrVOs, Map<String, String> data) {
////      if (!CollectionUtils.isEmpty(dateFormatAttrVOs)) {
////         dateFormatAttrVOs.stream().forEach(dateFormatAttrVO -> {
////            String attrId = dateFormatAttrVO.getId().toLowerCase(Locale.ROOT);
////            String oldValue = data.getOrDefault(attrId, null);
////            if (StringUtils.isNotBlank(oldValue)) {
////               DateConverter dateConverter = new DateConverter();
////               try {
////                  dateConverter.setAsText(oldValue);
////                  Date value = dateConverter.getValue();
////                  if (value != null) {
////                     data.put(attrId, VciDateUtil.date2Str(value, dateFormatAttrVO.getCodeDateFormat()));
////                  }
////               } catch (Throwable e) {
////                  //转换可能有问题，这就使用原本存储的值
////               }
////            }
////         });
////      }
////   }
////
////
////   /**
////    * å¤„理枚举的内容，如果不在枚举中，会返回原本的值
////    *
////    * @param enumAttrVOs æžšä¸¾å±žæ€§
////    * @param data        å½“前行数据
////    */
////   private void wrapperEnum(Collection<CodeClassifyTemplateAttrVO> enumAttrVOs, Map<String, String> data) {
////      //处理枚举的内容，为了兼容以前的数据,如果数据不能使用枚举转换的话，那还是显示以前的值
////      if (!CollectionUtils.isEmpty(enumAttrVOs)) {
////         enumAttrVOs.stream().forEach(enumAttrVO -> {
////            String attrId = enumAttrVO.getId().toLowerCase(Locale.ROOT);
////            String oldValue = data.getOrDefault(attrId, null);
////            if (StringUtils.isNotBlank(oldValue)) {
////               List<KeyValue> comboxKVs = listComboboxItems(enumAttrVO);
////               String newValue = oldValue;
////               KeyValue keyValue = Optional.ofNullable(comboxKVs).orElseGet(() -> new ArrayList<>()).stream().filter(s -> s.getKey().equalsIgnoreCase(oldValue)).findFirst().orElseGet(() -> null);
////               if (keyValue != null) {
////                  newValue = keyValue.getValue();
////               }
////               data.put(attrId + "Text", newValue);
////            }
////         });
////      }
////   }
////
////
////   /**
////    * æ ¹æ®æ¨¡æ¿å±žæ€§ç”Ÿæˆç›¸åº”çš„sql信息
////    *
////    * @param btmType      ä¸šåŠ¡ç±»åž‹
////    * @param templateVO   æ¨¡æ¿æ˜¾ç¤ºå¯¹è±¡ï¼Œå¿…须包含属性
////    * @param conditionMap æŸ¥è¯¢æ¡ä»¶
////    * @param pageHelper   åˆ†é¡µå’ŒæŽ’序对象
////    * @return sql的相关信息
////    */
////   @Override
////   public CodeTemplateAttrSqlBO getSqlByTemplateVO(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
////      //因为参照不一定是在平台的属性池里面设置，所以我们得需要自行处理
////      //参考VciQueryWrapper来处理
////      //1. æ‰¾åˆ°æ‰€æœ‰çš„字段，
////      Map<String, CodeClassifyTemplateAttrVO> attrVOMap = templateVO.getAttributes().stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////      List<String> selectFieldList = attrVOMap.keySet().stream().collect(Collectors.toList());
////
////      //所有的参照的字段
////      Map<String/**属性字段**/, String> joinTableList = new ConcurrentHashMap<>();
////      List<CodeClassifyTemplateAttrVO> referAttrVOs = templateVO.getAttributes().stream().filter(
////         s -> StringUtils.isNotBlank(s.getReferBtmId()) || StringUtils.isNotBlank(s.getReferConfig())
////      ).collect(Collectors.toList());
////      Map<String/**参照的属性**/, String/**实际的字段**/> referFieldMap = new HashMap<>();
////      if (!CollectionUtils.isEmpty(referAttrVOs)) {
////         referAttrVOs.parallelStream().forEach(attrVO -> {
////            UIFormReferVO referVO = null;
////            if (StringUtils.isNotBlank(attrVO.getReferConfig())) {
////               referVO = JSONObject.parseObject(attrVO.getReferConfig(), UIFormReferVO.class);
////            } else {
////               referVO = new UIFormReferVO();
////               referVO.setReferType(attrVO.getReferBtmId());
////               referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
////               referVO.setTextField("name");
////            }
////
////            String referTable = VciBaseUtil.getTableName(referVO.getReferType());
////            String referTableNick = attrVO.getId() + "0";
////            String left = " left join " + referTable + " " + referTableNick + " on " + referTableNick + "." + referVO.getValueField() + " =  t." + attrVO.getId();
////            joinTableList.put(attrVO.getId(), left);
////            String referShowField = attrVO.getId() + "Name";
////            List<String> textFields = VciBaseUtil.str2List(referVO.getTextField());
////            String showFieldInSource = "";
////            if (textFields.contains("name")) {
////               showFieldInSource = "name";
////            } else {
////               showFieldInSource = textFields.get(0);
////            }
////            referFieldMap.put(attrVO.getId(), referTableNick + "." + showFieldInSource);
////            selectFieldList.add(referTableNick + "." + showFieldInSource + " as " + referShowField);
////         });
////      }
////      Optional.ofNullable(attributeService.getDefaultAttributeVOMap()).orElseGet(() -> new HashMap<>()).keySet().stream().forEach(attrId -> {
////         if (!selectFieldList.contains(attrId) && !"secretgrade".equalsIgnoreCase(attrId)) {
////            selectFieldList.add(attrId);
////         }
////      });
////      if (!selectFieldList.contains(CODE_FIELD)) {
////         selectFieldList.add(CODE_FIELD);
////      }
////      if (!selectFieldList.contains(CODE_CLASSIFY_OID_FIELD)) {
////         selectFieldList.add(CODE_CLASSIFY_OID_FIELD);
////      }
////      if (!selectFieldList.contains(CODE_TEMPLATE_OID_FIELD)) {
////         selectFieldList.add(CODE_TEMPLATE_OID_FIELD);
////      }
////      if (!selectFieldList.contains(CODE_FULL_PATH_FILED)) {
////         selectFieldList.add(CODE_FULL_PATH_FILED);
////      }
////
////      //处理查询条件
////      //TODO éªŒè¯sql注入
////      List<String> andSql = new ArrayList<>();
////      List<String> orSql = new ArrayList<>();
////      if (!CollectionUtils.isEmpty(conditionMap)) {
////         Map<String, String> orConditionMap = new HashMap<>();
////         Map<String, String> andCondtionMap = new HashMap<>();
////         //先分离or的查询条件，另外当查询条件是空的时候也不查询
////         conditionMap.forEach((k, v) -> {
////            if (StringUtils.isNotBlank(v)) {
////               if (v.startsWith(QueryOptionConstant.OR)) {
////                  orConditionMap.put(k, v.substring(QueryOptionConstant.OR.length()));
////               } else {
////                  andCondtionMap.put(k, v);
////               }
////            }
////         });
////
////         andCondtionMap.forEach((k, v) -> {
////            andSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
////         });
////         orConditionMap.forEach((k, v) -> {
////            orSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
////         });
////      }
////      //组合起来
////      StringBuilder andSb = new StringBuilder();
////      andSql.stream().forEach(s -> {
////         andSb.append(s).append(SPACE).append(QueryOptionConstant.AND).append(SPACE);
////      });
////
////      String andString = andSb.toString().trim();
////      String endWithSql = QueryOptionConstant.AND;
////      if (andString.endsWith(endWithSql)) {
////         andString = andString.substring(0, andString.length() - endWithSql.length());
////      }
////
////      String orString = orSql.stream().collect(Collectors.joining(" or "));
////      String whereSql = "";
////      if (StringUtils.isNotBlank(orString)) {
////         if (StringUtils.isBlank(andString)) {
////            andString = " 1 = 1 ";
////         }
////         whereSql = SPACE + "(" + SPACE + andString + SPACE + ") and (" + SPACE + orString + SPACE + ")" + SPACE;
////      } else {
////         whereSql = andString + SPACE;
////      }
////      if (attrVOMap.keySet().contains("secretgrade")) {
////         Integer userSecret = VciBaseUtil.getCurrentUserSecret();
////         if (userSecret == null || userSecret == 0) {
////            userSecret = secretService.getMinUserSecret();
////         }
////         whereSql += " and ( t.secretGrade <= " + userSecret + ") ";
////      }
////      String tableName = VciBaseUtil.getTableName(btmType);
////      String sql = "select " + selectFieldList.stream().map(s -> (s.contains(".") ? s : ("t." + s))).collect(Collectors.joining(","))
////         + " from " + tableName + SPACE + "t" + SPACE
////         + joinTableList.values().stream().collect(Collectors.joining(SPACE))
////         + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
////      if (pageHelper == null) {
////         pageHelper = new PageHelper(-1);
////      }
////      //看看排序
////      String orderSql = pageHelper.getOrderSql("t");
////      sql += (orderSql == null ? "" : orderSql);
////      String whereSubfixForPage = " ) A where rownum < " + (pageHelper.getLimit() * pageHelper.getPage() + 1) + ") where RN >= "
////         + (pageHelper.getLimit() * (pageHelper.getPage() - 1) + 1);
////      String sqlHasPage = pageHelper.getLimit() > 0 ? ("select * from (select A.*,rownum RN from (" + sql + whereSubfixForPage) : sql;
////      String sqlCount = "select count(1) from " + tableName + SPACE + "t" + SPACE + joinTableList.values().stream().collect(Collectors.joining(SPACE))
////         + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
////      CodeTemplateAttrSqlBO sqlBO = new CodeTemplateAttrSqlBO();
////      sqlBO.setTableName(tableName);
////      sqlBO.setJoinTable(joinTableList);
////      sqlBO.setNickName("t");
//////      sqlBO.setPageHelper(pageHelper);
////      sqlBO.setSqlHasPage(sqlHasPage);
////      sqlBO.setSqlCount(sqlCount);
////      sqlBO.setSqlUnPage(sql);
////      return sqlBO;
////   }
////
////
////   /**
////    * ç»„合查询条件的sql
////    *
////    * @param key           å­—段
////    * @param value         åå­—
////    * @param referFieldMap å‚照的字段
////    * @param attrVOMap     å±žæ€§çš„映射
////    * @return Sql语句
////    */
////   private String getConditionSql(String key, String value, Map<String/**参照的属性**/, String/**实际的属性**/> referFieldMap, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
////      if (key.endsWith("_begin")) {
////         //说明是>=的。我们需要先获取一下
////         String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
////         if (referFieldMap.containsKey(field)) {
////            //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
////            return referFieldMap.get(field) + SPACE + " >= '" + value + "'" + SPACE;
////         } else {
////            return (field.contains(".") ? "" : "t.") + field + SPACE + " >= " + getStringValueInWhere(value, field, attrVOMap);
////         }
////      } else if (key.endsWith("_end")) {
////         //说明是<=的。我们需要先获取一下
////         String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
////         if (referFieldMap.containsKey(field)) {
////            //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
////            return referFieldMap.get(field) + SPACE + " <= '" + value + "'" + SPACE;
////         } else {
////            return (field.contains(".") ? "" : "t.") + field + SPACE + " <= " + getStringValueInWhere(field, value, attrVOMap);
////         }
////      } else {
////         if (referFieldMap.containsKey(key)) {
////            //说明是参照的，我们参照的查询都认为是字符串，如果是时间格式的查询肯定有问题，
////            String selectKey = referFieldMap.get(key);
////            return getSqlByValue(selectKey, value, null);
////         } else {
////            return getSqlByValue(key, value, attrVOMap);
////         }
////      }
////
////   }
////
////   /**
////    * èŽ·å–查询条件中的值的，处理不同的类型
////    *
////    * @param value å€¼
////    * @param field å­—段名称
////    * @return æ—¥æœŸæˆ–者时间格式会包括to_date，字符串会加'
////    */
////   private String getStringValueInWhere(String field, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
////      if ((field.contains(".") && !field.toLowerCase(Locale.ROOT).startsWith("t.")) || attrVOMap == null
////         || !field.replace("t.", "").matches(RegExpConstant.LETTER) || value.startsWith(ONLY)) {
////         //说明可能是指定的某个条件，直接返回
////         if (value.startsWith(ONLY)) {
////            value = value.replace(ONLY, "");
////         }
////         if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
////            return value;
////         }
////         if (field.contains(".") && attrVOMap != null && attrVOMap.containsKey(field.split("\\.")[0].toLowerCase(Locale.ROOT))) {
////            //是参照
////            return "'" + value + "'";
////         } else {
////            return value;
////         }
////      } else {
////         //看看是不是这个对象里的属性
////         if (attrVOMap.containsKey(field)) {
////            VciFieldTypeEnum fieldTypeEnum = VciFieldTypeEnum.valueOf(attrVOMap.get(field).getAttributeDataType());
////            if ("ts".equalsIgnoreCase(field)) {
////               return "to_timestamp('" + value + "', '" + DATETIME_FORMAT + ".ff')";
////            }
////            DateConverter dateConverter = new DateConverter();
////            if (VciFieldTypeEnum.VTDateTime.equals(fieldTypeEnum)) {
////               //实际上，数据库都是timestamp的类型.
////               dateConverter.setAsText(value);
////               return "to_date('" + dateConverter.getAsText(VciDateUtil.DateTimeFormat) + "','" + DATETIME_FORMAT + "')";
////            } else if (VciFieldTypeEnum.VTDate.equals(fieldTypeEnum)) {
////               dateConverter.setAsText(value);
////               return "to_date('" + dateConverter.getAsText(VciDateUtil.DateFormat) + "','" + DATE_FORMAT + "')";
////            } else if (VciFieldTypeEnum.VTDouble.equals(fieldTypeEnum)
////               || VciFieldTypeEnum.VTLong.equals(fieldTypeEnum)
////               || VciFieldTypeEnum.VTInteger.equals(fieldTypeEnum)) {
////               return value;
////            } else {
////               return "'" + value + "'";
////            }
////         } else {
////            if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
////               return value;
////            }
////            return "'" + value + "'";
////         }
////      }
////
////   }
////
////   /**
////    * å°è£…最终的sql语句中的值部分
////    *
////    * @param selectKey æŸ¥è¯¢çš„字段
////    * @param value     å€¼
////    * @param attrVOMap å±žæ€§çš„显示对象映射
////    * @return sql里的值
////    */
////   private String getSqlByValue(String selectKey, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
////      StringBuilder sql = new StringBuilder();
////      if (!selectKey.contains(".") && (attrVOMap.containsKey(selectKey.toLowerCase(Locale.ROOT)) || attributeService.isDefaultAttr(selectKey) || selectKey.matches(RegExpConstant.LETTER))) {
////         sql.append("t.");
////      }
////      if (value.startsWith(QueryOptionConstant.IN)) {
////         sql.append(selectKey)
////            .append(SPACE)
////            .append("in")
////            .append(SPACE)
////            .append("(")
////            .append(value.replace(QueryOptionConstant.IN, ""))
////            .append(")");
////      } else if (value.startsWith(QueryOptionConstant.NOTIN)) {
////         sql.append(selectKey)
////            .append(SPACE)
////            .append("not in")
////            .append(SPACE)
////            .append("(")
////            .append(value.replace(QueryOptionConstant.NOTIN, ""))
////            .append(")");
////      } else if (value.startsWith(QueryOptionConstant.NOTEQUAL)) {
////         value = value.replace(QueryOptionConstant.NOTEQUAL, "");
////         value = getStringValueInWhere(selectKey, value, attrVOMap);
////         sql.append(selectKey)
////            .append(SPACE)
////            .append(QueryOptionConstant.NOTEQUAL)
////            .append(SPACE)
////            .append(value);
////      } else if (value.startsWith(QueryOptionConstant.MORETHAN)) {
////         value = value.replace(QueryOptionConstant.MORETHAN, "");
////         value = getStringValueInWhere(selectKey, value, attrVOMap);
////         sql.append(selectKey)
////            .append(SPACE)
////            .append(QueryOptionConstant.MORETHAN)
////            .append(SPACE)
////            .append(value);
////      } else if (value.startsWith(QueryOptionConstant.MORE)) {
////         value = value.replace(QueryOptionConstant.MORE, "");
////         value = getStringValueInWhere(selectKey, value, attrVOMap);
////         sql.append(selectKey)
////            .append(SPACE)
////            .append(QueryOptionConstant.MORE)
////            .append(SPACE)
////            .append(value);
////      } else if (value.startsWith(QueryOptionConstant.LESSTHAN)) {
////         value = value.replace(QueryOptionConstant.LESSTHAN, "");
////         value = getStringValueInWhere(selectKey, value, attrVOMap);
////
////         sql.append(selectKey)
////            .append(SPACE)
////            .append(QueryOptionConstant.LESSTHAN)
////            .append(SPACE)
////            .append(value);
////      } else if (value.startsWith(QueryOptionConstant.LESS)) {
////         value = value.replace(QueryOptionConstant.LESS, "");
////         value = getStringValueInWhere(selectKey, value, attrVOMap);
////
////         sql.append(selectKey)
////            .append(SPACE)
////            .append(QueryOptionConstant.LESS)
////            .append(SPACE)
////            .append(value);
////      } else if (value.startsWith(QueryOptionConstant.ISNOTNULL)) {
////         sql.append(selectKey)
////            .append(SPACE)
////            .append(" is not null");
////      } else if (value.startsWith(QueryOptionConstant.ISNULL)) {
////         sql.append(selectKey)
////            .append(SPACE)
////            .append(" is null");
////      } else if (value.contains("*")) {
////         //说明是like，或者lefe like ,right like
////         value = getStringValueInWhere(selectKey, value, attrVOMap);
////         sql.append(selectKey)
////            .append(SPACE)
////            .append("like")
////            .append(SPACE)
////            //   .append("'")
////            .append(value.replace("*", "%"))
////            //  .append("'")
////            .append(SPACE);
////      } else {
////         value= value.replace(SPECIAL_CHAR,REQUIRED_CHAR);
////         value = getStringValueInWhere(selectKey, value, attrVOMap);
////
////         sql.append(selectKey)
////            .append(SPACE)
////            .append(QueryOptionConstant.EQUAL)
////            .append(SPACE)
////            .append(value);
////      }
////      sql.append(SPACE);
////      return sql.toString();
////   }
////
////   /**
////    * ä¿®æ”¹ä¸»é¢˜åº“数据
////    *
////    * @param orderDTO æ•°æ®çš„内容，不用包含码段的内容了
////    */
////   @Override
////   public void editSaveCode(CodeOrderDTO orderDTO) {
////      VciBaseUtil.alertNotNull(orderDTO, "编码申请相关的属性的内容都为空", orderDTO.getOid(), "数据主键",
////         orderDTO.getCodeClassifyOid(), "主题库分类的主键");
//////      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
////      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
////      //找业务类型，然后使用主键去获取数据库里的数据
//////      List<ClientBusinessObject> cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), WebUtil.getOidQuery(orderDTO.getOid()));
////
////      QueryWrapper<CodeOsbtmtypeEntity> btmWrapper = new QueryWrapper<>();
////      btmWrapper.eq("OID",orderDTO.getOid());
////      CodeWupinEntity cbo = codeOsbtmtypeMapper.selectOne(btmWrapper);
////
//////      CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
//////      CodeRuleVO ruleVO = ruleService.getObjectHasSecByOid(orderDTO.getCodeRuleOid());
////
////      if (cbo != null) {
////         throw new VciBaseException(DATA_OID_NOT_EXIST);
////      }
//////      ClientBusinessObject cbo = cbos.get(0);
////      if (!cbo.getTs().toString().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());
////      try {
////         cbo.setDescription(orderDTO.getDescription());
////         cbo.setName(orderDTO.getName());
////////         cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
//////         cbo.setAttributeValue("name", orderDTO.getName());
////      } catch (Exception e) {
////         e.printStackTrace();
////      }
////
////
////      List<CodeWupinEntity> cboList = new ArrayList<>();
////
////      //备注
////      cbo.setDescription(orderDTO.getDescription());
////      cboList.add(cbo);
//////
//////      cboList.add(cbo);
////      List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList);
////
////
////      List<String> charList = new ArrayList<>();
////      for (CodeWupinEntity wupinEntity : cboList) {
////         charList.add(wupinEntity.getId());
////      }
////      batchSaveSelectChar(templateVO, charList);
////      return codeList.size() > 0 ? codeList.get(0) : "";
////
////
////
////
////      //修改的时候，编码是不变的
//////      BatchCBO batchCBO = new BatchCBO();
//////      batchCBO.getUpdateCbos().add(cbo);
//////      List<ClientBusinessObject> cboList = new ArrayList<>();
//////      cboList.add(cbo);
//////      boService.persistenceBatch(batchCBO);
////      batchSaveSelectChar(templateVO, cboList);
////   }
//
}