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.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
|
import com.sun.org.apache.bcel.internal.generic.NEW;
|
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
|
import com.vci.ubcs.code.entity.*;
|
import com.vci.ubcs.code.enumpack.FrameworkDataLCStatus;
|
import com.vci.ubcs.code.mapper.*;
|
import com.vci.ubcs.code.po.CodeClassifyPO;
|
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.CodeAllCodeVO;
|
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 com.vci.ubcs.omd.cache.EnumCache;
|
import com.vci.ubcs.omd.enums.EnumEnum;
|
import com.vci.ubcs.omd.feign.IBtmTypeClient;
|
import com.vci.ubcs.omd.vo.BtmTypeAttributeVO;
|
import com.vci.ubcs.omd.feign.IBtmTypeClient;
|
import com.vci.ubcs.omd.vo.BtmTypeVO;
|
import com.vci.ubcs.starter.bo.WriteExcelData;
|
import com.vci.ubcs.starter.exception.VciBaseException;
|
import com.vci.ubcs.starter.poi.bo.ReadExcelOption;
|
import com.vci.ubcs.starter.poi.bo.WriteExcelOption;
|
import com.vci.ubcs.starter.poi.constant.ExcelLangCodeConstant;
|
import com.vci.ubcs.starter.poi.util.ExcelUtil;
|
import com.vci.ubcs.starter.revision.model.TreeQueryObject;
|
import com.vci.ubcs.starter.revision.model.TreeWrapperOptions;
|
import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
|
import com.vci.ubcs.starter.util.BladeTreeQueryObject;
|
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
|
import com.vci.ubcs.starter.util.LocalFileUtil;
|
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
|
import com.vci.ubcs.starter.web.pagemodel.BaseQueryObject;
|
import com.vci.ubcs.starter.web.pagemodel.DataGrid;
|
import com.vci.ubcs.starter.web.pagemodel.Tree;
|
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
|
import com.vci.ubcs.starter.web.util.LangBaseUtil;
|
import com.vci.ubcs.starter.web.util.VciBaseUtil;
|
import com.vci.ubcs.system.cache.NacosConfigCache;
|
import com.vci.ubcs.system.dto.ClassifyAuthDTO;
|
import com.vci.ubcs.system.feign.ISysClient;
|
import org.apache.poi.hssf.util.HSSFColor;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springblade.core.cache.utils.CacheUtil;
|
import org.springblade.core.launch.constant.AppConstant;
|
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.springblade.core.tool.utils.Func;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.context.annotation.Bean;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.awt.event.ItemEvent;
|
import java.io.File;
|
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 CodeClassifyTemplateMapper codeClassifyTemplateMapper;
|
|
@Resource
|
private ICodeRuleService codeRuleService;
|
|
@Resource
|
private IBtmTypeClient btmTypeClient;
|
|
@Resource
|
private ISysClient sysClient;
|
|
/**
|
* 日志
|
*/
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
/**
|
* 对象的操作
|
*/
|
@Resource
|
private RevisionModelUtil revisionModelUtil;
|
|
@Resource
|
private ICodeKeyAttrRepeatService iCodeKeyattrrepeatService;
|
|
@Resource
|
private CodeAllCodeMapper codeAllCodeMapper;
|
|
@Resource
|
private CodeSerialValueMapper codeSerialValueMapper;
|
|
@Resource
|
private CodeBasicSecMapper codeBasicSecMapper;
|
|
/**
|
* 上级节点的属性名称
|
*/
|
public static final String PARENT_FIELD_NAME = "parentCodeClassifyOid";
|
|
/**
|
* 使用查询封装器来查询
|
* @param wrapper 查询封装器
|
* @return 数据对象
|
*/
|
@Override
|
public List<CodeClassify> selectByWrapper(Wrapper wrapper) {
|
return codeClassifyMapper.selectList(wrapper);
|
}
|
|
/**
|
* 查询
|
* @param wrapper 查询封装器
|
* @return
|
*/
|
@Override
|
public List<String> select1(Wrapper wrapper) {
|
|
return codeClassifyMapper.selectObjs(wrapper);
|
}
|
|
@Override
|
public IPage<CodeClassifyVO> selectPlCodeClassifyPage(IPage<CodeClassifyVO> page, CodeClassifyVO plCodeClassify) {
|
return page.setRecords(codeClassifyMapper.selectPlCodeClassifyPage(page, plCodeClassify,AuthUtil.getTenantId()
|
.equals(
|
NacosConfigCache
|
.getAdminUserInfo()
|
.getTenantId()
|
) ? null:AuthUtil.getTenantId()));
|
}
|
|
/**
|
* 主题库定义表 新增
|
* @param
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R addSave(CodeClassify codeClassifyEntity) {
|
try {
|
VciBaseUtil.alertNotNull(codeClassifyEntity.getId(),"主题库编号不能为空！",codeClassifyEntity.getName(),"主题库名称不能为空！");
|
}catch (VciBaseException e){
|
return R.fail(e.getMessage());
|
}
|
if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
|
return R.fail("只有在顶层的主题库分类才能设置业务类型");
|
}
|
if(StringUtils.isEmpty(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isBlank(codeClassifyEntity.getBtmTypeId())){
|
return R.fail("主题库关联的业务类型不能为空！");
|
}
|
QueryWrapper<CodeClassify> classifyQueryWrapper = new QueryWrapper<>();
|
classifyQueryWrapper.eq("parentCodeClassifyOid",codeClassifyEntity.getParentCodeClassifyOid());
|
classifyQueryWrapper.eq("id",codeClassifyEntity.getId());
|
List<CodeClassify> codeClassifyList = baseMapper.selectList(classifyQueryWrapper);
|
if(codeClassifyList.size()!=0){
|
return R.fail("当前分类下不允许分类编号重复，请检查！！！");
|
}
|
if(Func.isNotEmpty(codeClassifyEntity.getParentCodeClassifyOid())){
|
CodeClassify codeClassify = baseMapper.selectOne(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getOid, codeClassifyEntity.getParentCodeClassifyOid()));
|
codeClassifyEntity.setBtmTypeId(codeClassify.getBtmTypeId());
|
codeClassifyEntity.setBtmTypeName(codeClassify.getBtmTypeName());
|
}
|
DefaultAttrAssimtUtil.addDefaultAttrAssimt(codeClassifyEntity, MdmBtmTypeConstant.CODE_CLASSIFY);
|
codeClassifyEntity.setLcStatus(FRAMEWORK_DATA_ENABLED);
|
boolean resBoolean = SqlHelper.retBool(codeClassifyMapper.insert(codeClassifyEntity));
|
if (!resBoolean) {
|
return R.status(resBoolean);
|
}
|
// 分类添加成功，给系统管理员和当前角色增加分类权限和数据权限
|
ClassifyAuthDTO classifyAuthDTO = new ClassifyAuthDTO();
|
classifyAuthDTO.setClassifyId(codeClassifyEntity.getOid());
|
// classifyAuthDTO.setClassId(codeClassifyEntity.getId());
|
R r = sysClient.saveAddClassifyDefaultAuth(classifyAuthDTO);
|
if (!r.isSuccess()) {
|
throw new ServiceException("给角色授予默认权限时出现错误，原因："+r.getMsg());
|
}
|
return R.status(resBoolean);
|
}
|
|
/**
|
* 修改主题库分类
|
* @param codeClassifyEntity 主题库分类数据传输对象
|
* @return 执行结果
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R editSave(CodeClassify codeClassifyEntity) {
|
if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
|
return R.fail("传入数据不能为空！");
|
}
|
//检查ts
|
CodeClassify detail = codeClassifyMapper.selectById(codeClassifyEntity.getOid());
|
if(!detail.getTs().toString().equals(codeClassifyEntity.getTs().toString())){//不是最新的不让改
|
return R.fail("当前数据不是最新，请刷新后再修改！");
|
}
|
|
if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
|
return R.fail("只有在顶层的主题库分类才能设置业务类型");
|
}
|
// codeClassifyEntity.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
|
codeClassifyEntity.setLastModifier(String.valueOf(AuthUtil.getUser().getAccount()));
|
codeClassifyEntity.setLastModifyTime(new Date());
|
codeClassifyEntity.setTs(new Date());
|
int updateEntity = codeClassifyMapper.updateById(codeClassifyEntity);
|
// 如果不是叶子结点，则需要修改其下所有的子分类，是否参与关键属性校验的值
|
String oid = codeClassifyEntity.getOid();
|
List<CodeClassify> codeClassifies = codeClassifyMapper.selectStartWithCurrentOid(oid);
|
int updateAttr = 0;
|
// 不为空就需要该当前分类下所有子分类的isParticipateCheck
|
if(!codeClassifies.isEmpty()){
|
List<String> oids = codeClassifies.stream().map(CodeClassify::getOid).collect(Collectors.toList());
|
LambdaUpdateWrapper<CodeClassify> updateWrapper = Wrappers.<CodeClassify>update()
|
.lambda().in(CodeClassify::getOid, oids)
|
.set(CodeClassify::getIsParticipateCheck, codeClassifyEntity.getIsParticipateCheck());
|
// 父分类的业务类型做了更改，所有子分类的都得进行更改
|
if(!codeClassifyEntity.getBtmTypeId().equals(detail.getBtmTypeId())){
|
updateWrapper.set(CodeClassify::getBtmTypeId,codeClassifyEntity.getBtmTypeId())
|
.set(CodeClassify::getBtmTypeName,codeClassifyEntity.getBtmTypeName());
|
}
|
updateAttr = codeClassifyMapper.update(null,updateWrapper);
|
|
}
|
|
// //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。只有启用状态的分类才推送
|
// 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(updateAttr) & SqlHelper.retBool(updateEntity));
|
}
|
|
/**
|
* 检查 主题库分类是否删除
|
* @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("传入数据不能为空！");
|
}
|
CodeClassify codeClassifyNew = selectByOid(codeClassifyEntity.getOid());
|
if(codeClassifyNew == null){
|
return R.fail("未查询到相关数据！");
|
}
|
codeClassifyNew.setTs(codeClassifyEntity.getTs());
|
return checkIsCanDeleteForDO(codeClassifyEntity);
|
}
|
|
/**
|
* 主键查询数据对象
|
* @param oid 主键
|
* @return 数据对象
|
*/
|
private CodeClassify selectByOid(String oid){
|
List<CodeClassify> codeClassifyEntityList = codeClassifyMapper.selectClassifyByKeyAndReseRel("'" + oid.trim() + "'");
|
if (codeClassifyEntityList.isEmpty() || codeClassifyEntityList.get(0) == null || StringUtils.isBlank(codeClassifyEntityList.get(0).getOid())) {
|
throw new ServiceException("dataOidNotExist");//根据主键id未查到相关数据
|
}
|
return codeClassifyEntityList.get(0);
|
}
|
|
/**
|
* 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
|
* @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(codeClassifyEntity));
|
// .selectOne(Condition.getQueryWrapper(condition,CodeClassify.class));
|
if(detail == null){//不是最新的不让改
|
throw new ServiceException("当前数据不是最新，请刷新后再修改！");
|
}
|
//校验下级是否有引用
|
if(checkChildIsLinked(detail.getOid())){
|
return R.fail("dataCascadeLinkedNotDelete");
|
}
|
if(checkHasChild(detail.getOid())){
|
return R.fail("此数据有下级，无法进行删除！");
|
}
|
return R.status(!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<CodeClassifyTemplate> codeClstemplateEntities = codeClassifyTemplateMapper.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);
|
baseMapper.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){
|
|
List<CodeClassify> classifyList = codeClassifyMapper.selectStartWithCurrentOid(oid);
|
Date now = new Date();
|
// String userId = String.valueOf(AuthUtil.getUserId());
|
String account = AuthUtil.getUserAccount();
|
classifyList = classifyList.stream().map(s -> {
|
s.setLcStatus(lcStatus);
|
s.setTs(now);
|
s.setLastModifier(account);
|
s.setLastModifyTime(now);
|
return s;
|
}).collect(Collectors.toList());
|
// //查询修改前ts
|
// CodeClassify codeClassify = codeClassifyMapper.selectById(oid);//主要是为了查询ts
|
// codeClassify.setLcStatus(lcStatus);
|
// codeClassify.setTs(new Date());
|
// codeClassify.setLastModifyTime(new Date());
|
// codeClassify.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
|
//启用、停用
|
// int u = codeClassifyMapper.updateLcStatus(oid,lcStatus);
|
// int count = codeClassifyMapper.updateById(codeClassify);
|
codeClassifyMapper.batchUpdateLcStatus(classifyList);
|
// //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
|
// if(u!=0) {
|
// codeDuckingServiceI.insertCache1(lcStatus,lcStatus,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, oid, codeClassifyDO_old.getTs());
|
// }
|
// return R.data(SqlHelper.retBool(count));
|
return R.success("");
|
}
|
|
/**
|
* 主键批量获取主题库分类
|
* @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) throws ServiceException{
|
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 主键
|
* @return 数据对象
|
*/
|
private CodeClassify selectByOidRel(String oid){
|
|
List<CodeClassify> codeClassifyList = codeClassifyMapper.selectClassifyByKeyAndReseRel("'"+oid.trim()+"'");
|
// CodeClassify codeClassifyEntity = (CodeClassify) codeClassifyList;
|
if(codeClassifyList.size() == 0 ){
|
throw new ServiceException("dataNotExist");//根据主键id未查到相关数据
|
}
|
// if(codeClassifyEntity == null || StringUtils.isBlank(codeClassifyEntity.getOid())){
|
// throw new ServiceException("dataOidNotExist");//根据主键id未查到相关数据
|
// }
|
return codeClassifyList.get(0);
|
}
|
|
/**
|
* 查询主题库分类 树
|
* @param treeQueryObject 树查询对象
|
* @return 主题库分类 显示树
|
*/
|
@Override
|
public List<Tree> treeCodeClassify(TreeQueryObject treeQueryObject) throws ServiceException{
|
List<CodeClassify> doList = null;
|
String id = null;
|
String lcStatus = null;
|
if(!Objects.isNull(treeQueryObject.getConditionMap())){
|
id = treeQueryObject.getConditionMap().getOrDefault("id",null);
|
lcStatus = treeQueryObject.getConditionMap().getOrDefault("lcStatus",null);
|
}
|
if(StringUtils.isNotBlank(id) || StringUtils.isNotBlank(lcStatus) ){
|
//String tableName = this.getTableName(treeQueryObject.getConditionMap().get("btmTypeId"),treeQueryObject.getConditionMap().get("id"), treeQueryObject.getConditionMap().get("lcStatus"));
|
// TODO: 2024-1-24 23:25我去掉了懒加载，因为会影响数据授权过滤和分类搜索功能，而且这儿感觉没必要做懒加载
|
doList = codeClassifyMapper
|
.selectCodeClassifyDOByTree(
|
treeQueryObject.getConditionMap().get("id"),
|
treeQueryObject.getConditionMap().get("lcStatus"),
|
treeQueryObject.getParentOid(),
|
VciBaseUtil.checkAdminTenant() ? null:AuthUtil.getTenantId()
|
/*tableName*/
|
);
|
}else{
|
// 只要前端会传参数过来就不会出现走这句的情况，所以查询总数没在这儿添加
|
doList =codeClassifyMapper.selectCodeClassifyVOByTree(
|
treeQueryObject.getParentOid(),
|
VciBaseUtil.checkAdminTenant() ? null:AuthUtil.getTenantId()
|
);
|
}
|
List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
|
TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME);
|
treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
|
List<Tree> tree = revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyVO s) ->{
|
//可以在这里处理树节点的显示
|
return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
|
.getLcStatus()) ? (" 【停用】 ") : "");
|
});
|
// 非超管过滤未授权的分类
|
if(!VciBaseUtil.checkAdminTenant()){
|
// 那些分类具备查看权限
|
R<List<String>> viewClassByRoleIds = sysClient.getViewClassByRoleIds(
|
Arrays.asList(AuthUtil.getUser().getRoleId().split(",")),
|
treeQueryObject.getConditionMap().getOrDefault("authType","classify_auth"),
|
treeQueryObject.getConditionMap().getOrDefault("buttonCode","classify_view"),
|
treeQueryObject.getConditionMap().getOrDefault("menuCode","classifyTree")
|
);
|
// 请求失败或者请求得到的具备查看权限的分类id集合为空
|
if(!viewClassByRoleIds.isSuccess() && viewClassByRoleIds.getData().isEmpty()){
|
throw new ServiceException("主数据查看权限未配置，或配置有误！");
|
}
|
// 过滤
|
filterTreeNodes(tree,viewClassByRoleIds.getData());
|
}
|
// 加载分类是否具有子分类
|
tree.parallelStream().forEach(item -> {
|
boolean checkHasChild = checkHasChild(item.getOid());
|
item.setLeaf(!checkHasChild);
|
});
|
return tree;
|
}
|
|
/**
|
* 分类授权过滤掉没有权限的分类
|
* @param trees
|
* @param classifyIds
|
*/
|
private void filterTreeNodes(List<Tree> trees, List<String> classifyIds) {
|
Iterator<Tree> iterator = trees.iterator();
|
while (iterator.hasNext()) {
|
Tree tree = iterator.next();
|
/*Boolean checkHasChild = checkHasChild(tree.getOid());
|
tree.setLeaf(!checkHasChild);*/
|
if (classifyIds.contains(tree.getOid())) {
|
// 如果顶层节点存在 classifyIds ，直接保留其子节点集合
|
continue;
|
}
|
if (tree.getChildren() != null && !tree.getChildren().isEmpty()) {
|
filterTreeNodes(tree.getChildren(), classifyIds);
|
}
|
if (!hasMatchingChild(tree, classifyIds)) {
|
iterator.remove();
|
}
|
}
|
}
|
|
private boolean hasMatchingChild(Tree tree, List<String> classifyIds) {
|
if (classifyIds.contains(tree.getOid())) {
|
return true;
|
}
|
if (tree.getChildren() != null) {
|
for (Tree child : tree.getChildren()) {
|
if (hasMatchingChild(child, classifyIds)) {
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
/**
|
* 分类加载时获取业务类型id，拼接业务类型表名
|
* @return
|
*/
|
private String getTableName(String btmTypeId,String id,String lcStatus){
|
if(Func.isNotEmpty(btmTypeId)){
|
return VciBaseUtil.getTableName(btmTypeId,true);
|
}
|
LambdaQueryWrapper<CodeClassify> wrapper = Wrappers.<CodeClassify>query()
|
.lambda().select(CodeClassify::getBtmTypeId)
|
.eq(CodeClassify::getLcStatus, lcStatus)
|
.isNotNull(CodeClassify::getBtmTypeId)
|
.last("limit 1")
|
.eq(CodeClassify::getId,id).isNull(CodeClassify::getParentCodeClassifyOid);
|
|
CodeClassify codeClassify = codeClassifyMapper.selectOne(wrapper);
|
if(Func.isEmpty(codeClassify) || Func.isEmpty(codeClassify.getBtmTypeId())){
|
throw new ServiceException("查询主数据总数时，未获取到业务类型ID！");
|
}
|
return VciBaseUtil.getTableName(codeClassify.getBtmTypeId(),true);
|
}
|
|
/**
|
* 根据树形查询对象来查询数据对象
|
*
|
* @param treeQueryObject 树形查询对象
|
* @return 查询结果,数据对象
|
*/
|
@Override
|
public List<CodeClassifyVO> selectCodeClassifyDOByTree(TreeQueryObject treeQueryObject) {
|
List<CodeClassify> doList =codeClassifyMapper.selectCodeClassifyVOByTree(treeQueryObject.getParentOid(),AuthUtil.getTenantId());
|
List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
|
return voList;
|
}
|
|
/***
|
*
|
* @param parentOid
|
* @return
|
*/
|
@Override
|
public List<CodeClassifyVO> selectCodeClassifyVOByParentId(String parentOid) {
|
List<CodeClassify> doList =codeClassifyMapper.selectCodeClassifyDOByParentId(parentOid,AuthUtil.getTenantId());
|
List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
|
return voList;
|
}
|
|
/**
|
* 根据库节点名称获取分类
|
* @param libName
|
* @return
|
*/
|
@Override
|
public List<CodeClassifyVO> getRMLibByName(String libName) {
|
List<String> libNameList=new ArrayList<>();
|
if(StringUtils.isNotBlank(libName)){
|
libNameList=VciBaseUtil.str2List(libName);
|
}
|
List<CodeClassify> doList =codeClassifyMapper.getRMLibByName(libNameList,"Enabled",AuthUtil.getTenantId()
|
.equals(
|
NacosConfigCache
|
.getAdminUserInfo()
|
.getTenantId()
|
) ? null:AuthUtil.getTenantId());
|
List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
|
return voList;
|
}
|
|
/***
|
* 根据oid获取下面所有的分类信息
|
* @param oid
|
* @return
|
*/
|
public List<CodeClassifyVO> selectAllClassifyByOid(String oid, String fieldInPath){
|
List<CodeClassify> codeClassifyList=codeClassifyMapper.selectAllClassifyByOid(oid,fieldInPath,AuthUtil.getTenantId());
|
List<CodeClassifyVO> voList = codeClassifyDO2VOs(codeClassifyList);
|
return voList;
|
|
}
|
|
/**
|
* 根据顶层节点oid查询所有除当前节点以外所有不参与校验的分类oid
|
* @param topOid
|
* @param currentOid
|
* @return
|
*/
|
@Override
|
public String selectLeafByParentClassifyOid(String topOid, String currentOid) {
|
List<CodeClassify> codeClassifies = codeClassifyMapper.selectLeafByParentClassifyOid(topOid, currentOid);
|
if(codeClassifies.isEmpty()){
|
return "";
|
}
|
String oids = codeClassifies.stream()
|
.map(CodeClassify::getOid)
|
.map(s -> "'" + s + "'")
|
.collect(Collectors.joining(","));;
|
return oids;
|
}
|
|
/**
|
* 根据顶层节点oid查询所有叶子节点分类oid
|
* @param pid
|
* @return
|
*/
|
@Override
|
public String selectLeafByPid(String pid) {
|
List<CodeClassify> codeClassifies = codeClassifyMapper.selectLeafByPid(pid);
|
if(codeClassifies.isEmpty()){
|
return "";
|
}
|
String oids = codeClassifies.stream()
|
.map(CodeClassify::getOid)
|
.map(s ->s)
|
.collect(Collectors.joining(","));;
|
return oids;
|
}
|
|
/**
|
* 流水依赖生成
|
*/
|
@Override
|
public R flowingDependencyGen(String classifyOid) {
|
//查询此分类下面的所有分类
|
List<CodeClassify> codeClassifyList=codeClassifyMapper.selectAllClassifyByOid(classifyOid,AuthUtil.getTenantId(),null);
|
//查询码值表，获取最大流水
|
List<CodeAllCode> codeAllCodeVOS = codeAllCodeMapper.selectGroupByClassify("'" + codeClassifyList.stream()
|
.map(classfiy -> classfiy.getOid()).collect(Collectors.joining("','")) + "'","'${sav}'");
|
//往流水表里面加数据，有则更新，无则添加数据。
|
for (CodeAllCode codeAllCodeVO : codeAllCodeVOS) {
|
if(Func.isEmpty(codeAllCodeVO.getSerialUnit())){
|
throw new ServiceException("编码为：" + codeAllCodeVO.getId() + "的码值数据流水依赖不能为空！");
|
}
|
try {
|
CodeRuleVO codeRuleVO = codeRuleService.getObjectByOid(codeAllCodeVO.getCodeRuleOid());
|
if(Func.isEmpty(codeRuleVO)){
|
continue;
|
}
|
}catch (Exception e){
|
continue;
|
}
|
QueryWrapper<CodeBasicSec> secWrapper = new QueryWrapper<>();
|
secWrapper.eq("PKCODERULE",codeAllCodeVO.getCodeRuleOid());
|
secWrapper.eq("SECTYPE","codeserialsec");
|
List<CodeBasicSec> codeBasicSecs = codeBasicSecMapper.selectList(secWrapper);
|
if(codeBasicSecs.size() == 0 ){
|
throw new ServiceException("根据码值ID：" + codeAllCodeVO.getCodeRuleOid() + ",码段类型为流水码段(codeserialsec),在基础码段中未找到相关数据！");
|
}
|
QueryWrapper<CodeSerialValue> wrapper = new QueryWrapper<>();
|
wrapper.eq("codeRuleOid",codeAllCodeVO.getCodeRuleOid());
|
wrapper.eq("serialUnit",codeAllCodeVO.getSerialUnit());
|
wrapper.eq("codeSecOid",codeBasicSecs.get(0).getOid());
|
List<CodeSerialValue> codeSerialValues = codeSerialValueMapper.selectList(wrapper);
|
if(codeSerialValues.size() == 0){
|
CodeSerialValue newSerialValue = new CodeSerialValue();
|
DefaultAttrAssimtUtil.addDefaultAttrAssimt(newSerialValue,"codeserialvalue");
|
newSerialValue.setCodeRuleOid(codeAllCodeVO.getCodeRuleOid());
|
newSerialValue.setCodeSecOid(codeBasicSecs.get(0).getOid());
|
newSerialValue.setSerialUnit(codeAllCodeVO.getSerialUnit());
|
newSerialValue.setMaxSerial(codeAllCodeVO.getUnFillSerial());
|
newSerialValue.setLctid("defaultLC");
|
newSerialValue.setLcStatus("Exist");
|
codeSerialValueMapper.insert(newSerialValue);
|
}else{
|
codeSerialValues.get(0).setMaxSerial(codeAllCodeVO.getUnFillSerial());
|
codeSerialValues.get(0).setLastModifyTime(new Date());
|
codeSerialValues.get(0).setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
|
codeSerialValues.get(0).setTs(new Date());
|
codeSerialValueMapper.updateById(codeSerialValues.get(0));
|
}
|
}
|
return R.success("操作成功！");
|
}
|
|
/***
|
* 根据分类描述备注和库节点查询分类信息
|
* @param desc
|
* @param codeLibName
|
* @return
|
*/
|
@Override
|
public List<CodeClassifyVO> getRMTypeByDescAndLib(String desc, String codeLibName) {
|
List<CodeClassify> doList =codeClassifyMapper.getRMTypeByDesc(desc,"Enabled",AuthUtil.getTenantId());
|
if (CollectionUtils.isEmpty(doList)) {
|
return new LinkedList<CodeClassifyVO>();
|
}
|
CodeClassify codeClassify=doList.get(0);
|
List<CodeClassify> codeClassifyList=codeClassifyMapper.selectAllParenClassifytByOid(codeClassify.getOid(),AuthUtil.getTenantId());
|
CodeClassify currentLib = codeClassifyList.get(codeClassifyList.size() - 1);
|
if (!currentLib.getName().equals(codeLibName)) {
|
return new ArrayList<>();
|
}
|
List<CodeClassifyVO> voList = codeClassifyDO2VOs(codeClassifyList);
|
return voList;
|
}
|
|
/**
|
* 使用编号的路径获取对象
|
*
|
* @param fieldPath 编号的路径，一定要从最顶层节点开始，格式为xxx/yyy/zz 这样
|
* @return 分类的显示对象
|
*/
|
@Override
|
public CodeClassifyVO getObjectByClsfNamePath(String fieldPath){
|
CodeClassifyVO codeClassifyVO=new CodeClassifyVO();
|
List<CodeClassify> classifyList = codeClassifyMapper.selectByFieldNamePath(fieldPath,"name");
|
if(classifyList.size()>0){
|
codeClassifyVO=codeClassifyDO2VO(classifyList.get(0));
|
}
|
return codeClassifyVO;
|
}
|
/***
|
* 根据上级节点获取下级节点代号路径和名称路径
|
* @param classifyId
|
* @param enable
|
* @return
|
*/
|
@Override
|
public List<CodeClassifyVO> getIdPathToNamePathByParentId(String classifyId, boolean enable) {
|
List<CodeClassify> doList= codeClassifyMapper.getIdPathToNamePathByParentId(classifyId);
|
List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
|
return voList;
|
}
|
|
// /**
|
// * 根据树形查询对象来查询数据对象
|
// *
|
// * @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 -> 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);
|
// Collection<CodeRuleVO> ruleVOS = null;
|
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 = 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,"描述"));
|
codeClassifyVOS = codeClassifyVOS.stream().sorted(Comparator.comparing(CodeClassifyVO::getDataLevel)).collect(Collectors.toList());
|
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(codeClassify.getOid())?vo.getPath():codeClassify.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;
|
}
|
|
/**
|
* 获取子级的主题库分类
|
*
|
* @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,fieldInPath,AuthUtil.getTenantId());
|
if(!CollectionUtils.isEmpty(classifyDOS)){
|
classifyDOS = classifyDOS.parallelStream().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));
|
}
|
}
|
|
/**
|
* 创建导入模板
|
*
|
* @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<CodeClassify> codeClassify = 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(","))});
|
}
|
//编号获取业务类型服务
|
List<String> ruleOids = poList.stream().filter(
|
s -> StringUtils.isNotBlank(s.getCodeRuleId()))
|
.map(CodeClassifyPO::getCodeRuleId)
|
.collect(Collectors.toList());
|
Map<String, CodeRuleVO> ruleVOMap = Optional.ofNullable(ruleOids.size()==0 ? null:codeRuleService.listCodeRuleByIds(ruleOids,true)
|
).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
|
|
List<String> keyOids = poList.stream().filter(s -> StringUtils.isNotBlank(s.getKeyRepeatRuleId()))
|
.map(CodeClassifyPO::getKeyRepeatRuleId).collect(Collectors.toList());
|
Map<String,CodeKeyAttrRepeatRuleVO> keyRuleVOMap =Optional.ofNullable(keyOids.size()==0 ? null: iCodeKeyattrrepeatService.listCodeKeyAttrRepeatRuleByOids(keyOids)
|
).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
|
|
List<String> btmOids = poList.stream().filter(s -> StringUtils.isNotBlank(s.getBtmTypeId()))
|
.map(CodeClassifyPO::getBtmTypeId).collect(Collectors.toList());
|
Map<String, BtmTypeVO> btmVOMap = Optional
|
.ofNullable(btmOids.size()==0 ? null: btmTypeClient.selectByIdCollection(btmOids).getData())
|
.orElse(new ArrayList<BtmTypeVO>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
|
// Map<String, CodeOsbtmtypeVO> btmVOMap = null;
|
Map<String/**路径**/,String/**主键**/> oidPathMap = new HashMap<>();
|
|
//我们需要查询所有已经存在的分类，主要是路径，用来判断分类的数据
|
List<CodeClassify> existClassifyDOs = codeClassifyMapper.selectAllLevelChildHasPath("",null,AuthUtil.getTenantId());
|
Map<String/**路径**/, CodeClassify/**已经存在的数据**/> 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->{
|
CodeClassify classify = new CodeClassify();
|
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()});
|
}
|
classify.setOid(VciBaseUtil.getPk());
|
classify.setId(po.getId());
|
classify.setName(po.getName());
|
classify.setDescription(po.getDescription());
|
oidPathMap.put(po.getPath(),classify.getOid());
|
if(StringUtils.isNotBlank(po.getBtmTypeId())){
|
BtmTypeVO typeVO = (BtmTypeVO)btmVOMap.get(po.getBtmTypeId().toLowerCase(Locale.ROOT));
|
classify.setBtmTypeId(typeVO.getId());
|
classify.setBtmTypeName(typeVO.getName());
|
}
|
if(StringUtils.isNotBlank(po.getCodeRuleId())){
|
CodeRuleVO codeRuleVO = ruleVOMap.get(po.getCodeRuleId().toLowerCase(Locale.ROOT));
|
classify.setCodeRuleOid(codeRuleVO.getOid());
|
}
|
if(StringUtils.isNotBlank(po.getKeyRepeatRuleId())){
|
CodeKeyAttrRepeatRuleVO repeatRuleVO = keyRuleVOMap.get(po.getKeyRepeatRuleId());
|
classify.setCodeKeyAttrRepeatOid(repeatRuleVO.getOid());
|
}
|
classify.setLcStatus(po.getLcStatus());
|
classify.setPath(po.getPath());
|
codeClassify.add(classify);
|
});
|
//要看存在的，修改路径对应的主键
|
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<CodeClassify> addClassifyDOList = new ArrayList<>();
|
List<CodeClassify> editClassifyDOList = new ArrayList<>();
|
codeClassify.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()));
|
CodeClassify classifyDOInDB = pathDOMap.get(classifyDO.getPath());
|
classifyDOInDB.setOid(classifyDO.getOid());
|
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..updateById(classifyDOs.stream().collect(Collectors.toList()));
|
classifyDos->{
|
for (CodeClassify classifyDo : classifyDos) {
|
codeClassifyMapper.updateById(classifyDo);
|
}
|
// }
|
});
|
}
|
if(!CollectionUtils.isEmpty(addClassifyDOList)){
|
// revisionModelUtil.wrapperForBatchAdd(addClassifyDOList);
|
VciBaseUtil.switchCollectionForOracleIn(addClassifyDOList).stream().forEach(classifyDOs->{
|
for (CodeClassify classifyDO : classifyDOs) {
|
classifyDO.setCreateTime(new Date());
|
classifyDO.setTs(new Date());
|
classifyDO.setBtmname("codeclassify");
|
classifyDO.setLcStatus("Enabled");
|
classifyDO.setOwner(String.valueOf(AuthUtil.getUser().getUserId()));
|
// classifyDO.setCreator(String.valueOf(AuthUtil.getUser().getUserId()));
|
// classifyDO.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
|
classifyDO.setCreator(String.valueOf(AuthUtil.getUser().getAccount()));
|
classifyDO.setLastModifier(String.valueOf(AuthUtil.getUser().getAccount()));
|
classifyDO.setLastModifyTime(new Date());
|
codeClassifyMapper.insert(classifyDO);
|
}
|
// codeClassifyMapper.batchInsert(classifyDOs.stream().collect(Collectors.toList()));
|
});
|
}
|
|
}
|
|
/**
|
* 获取分类关联的属性
|
*
|
* @param baseQueryObject 查询对象，必须有codeClassifyOid，支持id和name两种查询条件
|
* @return 属性的信息，包含默认的属性
|
*/
|
@Override
|
public DataGrid<BtmTypeAttributeVO> listClassifyLinkAttr(BaseQueryObject baseQueryObject) throws ServiceException{
|
if(baseQueryObject == null){
|
baseQueryObject = new BaseQueryObject();
|
}
|
if(baseQueryObject.getConditionMap() == null){
|
baseQueryObject.setConditionMap(new HashMap<>());
|
}
|
String classifyOid = baseQueryObject.getConditionMap().getOrDefault("codeClassifyOid","");
|
String btmTypeOid = baseQueryObject.getConditionMap().getOrDefault("btmTypeOid","");
|
String id = baseQueryObject.getConditionMap().getOrDefault("id","");
|
String name = baseQueryObject.getConditionMap().getOrDefault("name","");
|
if(StringUtils.isBlank(classifyOid)){
|
return new DataGrid<>();
|
}
|
if(StringUtils.isBlank(btmTypeOid)){
|
return new DataGrid<>();
|
}
|
CodeClassifyVO topClassifyVO = getTopClassifyVO(classifyOid);
|
if(topClassifyVO == null || StringUtils.isBlank(topClassifyVO.getBtmTypeId())){
|
return new DataGrid<>();
|
}
|
|
Map<String,Object> condition = new HashMap<>(1);
|
condition.put("pkbtmtype",topClassifyVO.getBtmTypeId());
|
R<BtmTypeVO> btmTypeDetail = btmTypeClient.getDetail(btmTypeOid);
|
if(!btmTypeDetail.isSuccess()){
|
throw new ServiceException("业务类型feign接口调用出错");
|
}
|
List<BtmTypeAttributeVO> unDefaultAttributes = btmTypeDetail.getData().getAttributes();
|
// List<CodeOsbtmtypeattributeEntity> unDefaultAttributes = codeOsbtmtypeattributeMapper.selectByMap(condition);
|
// List<OsBtmTypeAttributeVO> unDefaultAttributes = btmService. (topClassifyVO.getBtmtypeid());
|
List<BtmTypeAttributeVO> attributeVOS = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(unDefaultAttributes)){
|
unDefaultAttributes.stream().forEach(attr->{
|
BtmTypeAttributeVO attributeVO = new BtmTypeAttributeVO();
|
BeanUtils.copyProperties(attr,attributeVO);
|
attributeVO.setAttrDataType(attr.getAttrDataType());
|
attributeVO.setAttributeLength(attr.getAttributeLength());
|
attributeVO.setBtmTypeId(btmTypeDetail.getData().getId());
|
attributeVO.setBtmname(btmTypeDetail.getData().getName());
|
attributeVO.setAttrDataTypeText(EnumCache.getValue(EnumEnum.VCI_FIELD_TYPE,attr.getAttrDataType()));
|
boolean add = true;
|
if(StringUtils.isNotBlank(id) && !attributeVO.getId().contains(id.replace("*",""))){
|
add = false;
|
}
|
if(StringUtils.isNotBlank(name) && !attributeVO.getName().contains(name.replace("*",""))){
|
add = false;
|
}
|
if(add){
|
attributeVOS.add(attributeVO);
|
}
|
});
|
}
|
R<BtmTypeVO> btmTypeVOR = btmTypeClient.getDefaultAttrByBtmId(topClassifyVO.getBtmTypeId());
|
if(!btmTypeVOR.isSuccess()){
|
throw new ServiceException("业务类型feign接口调用出错");
|
}
|
List<BtmTypeAttributeVO> defaultAttrVOS = btmTypeVOR.getData().getAttributes();
|
|
// 取两个集合差集
|
List<String> ids = unDefaultAttributes.stream().map(BtmTypeAttributeVO::getId).collect(Collectors.toList());
|
defaultAttrVOS.forEach(item->{
|
if(!ids.contains(item.getId())){
|
BtmTypeAttributeVO attributeVO = new BtmTypeAttributeVO();
|
BeanUtils.copyProperties(item,attributeVO);
|
attributeVO.setAttrDataType(item.getAttrDataType());
|
attributeVO.setAttributeLength(item.getAttributeLength());
|
attributeVO.setBtmTypeId(btmTypeDetail.getData().getId());
|
attributeVO.setBtmname(btmTypeDetail.getData().getName());
|
attributeVO.setAttrDataTypeText(EnumCache.getValue(EnumEnum.VCI_FIELD_TYPE,item.getAttrDataType()));
|
boolean add = true;
|
if(StringUtils.isNotBlank(id) && !item.getId().contains(id.replace("*",""))){
|
add = false;
|
}
|
if(StringUtils.isNotBlank(name) && !item.getName().contains(name.replace("*",""))){
|
add = false;
|
}
|
if(add){
|
attributeVOS.add(attributeVO);
|
}
|
}
|
});
|
|
DataGrid<BtmTypeAttributeVO> dataGrid = new DataGrid<>();
|
dataGrid.setData(attributeVOS);
|
dataGrid.setTotal(attributeVOS.size());
|
return dataGrid;
|
}
|
|
/**
|
* 获取当前分类的顶层分类
|
*
|
* @param codeClassifyOid 分类的主键
|
* @return 顶层分类的信息
|
*/
|
@Override
|
public CodeClassifyVO getTopClassifyVO(String codeClassifyOid) {
|
VciBaseUtil.alertNotNull(codeClassifyOid,"分类的主键");
|
|
// List<Map<String,Object>> classifyDOS = codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid);
|
List<CodeClassify> classifyDOS = selectAllLevelParentByOid(codeClassifyOid);
|
|
if(!CollectionUtils.isEmpty(classifyDOS)){
|
CodeClassify classifyDO = classifyDOS.stream().filter(s -> StringUtils.isBlank(s.getParentCodeClassifyOid())).findFirst().orElseGet(() -> null);
|
if(classifyDO!=null){
|
return codeClassifyDO2VO(classifyDO);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 获取当前分类的所有上级分类（含本次查询层级号）
|
* @param oid 主键
|
* @return 所有的上级
|
*/
|
@Override
|
public List<CodeClassify> selectAllLevelParentByOid(String oid){
|
// String sql = "select oid,level from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY) + " start with oid= :oid connect by prior PARENTCODECLASSIFYOID = oid ";
|
// Map< String,String> conditionMap = new HashMap< String,String>();
|
// conditionMap.put("oid",oid);
|
|
List<Map<String,Object>> cbos = codeClassifyMapper.selectAllLevelParentByOid(oid);
|
Map<String,String> oidLevelMap = new HashMap<>();
|
Optional.ofNullable(cbos).orElseGet(()->new ArrayList<>()).stream().forEach(cbo->{
|
// 用key取map值并且不区分大小写
|
oidLevelMap.put(cbo.getOrDefault("OID",cbo.get("oid")).toString(),cbo.get("LEVEL").toString());
|
});
|
if(CollectionUtils.isEmpty(oidLevelMap)){
|
return new ArrayList<>();
|
}
|
|
//使用主键查询一下
|
String oids = "";
|
for (String s : oidLevelMap.keySet()) {
|
oids += "'"+s+"',";
|
}
|
List<CodeClassify> classifyDOS = codeClassifyMapper.selectClassifyByKeyAndReseRel(oids.substring(0,oids.length()-1));
|
if(!CollectionUtils.isEmpty(classifyDOS)){
|
classifyDOS.stream().forEach(classifyDO->{
|
classifyDO.setDataLevel(VciBaseUtil.getInt(oidLevelMap.getOrDefault(classifyDO.getOid(),"0")));
|
classifyDO.setLcStatusText(EnumCache.getValue("codeLcstatus",classifyDO.getLcStatus()));
|
});
|
}
|
return classifyDOS;
|
}
|
|
/**
|
* 主键获取主题库分类
|
* @param oid 主键
|
* @return 主题库分类显示对象
|
* @throws VciBaseException 参数为空，数据不存在时会抛出异常
|
*/
|
@Override
|
public CodeClassifyVO getObjectByOid(String oid) throws VciBaseException{
|
return codeClassifyDO2VO(selectByOid(oid));
|
}
|
|
/**
|
* 使用编号的路径获取对象
|
*
|
* @param idPath 编号的路径，一定要从最顶层节点开始，格式为xxx/yyy/zz 这样
|
* @return 分类的显示对象
|
*/
|
@Override
|
public CodeClassifyVO getObjectByIdPath(String idPath) {
|
List<Map<String, Object>> idPathValues = codeClassifyMapper.selectByFieldPath("#" + idPath);
|
CodeClassify classifyDO = null;
|
if (idPathValues != null){
|
classifyDO = codeClassifyMapper.selectByIdRel(idPathValues.get(0).get("OID").toString());
|
}
|
return codeClassifyDO2VO(classifyDO);
|
}
|
|
/**
|
* 主题库的树,已联调业务类型查询feign
|
* @param treeQueryObject 树形查询对象
|
* @return 主题库显示树
|
*/
|
@Override
|
public List<Tree> treeTopCodeClassify(TreeQueryObject treeQueryObject) {
|
if(treeQueryObject == null){
|
treeQueryObject = new TreeQueryObject();
|
}
|
if(treeQueryObject.getConditionMap() == null){
|
treeQueryObject.setConditionMap(new HashMap<String,String>());
|
}
|
treeQueryObject.getConditionMap().put(PARENT_FIELD_NAME, "=null");
|
List<Tree> trees = treeCodeClassify(treeQueryObject);
|
treeQueryObject.getConditionMap().put("domain", AppConstant.APPLICATION_NAME_CODE);
|
BaseQueryObject baseQueryObject = new BaseQueryObject();
|
baseQueryObject.setConditionMap(treeQueryObject.getConditionMap());
|
List<BtmTypeVO> btmTypeVOS = btmTypeClient.getRef(baseQueryObject).getData();
|
if(Func.isEmpty(btmTypeVOS) || Func.isEmpty(trees)){
|
return null;
|
}
|
List<Tree> treeList = trees.stream().filter(tree -> !CollectionUtils.isEmpty(btmTypeVOS.stream().filter(btmType -> {
|
if(Objects.equals(tree.getAttributes().get("btmTypeId"), btmType.getId())){
|
tree.getAttributes().put("btmTypeOid",btmType.getOid());
|
return true;
|
}
|
return false;
|
}).collect(Collectors.toList())))
|
.collect(Collectors.toList());
|
return treeList;
|
}
|
|
/**
|
* 获取这个分类下的业务类型，当前没有就获取上级的第一个业务类型
|
* @param oid 当前分类的oid
|
* @return oid,id,name,btmtypeid,btmtypename，没有就返回null
|
*/
|
@Override
|
public CodeClassify selectBtmOrParentBtm(String oid){
|
List<CodeClassify> oidList = selectAllLevelParents(oid);
|
return oidList.size()==0?null:oidList.get(0);
|
}
|
|
/**
|
* 获取所有层级上级关联业务类型数据
|
* @param oid 当前分类的oid
|
* @return oid,id,name,btmtypeid,btmtypename
|
*/
|
@Override
|
public List<CodeClassify> selectAllLevelParents(String oid){
|
// String sql = "select oid,id,name,btmtypeid,btmtypename from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY) + " where btmtypeid is not null start with oid= :oid connect by prior PARENTCODECLASSIFYOID=oid ";
|
// Map< String,String> conditionMap = new HashMap< String,String>();
|
// conditionMap.put("oid",oid);
|
// List<Map> dataList = boService.queryBySqlForMap(sql,conditionMap);
|
List<Map<String, Object>> dataList = codeClassifyMapper.selectAllLevelParents(oid);
|
List<CodeClassify> oidList = new ArrayList<CodeClassify>();
|
if(!CollectionUtils.isEmpty(dataList)){
|
for(Map data:dataList){
|
CodeClassify codeClassifyDO = new CodeClassify();
|
codeClassifyDO.setOid(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"OID")));
|
codeClassifyDO.setId(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"ID")));
|
codeClassifyDO.setName(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"NAME")));
|
codeClassifyDO.setBtmTypeId(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"BTMTYPEID")));
|
codeClassifyDO.setBtmTypeName(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"BTMTYPENAME")));
|
oidList.add(codeClassifyDO);
|
}
|
}
|
return oidList;
|
}
|
|
/**
|
* 查询所有上层父节点的oid
|
* @param oid
|
* @return
|
*/
|
@Override
|
public List<String> selectAllParentOid(String oid){
|
if(Func.isBlank(oid)){
|
return new ArrayList<>();
|
}
|
return this.codeClassifyMapper.selectAllParentOid(oid);
|
}
|
|
/**
|
* 使用分类主键获取分类相关的所有信息
|
*
|
* @param codeClassifyOid 分类的主键
|
* @return 分类上级，下级的信息
|
*/
|
@Override
|
public CodeClassifyFullInfoBO getClassifyFullInfo(String codeClassifyOid) {
|
VciBaseUtil.alertNotNull(codeClassifyOid,"分类的主键");
|
CodeClassifyFullInfoBO fullInfo = new CodeClassifyFullInfoBO();
|
CodeClassify classifyDO = selectByOidRel(codeClassifyOid);
|
//查询上级
|
fullInfo.setCurrentClassifyVO(codeClassifyDO2VO(classifyDO));
|
// List<Map<String, Object>> maps = codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid);
|
// List<Map<String, Object>> maps = selectAllLevelParentByOid(codeClassifyOid);
|
List<CodeClassify> codeClassifyList = selectAllLevelParentByOid(codeClassifyOid);
|
// for (Map<String, Object> map : maps) {
|
// CodeClassify codeClassify = new CodeClassify();
|
// codeClassify.setOid(String.valueOf(map.get("OID")));
|
// codeClassify.setDataLevel((Integer) map.get("LEVEL"));
|
// codeClassifyList.add(codeClassify);
|
// }
|
|
fullInfo.setParentClassifyVOs(codeClassifyDO2VOs(codeClassifyList));
|
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 int countChildrenByClassifyOid(String codeClassifyOid) {
|
// Map<String,String> conditionMap = new HashMap<>();
|
// conditionMap.put("parentCodeClassifyOid",codeClassifyOid);
|
QueryWrapper<CodeClassify> wrapper = new QueryWrapper<>();
|
wrapper.eq("parentCodeClassifyOid",codeClassifyOid);
|
return codeClassifyMapper.selectCount(wrapper).intValue();
|
}
|
|
}
|
