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.entity.CodeClassify;
|
import com.vci.ubcs.code.mapper.CodeClassifyMapper;
|
import com.vci.ubcs.code.service.ICodeClassifyService;
|
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
|
import com.vci.ubcs.core.log.exception.ServiceException;
|
import jodd.bean.BeanUtil;
|
import org.springblade.core.mp.support.Condition;
|
import org.springblade.core.secure.utils.AuthUtil;
|
import org.springblade.core.tool.api.R;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
@Service
|
public class ICodeClassifyServiceImpl extends ServiceImpl<CodeClassifyMapper, CodeClassify> implements ICodeClassifyService {
|
|
@Resource
|
private CodeClassifyMapper codeClassifyMapper;
|
|
/**
|
* 使用查询封装器来查询
|
* @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);
|
|
//先简称是否有关联模板，有模板要先删除
|
// 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(result.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);
|
return null;
|
}
|
|
}
|
