package com.vci.web.dao.impl;
|
|
import com.vci.dto.VciFileDocClassifyDTO;
|
import com.vci.dto.VciFileDocClassifyDTOList;
|
import com.vci.model.VciFileDocClassifyDO;
|
import com.vci.pagemodel.VciFileDocClassifyVO;
|
import com.vci.starter.revision.service.RevisionModelUtil;
|
import com.vci.starter.web.annotation.bus.VciChangeDocument;
|
import com.vci.starter.web.enumpck.VciChangeDocumentTypeEnum;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.pagemodel.BaseResult;
|
import com.vci.starter.web.pagemodel.DataGrid;
|
import com.vci.starter.web.pagemodel.KeyValue;
|
import com.vci.starter.web.pagemodel.PageHelper;
|
import com.vci.starter.web.util.BeanUtilForVCI;
|
import com.vci.starter.web.util.VciBaseUtil;
|
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
|
import com.vci.web.dao.VciFileDocClassifyDaoI;
|
import com.vci.web.service.VciFileDocClassifyServiceI;
|
import org.apache.commons.lang3.StringUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
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.constant.FrameWorkLangCodeConstant.*;
|
|
/**
|
* 文档的类型服务
|
*
|
* @author weidy
|
* @date 2020-08-04
|
*/
|
@Service
|
@VciChangeDocument(btmType = "fileDocClassify")
|
public class VciFileDocClassifyServiceImpl implements VciFileDocClassifyServiceI {
|
|
/**
|
* 日志
|
*/
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
|
/**
|
* 数据操作层
|
*/
|
@Resource
|
private VciFileDocClassifyDaoI vciFileDocClassifyMapper;
|
|
/**
|
* 版本和数据对象工具类
|
*/
|
@Autowired
|
private RevisionModelUtil revisionModelUtil;
|
|
/**
|
* 查询所有的文档的类型
|
* @param conditionMap 查询条件
|
* @param pageHelper 分页和排序
|
* @return 执行结果
|
* @throws VciBaseException 查询条件和分页出错的时候会抛出异常
|
*/
|
@Override
|
public DataGrid<VciFileDocClassifyVO> gridVciFileDocClassify(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
|
if (pageHelper == null) {
|
pageHelper = new PageHelper(-1);
|
}
|
VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(conditionMap,VciFileDocClassifyDO.class,pageHelper);
|
List<VciFileDocClassifyDO> doList = vciFileDocClassifyMapper.selectByWrapper(queryWrapper);
|
DataGrid<VciFileDocClassifyVO> dataGrid=new DataGrid<>();
|
if (!CollectionUtils.isEmpty(doList)) {
|
dataGrid.setData(vciFileDocClassifyDO2VOs(doList));
|
queryWrapper.clearPage();
|
dataGrid.setTotal(vciFileDocClassifyMapper.countByWrapper(queryWrapper));
|
}
|
return dataGrid;
|
}
|
|
/**
|
* 批量数据对象转换为显示对象
|
* @param vciFileDocClassifyDOs 数据对象列表
|
* @return 显示对象
|
* @throws VciBaseException 参数为空或者不存在的时候会抛出异常
|
*/
|
@Override
|
public List<VciFileDocClassifyVO> vciFileDocClassifyDO2VOs(Collection<VciFileDocClassifyDO> vciFileDocClassifyDOs) throws VciBaseException {
|
List<VciFileDocClassifyVO> voList = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(vciFileDocClassifyDOs)){
|
vciFileDocClassifyDOs.stream().forEach(s ->{
|
VciFileDocClassifyVO vo = vciFileDocClassifyDO2VO(s);
|
if(vo != null){
|
voList.add(vo);
|
}
|
});
|
}
|
return voList;
|
}
|
|
/**
|
* 数据对象转换为显示对象
|
* @param vciFileDocClassifyDO 数据对象
|
* @return 显示对象
|
* @throws VciBaseException 拷贝属性出错的时候会抛出异常
|
*/
|
@Override
|
public VciFileDocClassifyVO vciFileDocClassifyDO2VO(VciFileDocClassifyDO vciFileDocClassifyDO) throws VciBaseException {
|
VciFileDocClassifyVO vo = new VciFileDocClassifyVO();
|
if(vciFileDocClassifyDO != null){
|
BeanUtilForVCI.convert(vciFileDocClassifyDO,vo);
|
//还需要处理枚举等其他的内容
|
}
|
return vo;
|
}
|
|
/**
|
* 增加文档的类型
|
* @param vciFileDocClassifyDTO 文档的类型数据传输对象
|
* @return 执行结果
|
* @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
|
*/
|
@Override
|
@VciChangeDocument(changeType = VciChangeDocumentTypeEnum.ADD)
|
public VciFileDocClassifyVO addSave(VciFileDocClassifyDTO vciFileDocClassifyDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(vciFileDocClassifyDTO,"需要添加的数据对象");
|
//将DTO转换为DO
|
VciFileDocClassifyDO vciFileDocClassifyDO = new VciFileDocClassifyDO();
|
BeanUtilForVCI.convert(vciFileDocClassifyDTO,vciFileDocClassifyDO);
|
|
revisionModelUtil.wrapperForAdd(vciFileDocClassifyDO);
|
int insert = vciFileDocClassifyMapper.insert(vciFileDocClassifyDO);
|
if(insert>0){
|
return vciFileDocClassifyDO2VO(vciFileDocClassifyDO);
|
}else{
|
throw new VciBaseException(ADD_FAIL);
|
}
|
}
|
|
/**
|
* 修改文档的类型
|
* @param vciFileDocClassifyDTO 文档的类型数据传输对象
|
* @return 执行结果
|
* @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
|
*/
|
@Override
|
@VciChangeDocument(changeType = VciChangeDocumentTypeEnum.EDIT)
|
public VciFileDocClassifyVO editSave(VciFileDocClassifyDTO vciFileDocClassifyDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(vciFileDocClassifyDTO,"数据对象",vciFileDocClassifyDTO.getOid(),"文档的类型主键");
|
//将DTO转换为DO
|
VciFileDocClassifyDO vciFileDocClassifyDO = selectByOid(vciFileDocClassifyDTO.getOid());
|
revisionModelUtil.copyFromDTO(vciFileDocClassifyDTO,vciFileDocClassifyDO);
|
revisionModelUtil.wrapperForEdit(vciFileDocClassifyDO);
|
int update = vciFileDocClassifyMapper.updateByPrimaryKey(vciFileDocClassifyDO);
|
if(update>0){
|
return vciFileDocClassifyDO2VO(vciFileDocClassifyDO);
|
}else{
|
throw new VciBaseException(EDIT_FAIL);
|
}
|
}
|
|
|
/**
|
* 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
|
* @param vciFileDocClassifyDTO 数据传输对象
|
* @param vciFileDocClassifyDO 数据库中的数据对象
|
* @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
|
*/
|
private BaseResult checkIsCanDeleteForDO(VciFileDocClassifyDTO vciFileDocClassifyDTO, VciFileDocClassifyDO vciFileDocClassifyDO) {
|
revisionModelUtil.checkTs(vciFileDocClassifyDTO.getTs(),vciFileDocClassifyDO.getTs());
|
if(!checkIsLinked(vciFileDocClassifyDO.getOid())) {
|
return BaseResult.success();
|
}else{
|
return BaseResult.fail(DATA_LINKED_NOT_DELETE,new String[]{""});
|
}
|
}
|
|
/**
|
* 校验是否被引用
|
* @param oid 主键
|
* @throws VciBaseException 被引用的时候会抛出异常
|
*/
|
private boolean checkIsLinked(String oid) throws VciBaseException {
|
//TODO 添加需要校验引用的地方
|
return false;
|
}
|
|
/**
|
* 删除文档的类型
|
* @param vciFileDocClassifyDTO 文档的类型数据传输对象，oid和ts需要传输
|
* @return 删除结果反馈：：success：成功，fail：失败
|
* @throws VciBaseException 参数为空，被引用时抛出异常
|
*/
|
@Override
|
@VciChangeDocument(changeType = VciChangeDocumentTypeEnum.DELETE)
|
public BaseResult deleteVciFileDocClassify(VciFileDocClassifyDTO vciFileDocClassifyDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(vciFileDocClassifyDTO,"文档的类型数据对象",vciFileDocClassifyDTO.getOid(),"文档的类型的主键");
|
VciFileDocClassifyDO vciFileDocClassifyDO = selectByOid(vciFileDocClassifyDTO.getOid());
|
BaseResult baseResult = checkIsCanDeleteForDO(vciFileDocClassifyDTO,vciFileDocClassifyDO);
|
if(baseResult.isSuccess()) {
|
}else{
|
return baseResult;
|
}
|
//执行删除操作
|
return (vciFileDocClassifyMapper.deleteByPrimaryKey(vciFileDocClassifyDO.getOid()) > 0)? BaseResult.successMsg(DELETE_SUCCESS): BaseResult.fail(DELETE_FAIL);
|
}
|
|
/**
|
* 主键获取文档的类型
|
* @param oid 主键
|
* @return 文档的类型显示对象
|
* @throws VciBaseException 参数为空，数据不存在时会抛出异常
|
*/
|
@Override
|
public VciFileDocClassifyVO getObjectByOid(String oid) throws VciBaseException {
|
return vciFileDocClassifyDO2VO(selectByOid(oid));
|
}
|
|
/**
|
* 主键查询数据对象
|
* @param oid 主键
|
* @return 数据对象
|
* @throws VciBaseException 参数为空，并且数据不存在的时候会抛出异常
|
*/
|
private VciFileDocClassifyDO selectByOid(String oid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oid,"主键");
|
VciFileDocClassifyDO vciFileDocClassifyDO = vciFileDocClassifyMapper.selectByPrimaryKey(oid.trim());
|
if(vciFileDocClassifyDO == null || StringUtils.isBlank(vciFileDocClassifyDO.getOid())){
|
throw new VciBaseException(DATA_OID_NOT_EXIST);
|
}
|
return vciFileDocClassifyDO;
|
}
|
|
/**
|
* 主键批量获取文档的类型
|
* @param oidCollections 主键集合，但是受性能影响，建议一次查询不超过10000个
|
* @return 文档的类型显示对象
|
* @throws VciBaseException 查询出现异常时会抛出
|
*/
|
@Override
|
public Collection<VciFileDocClassifyVO> listVciFileDocClassifyByOids(Collection<String> oidCollections) throws VciBaseException {
|
VciBaseUtil.alertCollectionNotNull("数据对象主键集合",oidCollections);
|
List<VciFileDocClassifyDO> vciFileDocClassifyDOList = listVciFileDocClassifyDOByOidCollections(oidCollections);
|
return vciFileDocClassifyDO2VOs(vciFileDocClassifyDOList);
|
}
|
|
/**
|
* 使用主键集合查询数据对象
|
* @param oidCollections 主键的集合
|
* @return 数据对象列表
|
*/
|
private List<VciFileDocClassifyDO> listVciFileDocClassifyDOByOidCollections(Collection<String> oidCollections){
|
List<VciFileDocClassifyDO> vciFileDocClassifyDOList = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(oidCollections)){
|
Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
|
oidCollectionsList.stream().forEach(oids ->{
|
List<VciFileDocClassifyDO> tempDOList = vciFileDocClassifyMapper.selectByPrimaryKeyCollection(oids);
|
if(!CollectionUtils.isEmpty(tempDOList)){
|
vciFileDocClassifyDOList.addAll(tempDOList);
|
}
|
});
|
}
|
return vciFileDocClassifyDOList;
|
}
|
|
/**
|
* 参照文档的类型列表
|
* @param conditionMap 查询条件
|
* @param pageHelper 分页和排序
|
* @return 文档的类型显示对象列表，生效的内容
|
* @throws VciBaseException 查询条件和分页出错的时候会抛出异常
|
*/
|
@Override
|
public DataGrid<VciFileDocClassifyVO> refDataGridVciFileDocClassify(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
|
if(conditionMap == null){
|
conditionMap = new HashMap<>();
|
}
|
return gridVciFileDocClassify(conditionMap,pageHelper);
|
}
|
|
/**
|
* 校验编号是否存在
|
*
|
* @param idCollections 编号的集合
|
* @return success为true表示存在,否则在data中获取不存在的内容
|
*/
|
@Override
|
public BaseResult checkClassifyIdsExist(Collection<String> idCollections) {
|
VciBaseUtil.alertCollectionNotNull("文档类型编号",idCollections);
|
Collection<Collection<String>> idCollectionss = VciBaseUtil.switchCollectionForOracleIn(idCollections);
|
Set<String> existIdsSet = new HashSet<>();
|
idCollectionss.stream().forEach(ids-> {
|
List<VciFileDocClassifyDO> fileDocClassifyDOS = vciFileDocClassifyMapper.selectByIdCollection(ids);
|
if(!CollectionUtils.isEmpty(fileDocClassifyDOS)){
|
existIdsSet.addAll(fileDocClassifyDOS.stream().map(VciFileDocClassifyDO::getId).collect(Collectors.toSet()));
|
}
|
});
|
if(existIdsSet.size() ==0){
|
BaseResult baseResult = BaseResult.fail(DATA_ID_NOT_EXIST);
|
baseResult.setData(idCollections);
|
return baseResult;
|
}
|
Set<String> unExistIdSet = new HashSet<>();
|
idCollections.stream().forEach(id ->{
|
if(!existIdsSet.contains(id)){
|
unExistIdSet.add(id);
|
}
|
});
|
if(!CollectionUtils.isEmpty(unExistIdSet)){
|
BaseResult baseResult = BaseResult.fail(DATA_ID_NOT_EXIST);
|
baseResult.setData(unExistIdSet);
|
return baseResult;
|
}
|
return BaseResult.success();
|
}
|
|
/**
|
* 批量添加分类
|
*
|
* @param fileDocClassifyDTOList 分类的数据传输对象
|
* @return success为true表示执行成功
|
*/
|
@Override
|
public BaseResult batchAddSave(VciFileDocClassifyDTOList fileDocClassifyDTOList) {
|
VciBaseUtil.alertNotNull(fileDocClassifyDTOList,"文件类型的数据传输对象");
|
List<VciFileDocClassifyDO> doList = new ArrayList<>();
|
List<VciFileDocClassifyDTO> dtoList = fileDocClassifyDTOList.getDocClassifyDTOList();
|
VciBaseUtil.alertCollectionNotNull("文件类型的数据传输对象",dtoList);
|
//循环处理
|
dtoList.stream().forEach(dto->{
|
VciFileDocClassifyDO classifyDO = new VciFileDocClassifyDO();
|
BeanUtilForVCI.convert(dto,classifyDO);
|
VciBaseUtil.alertNotNull(classifyDO.getId(),"文件类型编号",classifyDO.getName(),"文件类型名称");
|
doList.add(classifyDO);
|
});
|
revisionModelUtil.wrapperForBatchAdd(doList);
|
doList.stream().forEach(classifyDO->{
|
vciFileDocClassifyMapper.insert(classifyDO);
|
});
|
return BaseResult.success(ADD_SUCCESS);
|
}
|
|
/**
|
* 使用编号查询对象
|
* @param id 编号
|
* @return 文档类型对象
|
* @throws VciBaseException 参数为空和不存在的时候会抛出异常
|
*/
|
private VciFileDocClassifyDO selectById(String id) throws VciBaseException {
|
VciBaseUtil.alertNotNull(id,"文档类型编号");
|
VciFileDocClassifyDO classifyDO = vciFileDocClassifyMapper.selectById(id.trim());
|
if(classifyDO == null || StringUtils.isBlank(classifyDO.getOid())){
|
throw new VciBaseException(DATA_ID_NOT_EXIST,new String[]{id});
|
}
|
return classifyDO;
|
}
|
|
/**
|
* 使用编号获取对象
|
*
|
* @param id 编号
|
* @return 显示对象
|
* @throws VciBaseException 参数为空或者执行出错的时候会抛出异常
|
*/
|
@Override
|
public VciFileDocClassifyVO getObjectById(String id) throws VciBaseException {
|
return vciFileDocClassifyDO2VO(selectById(id));
|
}
|
|
/**
|
* 使用编号批量获取类型对象
|
*
|
* @param idCollection 编号集合
|
* @return 显示对象
|
* @throws VciBaseException 参数为空或者执行出错的时候会抛出异常
|
*/
|
@Override
|
public List<VciFileDocClassifyVO> listVciFileDocClassifyByIds(Collection<String> idCollection) throws VciBaseException {
|
List<VciFileDocClassifyDO> classifyDOList = new ArrayList<>();
|
VciBaseUtil.alertCollectionNotNull("编号集合",idCollection);
|
Collection<Collection<String>> idCollections = VciBaseUtil.switchCollectionForOracleIn(idCollection);
|
idCollections.stream().forEach(ids->{
|
List<VciFileDocClassifyDO> classifyDOs = vciFileDocClassifyMapper.selectByIdCollection(ids);
|
if(!CollectionUtils.isEmpty(classifyDOs)){
|
classifyDOList.addAll(classifyDOs);
|
}
|
});
|
return vciFileDocClassifyDO2VOs(classifyDOList);
|
}
|
|
/**
|
* 文件类型的下拉菜单
|
*
|
* @return 下拉菜单的值
|
*/
|
@Override
|
public List<KeyValue> comboFileDocClassify() {
|
VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(new HashMap<>(),VciFileDocClassifyDO.class);
|
queryWrapper.neq("creator","sysAdmin");
|
List<VciFileDocClassifyDO> doList = vciFileDocClassifyMapper.selectByWrapper(queryWrapper);
|
List<KeyValue> keyValues = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(doList)){
|
doList.stream().forEach(doc->{
|
KeyValue keyValue = new KeyValue();
|
keyValue.setKey(doc.getId());
|
keyValue.setValue(doc.getName());
|
keyValues.add(keyValue);
|
});
|
}
|
return keyValues;
|
}
|
}
|
