liujie
2026-04-09 3adfcc5a9829a0231bf95c1a7e3aaad1d28b05d5
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package com.estate.expert.admin.initdata;
 
import com.estate.expert.admin.domain.standard.hierachy.Hierarchy;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
import com.estate.expert.admin.initdata.common.ImportUtil;
import com.estate.expert.admin.service.HierarchyService;
import com.estate.expert.admin.service.UserService;
import com.estate.expert.admin.utils.tree.SimpleTreeRoot;
import com.estate.expert.admin.utils.tree.TreeNode;
import lombok.Builder;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.*;
 
import java.io.File;
import java.io.FileInputStream;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
 
@Builder
@Slf4j
public class ImportHierarchyJob {
 
    private UserService userService;
 
    private HierarchyService hierarchyService;
 
    public void importDepartments() {
        var root = new TreeNode<HierarchyData>("成都信立隆");
        root.addChild("技术部");
        root.addChild("人事部");
        root.addChild("设备部");
        root.addChild("后勤部");
 
        var hierarchy = new Hierarchy();
        hierarchy.setName("部门");
        hierarchy.setContent(new SimpleTreeRoot<>(root));
        hierarchyService.add(userService.getSystemUser(), hierarchy);
    }
 
    // 导入标准层级数据
    public void importSystemHierarchyData() {
        File rootFolder = new File(ImportUtil.docsRoot("/综合体系-标准-层级"));
        importHierarchy("综合体系", rootFolder, 0);
    }
 
    // 导入设备层级数据
    public void importDeviceHierarchyData() {
        File rootFolder = new File(ImportUtil.docsRoot("/设备体系-标准-层级"));
        importHierarchy("设备体系", rootFolder, 0);
    }
 
    // 导入实测实量层级数据
    public void importMeasureHierarchyData() {
        File rootFolder = new File(ImportUtil.docsRoot("/实测实量-标准-规则管理"));
        importHierarchy("实测实量体系", rootFolder, 1);
    }
 
    private void importHierarchy(String name, File folder, int mode) {
        var root = processFolder(folder, mode,null, null);
        var hierarchy = new Hierarchy();
        hierarchy.setName(name);
        hierarchy.setContent(new SimpleTreeRoot<>(root));
        hierarchyService.add(userService.getSystemUser(), hierarchy);
    }
 
    /**
    * 递归处理文件夹
     */
    private TreeNode<HierarchyData> processFolder(File folder, int mode,
                                                  TreeNode<HierarchyData> parent, Map<String, HierarchyData> dataMap) {
        var name = folder.getName();
 
        TreeNode<HierarchyData> node = null;
        if (parent == null) {
            node = new TreeNode<>(name, new HierarchyData(100f, 1f));
        } else {
            node = parent.addChild(name, dataMap.get(name));
        }
 
        var dm = mode == 0 ? loadHierarchyData(folder) : loadMeasureData(folder);
        for (var key : dm.keySet()) {
            var subFolder = new File(folder, key);
            if(!subFolder.exists()){
                log.error("未找到文件夹: {}", subFolder.getAbsolutePath());
                continue;
            }
            processFolder(subFolder, mode, node, dm);
        }
        return node;
    }
 
    /**
     * 从data.xlsx文件中读取层级数据
      */
    private Map<String, HierarchyData> loadHierarchyData(File folder) {
        // 读取 Excel 文件
        File excelFile = new File(folder, "data.xlsx");
        // Map<ID, name>
        SortedMap<String, HierarchyData> map = new TreeMap<>();
 
        if (excelFile.exists()) {
            try (FileInputStream fis = new FileInputStream(excelFile)) {
                Workbook workbook = WorkbookFactory.create(fis);
                Sheet sheet = workbook.getSheetAt(0);
                for (Row row : sheet) {
                    Cell levelNameCell = row.getCell(0);
 
                    String levelName = levelNameCell.getStringCellValue();
                    if (StringUtils.isBlank(levelName)) {
                        continue;
                    }
 
                    HierarchyData data = loadWeightData(row);
 
                    map.put(levelName, data);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return map;
    }
 
    private Map<String, HierarchyData> loadMeasureData(File folder) {
        // Map<ID, name>
        SortedMap<String, HierarchyData> map = new TreeMap<>();
 
        // 读取目录下的子目录
        var subFolders = folder.listFiles();
        if (subFolders == null) {
            return map;
        }
        for (File subFolder : subFolders) {
            if (subFolder.isDirectory()) {
                map.put(subFolder.getName(), null);
            }
        }
        return map;
    }
 
    private HierarchyData loadWeightData(Row row){
        Cell scoreCell = row.getCell(1);
        Cell weightCell = row.getCell(2);
 
        var score = Float.parseFloat(scoreCell.getStringCellValue());
        var weight = Float.parseFloat(weightCell.getStringCellValue());
 
        return new HierarchyData(score, weight);
    }
}