package cn.iocoder.yudao.module.archive.service.category;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
|
import cn.iocoder.yudao.module.archive.controller.admin.category.vo.ArchiveCategoryListReqVO;
|
import cn.iocoder.yudao.module.archive.controller.admin.category.vo.ArchiveCategorySaveReqVO;
|
import cn.iocoder.yudao.module.archive.dal.dataobject.category.ArchiveCategoryDO;
|
import cn.iocoder.yudao.module.archive.dal.mysql.category.ArchiveCategoryMapper;
|
import cn.iocoder.yudao.module.archive.dal.mysql.document.ArchiveDocumentMapper;
|
import jakarta.annotation.Resource;
|
import org.springframework.stereotype.Service;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.Set;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.module.archive.enums.ErrorCodeConstants.*;
|
|
/**
|
* 档案分类 Service 实现类
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
@Validated
|
public class ArchiveCategoryServiceImpl implements ArchiveCategoryService {
|
|
/** 顶级分类的父分类编号 */
|
private static final Long ROOT_PARENT_ID = 0L;
|
|
@Resource
|
private ArchiveCategoryMapper categoryMapper;
|
|
@Resource
|
private ArchiveDocumentMapper documentMapper;
|
|
@Override
|
public Long createCategory(ArchiveCategorySaveReqVO createReqVO) {
|
// 1.1 校验父分类存在
|
validateParentCategory(createReqVO.getParentId(), createReqVO.getName());
|
// 1.2 校验同级分类名称不重复、分类编码不重复
|
validateNameUnique(createReqVO.getName(), createReqVO.getParentId(), null);
|
validateCodeUnique(createReqVO.getCode(), null);
|
|
// 2. 插入（补默认值）
|
ArchiveCategoryDO category = BeanUtils.toBean(createReqVO, ArchiveCategoryDO.class);
|
category.setId(null);
|
if (category.getSort() == null) {
|
category.setSort(0);
|
}
|
if (category.getDefaultSecretLevel() == null) {
|
category.setDefaultSecretLevel(1);
|
}
|
if (category.getStatus() == null) {
|
category.setStatus(0);
|
}
|
categoryMapper.insert(category);
|
return category.getId();
|
}
|
|
@Override
|
public void updateCategory(ArchiveCategorySaveReqVO updateReqVO) {
|
// 1.1 校验分类存在
|
ArchiveCategoryDO oldCategory = validateCategoryExists(updateReqVO.getId());
|
// 1.2 校验父分类存在，且不能把分类挂到自身或其子孙下（避免形成环）
|
validateParentCategory(updateReqVO.getParentId(), updateReqVO.getName());
|
validateParentNotSelfOrDescendant(oldCategory, updateReqVO.getParentId());
|
// 1.3 校验同级名称不重复、编码不重复
|
validateNameUnique(updateReqVO.getName(), updateReqVO.getParentId(), updateReqVO.getId());
|
validateCodeUnique(updateReqVO.getCode(), updateReqVO.getId());
|
|
// 2. 更新
|
ArchiveCategoryDO updateObj = BeanUtils.toBean(updateReqVO, ArchiveCategoryDO.class);
|
categoryMapper.updateById(updateObj);
|
}
|
|
@Override
|
public void deleteCategory(Long id) {
|
// 1.1 校验分类存在
|
ArchiveCategoryDO category = validateCategoryExists(id);
|
// 1.2 存在子分类时不允许删除
|
List<ArchiveCategoryDO> children = categoryMapper.selectListByParentId(id);
|
if (CollUtil.isNotEmpty(children)) {
|
throw exception(CATEGORY_HAS_CHILDREN, category.getName(), children.size());
|
}
|
// 1.3 分类下存在档案时不允许删除
|
Long documentCount = documentMapper.selectCountByCategoryId(id);
|
if (documentCount != null && documentCount > 0) {
|
throw exception(CATEGORY_HAS_DOCUMENT, category.getName(), documentCount);
|
}
|
|
categoryMapper.deleteById(id);
|
}
|
|
@Override
|
public ArchiveCategoryDO getCategory(Long id) {
|
return categoryMapper.selectById(id);
|
}
|
|
@Override
|
public List<ArchiveCategoryDO> getCategoryList(ArchiveCategoryListReqVO reqVO) {
|
return categoryMapper.selectList(new LambdaQueryWrapperX<ArchiveCategoryDO>()
|
.likeIfPresent(ArchiveCategoryDO::getName, reqVO.getName())
|
.eqIfPresent(ArchiveCategoryDO::getStatus, reqVO.getStatus())
|
.orderByAsc(ArchiveCategoryDO::getSort)
|
.orderByAsc(ArchiveCategoryDO::getId));
|
}
|
|
@Override
|
public List<ArchiveCategoryDO> getCategoryList() {
|
return categoryMapper.selectListOrdered();
|
}
|
|
@Override
|
public ArchiveCategoryDO getCategoryByCode(String code) {
|
if (StrUtil.isBlank(code)) {
|
return null;
|
}
|
return categoryMapper.selectByCode(code);
|
}
|
|
// ==================== 校验逻辑 ====================
|
|
/** 校验分类存在，不存在时抛出精确提示 */
|
private ArchiveCategoryDO validateCategoryExists(Long id) {
|
ArchiveCategoryDO category = id != null ? categoryMapper.selectById(id) : null;
|
if (category == null) {
|
throw exception(CATEGORY_NOT_EXISTS);
|
}
|
return category;
|
}
|
|
/** 校验父分类：0 表示顶级；非 0 时必须存在 */
|
private void validateParentCategory(Long parentId, String categoryName) {
|
if (parentId == null) {
|
throw exception(CATEGORY_PARENT_INVALID, categoryName);
|
}
|
if (Objects.equals(parentId, ROOT_PARENT_ID)) {
|
return;
|
}
|
if (categoryMapper.selectById(parentId) == null) {
|
throw exception(CATEGORY_PARENT_INVALID, categoryName);
|
}
|
}
|
|
/** 校验父分类不能是自身，也不能是自己的子孙分类 */
|
private void validateParentNotSelfOrDescendant(ArchiveCategoryDO category, Long parentId) {
|
if (Objects.equals(category.getId(), parentId)) {
|
throw exception(CATEGORY_PARENT_INVALID, category.getName());
|
}
|
Set<Long> descendantIds = collectDescendantIds(category.getId());
|
if (descendantIds.contains(parentId)) {
|
throw exception(CATEGORY_PARENT_INVALID, category.getName());
|
}
|
}
|
|
/** 收集分类的全部子孙分类编号（含自身） */
|
private Set<Long> collectDescendantIds(Long id) {
|
List<ArchiveCategoryDO> all = categoryMapper.selectListOrdered();
|
Set<Long> result = new HashSet<>();
|
result.add(id);
|
boolean changed = true;
|
while (changed) {
|
changed = false;
|
for (ArchiveCategoryDO category : all) {
|
if (result.contains(category.getParentId()) && result.add(category.getId())) {
|
changed = true;
|
}
|
}
|
}
|
return result;
|
}
|
|
private void validateNameUnique(String name, Long parentId, Long excludeId) {
|
Long count = categoryMapper.selectCountByName(name, parentId, excludeId);
|
if (count != null && count > 0) {
|
throw exception(CATEGORY_NAME_DUPLICATE, name);
|
}
|
}
|
|
private void validateCodeUnique(String code, Long excludeId) {
|
Long count = categoryMapper.selectCountByCode(code, excludeId);
|
if (count != null && count > 0) {
|
ArchiveCategoryDO exists = categoryMapper.selectByCode(code);
|
throw exception(CATEGORY_CODE_DUPLICATE, code, exists != null ? exists.getName() : code);
|
}
|
}
|
|
}
|
