update

liujie

2026-09-15 5a95ec36565d7ecc1a5ecb261f26752c90dec120

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
package com.estate.expert.admin.service.impl;
 
import com.estate.expert.admin.domain.common.EntityRef;
import com.estate.expert.admin.domain.common.request.PageReq;
import com.estate.expert.admin.domain.common.response.PageResp;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyIds;
import com.estate.expert.admin.domain.standard.problem.Problem;
import com.estate.expert.admin.domain.standard.problem.ProblemDto;
import com.estate.expert.admin.domain.standard.problem.ProblemRepository;
import com.estate.expert.admin.domain.user.User;
import com.estate.expert.admin.enums.BizResultCode;
import com.estate.expert.admin.service.HierarchyService;
import com.estate.expert.admin.service.ProblemService;
import com.estate.expert.admin.service.common.CrudServiceBaseImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
 
import javax.annotation.Resource;
import java.util.List;
import java.util.UUID;
 
/**
 * 问题服务实现
* @author daisyli
*/
@Slf4j
@Service
public class ProblemServiceImpl extends CrudServiceBaseImpl<Problem, ProblemDto> implements ProblemService {
 
    @Resource
    private ProblemRepository problemRepository;
 
    @Resource
    private HierarchyService hierarchyService;
 
    @Override
    public PageResp<ProblemDto> list(Integer hierarchyId, List<String> hierarchyPaths, String keyword, PageReq pageReq) {
        var paths = hierarchyService.findAllPaths(hierarchyId, hierarchyPaths);
        var page = problemRepository.findProblems(hierarchyId, paths, keyword, pageReq.toPageRequest());
        return PageResp.of(page, toDto(page.getContent()));
    }
 
    @Override
    public PageResp<EntityRef> listAbstracts(Integer hierarchyId, List<String> hierarchyPaths, String keyword, PageReq pageReq) {
        var paths = hierarchyService.findAllPaths(hierarchyId, hierarchyPaths);
        var page = problemRepository.findProblems(hierarchyId, paths, keyword, pageReq.toPageRequest());
        var abstracts = page.getContent().stream().map(entityRefMapper::toReference).toList();
        return PageResp.of(page, abstracts);
    }
 
    @Override
    public List<Integer> listIds(Integer hierarchyId, List<String> hierarchyPaths) {
        if(CollectionUtils.isEmpty(hierarchyPaths))
            hierarchyPaths = List.of("/");
        var paths = hierarchyService.findAllPaths(hierarchyId, hierarchyPaths);
        return problemRepository.findProblemIds(hierarchyId, paths);
    }
 
    @Override
    public List<Integer> findAllProblemIds(Integer hierarchyId) {
        return problemRepository.findAllProblemIds(hierarchyId);
    }
 
    @Override
    public void cloneProblems(Integer hierarchyId, Integer newHierarchyId) {
        var problems = problemRepository.findAllByHierarchyIdAndDeleted(hierarchyId, false);
 
        problems.forEach(problem -> {
            entityManager.detach(problem);
            problem.setId(null);
            problem.setName(UUID.randomUUID().toString());
        });
        var newProblems = problems.stream()
                .peek(problem -> problem.setHierarchyId(newHierarchyId)).toList();
        addEntities(null, newProblems);
    }
 
    @Override
    public List<Problem> findProblems(Integer hierarchyId, List<String> hierarchyPaths, List<Integer> problemIds) {
        var problems =
                CollectionUtils.isEmpty(problemIds) ?
                        problemRepository.findProblems(hierarchyId, hierarchyPaths) :
                        problemRepository.findProblems(hierarchyId, hierarchyPaths, problemIds);
        return problems;
    }
 
    @Override
    public void deleteByHierarchy(Integer hierarchyId, List<String> hierarchyPaths) {
        if(hierarchyId == null)
            return;
        if(hierarchyId.equals(HierarchyIds.DEPARTMENT))
            return;
        // 对于综合模型和设备模型，需要删除相关问题
        var ids = listIds(hierarchyId, hierarchyPaths);
        if(CollectionUtils.isEmpty(ids))
            return;
        this.deleteAllById(ids);
    }
 
 
    @Override
    public List<String> getHierarchyNames(Problem problem) {
        if (problem == null)
            return List.of();
 
        var hierarchy = hierarchyService.get(problem.getHierarchyId());
        BizResultCode.HIERARCHY_NOT_EXIST.check(hierarchy == null);
        var node = hierarchy.getContent().get(problem.getHierarchyPath());
        if(node == null)
            return List.of();
 
        return node.getNames();
    }
 
    @Override
    public Problem add(User creator, Problem entity) {
        entity.setName(UUID.randomUUID().toString());
        return super.add(creator, entity);
    }
}