package com.vci.ubcs.code.service.impl;
|
|
import com.vci.ubcs.code.mapper.CodeClassifyMapper;
|
import com.vci.ubcs.code.mapper.CodeClassifyTemplateMapper;
|
import com.vci.ubcs.code.entity.CodeClassifyDO;
|
import com.vci.ubcs.code.entity.CodeClassifyTemplateDO;
|
import com.vci.ubcs.code.service.CodeClassifyServiceI;
|
import com.vci.ubcs.code.service.CodeDuckingServiceI;
|
import com.vci.ubcs.code.service.CodeKeyAttrRepeatRuleServiceI;
|
import com.vci.ubcs.code.service.CodeRuleServiceI;
|
import com.vci.frameworkcore.lcstatuspck.FrameworkDataLCStatus;
|
import com.vci.starter.poi.bo.ReadExcelOption;
|
import com.vci.starter.poi.bo.WriteExcelData;
|
import com.vci.starter.poi.bo.WriteExcelOption;
|
import com.vci.starter.poi.constant.ExcelLangCodeConstant;
|
import com.vci.starter.poi.util.ExcelUtil;
|
import com.vci.starter.revision.bo.TreeWrapperOptions;
|
import com.vci.starter.revision.service.RevisionModelUtil;
|
import com.vci.starter.web.constant.QueryOptionConstant;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.pagemodel.*;
|
import com.vci.starter.web.util.*;
|
import com.vci.starter.web.wrapper.VciParentQueryOption;
|
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
|
import com.vci.web.pageModel.BatchCBO;
|
import com.vci.web.pageModel.OsAttributeVO;
|
import com.vci.web.pageModel.OsBtmTypeAttributeVO;
|
import com.vci.web.pageModel.OsBtmTypeVO;
|
import com.vci.web.service.OsAttributeServiceI;
|
import com.vci.web.service.OsBtmServiceI;
|
import com.vci.web.service.WebBoServiceI;
|
import org.apache.commons.lang.StringUtils;
|
import org.apache.poi.hssf.util.HSSFColor;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
|
import com.vci.ubcs.code.dto.CodeClassifyDTO;
|
import com.vci.ubcs.code.po.CodeClassifyPO;
|
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
|
import com.vci.ubcs.code.vo.pagemodel.CodeKeyAttrRepeatRuleVO;
|
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.io.File;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static com.vci.frameworkcore.constant.FrameWorkBusLangCodeConstant.*;
|
import static com.vci.frameworkcore.constant.FrameWorkDefaultValueConstant.*;
|
|
/**
|
* 主题库分类服务
|
* @author weidy
|
* @date 2022-01-20
|
*/
|
@Service
|
public class CodeClassifyServiceImpl implements CodeClassifyServiceI {
|
|
/**
|
* 日志
|
*/
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
|
/**
|
* 数据操作层
|
*/
|
@Resource
|
private CodeClassifyMapper codeClassifyMapper;
|
|
/**
|
* 业务类型操作的服务
|
*/
|
@Autowired
|
@Lazy
|
private WebBoServiceI boService;
|
|
/**
|
* 对象的操作
|
*/
|
@Autowired
|
private RevisionModelUtil revisionModelUtil;
|
|
/**
|
* 规则的服务
|
*/
|
@Autowired
|
@Lazy
|
private CodeRuleServiceI codeRuleService;
|
|
/**
|
* 关键属性的服务
|
*/
|
@Autowired
|
private CodeKeyAttrRepeatRuleServiceI keyAttrRepeatRuleService;
|
|
/**
|
* 数据集成
|
*/
|
@Autowired
|
@Lazy
|
private CodeDuckingServiceI codeDuckingServiceI;
|
|
/**
|
* 业务类型的服务
|
*/
|
@Autowired
|
private OsBtmServiceI btmService;
|
|
/**
|
* 属性服务
|
*/
|
@Autowired
|
private OsAttributeServiceI attributeService;
|
|
/**
|
* 数据操作层
|
*/
|
@Resource
|
private CodeClassifyTemplateMapper codeClassifyTemplateMapper;
|
|
/**
|
* 上级节点的属性名称
|
*/
|
public static final String PARENT_FIELD_NAME = "parentCodeClassifyOid";
|
/**
|
* 查询主题库分类 树
|
* @param treeQueryObject 树查询对象
|
* @return 主题库分类 显示树
|
* @throws VciBaseException 查询条件不符合要求的时候会抛出异常
|
*/
|
@Override
|
public List<Tree> treeCodeClassify(TreeQueryObject treeQueryObject) throws VciBaseException {
|
List<CodeClassifyDO> doList =selectCodeClassifyDOByTree(treeQueryObject);
|
List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
|
TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME.toLowerCase(Locale.ROOT));
|
treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
|
List<Tree> tree= revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyVO s) ->{
|
//可以在这里处理树节点的显示
|
return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
|
.getLcStatus()) ? (" 【停用】 ") : "");
|
});
|
Iterator var6 = tree.listIterator();
|
while(var6.hasNext()){
|
Tree trees = (Tree) var6.next();
|
boolean checkHasChild=codeClassifyMapper.checkHasChild(trees.getOid());
|
if(checkHasChild){
|
trees.setLeaf(false);
|
}else{
|
trees.setLeaf(true);
|
}
|
}
|
return tree;
|
}
|
|
/**
|
* 主题库的树
|
*
|
* @param treeQueryObject 树形查询对象
|
* @return 主题库显示树
|
*/
|
@Override
|
public List<Tree> treeTopCodeClassify(TreeQueryObject treeQueryObject) {
|
if(treeQueryObject == null){
|
treeQueryObject = new TreeQueryObject();
|
}
|
if(treeQueryObject.getConditionMap() == null){
|
treeQueryObject.setConditionMap(new HashMap<>());
|
}
|
treeQueryObject.getConditionMap().put(PARENT_FIELD_NAME, QueryOptionConstant.ISNULL);
|
return treeCodeClassify(treeQueryObject);
|
}
|
|
/**
|
* 根据树形查询对象来查询数据对象
|
*
|
* @param treeQueryObject 树形查询对象
|
* @return 查询结果,数据对象
|
*/
|
@Override
|
public List<CodeClassifyDO> selectCodeClassifyDOByTree(TreeQueryObject treeQueryObject) {
|
VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(null,CodeClassifyDO.class);
|
VciParentQueryOption parentQueryOption = new VciParentQueryOption();
|
parentQueryOption.setParentFieldName(PARENT_FIELD_NAME);
|
queryWrapperForDO.parentQueryChild(treeQueryObject,parentQueryOption);
|
if(StringUtils.isBlank(treeQueryObject.getSort())) {
|
PageHelper pageHelper = new PageHelper(-1);
|
pageHelper.addDefaultAsc("id");
|
queryWrapperForDO.setPageHelper(pageHelper);
|
}
|
return codeClassifyMapper.selectByWrapper(queryWrapperForDO);
|
}
|
|
/**
|
* 批量数据对象转换为显示对象
|
* @param codeClassifyDOs 数据对象列表
|
* @return 显示对象
|
* @throws VciBaseException 参数为空或者不存在的时候会抛出异常
|
*/
|
@Override
|
public List<CodeClassifyVO> codeClassifyDO2VOs(Collection<CodeClassifyDO> codeClassifyDOs) throws VciBaseException{
|
List<CodeClassifyVO> voList = new ArrayList<CodeClassifyVO>();
|
if(!CollectionUtils.isEmpty(codeClassifyDOs)){
|
for(CodeClassifyDO s: codeClassifyDOs){
|
CodeClassifyVO vo = codeClassifyDO2VO(s);
|
if(vo != null){
|
voList.add(vo);
|
}
|
}
|
}
|
return voList;
|
}
|
|
/**
|
* 数据对象转换为显示对象
|
* @param codeClassifyDO 数据对象
|
* @return 显示对象
|
* @throws VciBaseException 拷贝属性出错的时候会抛出异常
|
*/
|
@Override
|
public CodeClassifyVO codeClassifyDO2VO(CodeClassifyDO codeClassifyDO) throws VciBaseException{
|
CodeClassifyVO vo = new CodeClassifyVO();
|
if(codeClassifyDO != null){
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDO,vo);
|
//如果有lcstatus的类的话
|
vo.setLcStatusText(FrameworkDataLCStatus.getTextByValue(vo.getLcStatus()));
|
}
|
return vo;
|
}
|
|
/**
|
* 增加主题库分类
|
* @param codeClassifyDTO 主题库分类数据传输对象
|
* @return 执行结果
|
* @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
|
*/
|
@Override
|
public CodeClassifyVO addSave(CodeClassifyDTO codeClassifyDTO) throws VciBaseException{
|
VciBaseUtil.alertNotNull(codeClassifyDTO,"需要添加的数据对象");
|
//将DTO转换为DO
|
CodeClassifyDO codeClassifyDO = new CodeClassifyDO();
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDTO,codeClassifyDO);
|
if(StringUtils.isNotBlank(codeClassifyDO.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyDO.getBtmTypeId())){
|
throw new VciBaseException("只有在顶层的主题库分类才能设置业务类型");
|
}
|
BatchCBO cbo_insert = codeClassifyMapper.insert(codeClassifyDO);
|
|
// //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理
|
// ClientBusinessObject[] clientBusinessObjects = cbo_insert.getCreateCboArray();
|
// if(clientBusinessObjects.length!=0);
|
// {
|
// codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_ADD,FRAMEWORK_DATA_ENABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO.getOid(), DateUtils.addHours(new Date(),1));
|
// }
|
|
return codeClassifyDO2VO(codeClassifyDO);
|
}
|
|
/**
|
* 修改主题库分类
|
* @param codeClassifyDTO 主题库分类数据传输对象
|
* @return 执行结果
|
* @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
|
*/
|
@Override
|
public BaseResult editSave(CodeClassifyDTO codeClassifyDTO) throws VciBaseException{
|
VciBaseUtil.alertNotNull(codeClassifyDTO,"数据对象",codeClassifyDTO.getOid(),"主题库分类主键");
|
|
//检查ts
|
CodeClassifyDO codeClassifyDOCopyFromDTO = new CodeClassifyDO();
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDTO,codeClassifyDOCopyFromDTO);
|
boolean tsBoolean = boService.checkTs(codeClassifyDOCopyFromDTO);
|
if(!tsBoolean){//不是最新的不让改
|
return BaseResult.fail("当前数据不是最新，请刷新后再修改！");
|
}
|
|
//将DTO转换为DO
|
CodeClassifyDO codeClassifyDO = selectByOid(codeClassifyDTO.getOid());
|
revisionModelUtil.copyFromDTOIgnore(codeClassifyDTO,codeClassifyDO);
|
if(StringUtils.isNotBlank(codeClassifyDO.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyDO.getBtmTypeId())){
|
throw new VciBaseException("只有在顶层的主题库分类才能设置业务类型");
|
}
|
codeClassifyMapper.updateByPrimaryKey(codeClassifyDO);
|
|
// //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。只有启用状态的分类才推送
|
// if(FRAMEWORK_DATA_ENABLED.equals(codeClassifyDO.getLcStatus()));
|
// {
|
// codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_EDIT,FRAMEWORK_DATA_ENABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO.getOid(), codeClassifyDTO.getTs());
|
// }
|
|
return BaseResult.success(codeClassifyDO2VO(codeClassifyDO));
|
}
|
|
/**
|
* 检查 主题库分类是否删除
|
* @param codeClassifyDTO 主题库分类数据传输对象，必须要有oid和ts属性
|
* @return 执行结果 success为true为可以删除，false表示有数据引用，obj为true表示有下级
|
* @throws VciBaseException 参数为空，被引用时抛出异常
|
*/
|
@Override
|
public BaseResult checkIsCanDelete(CodeClassifyDTO codeClassifyDTO) throws VciBaseException{
|
VciBaseUtil.alertNotNull(codeClassifyDTO,"数据传输对象",codeClassifyDTO.getOid(),"主键");
|
CodeClassifyDO codeClassifyDO = selectByOid(codeClassifyDTO.getOid());
|
return checkIsCanDeleteForDO(codeClassifyDTO,codeClassifyDO);
|
}
|
|
/**
|
* 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
|
* @param codeClassifyDTO 数据传输对象
|
* @param codeClassifyDO 数据库中的数据对象
|
* @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
|
*/
|
private BaseResult checkIsCanDeleteForDO(CodeClassifyDTO codeClassifyDTO, CodeClassifyDO codeClassifyDO) {
|
CodeClassifyDO tsDO = new CodeClassifyDO();
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDTO,tsDO);
|
boService.checkTs(tsDO);
|
//校验下级是否有引用
|
if(checkChildIsLinked(codeClassifyDO.getOid())){
|
return BaseResult.fail(DATA_CASCADE_LINKED_NOT_DELETE,new String[]{""});
|
}
|
return BaseResult.success(checkHasChild(codeClassifyDO.getOid()));
|
}
|
/**
|
* 检查是否有下级是否关联了数据
|
*
|
* @param oid 主键
|
* @return true 表示有引用，false表示没有引用
|
* @throws VciBaseException 参数为空和有引用的时候会抛出异常
|
*/
|
@Override
|
public boolean checkChildIsLinked(String oid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oid,"主键");
|
Map<String,String> childOids = codeClassifyMapper.selectAllLevelChildOid(oid.trim());
|
if(!CollectionUtils.isEmpty(childOids)){
|
for(String childOid: childOids.keySet()){
|
if(!checkIsLinked(childOid)){
|
return false;
|
}
|
}
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 校验是否有下级节点，不校验是否关联了数据
|
*
|
* @param oid 主键
|
* @return true表示有下级，false表示没有下级
|
* @throws VciBaseException 参数错误，或者数据不存在的时候会抛出异常
|
*/
|
@Override
|
public boolean checkHasChild(String oid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oid,"主键");
|
return codeClassifyMapper.checkHasChild(oid.trim());
|
}
|
|
/**
|
* 校验是否被引用
|
* @param oid 主键
|
* @throws VciBaseException 被引用的时候会抛出异常
|
*/
|
private boolean checkIsLinked(String oid) throws VciBaseException{
|
//TODO 添加需要校验引用的地方
|
return false;
|
}
|
|
/**
|
* 删除主题库分类
|
* @param codeClassifyDTO 主题库分类数据传输对象，oid和ts需要传输
|
* @return 删除结果反馈：：success：成功，fail：失败
|
* @throws VciBaseException 参数为空，被引用时抛出异常
|
*/
|
@Override
|
public BaseResult deleteCodeClassify(CodeClassifyDTO codeClassifyDTO) throws VciBaseException{
|
VciBaseUtil.alertNotNull(codeClassifyDTO,"主题库分类数据对象",codeClassifyDTO.getOid(),"主题库分类的主键");
|
CodeClassifyDO codeClassifyDO = selectByOid(codeClassifyDTO.getOid());
|
BaseResult baseResult = checkIsCanDeleteForDO(codeClassifyDTO,codeClassifyDO);
|
|
//先简称是否有关联模板，有模板要先删除
|
VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateDO.class);
|
queryWrapper.addQueryMap("codeClassifyOid",codeClassifyDTO.getOid());
|
List<CodeClassifyTemplateDO> codeClassifyTemplateDOListHaveTemplate = codeClassifyTemplateMapper.selectByWrapper(queryWrapper);
|
if(codeClassifyTemplateDOListHaveTemplate.size()>0){
|
return BaseResult.fail("分类关联模板，请先删除!");
|
}
|
|
//处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
|
//1、查询要删除的父类数据
|
List<CodeClassifyDO> deletes = new ArrayList<CodeClassifyDO>();
|
deletes.add(codeClassifyDO);
|
|
if(baseResult.isSuccess()) {
|
//找下级的，这个是可以删除的时候
|
Map<String,String> childrenOids = codeClassifyMapper.selectAllLevelChildOid(codeClassifyDO.getOid().trim());
|
if (!CollectionUtils.isEmpty(childrenOids)) {
|
Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids.keySet());
|
for(Collection<String> s : childrenCollections){
|
|
//处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
|
//2、查询要删除的子类数据
|
List<CodeClassifyDO> codeClassifyDOList = codeClassifyMapper.selectByPrimaryKeyCollection(s);
|
deletes.addAll(codeClassifyDOList);
|
|
codeClassifyMapper.batchDeleteByOids(s);
|
}
|
|
}
|
}else{
|
return baseResult;
|
}
|
|
//执行删除操作
|
BatchCBO batchCBO = codeClassifyMapper.deleteByPrimaryKey(codeClassifyDO.getOid());
|
|
//处理数据集成逻辑,成功后执行集成第一步
|
for (CodeClassifyDO codeClassifyDO1:deletes){
|
//codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_DELETE,FRAMEWORK_DATA_DISABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO1.getOid(), DateUtils.addHours(new Date(),1));//这里是当前时间
|
|
//存储要删除的数据
|
codeDuckingServiceI.cacheDeleteData(codeClassifyDO1.getOid(), codeClassifyDO1);
|
}
|
return (batchCBO!=null && batchCBO.getDeleteCbos() !=null &&batchCBO.getDeleteCbos().size() > 0)?BaseResult.successMsg(DELETE_SUCCESS):BaseResult.fail(DELETE_FAIL);
|
}
|
|
/**
|
* 主键获取主题库分类
|
* @param oid 主键
|
* @return 主题库分类显示对象
|
* @throws VciBaseException 参数为空，数据不存在时会抛出异常
|
*/
|
@Override
|
public CodeClassifyVO getObjectByOid(String oid) throws VciBaseException{
|
return codeClassifyDO2VO(selectByOid(oid));
|
}
|
|
/**
|
* 主键查询数据对象
|
* @param oid 主键
|
* @return 数据对象
|
* @throws VciBaseException 参数为空，并且数据不存在的时候会抛出异常
|
*/
|
private CodeClassifyDO selectByOid(String oid) throws VciBaseException{
|
VciBaseUtil.alertNotNull(oid,"主键");
|
CodeClassifyDO codeClassifyDO = codeClassifyMapper.selectByPrimaryKey(oid.trim());
|
if(codeClassifyDO == null || StringUtils.isBlank(codeClassifyDO.getOid())){
|
throw new VciBaseException(DATA_OID_NOT_EXIST);
|
}
|
return codeClassifyDO;
|
}
|
|
/**
|
* 主键批量获取主题库分类
|
* @param oidCollections 主键集合，但是受性能影响，建议一次查询不超过10000个
|
* @return 主题库分类显示对象
|
* @throws VciBaseException 查询出现异常时会抛出
|
*/
|
@Override
|
public Collection<CodeClassifyVO> listCodeClassifyByOids(Collection<String> oidCollections) throws VciBaseException{
|
VciBaseUtil.alertNotNull(oidCollections,"数据对象主键集合");
|
List<CodeClassifyDO> codeClassifyDOList = listCodeClassifyDOByOidCollections(oidCollections);
|
return codeClassifyDO2VOs(codeClassifyDOList);
|
}
|
|
/**
|
* 使用主键集合查询数据对象
|
* @param oidCollections 主键的集合
|
* @return 数据对象列表
|
*/
|
private List<CodeClassifyDO> listCodeClassifyDOByOidCollections(Collection<String> oidCollections){
|
List<CodeClassifyDO> codeClassifyDOList = new ArrayList<CodeClassifyDO>();
|
if(!CollectionUtils.isEmpty(oidCollections)){
|
Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
|
for(Collection<String> oids: oidCollectionsList){
|
List<CodeClassifyDO> tempDOList = codeClassifyMapper.selectByPrimaryKeyCollection(oids);
|
if(!CollectionUtils.isEmpty(tempDOList)){
|
codeClassifyDOList.addAll(tempDOList);
|
}
|
}
|
}
|
return codeClassifyDOList;
|
}
|
|
|
|
/**
|
* 参照树 主题库分类
|
* @param treeQueryObject 树形查询对象
|
* @return 主题库分类显示树
|
* @throws VciBaseException 查询条件和分页出错的时候会抛出异常
|
*/
|
@Override
|
public List<Tree> referTree(TreeQueryObject treeQueryObject) throws VciBaseException{
|
if(treeQueryObject == null){
|
treeQueryObject = new TreeQueryObject();
|
}
|
if(treeQueryObject.getConditionMap() == null){
|
treeQueryObject.setConditionMap(new HashMap<>());
|
}
|
if(treeQueryObject.getConditionMap().containsKey(LC_STATUS)) {
|
treeQueryObject.getConditionMap().remove(LC_STATUS);
|
}
|
if(treeQueryObject.getExtandParamsMap() ==null || !treeQueryObject.getExtandParamsMap().containsKey(REFER_SHOW_DISABLED_QUERY_KEY)) {
|
}
|
treeQueryObject.getConditionMap().put(LC_STATUS, FRAMEWORK_DATA_ENABLED);
|
return treeCodeClassify(treeQueryObject);
|
}
|
|
/**
|
* 启用、停用
|
* @param oid 主键
|
* @param lcStatus 状态
|
* @return 执行结果
|
*/
|
@Override
|
public BaseResult updateLcStatus(String oid, String lcStatus){
|
|
//查询修改前ts
|
CodeClassifyDO codeClassifyDO_old = selectByOid(oid);//主要是为了查询ts
|
|
//启用、停用
|
int u = codeClassifyMapper.updateLcStatus(oid,lcStatus);
|
|
// //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
|
// if(u!=0) {
|
// codeDuckingServiceI.insertCache1(lcStatus,lcStatus,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, oid, codeClassifyDO_old.getTs());
|
// }
|
BaseResult baseResult = u==0?BaseResult.error("修改失败！"):BaseResult.success("修改成功");
|
return baseResult;
|
}
|
|
/**
|
* 使用查询封装器来查询
|
* @param queryWrapper 查询封装器
|
* @return 数据对象
|
*/
|
@Override
|
public List<CodeClassifyDO> selectByWrapper(VciQueryWrapperForDO queryWrapper) {
|
return codeClassifyMapper.selectByWrapper(queryWrapper);
|
}
|
|
/**
|
* 使用分类主键获取分类相关的所有信息
|
*
|
* @param codeClassifyOid 分类的主键
|
* @return 分类上级，下级的信息
|
*/
|
@Override
|
public CodeClassifyFullInfoBO getClassifyFullInfo(String codeClassifyOid) {
|
VciBaseUtil.alertNotNull(codeClassifyOid,"分类的主键");
|
CodeClassifyFullInfoBO fullInfo = new CodeClassifyFullInfoBO();
|
CodeClassifyDO classifyDO = selectByOid(codeClassifyOid);
|
//查询上级
|
fullInfo.setCurrentClassifyVO(codeClassifyDO2VO(classifyDO));
|
fullInfo.setParentClassifyVOs(codeClassifyDO2VOs(codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid)));
|
if(!CollectionUtils.isEmpty(fullInfo.getParentClassifyVOs())){
|
fullInfo.setTopClassifyVO(fullInfo.getParentClassifyVOs().stream().filter(s->StringUtils.isBlank(s.getParentcodeclassifyoid())).findFirst().orElseGet(()->null));
|
}
|
return fullInfo;
|
}
|
|
/**
|
* 获取当前分类的顶层分类
|
*
|
* @param codeClassifyOid 分类的主键
|
* @return 顶层分类的信息
|
*/
|
@Override
|
public CodeClassifyVO getTopClassifyVO(String codeClassifyOid) {
|
VciBaseUtil.alertNotNull(codeClassifyOid,"分类的主键");
|
List<CodeClassifyDO> classifyDOS = codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid);
|
if(!CollectionUtils.isEmpty(classifyDOS)){
|
CodeClassifyDO classifyDO = classifyDOS.stream().filter(s -> StringUtils.isBlank(s.getParentCodeClassifyOid())).findFirst().orElseGet(() -> null);
|
if(classifyDO!=null){
|
return codeClassifyDO2VO(classifyDO);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 统计子节点的个数
|
*
|
* @param codeClassifyOid 分类的主键
|
* @return 个数
|
*/
|
@Override
|
public int countChildrenByClassifyOid(String codeClassifyOid) {
|
Map<String,String> conditionMap = new HashMap<>();
|
conditionMap.put("parentCodeClassifyOid",codeClassifyOid);
|
return codeClassifyMapper.countByCondition(conditionMap).intValue();
|
}
|
|
/**
|
* 获取子级的主题库分类
|
*
|
* @param codeClassifyOid 分类的主键
|
* @param allLevel 是否所有的层级
|
* @param fieldInPath 在路径中的字段
|
* @param enable 是否只显示启用
|
* @return 分类的显示对象
|
*/
|
@Override
|
public List<CodeClassifyVO> listChildrenClassify(String codeClassifyOid, boolean allLevel, String fieldInPath, boolean enable) {
|
if(allLevel){
|
List<CodeClassifyDO> classifyDOS = codeClassifyMapper.selectAllLevelChildHasPath(codeClassifyOid,fieldInPath,enable);
|
if(!CollectionUtils.isEmpty(classifyDOS)){
|
classifyDOS = classifyDOS.stream().filter(s->FRAMEWORK_DATA_ENABLED.equalsIgnoreCase(s.getLcStatus())).collect(Collectors.toList());
|
}
|
return codeClassifyDO2VOs(classifyDOS);
|
}else{
|
//只查询一条，那path就没必要查询了
|
Map<String,String> conditionMap = new HashMap<>();
|
conditionMap.put("parentcodeclassifyoid",codeClassifyOid);
|
if (enable){
|
conditionMap.put(VciQueryWrapperForDO.LC_STATUS_FIELD,FRAMEWORK_DATA_ENABLED);
|
}
|
return codeClassifyDO2VOs(codeClassifyMapper.selectByCondition(conditionMap,new PageHelper(-1)));
|
}
|
}
|
|
/**
|
* 反向从子级获取父级的主题库分类
|
*
|
* @param codeClassifyOid 分类的主键
|
* @return 分类的显示对象
|
*/
|
@Override
|
public List<CodeClassifyVO> listParentClassify(String codeClassifyOid){
|
List<CodeClassifyDO> classifyDOS = codeClassifyMapper.listParentClassify(codeClassifyOid);
|
return codeClassifyDO2VOs(classifyDOS);
|
}
|
|
/**
|
* 导出分类
|
*
|
* @param oid 分类主键
|
* @return excel文件路径
|
*/
|
@Override
|
public String exportClassify(String oid) {
|
VciBaseUtil.alertNotNull(oid,"分类的主键");
|
CodeClassifyVO classifyVO = getObjectByOid(oid);
|
classifyVO.setDataLevel(0);
|
classifyVO.setPath(classifyVO.getId());
|
List<CodeClassifyVO> codeClassifyVOS = listChildrenClassify(oid, true, "id", false);
|
if(codeClassifyVOS ==null){
|
codeClassifyVOS = new ArrayList<>();
|
}
|
codeClassifyVOS.add(classifyVO);
|
|
//查询一下规则的编号，和关键属性重复规则
|
List<String> codeRuleOids = codeClassifyVOS.stream().filter(s -> StringUtils.isNotBlank(s.getCoderuleoid())).map(CodeClassifyVO::getCoderuleoid).collect(Collectors.toList());
|
Map<String, CodeRuleVO> ruleVOMap = new HashMap<>();
|
if(!CollectionUtils.isEmpty(codeRuleOids)){
|
VciBaseUtil.switchCollectionForOracleIn(codeRuleOids).stream().forEach(ruleOids->{
|
Collection<CodeRuleVO> ruleVOS = codeRuleService.listCodeRuleByOids(ruleOids);
|
ruleVOMap.putAll( Optional.ofNullable(ruleVOS).orElseGet(()->new ArrayList<>()).stream().collect(Collectors.toMap(s->s.getOid(),t->t)));
|
});
|
}
|
//找关键属性规则
|
List<String> keyRuleOids = codeClassifyVOS.stream().filter(s -> StringUtils.isNotBlank(s.getCodekeyattrrepeatoid())).map(CodeClassifyVO::getCodekeyattrrepeatoid).collect(Collectors.toList());
|
Map<String, CodeKeyAttrRepeatRuleVO> keyRuleVOMap = new HashMap<>();
|
if(!CollectionUtils.isEmpty(keyRuleOids)){
|
VciBaseUtil.switchCollectionForOracleIn(keyRuleOids).stream().forEach(ruleOids->{
|
Collection<CodeKeyAttrRepeatRuleVO> ruleVOS = keyAttrRepeatRuleService.listCodeKeyAttrRepeatRuleByOids(ruleOids);
|
keyRuleVOMap.putAll( Optional.ofNullable(ruleVOS).orElseGet(()->new ArrayList<>()).stream().collect(Collectors.toMap(s->s.getOid(),t->t)));
|
});
|
}
|
//ok,写excel
|
String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + "导出分类.xls";
|
try {
|
new File(excelName).createNewFile();
|
} catch (Throwable e) {
|
throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
|
}
|
List<WriteExcelData> excelDataList = new ArrayList<>();
|
excelDataList.add(new WriteExcelData(0,0,"分类编号"));
|
excelDataList.add(new WriteExcelData(0,1,"分类名称"));
|
excelDataList.add(new WriteExcelData(0,2,"业务类型编号"));
|
excelDataList.add(new WriteExcelData(0,3,"业务类型名称"));
|
excelDataList.add(new WriteExcelData(0,4,"编码规则编号"));
|
excelDataList.add(new WriteExcelData(0,5,"编码规则名称"));
|
excelDataList.add(new WriteExcelData(0,6,"查重规则编号"));
|
excelDataList.add(new WriteExcelData(0,7,"查重规则名称"));
|
excelDataList.add(new WriteExcelData(0,8,"分类路径"));
|
excelDataList.add(new WriteExcelData(0,9,"状态"));
|
excelDataList.add(new WriteExcelData(0,10,"分类层级"));
|
excelDataList.add(new WriteExcelData(0,11,"描述"));
|
for (int i = 0; i < codeClassifyVOS.size(); i++) {
|
CodeClassifyVO vo = codeClassifyVOS.get(i);
|
excelDataList.add(new WriteExcelData(i+1,0,vo.getId()));
|
excelDataList.add(new WriteExcelData(i+1,1,vo.getName()));
|
excelDataList.add(new WriteExcelData(i+1,2,vo.getBtmtypeid()));
|
excelDataList.add(new WriteExcelData(i+1,3,vo.getBtmtypename()));
|
excelDataList.add(new WriteExcelData(i+1,4,StringUtils.isNotBlank(vo.getCoderuleoid())?ruleVOMap.getOrDefault(vo.getCoderuleoid(),new CodeRuleVO()).getId():""));
|
excelDataList.add(new WriteExcelData(i+1,5,StringUtils.isNotBlank(vo.getCoderuleoid())?ruleVOMap.getOrDefault(vo.getCoderuleoid(),new CodeRuleVO()).getName():""));
|
excelDataList.add(new WriteExcelData(i+1,6,StringUtils.isNotBlank(vo.getCodekeyattrrepeatoid())?keyRuleVOMap.getOrDefault(vo.getCodekeyattrrepeatoid(),new CodeKeyAttrRepeatRuleVO()).getId():""));
|
excelDataList.add(new WriteExcelData(i+1,7,StringUtils.isNotBlank(vo.getCodekeyattrrepeatoid())?keyRuleVOMap.getOrDefault(vo.getCodekeyattrrepeatoid(),new CodeKeyAttrRepeatRuleVO()).getName():""));
|
excelDataList.add(new WriteExcelData(i+1,8,vo.getOid().equalsIgnoreCase(classifyVO.getOid())?vo.getPath():classifyVO.getPath() + vo.getPath()));
|
excelDataList.add(new WriteExcelData(i+1,9,FrameworkDataLCStatus.getTextByValue(vo.getLcStatus())));
|
excelDataList.add(new WriteExcelData(i+1,10,vo.getDataLevel()));
|
excelDataList.add(new WriteExcelData(i+1,11,vo.getDescription()));
|
}
|
WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
|
ExcelUtil.writeDataToFile(excelName, excelOption);
|
return excelName;
|
}
|
|
/**
|
* 创建导入模板
|
*
|
* @return excel文件路径
|
*/
|
@Override
|
public String createImportExcel() {
|
//ok,写excel
|
String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + "分类导入模板.xls";
|
try {
|
new File(excelName).createNewFile();
|
} catch (Throwable e) {
|
throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
|
}
|
List<WriteExcelData> excelDataList = new ArrayList<>();
|
WriteExcelData excelData = new WriteExcelData(0, 0, "分类编号");
|
excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
|
excelDataList.add(excelData);
|
WriteExcelData excelData1 = new WriteExcelData(0, 1, "分类名称");
|
excelData1.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
|
excelDataList.add(excelData1);
|
excelDataList.add(new WriteExcelData(0,2,"业务类型编号"));
|
excelDataList.add(new WriteExcelData(0,3,"编码规则编号"));
|
excelDataList.add(new WriteExcelData(0,4,"查重规则编号"));
|
WriteExcelData excelData2 = new WriteExcelData(0, 5, "分类路径");
|
excelData2.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
|
excelDataList.add(excelData2);
|
excelDataList.add(new WriteExcelData(0,6,"状态"));
|
WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
|
ExcelUtil.writeDataToFile(excelName, excelOption);
|
return excelName;
|
}
|
|
/**
|
* 导入分类
|
*
|
* @param file1 文件的信息
|
* @return 错误文件的地址
|
*/
|
@Override
|
public void importClassify(File file1) {
|
VciBaseUtil.alertNotNull(file1,"excel文件");
|
if(!file1.exists()){
|
throw new VciBaseException("导入的excel文件不存在,{0}",new String[]{file1.getPath()});
|
}
|
ReadExcelOption excelOption = new ReadExcelOption();
|
List<CodeClassifyPO> poList = null;
|
try{
|
poList = ExcelUtil.readDataObjectFromExcel(file1,CodeClassifyPO.class,excelOption,(value,po,fieldName)->{
|
po.setLcStatus(FrameworkDataLCStatus.getValueByText(po.getLcStatusText()));
|
if(StringUtils.isBlank(po.getLcStatusText())){
|
po.setLcStatus(FrameworkDataLCStatus.ENABLED.getValue());
|
}
|
});
|
}catch (Exception e){
|
if(logger.isErrorEnabled()){
|
logger.error("读取excel内容的时候出现了错误",e);
|
}
|
throw new VciBaseException(LangBaseUtil.getErrorMsg(e),new String[]{},e);
|
}
|
//去除整行都是空的情况
|
|
if(CollectionUtils.isEmpty(poList)){
|
throw new VciBaseException(ExcelLangCodeConstant.IMPORT_CONTENT_NULL,new String[]{});
|
}
|
|
poList = poList.stream().filter(s->!(StringUtils.isBlank(s.getId()) && StringUtils.isBlank(s.getName()) && StringUtils.isBlank(s.getPath()))).collect(Collectors.toList());
|
|
List<CodeClassifyDO> classifyDOList = new ArrayList<>();
|
//看看路径是否有重复
|
Map<String/**路径**/, Long/**个数**/> pathCountMap = poList.stream().filter(s->StringUtils.isNotBlank(s.getPath())).collect(Collectors.groupingBy(s -> s.getPath(), Collectors.counting()));
|
List<String> repeatPaths = Optional.ofNullable(pathCountMap).orElse(new HashMap<>()).entrySet().stream().filter(entry -> entry.getValue() > 1).map(entry -> entry.getKey()).collect(Collectors.toList());
|
if(!CollectionUtils.isEmpty(repeatPaths)){
|
//有重复的内容
|
List<String> rowIndexList = new ArrayList<>();
|
poList.stream().forEach(po->{
|
if(repeatPaths.contains(po.getPath())){
|
rowIndexList.add(po.getRowIndex());
|
}
|
});
|
throw new VciBaseException("路径有重复,{0}",new String[]{rowIndexList.stream().collect(Collectors.joining(","))});
|
}
|
|
Map<String, CodeRuleVO> ruleVOMap = Optional.ofNullable(codeRuleService.listCodeRuleByIds(
|
poList.stream().filter(s->StringUtils.isNotBlank(s.getCodeRuleId())).map(CodeClassifyPO::getCodeRuleId).collect(Collectors.toList()))
|
).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
|
|
Map<String,CodeKeyAttrRepeatRuleVO> keyRuleVOMap =Optional.ofNullable(keyAttrRepeatRuleService.listCodeKeyAttrRepeatRuleByIds(
|
poList.stream().filter(s->StringUtils.isNotBlank(s.getKeyRepeatRuleId())).map(CodeClassifyPO::getKeyRepeatRuleId).collect(Collectors.toList()))
|
).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
|
|
Map<String, OsBtmTypeVO> btmVOMap = Optional.ofNullable(btmService.listBtmByIds(
|
poList.stream().filter(s -> StringUtils.isNotBlank(s.getBtmTypeId())).map(CodeClassifyPO::getBtmTypeId).collect(Collectors.toList()))
|
).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
|
|
Map<String/**路径**/,String/**主键**/> oidPathMap = new HashMap<>();
|
|
//我们需要查询所有已经存在的分类，主要是路径，用来判断分类的数据
|
List<CodeClassifyDO> existClassifyDOs = codeClassifyMapper.selectAllLevelChildHasPath("", "id", false);
|
Map<String/**路径**/, CodeClassifyDO/**已经存在的数据**/> pathDOMap = Optional.ofNullable(existClassifyDOs).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> {
|
String path = s.getPath();
|
if(StringUtils.isNotBlank(path) && path.startsWith("#")){
|
return path.substring(1);
|
}
|
return path;
|
}, t -> t));
|
poList.stream().forEach(po->{
|
CodeClassifyDO classifyDO = new CodeClassifyDO();
|
VciBaseUtil.alertNotNull(po.getId(),"分类编号",po.getName(),"分类名称",po.getPath(),"分类路径");
|
if(StringUtils.isNotBlank(po.getBtmTypeId()) && !btmVOMap.containsKey(po.getBtmTypeId().toLowerCase(Locale.ROOT))){
|
throw new VciBaseException("第{0}行的业务类型{1}在系统中不存在",new String[]{String.valueOf(VciBaseUtil.getInt(po.getRowIndex())+1),po.getBtmTypeId()});
|
}
|
if(StringUtils.isNotBlank(po.getCodeRuleId()) && !ruleVOMap.containsKey(po.getCodeRuleId().toLowerCase(Locale.ROOT))){
|
throw new VciBaseException("第{0}行的编码规则{1}在系统中不存在",new String[]{String.valueOf(po.getRowIndex()+1),po.getCodeRuleId()});
|
}
|
if(StringUtils.isNotBlank(po.getKeyRepeatRuleId()) && !keyRuleVOMap.containsKey(po.getKeyRepeatRuleId().toLowerCase(Locale.ROOT))){
|
throw new VciBaseException("第{0}行的关键属性查重规则{1}在系统中不存在",new String[]{String.valueOf(po.getRowIndex()+1),po.getKeyRepeatRuleId()});
|
}
|
classifyDO.setOid(VciBaseUtil.getPk());
|
classifyDO.setId(po.getId());
|
classifyDO.setName(po.getName());
|
classifyDO.setDescription(po.getDescription());
|
oidPathMap.put(po.getPath(),classifyDO.getOid());
|
if(StringUtils.isNotBlank(po.getBtmTypeId())){
|
OsBtmTypeVO typeVO = btmVOMap.get(po.getBtmTypeId().toLowerCase(Locale.ROOT));
|
classifyDO.setBtmTypeId(typeVO.getId());
|
classifyDO.setBtmTypeName(typeVO.getName());
|
}
|
if(StringUtils.isNotBlank(po.getCodeRuleId())){
|
CodeRuleVO codeRuleVO = ruleVOMap.get(po.getCodeRuleId().toLowerCase(Locale.ROOT));
|
classifyDO.setCodeRuleOid(codeRuleVO.getOid());
|
}
|
if(StringUtils.isNotBlank(po.getKeyRepeatRuleId())){
|
CodeKeyAttrRepeatRuleVO repeatRuleVO = keyRuleVOMap.get(po.getKeyRepeatRuleId());
|
classifyDO.setCodeKeyAttrRepeatOid(repeatRuleVO.getOid());
|
}
|
classifyDO.setLcStatus(po.getLcStatus());
|
classifyDO.setPath(po.getPath());
|
classifyDOList.add(classifyDO);
|
});
|
//要看存在的，修改路径对应的主键
|
Map<String/**路径**/,String/**主键**/> catchedOidPathMap = new HashMap<>();
|
if(!CollectionUtils.isEmpty(oidPathMap)){
|
oidPathMap.forEach((path,oid)->{
|
if(pathDOMap.containsKey(path)){
|
//说明存在
|
catchedOidPathMap.put(path,pathDOMap.get(path).getOid());
|
}else{
|
catchedOidPathMap.put(path,oid);
|
}
|
});
|
}
|
List<CodeClassifyDO> addClassifyDOList = new ArrayList<>();
|
List<CodeClassifyDO> editClassifyDOList = new ArrayList<>();
|
classifyDOList.stream().forEach(classifyDO->{
|
|
//要看上级是不是存在哦
|
String parentPath = classifyDO.getPath();
|
if(parentPath.contains("#")) {
|
parentPath = parentPath.substring(0, parentPath.lastIndexOf("#"));
|
}
|
if((!catchedOidPathMap.containsKey(parentPath) && !pathDOMap.containsKey(parentPath) )&& !classifyDO.getPath().equalsIgnoreCase(classifyDO.getId())){
|
throw new VciBaseException("分类编号[{0}],分类名称[{1}]，路径为[{2}]的上级分类在系统中，在本次导入的数据和系统中均没有找到",new String[]{classifyDO.getId(),classifyDO.getName(),classifyDO.getPath()});
|
}
|
if (!classifyDO.getPath().equalsIgnoreCase(classifyDO.getId())){
|
//不是顶级的时候，要设置上级的主键
|
|
classifyDO.setParentCodeClassifyOid(catchedOidPathMap.containsKey(parentPath)?catchedOidPathMap.get(parentPath):pathDOMap.get(parentPath).getOid());
|
}
|
if(classifyDO.getPath().equalsIgnoreCase(classifyDO.getId()) && StringUtils.isBlank(classifyDO.getBtmTypeId())){
|
throw new VciBaseException("分类编号[{0}],分类名称[{1}]，是顶层分类，需要设置业务类型编号",new String[]{classifyDO.getId(),classifyDO.getName()});
|
}
|
if(pathDOMap.containsKey(classifyDO.getPath())){
|
//存在，需要修改对象
|
classifyDO.setOid(catchedOidPathMap.get(classifyDO.getPath()));
|
CodeClassifyDO classifyDOInDB = pathDOMap.get(classifyDO.getPath());
|
classifyDOInDB.setId(classifyDO.getId());
|
classifyDOInDB.setName(classifyDO.getName());
|
classifyDOInDB.setDescription(classifyDO.getDescription());
|
classifyDOInDB.setBtmTypeId(classifyDO.getBtmTypeId());
|
classifyDOInDB.setBtmTypeName(classifyDO.getBtmTypeName());
|
classifyDOInDB.setCodeRuleOid(classifyDO.getCodeRuleOid());
|
classifyDOInDB.setCodeRuleOidName(classifyDO.getCodeRuleOidName());
|
classifyDOInDB.setParentCodeClassifyOid(classifyDO.getParentCodeClassifyOid());
|
classifyDOInDB.setCodeKeyAttrRepeatOid(classifyDO.getCodeKeyAttrRepeatOid());
|
classifyDOInDB.setCodeKeyAttrRepeatOidName(classifyDO.getCodeKeyAttrRepeatOidName());
|
if(classifyDOInDB.getOrderNum() == null){
|
classifyDOInDB.setOrderNum(0);
|
}
|
editClassifyDOList.add(classifyDOInDB);
|
}else{
|
//是新的，直接添加就行了
|
//判断号怎么处理?
|
classifyDO.setOrderNum(0);
|
addClassifyDOList.add(classifyDO);
|
}
|
});
|
if(!CollectionUtils.isEmpty(editClassifyDOList)){
|
VciBaseUtil.switchCollectionForOracleIn(editClassifyDOList).stream().forEach(classifyDOs->{
|
codeClassifyMapper.batchUpdate(classifyDOs.stream().collect(Collectors.toList()));
|
});
|
}
|
if(!CollectionUtils.isEmpty(addClassifyDOList)){
|
revisionModelUtil.wrapperForBatchAdd(addClassifyDOList);
|
VciBaseUtil.switchCollectionForOracleIn(addClassifyDOList).stream().forEach(classifyDOs->{
|
codeClassifyMapper.batchInsert(classifyDOs.stream().collect(Collectors.toList()));
|
});
|
}
|
|
}
|
|
/**
|
* 获取分类关联的属性
|
*
|
* @param baseQueryObject 查询对象，必须有codeClassifyOid，支持id和name两种查询条件
|
* @return 属性的信息，包含默认的属性
|
*/
|
@Override
|
public DataGrid<OsAttributeVO> listClassifyLinkAttr(BaseQueryObject baseQueryObject) {
|
if(baseQueryObject == null){
|
baseQueryObject = new BaseQueryObject();
|
}
|
if(baseQueryObject.getConditionMap() == null){
|
baseQueryObject.setConditionMap(new HashMap<>());
|
}
|
String classifyOid = baseQueryObject.getConditionMap().getOrDefault("codeClassifyOid","");
|
String id = baseQueryObject.getConditionMap().getOrDefault("id","");
|
String name = baseQueryObject.getConditionMap().getOrDefault("name","");
|
if(StringUtils.isBlank(classifyOid)){
|
return new DataGrid<>();
|
}
|
CodeClassifyVO topClassifyVO = getTopClassifyVO(classifyOid);
|
if(topClassifyVO == null || StringUtils.isBlank(topClassifyVO.getBtmtypeid())){
|
return new DataGrid<>();
|
}
|
List<OsBtmTypeAttributeVO> unDefaultAttributes = btmService.listAttributeByBtmId(topClassifyVO.getBtmtypeid());
|
List<OsAttributeVO> attributeVOS = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(unDefaultAttributes)){
|
unDefaultAttributes.stream().forEach(attr->{
|
OsAttributeVO attributeVO = new OsAttributeVO();
|
BeanUtil.convert(attr,attributeVO);
|
attributeVO.setAttributeDataType(attr.getAttrDataType());
|
attributeVO.setAttrLength(attr.getAttributeLength());
|
attributeVO.setBtmTypeId(attr.getReferBtmTypeId());
|
attributeVO.setBtmTypeName(attr.getReferBtmTypeName());
|
boolean add = true;
|
if(StringUtils.isNotBlank(id) && !attributeVO.getId().contains(id.replace("*",""))){
|
add = false;
|
}
|
if(StringUtils.isNotBlank(name) && !attributeVO.getId().contains(name.replace("*",""))){
|
add = false;
|
}
|
if(add){
|
attributeVOS.add(attributeVO);
|
}
|
});
|
}
|
if(!CollectionUtils.isEmpty(attributeService.getDefaultAttributeVOs())){
|
attributeService.getDefaultAttributeVOs().stream().forEach(attr->{
|
boolean add = true;
|
if(StringUtils.isNotBlank(id) && !attr.getId().contains(id.replace("*",""))){
|
add = false;
|
}
|
if(StringUtils.isNotBlank(name) && !attr.getId().contains(name.replace("*",""))){
|
add = false;
|
}
|
if(add){
|
attributeVOS.add(attr);
|
}
|
});
|
}
|
DataGrid<OsAttributeVO> dataGrid = new DataGrid<>();
|
dataGrid.setData(attributeVOS);
|
dataGrid.setTotal(attributeVOS.size());
|
return dataGrid;
|
}
|
|
/**
|
* 使用编号的路径获取对象
|
*
|
* @param idPath 编号的路径，一定要从最顶层节点开始，格式为xxx/yyy/zz 这样
|
* @return 分类的显示对象
|
*/
|
@Override
|
public CodeClassifyVO getObjectByIdPath(String idPath) {
|
CodeClassifyDO classifyDO = codeClassifyMapper.selectByFieldPath(idPath, VciQueryWrapperForDO.ID_FIELD);
|
return codeClassifyDO2VO(classifyDO);
|
}
|
/**
|
* 使用编号的路径获取对象
|
*
|
* @param clsfNamePath 编号的路径，一定要从最顶层节点开始，格式为xxx/yyy/zz 这样
|
* @return 分类的显示对象
|
*/
|
@Override
|
public CodeClassifyVO getObjectByClsfNamePath(String clsfNamePath){
|
CodeClassifyDO classifyDO = codeClassifyMapper.selectByFieldPath(clsfNamePath, "name");
|
return codeClassifyDO2VO(classifyDO);
|
}
|
|
/***
|
* 根据上级节点获取下级节点代号路径和名称路径
|
* @param codeClassifyId
|
* @param enable
|
* @return
|
*/
|
@Override
|
public List<CodeClassifyVO> getIdPathToNamePathByParentId(String codeClassifyId,boolean enable){
|
|
List<CodeClassifyDO> classifyDOs= codeClassifyMapper.getIdPathToNamePathByParentId(codeClassifyId,enable);
|
return codeClassifyDO2VOs(classifyDOs);
|
|
}
|
}
|
