增加节点类型

blade-service-api/blade-manager-api/src/main/java/org/springblade/manager/entity/ArchiveTreeContract.java

@@ -159,6 +159,12 @@ public class ArchiveTreeContract extends BaseEntity {
      */
     private Long extKeyId;
 
+    /**
+     *
+     * １单位工程２分部工程 ３子分部工程　４分项工程５子分项工程 ６工序
+     */
+    private Integer extNodeType;
+
     /**
      * 自动立卷类型 1最高 2分类并卷 3单独组卷   说明：1规则下可以有2或3；2和3两种规则互斥,2下不能有3,3下不能有2；
      */

blade-service/blade-archive/src/main/java/org/springblade/archive/service/IArchiveNameService.java

@@ -0,0 +1,65 @@
+package org.springblade.archive.service;
+
+import org.springblade.manager.entity.ArchiveTreeContract;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+public interface IArchiveNameService {
+
+    /* 节点层级结构（通用静态类）
+     */
+    public class NodeHierarchy {
+        private final Map<Long, List<ArchiveTreeContract>> hierarchyMap;
+        private final Map<Long, ArchiveTreeContract> allNodeMap;
+        private final Map<Long, List<ArchiveTreeContract>> childrenMap; // 新增：父节点到子节点映射
+        private final Map<Long, Integer> totalChildrenCountMap; // 新增：每个父节点的子节点总数
+
+        public NodeHierarchy(
+                Map<Long, List<ArchiveTreeContract>> hierarchyMap,
+                Map<Long, ArchiveTreeContract> allNodeMap,
+                Map<Long, List<ArchiveTreeContract>> childrenMap,
+                Map<Long, Integer> totalChildrenCountMap
+        ) {
+            this.hierarchyMap = hierarchyMap;
+            this.allNodeMap = allNodeMap;
+            this.childrenMap = childrenMap;
+            this.totalChildrenCountMap = totalChildrenCountMap;
+        }
+
+        // 获取某个节点的所有直接子节点
+        public List<ArchiveTreeContract> getChildren(Long parentId) {
+            return childrenMap.getOrDefault(parentId, Collections.emptyList());
+        }
+
+        // 获取某个父节点的子节点总数
+        public int getTotalChildrenCount(Long parentId) {
+            return totalChildrenCountMap.getOrDefault(parentId, 0);
+        }
+
+        // 原始 getters...
+        public Map<Long, List<ArchiveTreeContract>> getHierarchyMap() {
+            return hierarchyMap;
+        }
+
+        public Map<Long, ArchiveTreeContract> getAllNodeMap() {
+            return allNodeMap;
+        }
+    }
+
+    /* 构建节点层级结构映射
+     */
+    NodeHierarchy buildNodeHierarchy(List<ArchiveTreeContract> nodeList);
+
+    /* 获取节点的层级名称
+     */
+    String getLevelName(NodeHierarchy hierarchy, Long nodeId);
+
+    /* 生成完整的层级名称
+     */
+    String generateFullLevelName(
+            List<Long> nodeList,
+            NodeHierarchy hierarchy
+    );
+}

blade-service/blade-archive/src/main/java/org/springblade/archive/service/impl/ArchiveNameServiceImpl.java

@@ -0,0 +1,287 @@
+package org.springblade.archive.service.impl;
+
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springblade.archive.service.IArchiveNameService;
+import org.springblade.manager.entity.ArchiveTreeContract;
+import org.springblade.manager.feign.ArchiveTreeContractClient;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@AllArgsConstructor
+public class ArchiveNameServiceImpl implements IArchiveNameService {
+
+    private final ArchiveTreeContractClient archiveTreeContractClient;
+
+
+    @Override
+    public NodeHierarchy buildNodeHierarchy(List<ArchiveTreeContract> nodeList) {
+        if (nodeList == null || nodeList.isEmpty()) {
+            return new NodeHierarchy(
+                    Collections.emptyMap(),
+                    Collections.emptyMap(),
+                    Collections.emptyMap(),
+                    Collections.emptyMap()
+            );
+        }
+
+        // 1. 创建数据结构容器
+        Map<Long, List<ArchiveTreeContract>> hierarchyMap = new HashMap<>();
+        Map<Long, ArchiveTreeContract> allNodeMap = new HashMap<>();
+        Map<Long, List<ArchiveTreeContract>> childrenMap = new HashMap<>();
+        Map<Long, Integer> totalChildrenCountMap = new HashMap<>();
+
+        // 2. 处理当前节点并加入映射
+        Map<Long, ArchiveTreeContract> tempNodeMap = new HashMap<>();
+        for (ArchiveTreeContract node : nodeList) {
+            Long nodeId = node.getId();
+            tempNodeMap.put(nodeId, node);
+            allNodeMap.put(nodeId, node);
+            childrenMap.putIfAbsent(nodeId, new ArrayList<>());
+        }
+
+        // 3. 收集缺失的祖先节点ID
+        Set<Long> missingAncestorIds = new HashSet<>();
+        for (ArchiveTreeContract node : nodeList) {
+            String ancestors = node.getAncestors();
+            if (ancestors == null || ancestors.isEmpty()) continue;
+
+            Arrays.stream(ancestors.split(","))
+                    .map(String::trim)
+                    .filter(id -> !id.isEmpty())
+                    .map(Long::parseLong)
+                    .filter(ancestorId -> !tempNodeMap.containsKey(ancestorId))
+                    .forEach(missingAncestorIds::add);
+        }
+
+        // 4. 批量获取缺失的祖先节点
+        List<ArchiveTreeContract> missingAncestors = Collections.emptyList();
+        if (!missingAncestorIds.isEmpty()) {
+            String ancestorIdsStr = missingAncestorIds.stream()
+                    .map(String::valueOf)
+                    .collect(Collectors.joining(","));
+
+            missingAncestors = archiveTreeContractClient
+                    .getArchiveTreeContractListByIds(ancestorIdsStr);
+
+            for (ArchiveTreeContract ancestor : missingAncestors) {
+                Long ancestorId = ancestor.getId();
+                tempNodeMap.put(ancestorId, ancestor);
+                allNodeMap.put(ancestorId, ancestor);
+                childrenMap.putIfAbsent(ancestorId, new ArrayList<>());
+            }
+
+            log.debug("成功获取 {} 个祖先节点", missingAncestors.size());
+        }
+
+        // 5. 合并所有节点
+        List<ArchiveTreeContract> allNodes = new ArrayList<>(nodeList);
+        allNodes.addAll(missingAncestors);
+
+        // 6. 为每个节点构建完整的层级路径
+        for (ArchiveTreeContract node : allNodes) {
+            Long nodeId = node.getId();
+            List<ArchiveTreeContract> hierarchyList = new ArrayList<>();
+
+            // 处理祖先路径
+            String ancestors = node.getAncestors();
+            if (ancestors != null && !ancestors.isEmpty()) {
+                String[] pathIds = ancestors.split(",");
+                for (String idStr : pathIds) {
+                    idStr = idStr.trim();
+                    if (!idStr.isEmpty()) {
+                        Long id = Long.parseLong(idStr);
+                        ArchiveTreeContract ancestor = tempNodeMap.get(id);
+                        if (ancestor != null) {
+                            hierarchyList.add(ancestor);
+                        }
+                    }
+                }
+            }
+
+            // 添加当前节点到路径末端
+            hierarchyList.add(node);
+
+            // 存入层级映射
+            hierarchyMap.put(nodeId, hierarchyList);
+
+            // 构建父子关系映射
+            Long parentId = node.getParentId();
+            if (parentId != null) {
+                childrenMap.computeIfAbsent(parentId, k -> new ArrayList<>()).add(node);
+            }
+        }
+
+        // 7. 填充总子节点计数
+        for (Map.Entry<Long, List<ArchiveTreeContract>> entry : childrenMap.entrySet()) {
+            totalChildrenCountMap.put(entry.getKey(), entry.getValue().size());
+        }
+
+        return new NodeHierarchy(hierarchyMap, allNodeMap, childrenMap, totalChildrenCountMap);
+    }
+
+    @Override
+    public String getLevelName(NodeHierarchy hierarchy, Long nodeId) {
+        Map<Long, ArchiveTreeContract> allNodeMap = hierarchy.getAllNodeMap();
+
+        // 1. 获取目标节点
+        ArchiveTreeContract targetNode = allNodeMap.get(nodeId);
+        if (targetNode == null) {
+            log.warn("无法找到节点 {} 的详细信息", nodeId);
+            return "未知节点";
+        }
+
+        // 2. 获取节点的层级路径
+        Map<Long, List<ArchiveTreeContract>> hierarchyMap = hierarchy.getHierarchyMap();
+        List<ArchiveTreeContract> hierarchyList = hierarchyMap.getOrDefault(
+                nodeId, Collections.emptyList()
+        );
+
+        // 3. 提取关键层级的节点
+        ArchiveTreeContract lastUnitNode = null;
+        ArchiveTreeContract lastDivisionNode = null;
+        ArchiveTreeContract lastItemNode = null;
+
+        for (ArchiveTreeContract node : hierarchyList) {
+            // 获取displayHierarchy值
+            Integer extNodeType = node.getExtNodeType();
+
+            // 处理空值或空白值
+            if (extNodeType == null ) {
+                continue;
+            }
+
+            try {
+                // 尝试转换为
+
+                switch (extNodeType) {
+                    case 1:
+                        lastUnitNode = node;
+                        break;
+                    case 2:
+                    case 3:
+                        lastDivisionNode = node;
+                        break;
+                    case 4:
+                    case 5:
+                        lastItemNode = node;
+                        break;
+                    // 其他情况不处理
+                }
+            } catch (NumberFormatException e) {
+                // 记录格式错误但继续处理其他节点
+                log.warn("节点 {} 的displayHierarchy值 '{}' 无法转换为整数",
+                        node.getNodeName(), extNodeType);
+            }
+        }
+
+        // 4. 构建层级名称
+        StringBuilder nameBuilder = new StringBuilder();
+
+        // 依次添加单位工程、分部工程、分项工程的名称
+        if (lastUnitNode != null) {
+            nameBuilder.append(lastUnitNode.getNodeName());
+        }
+        if (lastDivisionNode != null) {
+            nameBuilder.append(lastDivisionNode.getNodeName());
+        }
+        if (lastItemNode != null) {
+            nameBuilder.append(lastItemNode.getNodeName());
+        }
+
+        // 5. 返回结果（如果没有找到任何层级节点，则返回目标节点名称）
+        return nameBuilder.length() > 0 ?
+                nameBuilder.toString() :
+                targetNode.getNodeName();
+    }
+
+
+    @Override
+    public String generateFullLevelName(
+            List<Long> nodeIds,
+            NodeHierarchy hierarchy
+    ) {
+        // 1. 获取输入节点
+        Map<Long, ArchiveTreeContract> allNodeMap = hierarchy.getAllNodeMap();
+        List<ArchiveTreeContract> nodes = new ArrayList<>();
+
+        for (Long nodeId : nodeIds) {
+            ArchiveTreeContract node = allNodeMap.get(nodeId);
+            if (node != null) {
+                nodes.add(node);
+            }
+        }
+
+        if (nodes.isEmpty()) {
+            return "";
+        }
+
+        // 2. 按父节点分组
+        Map<Long, List<ArchiveTreeContract>> parentGroups = new LinkedHashMap<>();
+
+        for (ArchiveTreeContract node : nodes) {
+            Long parentId = node.getParentId();
+
+            // 如果没有父节点，单独处理
+            if (parentId == null) {
+                parentGroups.put(node.getId(), Collections.singletonList(node));
+            } else {
+                parentGroups.computeIfAbsent(parentId, k -> new ArrayList<>()).add(node);
+            }
+        }
+
+        // 3. 构建结果部分
+        List<String> nameParts = new ArrayList<>();
+
+        for (Map.Entry<Long, List<ArchiveTreeContract>> entry : parentGroups.entrySet()) {
+            Long groupId = entry.getKey();
+            List<ArchiveTreeContract> groupNodes = entry.getValue();
+
+            // 处理没有父节点的情况
+            if (groupId == null) {
+                groupId = groupNodes.get(0).getId();
+            }
+
+            // 获取父节点（组代表）
+            ArchiveTreeContract parent = allNodeMap.get(groupId);
+
+            // 父节点不存在（特殊情况处理）
+            if (parent == null) {
+                // 可能是没有父节点的单独节点
+                for (ArchiveTreeContract node : groupNodes) {
+                    nameParts.add(node.getNodeName());
+                }
+                continue;
+            }
+
+            // 获取父节点层级名称
+            String parentLevelName = getLevelName(hierarchy, parent.getId());
+
+            // 获取该父节点下的所有子节点（在hierarchy中）
+            List<ArchiveTreeContract> allChildren = hierarchy.getChildren(parent.getId());
+
+            // 获取该父节点下的所有子节点数量
+            int totalChildrenCount = hierarchy.getTotalChildrenCount(parent.getId());
+
+            // 判断是否涵盖所有子节点
+            if (groupNodes.size() == totalChildrenCount && !allChildren.isEmpty()) {
+                // 涵盖所有子节点，直接使用父节点层级名称
+                nameParts.add(parentLevelName);
+            } else {
+                // 部分子节点，添加节点名称
+                StringBuilder groupName = new StringBuilder(parentLevelName);
+                for (ArchiveTreeContract node : groupNodes) {
+                    groupName.append(node.getNodeName());
+                }
+                nameParts.add(groupName.toString());
+            }
+        }
+
+        // 4. 拼接最终结果
+        return String.join("、", nameParts);
+    }
+}

blade-service/blade-archive/src/main/java/org/springblade/archive/service/impl/ArchivesAutoServiceImpl.java

@@ -134,6 +134,7 @@ public class ArchivesAutoServiceImpl extends BaseServiceImpl<ArchivesAutoMapper,
 
 	private final IArchiveExpertConclusionService expertConclusionService;
 	private final ITraceLogService iTraceLogService;
+	private  final IArchiveNameService archiveNameService;
 
 	//表格高度
 	private static int high = 20;
@@ -1319,6 +1320,8 @@ public class ArchivesAutoServiceImpl extends BaseServiceImpl<ArchivesAutoMapper,
 		//获取案卷题名
 		String archiveName = builtArchiveName(waitArchiveFiles, node, true);//获取案卷题名
 
+		//test(waitArchiveFiles);
+
 		//1.创建新案卷
 		ArchivesAuto archivesAuto = builtArchives(node, pageN, fileN, startDate, endDate, archiveName);
 
@@ -4087,18 +4090,71 @@ public class ArchivesAutoServiceImpl extends BaseServiceImpl<ArchivesAutoMapper,
 
 	}
 
+	public void test(List<ArchiveFile> waitArchiveFiles) {
+		// 1. 提取并保持节点ID顺序（使用LinkedHashSet保持原始顺序）
+		Set<String> uniqueNodeIds = waitArchiveFiles.stream()
+				.map(ArchiveFile::getNodeId)
+				.filter(nodeId -> nodeId != null && !nodeId.isEmpty())
+				.collect(Collectors.toCollection(LinkedHashSet::new));
 
-	private String formatExecutionTime(long millis) {
-		if (millis < 1000) {
-			return millis + "毫秒";
-		} else if (millis < 60000) {
-			return String.format("%.2f秒", millis / 1000.0);
-		} else {
-			long minutes = TimeUnit.MILLISECONDS.toMinutes(millis);
-			long seconds = TimeUnit.MILLISECONDS.toSeconds(millis) % 60;
-			return minutes + "分钟" + seconds + "秒";
+		if (uniqueNodeIds.isEmpty()) {
+			log.info("没有需要处理的节点ID");
+			return;
+		}
+
+		try {
+			// 2. 将节点ID从String转换为Long（保持原始顺序）
+			List<Long> nodeIds = uniqueNodeIds.stream()
+					.map(this::safeParseLong)
+					.filter(Objects::nonNull)
+					.collect(Collectors.toList());
+
+			if (nodeIds.isEmpty()) {
+				log.warn("无法解析任何有效的节点ID");
+				return;
+			}
+			String nodeIdsStr = nodeIds.stream()
+					.map(String::valueOf)
+					.collect(Collectors.joining(","));
+			// 3. 批量获取节点信息
+			List<ArchiveTreeContract> nodeList = archiveTreeContractClient
+					.getArchiveTreeContractListByIds(nodeIdsStr);
+
+			if (nodeList.isEmpty()) {
+				log.warn("未找到任何节点信息");
+				return;
+			}
+
+			// 4. 构建节点层级关系
+			IArchiveNameService.NodeHierarchy hierarchy =
+					archiveNameService.buildNodeHierarchy(nodeList);
+
+			// 5. 生成完整层级名称
+			String fullName = archiveNameService.generateFullLevelName(nodeIds, hierarchy);
+
+			// 6. 输出或使用结果
+			System.out.println("完整层级名称: " + fullName);
+			log.info("成功生成长度 {} 的层级名称", fullName.length());
+
+		} catch (Exception e) {
+			log.error("生成层级名称时出错", e);
+		}
+	}
+
+	// 安全解析Long的方法（处理格式异常）
+	private Long safeParseLong(String value) {
+		try {
+			return Long.parseLong(value);
+		} catch (NumberFormatException e) {
+			log.warn("无法转换的节点ID格式: {}", value);
+			return null;
 		}
 	}
 
 
+
+
+
+
+
 }

blade-service/blade-archive/src/main/java/org/springblade/archive/service/impl/TraceLogServiceImpl.java

@@ -59,7 +59,7 @@ public class TraceLogServiceImpl extends BaseServiceImpl<TraceLogMapper, TraceLo
             TraceLog traceLog = new TraceLog();
             traceLog.setTraceId(traceId);
             traceLog.setContent(content);
-            save(traceLog);
+            //save(traceLog);
 
         } catch (Exception e) {
             // 异常处理逻辑，比如打印日志

blade-service/blade-manager/src/main/java/org/springblade/manager/mapper/ArchiveTreeContractMapper.xml

@@ -50,6 +50,7 @@
         <result column="archive_name_suffix" property="archiveNameSuffix"/>
         <result column="ext_key_id" property="extKeyId"/>
         <result column="out_id" property="outId"/>
+        <result column="ext_node_type" property="extNodeType"/>
     </resultMap>
     <delete id="removeImageNodeChild">
         delete from m_archive_tree_contract

blade-service/blade-manager/src/main/java/org/springblade/manager/service/impl/ArTreeContractInitServiceImpl.java

@@ -513,6 +513,7 @@ public class ArTreeContractInitServiceImpl {
             archiveTree.setExtAttachId(subTree.getId());
             archiveTree.setSort(wbsTreeVO2.getSort());
             archiveTree.setDisplayHierarchy(level.toString());
+            archiveTree.setExtNodeType(wbsTreeVO2.getNodeType());
             archiveTree.setIsDeleted(0);
             //上传节点
             if (wbsTreeVO2.getNodeType() != null && wbsTreeVO2.getNodeType().longValue() == level) {