package com.vci.ubcs.code.service.impl;
|
|
import com.alibaba.nacos.common.utils.StringUtils;
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
|
import com.vci.ubcs.code.bo.TreeWrapperOptions;
|
import com.vci.ubcs.code.entity.CodeClassify;
|
import com.vci.ubcs.code.entity.CodeClstemplateEntity;
|
import com.vci.ubcs.code.enumpack.FrameworkDataLCStatus;
|
import com.vci.ubcs.code.mapper.CodeClassifyMapper;
|
import com.vci.ubcs.code.mapper.CodeClstemplateMapper;
|
import com.vci.ubcs.code.service.ICodeClassifyService;
|
import com.vci.ubcs.code.service.ICodeKeyattrrepeatService;
|
import com.vci.ubcs.code.service.ICodeRuleService;
|
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
|
import com.vci.ubcs.code.vo.pagemodel.TreeQueryObject;
|
import com.vci.ubcs.com.vci.starter.revision.service.RevisionModelUtil;
|
import com.vci.ubcs.com.vci.starter.web.pagemodel.Tree;
|
import com.vci.ubcs.com.vci.starter.web.util.BeanUtilForVCI;
|
import com.vci.ubcs.com.vci.starter.web.util.VciBaseUtil;
|
import org.springblade.core.cache.utils.CacheUtil;
|
import org.springblade.core.log.exception.ServiceException;
|
import org.springblade.core.mp.support.Condition;
|
import org.springblade.core.secure.utils.AuthUtil;
|
import org.springblade.core.tool.api.R;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.*;
|
|
@Service
|
public class CodeClassifyServiceImpl extends ServiceImpl<CodeClassifyMapper, CodeClassify> implements ICodeClassifyService {
|
|
@Resource
|
private CodeClassifyMapper codeClassifyMapper;
|
|
@Resource
|
private CodeClstemplateMapper codeClstemplateMapper;
|
|
@Resource
|
private ICodeRuleService codeRuleService;
|
/**
|
* 对象的操作
|
*/
|
@Resource
|
private RevisionModelUtil revisionModelUtil;
|
|
@Resource
|
private ICodeKeyattrrepeatService iCodeKeyattrrepeatService;
|
/**
|
* 上级节点的属性名称
|
*/
|
public static final String PARENT_FIELD_NAME = "parentCodeClassifyOid";
|
/**
|
* 使用查询封装器来查询
|
* @param wrapper 查询封装器
|
* @return 数据对象
|
*/
|
@Override
|
public List<CodeClassify> selectByWrapper(Wrapper wrapper) {
|
return codeClassifyMapper.selectList(wrapper);
|
}
|
|
@Override
|
public IPage<CodeClassifyVO> selectPlCodeClassifyPage(IPage<CodeClassifyVO> page, CodeClassifyVO plCodeClassify) {
|
return page.setRecords(codeClassifyMapper.selectPlCodeClassifyPage(page, plCodeClassify));
|
}
|
|
@Override
|
public R addSave(CodeClassify codeClassifyEntity) {
|
|
if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
|
return R.fail("只有在顶层的主题库分类才能设置业务类型");
|
}
|
codeClassifyEntity.setCreator(AuthUtil.getUser().getUserName());
|
codeClassifyEntity.setCreateTime(new Date());
|
codeClassifyEntity.setTs(new Date());
|
codeClassifyEntity.setLastModifier(AuthUtil.getUser().getUserName());
|
codeClassifyEntity.setLastModifyTime(new Date());
|
int insertNumber = codeClassifyMapper.insert(codeClassifyEntity);
|
return R.status(SqlHelper.retBool(insertNumber));
|
}
|
|
/**
|
* 修改主题库分类
|
* @param codeClassifyEntity 主题库分类数据传输对象
|
* @return 执行结果
|
*/
|
@Override
|
public R editSave(CodeClassify codeClassifyEntity) {
|
if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
|
return R.fail("传入数据不能为空！");
|
}
|
//检查ts
|
Map<String,Object> condition = new HashMap<>(2);
|
condition.put("oid",codeClassifyEntity.getOid());
|
condition.put("ts",codeClassifyEntity.getTs());
|
CodeClassify detail = codeClassifyMapper
|
.selectOne(Condition.getQueryWrapper(condition,CodeClassify.class));
|
if(detail == null){//不是最新的不让改
|
return R.fail("当前数据不是最新，请刷新后再修改！");
|
}
|
|
if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
|
return R.fail("只有在顶层的主题库分类才能设置业务类型");
|
}
|
codeClassifyEntity.setLastModifier(AuthUtil.getUser().getUserName());
|
codeClassifyEntity.setLastModifyTime(new Date());
|
int insertNumber = codeClassifyMapper.updateById(codeClassifyEntity);
|
|
// //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。只有启用状态的分类才推送
|
// 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 R.status(SqlHelper.retBool(insertNumber));
|
// return BaseResult.success(codeClassifyDO2VO(codeClassifyDO));
|
}
|
|
/**
|
* 检查 主题库分类是否删除
|
* @param codeClassifyEntity 主题库分类数据传输对象，必须要有oid和ts属性
|
* @return 执行结果 success为true为可以删除，false表示有数据引用，obj为true表示有下级
|
*/
|
@Override
|
public R checkIsCanDelete(CodeClassify codeClassifyEntity) {
|
if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
|
return R.fail("传入数据不能为空！");
|
}
|
codeClassifyEntity = selectByOid(codeClassifyEntity.getOid());
|
return checkIsCanDeleteForDO(codeClassifyEntity);
|
}
|
|
/**
|
* 主键查询数据对象
|
* @param oid 主键
|
* @return 数据对象
|
*/
|
private CodeClassify selectByOid(String oid){
|
|
CodeClassify codeClassifyEntity = codeClassifyMapper.selectById(oid.trim());
|
if(codeClassifyEntity == null || StringUtils.isBlank(codeClassifyEntity.getOid())){
|
throw new ServiceException("dataOidNotExist");//根据主键id未查到相关数据
|
}
|
return codeClassifyEntity;
|
}
|
|
/**
|
* 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
|
* @param codeClassifyEntity 数据库中的数据对象
|
* @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
|
*/
|
private R checkIsCanDeleteForDO(CodeClassify codeClassifyEntity) {
|
|
//检查ts
|
Map<String,Object> condition = new HashMap<>(2);
|
condition.put("oid",codeClassifyEntity.getOid());
|
condition.put("ts",codeClassifyEntity.getTs());
|
CodeClassify detail = codeClassifyMapper
|
.selectOne(Condition.getQueryWrapper(condition,CodeClassify.class));
|
if(detail == null){//不是最新的不让改
|
throw new ServiceException("当前数据不是最新，请刷新后再修改！");
|
// return R.fail("当前数据不是最新，请刷新后再修改！");
|
}
|
//校验下级是否有引用
|
if(checkChildIsLinked(detail.getOid())){
|
return R.fail("dataCascadeLinkedNotDelete");
|
}
|
return R.data(checkHasChild(detail.getOid()));
|
}
|
|
/**
|
* 检查是否有下级是否关联了数据
|
*
|
* @param oid 主键
|
* @return true 表示有引用，false表示没有引用
|
*/
|
@Override
|
public boolean checkChildIsLinked(String 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 主键
|
*/
|
private boolean checkIsLinked(String oid) {
|
//TODO 添加需要校验引用的地方
|
return false;
|
}
|
|
@Override
|
public boolean checkHasChild(String oid) {
|
if(StringUtils.isBlank(oid)){
|
throw new ServiceException("oid不能为空！");
|
}
|
return codeClassifyMapper.checkHasChild(oid.trim());
|
}
|
|
|
/**
|
* 删除主题库分类
|
* @param codeClassify 主题库分类数据传输对象，oid和ts需要传输
|
* @return 删除结果反馈：：success：成功，fail：失败
|
*/
|
@Override
|
public R deleteCodeClassify(CodeClassify codeClassify) {
|
|
if(codeClassify == null || codeClassify.getOid() == null){
|
throw new ServiceException("传入参数不能为空！");
|
}
|
codeClassify = codeClassifyMapper.selectById(codeClassify.getOid());
|
|
R result = checkIsCanDeleteForDO(codeClassify);
|
|
//先简称是否有关联模板，有模板要先删除
|
Map<String,Object> condition = new HashMap<>(2);
|
condition.put("codeClassifyOid",codeClassify.getOid());
|
List<CodeClstemplateEntity> codeClstemplateEntities = codeClstemplateMapper.selectByMap(condition);
|
// VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateDO.class);
|
// queryWrapper.addQueryMap("codeClassifyOid",codeClassifyDTO.getOid());
|
// List<CodeClassifyTemplateDO> codeClassifyTemplateDOListHaveTemplate = codeClassifyTemplateMapper.selectByWrapper(queryWrapper);
|
if(codeClstemplateEntities.size()>0){
|
return R.fail("分类关联模板，请先删除!");
|
}
|
|
//处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
|
//1、查询要删除的父类数据
|
List<CodeClassify> deletes = new ArrayList<CodeClassify>();
|
deletes.add(codeClassify);
|
|
if(result.isSuccess()) {
|
//找下级的，这个是可以删除的时候
|
Map<String,String> childrenOids = codeClassifyMapper.selectAllLevelChildOid(codeClassify.getOid().trim());
|
if (!CollectionUtils.isEmpty(childrenOids)) {
|
Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids.keySet());
|
for(Collection<String> s : childrenCollections){
|
|
//处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
|
//2、查询要删除的子类数据
|
List<CodeClassify> codeClassifyDOList = codeClassifyMapper.selectBatchIds(s);
|
deletes.addAll(codeClassifyDOList);
|
codeClassifyMapper.deleteBatchIds(s);
|
}
|
|
}
|
}else{
|
return result;
|
}
|
|
//执行删除操作
|
int deleteCount = codeClassifyMapper.deleteById(codeClassify.getOid());
|
|
//处理数据集成逻辑,成功后执行集成第一步
|
for (CodeClassify codeClassifyTemp:deletes){
|
//codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_DELETE,FRAMEWORK_DATA_DISABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO1.getOid(), DateUtils.addHours(new Date(),1));//这里是当前时间
|
|
//存储要删除的数据
|
// CacheUtil.put();
|
CacheUtil.put("ubcs:code", "bean:id:", codeClassifyTemp.getOid(), codeClassifyTemp);
|
// codeDuckingServiceI.cacheDeleteData(codeClassifyTemp.getOid(), codeClassifyTemp);
|
}
|
return R.data(deleteCount>0);
|
// return null;
|
}
|
|
/**
|
* 启用、停用
|
* @param oid 主键
|
* @param lcStatus 状态
|
* @return 执行结果
|
*/
|
@Override
|
public R updateLcStatus(String oid, String lcStatus){
|
|
//查询修改前ts
|
CodeClassify codeClassify = codeClassifyMapper.selectById(oid);//主要是为了查询ts
|
codeClassify.setLcStatus(lcStatus);
|
//启用、停用
|
// int u = codeClassifyMapper.updateLcStatus(oid,lcStatus);
|
int count = codeClassifyMapper.updateById(codeClassify);
|
// //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
|
// if(u!=0) {
|
// codeDuckingServiceI.insertCache1(lcStatus,lcStatus,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, oid, codeClassifyDO_old.getTs());
|
// }
|
return R.data(SqlHelper.retBool(count));
|
}
|
|
/**
|
* 主键批量获取主题库分类
|
* @param oidCollections 主键集合，但是受性能影响，建议一次查询不超过10000个
|
* @return 主题库分类显示对象
|
*/
|
@Override
|
public Collection<CodeClassifyVO> listCodeClassifyByOids(Collection<String> oidCollections) {
|
VciBaseUtil.alertNotNull(oidCollections,"数据对象主键集合");
|
List<CodeClassify> codeClassifyDOList = listCodeClassifyDOByOidCollections(oidCollections);
|
return codeClassifyDO2VOs(codeClassifyDOList);
|
}
|
|
|
/**
|
* 使用主键集合查询数据对象
|
* @param oidCollections 主键的集合
|
* @return 数据对象列表
|
*/
|
private List<CodeClassify> listCodeClassifyDOByOidCollections(Collection<String> oidCollections){
|
List<CodeClassify> codeClassifyList = new ArrayList<CodeClassify>();
|
if(!CollectionUtils.isEmpty(oidCollections)){
|
Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
|
for(Collection<String> oids: oidCollectionsList){
|
List<CodeClassify> tempDOList = codeClassifyMapper.selectBatchIds(oids);
|
if(!CollectionUtils.isEmpty(tempDOList)){
|
codeClassifyList.addAll(tempDOList);
|
}
|
}
|
}
|
return codeClassifyList;
|
}
|
|
|
/**
|
* 批量数据对象转换为显示对象
|
* @param codeClassifys 数据对象列表
|
* @return 显示对象
|
*/
|
@Override
|
public List<CodeClassifyVO> codeClassifyDO2VOs(Collection<CodeClassify> codeClassifys) {
|
List<CodeClassifyVO> voList = new ArrayList<CodeClassifyVO>();
|
if(!CollectionUtils.isEmpty(codeClassifys)){
|
for(CodeClassify s: codeClassifys){
|
CodeClassifyVO vo = codeClassifyDO2VO(s);
|
if(vo != null){
|
voList.add(vo);
|
}
|
}
|
}
|
return voList;
|
}
|
|
/**
|
* 数据对象转换为显示对象
|
* @param codeClassify 数据对象
|
* @return 显示对象
|
*/
|
@Override
|
public CodeClassifyVO codeClassifyDO2VO(CodeClassify codeClassify) {
|
CodeClassifyVO vo = new CodeClassifyVO();
|
if(codeClassify != null){
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassify,vo);
|
//如果有lcstatus的类的话
|
vo.setLcStatusText(FrameworkDataLCStatus.getTextByValue(vo.getLcStatus()));
|
}
|
return vo;
|
}
|
|
/**
|
* 参照树 主题库分类
|
* @param treeQueryObject 树形查询对象
|
* @return 主题库分类显示树
|
*/
|
@Override
|
public List<Tree> referTree(TreeQueryObject treeQueryObject) {
|
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 treeQueryObject 树查询对象
|
* @return 主题库分类 显示树
|
*/
|
@Override
|
public List<Tree> treeCodeClassify(TreeQueryObject treeQueryObject) {
|
List<CodeClassify> doList =codeClassifyMapper.selectCodeClassifyVOByTree(treeQueryObject.getParentOid());
|
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<CodeClassifyVO> 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 oid 分类主键
|
* @return excel文件路径
|
*/
|
@Override
|
public String exportClassify(String oid) {
|
// VciBaseUtil.alertNotNull(oid,"分类的主键");
|
// CodeClassify codeClassify = codeClassifyMapper.selectById(oid);
|
// codeClassify.setDataLevel(0);
|
// codeClassify.setPath(codeClassify.getId());
|
// List<CodeClassifyVO> codeClassifyVOS = listChildrenClassify(oid, true, "id", false);
|
// if(codeClassifyVOS ==null){
|
// codeClassifyVOS = new ArrayList<>();
|
// }
|
// CodeClassifyVO codeClassifyVO = new CodeClassifyVO();
|
// BeanUtils.copyProperties(codeClassify,codeClassifyVO);
|
// codeClassifyVOS.add(codeClassifyVO);
|
//
|
// //查询一下规则的编号，和关键属性重复规则
|
// List<String> codeRuleOids = codeClassifyVOS.stream().filter(s -> org.apache.commons.lang3.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 -> org.apache.commons.lang3.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 = iCodeKeyattrrepeatService.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, org.apache.commons.lang3.StringUtils.isNotBlank(vo.getCoderuleoid())?ruleVOMap.getOrDefault(vo.getCoderuleoid(),new CodeRuleVO()).getId():""));
|
// excelDataList.add(new WriteExcelData(i+1,5, org.apache.commons.lang3.StringUtils.isNotBlank(vo.getCoderuleoid())?ruleVOMap.getOrDefault(vo.getCoderuleoid(),new CodeRuleVO()).getName():""));
|
// excelDataList.add(new WriteExcelData(i+1,6, org.apache.commons.lang3.StringUtils.isNotBlank(vo.getCodekeyattrrepeatoid())?keyRuleVOMap.getOrDefault(vo.getCodekeyattrrepeatoid(),new CodeKeyAttrRepeatRuleVO()).getId():""));
|
// excelDataList.add(new WriteExcelData(i+1,7, org.apache.commons.lang3.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 null;
|
// return excelName;
|
}
|
|
/**
|
* 获取子级的主题库分类
|
*
|
* @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<CodeClassify> classifyDOS = codeClassifyMapper.selectAllLevelChildHasPath(codeClassifyOid);
|
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,Object> conditionMap = new HashMap<>();
|
conditionMap.put("parentcodeclassifyoid",codeClassifyOid);
|
if (enable){
|
conditionMap.put("lcstatus",FRAMEWORK_DATA_ENABLED);
|
}
|
return codeClassifyDO2VOs(codeClassifyMapper.selectByMap(conditionMap));
|
}
|
}
|
}
|
