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.knowledge.service.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.iailab.framework.common.constant.Constant;
import com.iailab.framework.common.page.PageData;
import com.iailab.framework.common.service.impl.BaseServiceImpl;
import com.iailab.framework.common.util.object.ConvertUtils;
import com.iailab.module.knowledge.dao.KnowledgePathDao;
import com.iailab.module.knowledge.dto.KnowledgePathDTO;
import com.iailab.module.knowledge.entity.KnowledgePathEntity;
import com.iailab.module.knowledge.service.KnowledgePathService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
 
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
 
/**
 * @author PanZhibao
 * @Description
 * @createTime 2023年12月25日 17:33:00
 */
@Service
public class KnowledgePathServiceImpl extends BaseServiceImpl<KnowledgePathDao, KnowledgePathEntity> implements KnowledgePathService {
    @Resource
    public KnowledgePathDao knowledgePathDao;
 
    final String ROOT = "0000000000";
 
    @Override
    public PageData<KnowledgePathDTO> page(Map<String, Object> params) {
        IPage<KnowledgePathEntity> page = baseDao.selectPage(
                getPage(params, Constant.CREATE_DATE, false),
                getWrapper(params)
        );
        return getPageData(page, KnowledgePathDTO.class);
    }
 
    private QueryWrapper<KnowledgePathEntity> getWrapper(Map<String, Object> params) {
        String treeId = (String) params.get("treeId");
        String title = (String) params.get("title");
        String keyWords = (String) params.get("keyWords");
        QueryWrapper<KnowledgePathEntity> wrapper = new QueryWrapper<>();
        wrapper.eq(StringUtils.isNotBlank(treeId), "tree_id", treeId)
                .like(StringUtils.isNotBlank(title), "title", title)
                .like(StringUtils.isNotBlank(keyWords), "key_words", keyWords);
        return wrapper;
    }
 
    @Override
    public List<KnowledgePathDTO> list(Map<String, Object> params) {
        return baseDao.selectPathList();
    }
 
    /**
     * 查询树形图
     *
     * @return 树形图
     */
    @Override
    public List<KnowledgePathDTO> tree() {
        List<KnowledgePathDTO> resultList = new ArrayList<>();
        // 所有树形图节点
        List<KnowledgePathDTO> dataList = knowledgePathDao.selectPathList();
        // 先取出根节点
        for (KnowledgePathDTO item : dataList) {
            // 根节点的父id为0000000000
            if (ROOT.equals(item.getParentId())) {
                resultList.add(item);
            }
        }
        // 根据根节点id，查询对应子节点
        for (KnowledgePathDTO parent : resultList) {
            List<KnowledgePathDTO> childList = getChild(parent.getId(), dataList);
            parent.setChildren(childList);
        }
 
        return resultList;
    }
 
    /**
     * 设置子节点
     *
     * @param parentId 父节点id
     * @param dataList 所有节点
     * @return 子节点列表
     */
    private List<KnowledgePathDTO> getChild(String parentId, List<KnowledgePathDTO> dataList) {
        List<KnowledgePathDTO> childList = new ArrayList<>();
        // 把节点的子节点找出
        for (KnowledgePathDTO item : dataList) {
            if (parentId.equals(item.getParentId())) {
                childList.add(item);
            }
        }
        // 递归
        for (KnowledgePathDTO parent : childList) {
            parent.setChildren(getChild(parent.getId(), dataList));
        }
        // 如果没有子节点了，设置一个空列表
        if (childList.size() == 0) {
            return new ArrayList<>();
        }
        return childList;
    }
 
    @Override
    public KnowledgePathDTO get(String id) {
        KnowledgePathEntity entity = baseDao.selectById(id);
 
        return ConvertUtils.sourceToTarget(entity, KnowledgePathDTO.class);
    }
 
    @Override
    public void save(KnowledgePathDTO dto) {
        KnowledgePathEntity entity = ConvertUtils.sourceToTarget(dto, KnowledgePathEntity.class);
        insert(entity);
    }
 
    @Override
    public void update(KnowledgePathDTO dto) {
        KnowledgePathEntity entity = ConvertUtils.sourceToTarget(dto, KnowledgePathEntity.class);
        updateById(entity);
    }
 
    @Override
    public void delete(String id) {
        baseDao.delete(new QueryWrapper<KnowledgePathEntity>()
                .eq(StringUtils.isNotBlank(id), "id", id)
                .or().eq(StringUtils.isNotBlank(id), "parent_id", id)
        );
    }
}