package com.estate.expert.admin.service.impl;
|
|
import com.estate.expert.admin.domain.standard.hierachy.Hierarchy;
|
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
|
import com.estate.expert.admin.domain.standard.hierachy.HierarchyDto;
|
import com.estate.expert.admin.domain.standard.problem.Problem;
|
import com.estate.expert.admin.domain.standard.problem.ProblemRepository;
|
import com.estate.expert.admin.enums.BizResultCode;
|
import com.estate.expert.admin.service.HierarchyService;
|
import com.estate.expert.admin.service.common.CrudServiceBaseImpl;
|
import com.estate.expert.admin.utils.tree.TreeNode;
|
import com.estate.expert.admin.utils.tree.TreeRoot;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.TreeSet;
|
import java.util.UUID;
|
|
/**
|
* 层级管理服务实现
|
* 包括综合层级、设备体系
|
* 也包括部门数据
|
*/
|
@Service
|
public class HierarchyServiceImpl extends CrudServiceBaseImpl<Hierarchy, HierarchyDto> implements HierarchyService {
|
|
@Resource
|
private ProblemRepository problemRepository;
|
|
|
// @PostConstruct
|
// private void init(){
|
// load();
|
// }
|
//
|
// /*
|
// * 加载数据, 为了加速查询，将数据时刻保存在内存中
|
// * 层级数据不会频繁修改
|
// */
|
// private void load(){
|
// hierarchyRepository.findAll().forEach(store -> {
|
// store.buildTree();
|
// storeMap.put(store.getType(), store);
|
// });
|
// }
|
//
|
// private void save(Hierarchy store){
|
// store.setUpdateTime(LocalDateTime.now());
|
// hierarchyRepository.save(store);
|
// store.buildTree();
|
// storeMap.put(store.getType(), store);
|
// }
|
|
// @Override
|
// public void create(HierarchyType type, TreeNode<HierarchyData> root) {
|
// delete(type);
|
// Hierarchy store = new Hierarchy();
|
// store.setType(type);
|
// store.setContent(root);
|
// store.setCreateTime(LocalDateTime.now());
|
// save(store);
|
// }
|
//
|
// @Override
|
// public void delete(HierarchyType type) {
|
// var store = storeMap.get(type);
|
// if(store != null){
|
// hierarchyRepository.delete(store);
|
// storeMap.remove(type);
|
// }
|
// }
|
|
@Override
|
public TreeRoot<HierarchyData> root(Integer id) {
|
var store = get(id);
|
BizResultCode.HIERARCHY_NOT_FOUND.check(store == null);
|
return store.getContent();
|
}
|
|
@Override
|
public TreeNode<HierarchyData> node(Integer id, String path, boolean includeChildren) {
|
return root(id).get(path, includeChildren);
|
}
|
|
@Override
|
public List<TreeNode<HierarchyData>> children(Integer id, String path, String keyword) {
|
var children = root(id).children(path);
|
if(keyword == null || keyword.isEmpty()){
|
return children;
|
}
|
return children.stream().filter(node -> node.getName().contains(keyword)).toList();
|
}
|
|
@Override
|
public void edit(Integer id, String path, String name, HierarchyData data) {
|
var store = get(id);
|
BizResultCode.HIERARCHY_NOT_FOUND.check(store == null);
|
store.getContent().edit(path, name, data);
|
save(store);
|
}
|
|
@Override
|
public TreeNode<HierarchyData> addChild(Integer id, String parentPath, String name, HierarchyData data) {
|
var store = get(id);
|
BizResultCode.HIERARCHY_NOT_FOUND.check(store == null);
|
var child = store.getContent().addChild(parentPath, name, data);
|
save(store);
|
return child;
|
}
|
|
@Override
|
public void deleteNode(Integer id, String path) {
|
var store = get(id);
|
BizResultCode.HIERARCHY_NOT_FOUND.check(store == null);
|
store.getContent().remove(path);
|
save(store);
|
}
|
|
@Override
|
public void deleteNodes(Integer id, List<String> paths) {
|
var store = get(id);
|
BizResultCode.HIERARCHY_NOT_FOUND.check(store == null);
|
paths.forEach(store.getContent()::remove);
|
save(store);
|
}
|
|
@Override
|
public List<String> findAllPaths(Integer id, List<String> hierarchyPaths) {
|
// 如果没有传入路径，则返回所有路径
|
if(hierarchyPaths == null || hierarchyPaths.isEmpty()) {
|
var allPaths = root(id).root().allPaths();
|
var pathMap = new TreeSet<>(allPaths);
|
return pathMap.stream().toList();
|
}
|
return root(id).findAllPaths(hierarchyPaths);
|
}
|
|
@Override
|
@Transactional
|
public TreeNode<HierarchyData> cloneNode(Integer id, String sourcePath) {
|
var store = get(id);
|
BizResultCode.HIERARCHY_NOT_FOUND.check(store == null);
|
|
// 获取源节点
|
var sourceNode = store.getContent().get(sourcePath);
|
BizResultCode.HIERARCHY_NODE_NOT_FOUND.check(sourceNode == null);
|
|
// 获取父节点（复制到同一个父节点下）
|
var parent = sourceNode.getParent();
|
BizResultCode.HIERARCHY_PARENT_NOT_FOUND.check(parent == null);
|
|
// 生成新节点名称：原名称（克隆）
|
String newName = sourceNode.getName() + "（克隆）";
|
|
// 用于存储旧路径到新路径的映射
|
Map<String, String> pathMapping = new HashMap<>();
|
|
// 收集源节点树中所有节点的路径
|
List<String> sourceNodePaths = collectAllPaths(sourceNode);
|
|
// 克隆节点树到同一个父节点下
|
TreeNode<HierarchyData> newNode = cloneNodeRecursive(sourceNode, parent, newName);
|
|
// 重建树结构，更新所有路径
|
store.getContent().buildTree();
|
|
// 收集新节点树中所有节点的路径
|
List<String> newNodePaths = collectAllPaths(newNode);
|
|
// 建立路径映射关系（按照树的遍历顺序，源路径和新路径是一一对应的）
|
for (int i = 0; i < sourceNodePaths.size() && i < newNodePaths.size(); i++) {
|
pathMapping.put(sourceNodePaths.get(i), newNodePaths.get(i));
|
}
|
|
// 克隆关联的问题
|
cloneProblems(id, pathMapping);
|
|
// 保存
|
save(store);
|
|
return newNode;
|
}
|
|
/**
|
* 收集节点树中所有节点的路径（按照深度优先遍历顺序）
|
*/
|
private List<String> collectAllPaths(TreeNode<HierarchyData> node) {
|
List<String> paths = new ArrayList<>();
|
paths.add(node.getPath());
|
for (TreeNode<HierarchyData> child : node.getChildren().values()) {
|
paths.addAll(collectAllPaths(child));
|
}
|
return paths;
|
}
|
|
/**
|
* 递归克隆节点
|
*/
|
private TreeNode<HierarchyData> cloneNodeRecursive(TreeNode<HierarchyData> sourceNode,
|
TreeNode<HierarchyData> targetParent,
|
String newName) {
|
// 复制节点数据
|
HierarchyData newData = null;
|
if (sourceNode.getData() != null) {
|
newData = HierarchyData.builder()
|
.score(sourceNode.getData().getScore())
|
.weight(sourceNode.getData().getWeight())
|
.build();
|
}
|
|
// 创建新节点
|
TreeNode<HierarchyData> newNode = targetParent.addChild(newName, newData);
|
|
// 递归克隆所有子节点
|
for (TreeNode<HierarchyData> child : sourceNode.getChildren().values()) {
|
cloneNodeRecursive(child, newNode, child.getName());
|
}
|
|
return newNode;
|
}
|
|
/**
|
* 克隆关联的问题
|
*/
|
private void cloneProblems(Integer hierarchyId, Map<String, String> pathMapping) {
|
// 查询所有关联到源路径的问题
|
List<String> sourcePaths = pathMapping.keySet().stream().toList();
|
List<Problem> problems = problemRepository.findProblems(hierarchyId, sourcePaths);
|
|
if (problems.isEmpty()) {
|
return;
|
}
|
|
// 复制问题
|
List<Problem> newProblems = new ArrayList<>();
|
for (Problem problem : problems) {
|
// 使用 entityManager.detach 确保创建新实体
|
entityManager.detach(problem);
|
|
// 重置ID和名称
|
problem.setId(null);
|
problem.setName(UUID.randomUUID().toString());
|
|
// 更新 hierarchyPath 到新路径
|
String oldPath = problem.getHierarchyPath();
|
String newPath = pathMapping.get(oldPath);
|
if (newPath != null) {
|
problem.setHierarchyPath(newPath);
|
newProblems.add(problem);
|
}
|
}
|
|
// 批量保存新问题
|
if (!newProblems.isEmpty()) {
|
problemRepository.saveAll(newProblems);
|
}
|
}
|
|
}
|
