ubcs.git - Gitblit

			@@ -1,57 +1,10 @@
			package com.vci.ubcs.code.service.impl;

			import com.alibaba.fastjson.JSONObject;
			import com.alibaba.nacos.common.utils.StringUtils;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.baomidou.mybatisplus.extension.service.IService;
			import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
			import com.sun.corba.se.impl.orbutil.ObjectUtility;
			import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
			import com.vci.ubcs.code.dto.CodeOrderDTO;
			import com.vci.ubcs.code.dto.datapush.BaseModelDTO;
			import com.vci.ubcs.code.entity.CodeAllCode;
			import com.vci.ubcs.code.entity.CodeOsbtmtypeEntity;
			import com.vci.ubcs.code.entity.CodeRule;
			import com.vci.ubcs.code.entity.CodeWupinEntity;
			import com.vci.ubcs.code.enumpack.CodeDefaultLC;
			import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
			import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
			import com.vci.ubcs.code.mapper.CodeAllCodeMapper;
			import com.vci.ubcs.code.mapper.CodeOsbtmtypeMapper;
			import com.vci.ubcs.code.mapper.CodeRuleMapper;
			import com.vci.ubcs.code.service.*;
			import com.vci.ubcs.code.vo.CodeClstempattrVO;
			import com.vci.ubcs.code.vo.CodeClstemplateVO;
			import com.vci.ubcs.code.vo.CodeKeyattrrepeatVO;
			import com.vci.ubcs.code.vo.pagemodel.CodeBasicSecVO;
			import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
			import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
			import com.vci.ubcs.omd.entity.Dict;
			import com.vci.ubcs.starter.exception.VciBaseException;
			import com.vci.ubcs.starter.revision.model.BaseModel;
			import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
			import com.vci.ubcs.starter.web.pagemodel.KeyValue;
			import com.vci.ubcs.starter.web.toolmodel.DateConverter;
			import com.vci.ubcs.starter.web.util.VciBaseUtil;
			import com.vci.ubcs.starter.web.util.VciDateUtil;
			import com.vci.ubcs.starter.web.util.VciQueryWrapperForDO;
			import com.vci.ubcs.starter.web.util.WebUtil;
			import com.vci.ubcs.system.entity.DictBiz;
			import com.vci.ubcs.system.feign.IDictBizClient;
			import org.slf4j.Logger;
			import org.slf4j.LoggerFactory;
			import org.springblade.core.mp.support.Query;
			import org.springblade.core.secure.utils.AuthUtil;
			import org.springblade.core.tool.api.R;
			import org.springframework.beans.BeanUtils;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;
			import org.springframework.util.CollectionUtils;

			import javax.annotation.Resource;
			import java.util.*;
			import java.util.concurrent.CopyOnWriteArrayList;
			import java.util.stream.Collectors;

			/**
			* 主数据引擎服务
			@@ -63,397 +16,454 @@
			public class MdmEngineServiceImpl extends ServiceImpl<CodeAllCodeMapper, CodeAllCode> implements MdmEngineService {


			/**
			* 模板的服务
			*/
			@Resource
			private CodeClstemplateServiceImpl templateService;
			/**
			* 模板的服务
			*/
			@Resource
			private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
			/**
			* 生成编码的服务
			*/
			@Resource
			private MdmProductCodeService productCodeService;
			/**
			* 字典的服务
			*/
			@Resource
			IDictBizClient iDictBizClient;

			/**
			* 编码规则的服务
			*/
			@Autowired
			private ICodeRuleService ruleService;

			/**
			* 分类的服务
			*/
			@Resource
			private ICodeClassifyService classifyService;

			/**
			* 关键属性的配置
			*/
			@Autowired
			private ICodeKeyattrrepeatService keyRuleService;
			/**
			* 日志
			*/
			private Logger logger = LoggerFactory.getLogger(getClass());

			// @Autowired
			// /**
			// * 模板的服务
			// */
			// @Resource
			// private CodeClstemplateServiceImpl templateService;
			// /**
			// * 模板的服务
			// */
			// @Resource
			// private CodeOsbtmtypeMapper codeOsbtmtypeMapper;



			/**
			* 使用分类的主键获取可以使用的模板对象
			*
			* @param codeClassifyOid 分类的主键
			* @return 模板的显示对象
			*/
			@Override
			public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid) {
			return getUsedTemplateByClassifyOid(codeClassifyOid, true);
			}

			/**
			* 使用分类的主键获取可以使用的模板对象
			*
			* @param codeClassifyOid 分类的主键
			* @param hasAttr 包含属性
			* @return 模板的显示对象
			*/
			@Override
			public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr) {
			List<CodeClstemplateVO> templateVOs = templateService.listReleaseTemplateByClassifyOid(codeClassifyOid, hasAttr);
			return templateVOs.get(templateVOs.size() - 1);
			}

			/**
			* 获取枚举的下拉选项
			*
			* @param attrVO 模板属性的对象
			* @return 下拉选项
			*/
			@Override
			public List<KeyValue> listComboboxItems(CodeClstempattrVO 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);
			// 回收需要业务数据删除
			// /**
			// * 生成编码的服务
			// */
			// @Resource
			// private MdmProductCodeService productCodeService;
			// /**
			// * 字典的服务
			// */
			// @Resource
			// IDictBizClient iDictBizClient;
			// /**
			// * 公式的服务
			// */
			// @Autowired
			// private FormulaServiceImpl formulaService;
			//
			// /**
			// * 通用查询
			// */
			// @Resource
			// CommonsMapper commonsMapper;
			// /**
			// * 编码规则的服务
			// */
			// @Autowired
			// private ICodeRuleService ruleService;
			//
			// /**
			// * 分类的服务
			// */
			// @Resource
			// private ICodeClassifyService classifyService;
			//
			// /**
			// * 关键属性的配置
			// */
			// @Autowired
			// private ICodeKeyattrrepeatService keyRuleService;
			// /**
			// * 日志
			// */
			// private Logger logger = LoggerFactory.getLogger(getClass());
			//
			// /**
			// * 空格
			// */
			// public static final String SPACE = " ";
			//
			// /**
			// * 密级的字段
			// */
			// public static final String SECRET_FILED = "secretgrade";
			// /**
			// * 用户新增数据的时候可以查看的密级
			// */
			// public static final String MY_DATA_SECRET = "myDataSecret";
			// /**
			// * 拷贝的版本
			// */
			// public static final String COPY_FROM_VERSION = "copyfromversion";
			// /**
			// * 只是sql
			// */
			// public static final String ONLY = "${vcionly}";
			//
			// /**
			// * 默认的时间格式
			// */
			// private static final String DATETIME_FORMAT = "yyyy-mm-dd hh24:mi:ss";
			//
			// /**
			// * 日期格式
			// */
			// private static final String DATE_FORMAT = "yyyy-mm-dd";
			//
			// /**
			// * 必输
			// */
			// public static final String REQUIRED_CHAR = "*";
			// /**
			// * 替换字符
			// */
			// public static final String SPECIAL_CHAR = "VCI";
			//// @Autowired
			//// private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
			//
			//
			//
			// /**
			// * 使用分类的主键获取可以使用的模板对象
			// *
			// * @param codeClassifyOid 分类的主键
			// * @return 模板的显示对象
			// */
			// @Override
			// public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid) {
			// return getUsedTemplateByClassifyOid(codeClassifyOid, true);
			// }
			//
			// /**
			// * 使用分类的主键获取可以使用的模板对象
			// *
			// * @param codeClassifyOid 分类的主键
			// * @param hasAttr 包含属性
			// * @return 模板的显示对象
			// */
			// @Override
			// public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr) {
			// List<CodeClstemplateVO> templateVOs = templateService.listReleaseTemplateByClassifyOid(codeClassifyOid, hasAttr);
			// return templateVOs.get(templateVOs.size() - 1);
			// }
			//
			// /**
			// * 获取枚举的下拉选项
			// *
			// * @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(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());
			//// 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里。增加一个单独处理，以后再看要不要调整
			//// //TODO:因为默认的属性都不拷贝，目前集团码叫name，并没有从DTO拷贝到cbo里。增加一个单独处理，以后再看要不要调整
			// cbo.setName(orderDTO.getName() == null ? "" : orderDTO.getName());
			// //end -- modify by lihang @20220407
			//// //end -- modify by lihang @20220407
			// 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);
			//// batchSaveSelectChar(templateVO, 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) -> {
			//// 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 = "";
			}
			// });
			// 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) -> {
			@@ -466,26 +476,27 @@
			// sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
			// }
			// sql[0] += " and islastR = '1' and islastV = '1' ";
			// if (boService.queryCountBySql(sql[0], new HashMap<>()) > 0) {
			//// 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 查询条件
			*/
			// }
			//
			// /**
			// * 封装关键属性的查询语句
			// *
			// * @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,
			@@ -534,132 +545,134 @@
			// }
			// }
			// }

			/**
			* 校验枚举的内容
			*
			* @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)) {
			//有值才能校验
			List<KeyValue> comboboxKVs = listComboboxItems(attrVO);
			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());
			//
			// /**
			// * 校验枚举的内容
			// *
			// * @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()});
			// }
			} 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 初始化出错的是会抛出异常
			*/
			// }
			// });
			// }
			// }
			//
			// /**
			// * 转换时间的格式
			// *
			// * @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 {
			@@ -731,30 +744,31 @@
			//
			//// 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 数据的内容
			*/
			//
			// /**
			// * 是否为修改忽略的属性
			// * @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) {
			// 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());
			@@ -762,18 +776,1055 @@
			// if (!CollectionUtils.isEmpty(selectAttrVOs)) {
			//// SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
			// selectAttrVOs.parallelStream().forEach(attrVO -> {
			// List<String> valuesList = new CopyOnWriteArrayList<>();
			// cboList.parallelStream().forEach(cbo -> {
			// String value = cbo.getAttributeValue(attrVO.getId());
			// if (StringUtils.isNotBlank(value)) {
			// valuesList.add(value);
			// }
			// });
			// 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)) {
			// charService.saveBySameNamespaceAndFlag(templateVO.getBtmTypeId(), attrVO.getLibraryIdentification(), valuesList, sessionInfo);
			// 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);
			// }

			}