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 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; /*** * 分类模板服务 */ @Autowired(required = false) private ICodeClstemplateService plCodeClstemplateService; /** * 使用分类的主键获取可以使用的模板对象 * * @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) { CodeClassifyTemplateVO templateVO=new CodeClassifyTemplateVO(); ListtemplateVOs=plCodeClstemplateService.listReleaseTemplateByClassifyOid(codeClassifyOid,hasAttr); if(templateVOs.size()>0){ templateVO= templateVOs.get(templateVOs.size() - 1); } return templateVO; } /** * 使用分类的全部信息获取编码规则 * * @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 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 listComboboxItems(CodeClassifyTemplateAttrVO attrVO) { // List 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 = 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 oids = VciBaseUtil.str2List(baseModelDTO.getOid()); //// List cboList = boService.selectCBOByOidCollection(oids, baseModelDTO.getBtmname()); // //插个点 业务类型完成后需要修改 // QueryWrapper wrapper = new QueryWrapper<>(); // wrapper.eq("BTMNAME",baseModelDTO.getBtmname()); // wrapper.in("OID",oids); // List cboList = codeOsbtmtypeMapper.selectList(wrapper); // //还需要修改allCode的生命周期 //// Map conditionMap = new HashMap<>(); // QueryWrapper 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 codeCbos = baseMapper.selectList(allCodeWrapper); //// List 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 cboList = new ArrayList<>(); //// //// //备注 //// cbo.setDescription(orderDTO.getDescription()); //// //// cboList.add(cbo); //// List codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList); //// //// //// List 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 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 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 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 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 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 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 dataMap = WebUtil.objectToMapString(orderDTO); //// //// Map 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 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 ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyattrflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t)); //// Map 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 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 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 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 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 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 cboList*/ //// List cboList) { //// if (templateVO != null && !CollectionUtils.isEmpty(cboList)) { //// //是异步的，所以直接循环 //// List 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 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 itemVOS = new ArrayList<>(); //// Map> 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 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 vciFieldTypeMap = new HashMap() {{ //// 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 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 fieldVOList = new ArrayList<>(); //// resembleAttrList.forEach(attrVO -> { //// UITableFieldVO tableFieldVO = templateAttr2TableField(attrVO,false); //// tableFieldVO.setHidden(false); //// fieldVOList.add(tableFieldVO); //// }); //// List> 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 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 eventJsMap = new HashMap<>(); //// //超链接与模板是互斥 //// if (StringUtils.isNotBlank(attrVO.getTablehref())) { //// String event = fieldVO.getSortField() + "_href"; //// eventJsMap.put(event, attrVO.getTablehref()); //// fieldVO.setTemplet("function(d){ return 'd." + fieldVO.getField() + "';}"); //// } //// 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> 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 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 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 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 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 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 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> queryGrid(String btmType, CodeClassifyTemplateVO templateVO, Map conditionMap, PageHelper pageHelper) { //// CodeTemplateAttrSqlBO sqlBO = getSqlByTemplateVO(btmType, templateVO, conditionMap, pageHelper); ////// List maps = boService.queryByOnlySqlForMap(sqlBO.getSqlHasPage()); //// List maps = commonsMapper.selectBySql(sqlBO.getSqlHasPage()); //// DataGrid> dataGrid = new DataGrid<>(); //// List> dataList = new ArrayList<>(); //// if (!CollectionUtils.isEmpty(maps)) { //// maps.stream().forEach(map -> { //// Map 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> dataMap, CodeClassifyTemplateVO templateVO, //// Collection onlySelectAttrIdList, boolean form) { //// if (onlySelectAttrIdList == null) { //// onlySelectAttrIdList = new ArrayList<>(); //// } //// //先转换一下时间格式 //// List finalOnlySelectAttrIdList = onlySelectAttrIdList.stream().collect(Collectors.toList()); //// List dateFormatAttrVOs = templateVO.getAttributes().stream().filter( //// s -> StringUtils.isNotBlank(s.getCodeDateFormat()) && //// (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT))) //// ).collect(Collectors.toList()); //// //枚举的内容 //// List 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 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 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 dateFormatAttrVOs, Map 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 enumAttrVOs, Map 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 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 conditionMap, PageHelper pageHelper) { //// //因为参照不一定是在平台的属性池里面设置，所以我们得需要自行处理 //// //参考VciQueryWrapper来处理 //// //1. 找到所有的字段， //// Map attrVOMap = templateVO.getAttributes().stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t)); //// List selectFieldList = attrVOMap.keySet().stream().collect(Collectors.toList()); //// //// //所有的参照的字段 //// Map joinTableList = new ConcurrentHashMap<>(); //// List referAttrVOs = templateVO.getAttributes().stream().filter( //// s -> StringUtils.isNotBlank(s.getReferBtmId()) || StringUtils.isNotBlank(s.getReferConfig()) //// ).collect(Collectors.toList()); //// Map 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 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 andSql = new ArrayList<>(); //// List orSql = new ArrayList<>(); //// if (!CollectionUtils.isEmpty(conditionMap)) { //// Map orConditionMap = new HashMap<>(); //// Map 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 referFieldMap, Map 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 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 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 cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), WebUtil.getOidQuery(orderDTO.getOid())); //// //// QueryWrapper 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 cboList = new ArrayList<>(); //// //// //备注 //// cbo.setDescription(orderDTO.getDescription()); //// cboList.add(cbo); ////// ////// cboList.add(cbo); //// List codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList); //// //// //// List 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 cboList = new ArrayList<>(); ////// cboList.add(cbo); ////// boService.persistenceBatch(batchCBO); //// batchSaveSelectChar(templateVO, cboList); //// } // }