Merge branch 'feature-lihb-20250610' of http://219.151.181.73:3000/zhuwei/bladex into test-merge-02

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/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-business/src/main/java/org/springblade/business/controller/PrivateStandardController.java

@@ -147,8 +147,8 @@ public class PrivateStandardController {
     @PostMapping("updateTypeByTwo")
     @ApiOperation(value = "规范文件修改数据")
     public R<Boolean> updateTypeByTwo(@RequestPart("data") @Validated List<PrivateStandardDTO> data,
-                             @RequestPart("delIds") @Validated List<Long> delIds,
-                             @RequestPart("delFileIds") @Validated List<Long> delFileIds,
+                             @RequestPart("delIds")  List<Long> delIds,
+                             @RequestPart("delFileIds") List<Long> delFileIds,
                              @RequestPart("files") MultipartFile[] files) {
         //封装数据
         boolean save = this.privateStandardService.updateTypeByTwo(data,delIds,delFileIds,files);

blade-service/blade-business/src/main/java/org/springblade/business/service/impl/PrivateStandardServiceImpl.java

@@ -200,10 +200,12 @@ public class PrivateStandardServiceImpl extends ServiceImpl<PrivateStandardMappe
         BladeUser user = SecureUtil.getUser();
         //先删除文件
         try {
-            List<StandardFile> standardFiles = standardFileService.listByIds(delFileIds);
-            if(CollectionUtils.isNotEmpty(standardFiles)){
-                for (StandardFile standardFile : standardFiles) {
-                    this.deleteFile(standardFile.getId());
+            if(CollectionUtils.isNotEmpty(delFileIds)){
+                List<StandardFile> standardFiles = standardFileService.listByIds(delFileIds);
+                if(CollectionUtils.isNotEmpty(standardFiles)){
+                    for (StandardFile standardFile : standardFiles) {
+                        this.deleteFile(standardFile.getId());
+                    }
                 }
             }
             //删除规范文件
@@ -213,6 +215,7 @@ public class PrivateStandardServiceImpl extends ServiceImpl<PrivateStandardMappe
                 }
             }
         } catch (Exception e) {
+            e.printStackTrace();
             throw new ServiceException("Oss删除文件失败");
         }
         try {

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) {