1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package com.iailab.module.infra.service.demo;
 
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.*;
import com.iailab.module.infra.controller.admin.demo.vo.*;
import com.iailab.module.infra.dal.dataobject.demo.InfraCategoryDO;
import com.iailab.framework.common.pojo.PageResult;
import com.iailab.framework.common.pojo.PageParam;
import com.iailab.framework.common.util.object.BeanUtils;
 
import com.iailab.module.infra.dal.mysql.demo.InfraCategoryMapper;
 
import static com.iailab.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.iailab.module.infra.enums.ErrorCodeConstants.*;
 
/**
 * 分类 Service 实现类
 *
 * @author iailab
 */
@Service
@Validated
public class InfraCategoryServiceImpl implements InfraCategoryService {
 
    @Resource
    private InfraCategoryMapper categoryMapper;
 
    @Override
    public Long createCategory(InfraCategorySaveReqVO createReqVO) {
        // 校验父编号的有效性
        validateParentCategory(null, createReqVO.getParentId());
        // 校验名字的唯一性
        validateCategoryNameUnique(null, createReqVO.getParentId(), createReqVO.getName());
 
        // 插入
        InfraCategoryDO category = BeanUtils.toBean(createReqVO, InfraCategoryDO.class);
        categoryMapper.insert(category);
        // 返回
        return category.getId();
    }
 
    @Override
    public void updateCategory(InfraCategorySaveReqVO updateReqVO) {
        // 校验存在
        validateCategoryExists(updateReqVO.getId());
        // 校验父编号的有效性
        validateParentCategory(updateReqVO.getId(), updateReqVO.getParentId());
        // 校验名字的唯一性
        validateCategoryNameUnique(updateReqVO.getId(), updateReqVO.getParentId(), updateReqVO.getName());
 
        // 更新
        InfraCategoryDO updateObj = BeanUtils.toBean(updateReqVO, InfraCategoryDO.class);
        categoryMapper.updateById(updateObj);
    }
 
    @Override
    public void deleteCategory(Long id) {
        // 校验存在
        validateCategoryExists(id);
        // 校验是否有子分类
        if (categoryMapper.selectCountByParentId(id) > 0) {
            throw exception(CATEGORY_EXITS_CHILDREN);
        }
        // 删除
        categoryMapper.deleteById(id);
    }
 
    private void validateCategoryExists(Long id) {
        if (categoryMapper.selectById(id) == null) {
            throw exception(CATEGORY_NOT_EXISTS);
        }
    }
 
    private void validateParentCategory(Long id, Long parentId) {
        if (parentId == null || CategoryDO.PARENT_ID_ROOT.equals(parentId)) {
            return;
        }
        // 1. 不能设置自己为父分类
        if (Objects.equals(id, parentId)) {
            throw exception(CATEGORY_PARENT_ERROR);
        }
        // 2. 父分类不存在
        CategoryDO parentCategory = categoryMapper.selectById(parentId);
        if (parentCategory == null) {
            throw exception(CATEGORY_PARENT_NOT_EXITS);
        }
        // 3. 递归校验父分类，如果父分类是自己的子分类，则报错，避免形成环路
        if (id == null) { // id 为空，说明新增，不需要考虑环路
            return;
        }
        for (int i = 0; i < Short.MAX_VALUE; i++) {
            // 3.1 校验环路
            parentId = parentCategory.getParentId();
            if (Objects.equals(id, parentId)) {
                throw exception(CATEGORY_PARENT_IS_CHILD);
            }
            // 3.2 继续递归下一级父分类
            if (parentId == null || CategoryDO.PARENT_ID_ROOT.equals(parentId)) {
                break;
            }
            parentCategory = categoryMapper.selectById(parentId);
            if (parentCategory == null) {
                break;
            }
        }
    }
 
    private void validateCategoryNameUnique(Long id, Long parentId, String name) {
        CategoryDO category = categoryMapper.selectByParentIdAndName(parentId, name);
        if (category == null) {
            return;
        }
        // 如果 id 为空，说明不用比较是否为相同 id 的分类
        if (id == null) {
            throw exception(CATEGORY_NAME_DUPLICATE);
        }
        if (!Objects.equals(category.getId(), id)) {
            throw exception(CATEGORY_NAME_DUPLICATE);
        }
    }
 
    @Override
    public InfraCategoryDO getCategory(Long id) {
        return categoryMapper.selectById(id);
    }
 
    @Override
    public List<InfraCategoryDO> getCategoryList(InfraCategoryListReqVO listReqVO) {
        return categoryMapper.selectList(listReqVO);
    }
 
}