档案-同步合同段日志资料

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

@@ -176,6 +176,12 @@ public class ArchiveTree extends BaseEntity {
     @ApiModelProperty(value = "试验资料类型,‘使用逗号拼接’")
     private String expDataType;
 
+    /**
+     * 日志资料类型
+     */
+    @ApiModelProperty(value = "日志资料类型,逗号拼接")
+    private String contractLogType;
+
     public ArchiveTree() {
     }
 

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

@@ -184,7 +184,7 @@ public class ArchiveTreeContract extends BaseEntity {
     //系统级模板Id
     private Long baseId;
     /**
-     * 来源id，项目级，用于后续同步更新
+     * 来源id，archiveTree的id，用于后续同步更新
      */
     private Long fromId;
     /**
@@ -241,6 +241,12 @@ public class ArchiveTreeContract extends BaseEntity {
     @ApiModelProperty(value = "树结构，1-正常树，2-时间树")
     private Integer treeStructure;
 
+    /**
+     * 日志资料类型
+     */
+    @ApiModelProperty(value = "日志资料类型,逗号拼接")
+    private String contractLogType;
+
     public ArchiveTreeContract() {
     }
 
@@ -310,6 +316,7 @@ public class ArchiveTreeContract extends BaseEntity {
         this.archiveAutoGroupId = archiveTree.getArchiveAutoGroupId();
         this.archiveAutoGroupSelect = archiveTree.getArchiveAutoGroupSelect();
         this.isUploadFileDisplayConfigurationTree = archiveTree.getIsUploadFileDisplayConfigurationTree();
+        this.contractLogType = archiveTree.getContractLogType();
     }
 
     public void sync(ArchiveTreeVO2 archiveTree) {

blade-service-api/blade-manager-api/src/main/java/org/springblade/manager/vo/ArchiveSyncLogVO.java

@@ -0,0 +1,39 @@
+package org.springblade.manager.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * @Param   档案同步质检日志资料VO
+ * @Author wangwl
+ * @Date 2024/9/24 11:20
+ **/
+@Data
+public class ArchiveSyncLogVO {
+
+    private Long id;
+
+    @ApiModelProperty("日志类型")
+    private Integer logType;
+
+    @ApiModelProperty("日志类型名称")
+    private String logName;
+
+    @ApiModelProperty("创建人")
+    private Long createUser;
+
+    @ApiModelProperty("填报人姓名")
+    private String createUserName;
+
+    @ApiModelProperty("填报时间、施工时间")
+    private String recordTime;
+
+    @ApiModelProperty("文件名称")
+    private String fileName;
+
+    @ApiModelProperty("文件路径")
+    private String pdfUrl;
+
+    @ApiModelProperty("电签文件路径")
+    private String eVisaPdfUrl;
+}

blade-service/blade-business/src/main/java/org/springblade/business/mapper/ArchiveFileMapper.xml

@@ -337,7 +337,7 @@
         SELECT uaf.*, matc.tree_code as 'contractType'
         FROM u_archive_file uaf
                  left join m_archive_tree_contract matc on uaf.node_id = matc.id
-        WHERE uaf.project_id = #{projectId} and uaf.is_deleted = 0
+        WHERE uaf.project_id = #{projectId} and matc.is_deleted = 0  and uaf.is_deleted = 0
             and (uaf.is_auto_file is null or uaf.is_auto_file != 1);
     </select>
     <select id="getAllArchiveFileUrl" resultType="org.springblade.business.entity.ArchiveFile">

blade-service/blade-manager/src/main/java/org/springblade/manager/controller/ArchiveTreeContractController.java

@@ -512,14 +512,15 @@ public class ArchiveTreeContractController extends BladeController {
             @ApiImplicitParam(name = "projectId", value = "项目id", required = true, dataType = "Long"),
             @ApiImplicitParam(name = "contractId", value = "合同段id", required = true, dataType = "Long"),
             @ApiImplicitParam(name = "nodeId", value = "当前节点id", required = true, dataType = "Long"),
+            @ApiImplicitParam(name = "associationType", value = "同步类型1影像2日志3试验", required = true, dataType = "Integer"),
     })
-    public R syncSoundImageData(Long projectId, Long contractId, Long nodeId) {
-        R returnObject = R.success("同步合同段声像文件完成" );
+    public R syncSoundImageData(Long projectId, Long contractId, Long nodeId,Integer associationType) {
         try {
-            archiveTreeContractSync.syncSoundImageData(projectId,contractId, nodeId);
+            archiveTreeContractSync.syncDataCheck(projectId,contractId, nodeId,associationType);
         }catch (Exception e) {
-            returnObject = R.fail(e.getMessage());
+            return R.fail("同步失败："+e.getMessage());
         }
-        return returnObject;
+        return R.success("同步完成" );
     }
+
 }

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

@@ -29,6 +29,7 @@ import org.springblade.manager.entity.WbsTreePrivate;
 import org.springblade.manager.vo.*;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.springblade.system.entity.DictBiz;
 
 import java.util.List;
 import java.util.Map;
@@ -157,4 +158,7 @@ public interface ArchiveTreeContractMapper extends BaseMapper<ArchiveTreeContrac
     void removeImageNodeChild(@Param("contractId") Long contractId,@Param("id") Long id);
 
     void removeImageNodeFile(@Param("contractId") Long contractId,@Param("id") Long id);
+
+    List<DictBiz> getLogDict();
+
 }

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

@@ -765,4 +765,7 @@
     </foreach>
         or a.contract_id is null) and a.tenant_id!='000000';
     </select>
+    <select id="getLogDict" resultType="org.springblade.system.entity.DictBiz">
+        select * from blade_dict_biz where parent_id != 0 and code = 'contract_log_type' and is_deleted = 0
+    </select>
 </mapper>

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

@@ -124,4 +124,6 @@ public interface WbsTreePrivateMapper extends EasyBaseMapper<WbsTreePrivate> {
     List<Long> linkNodeTreeBynodeId(@Param("pkeyid") String pkeyid);
 
     void batchUpdateIsAddConceal(@Param("private") WbsTreePrivate wbsTreePrivate);
+
+    List<ArchiveSyncLogVO> getContractAllLog(@Param("contractId") Long contractId);
 }

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

@@ -896,4 +896,11 @@
     <select id="linkNodeTreeBynodeId" resultType="java.lang.Long" >
         select p_key_id from m_wbs_tree_private where (yzer_tree_id = #{pkeyid} or jler_tree_id = #{pkeyid})  and `type` = 1 and is_deleted = 0
     </select>
+    <select id="getContractAllLog" resultType="org.springblade.manager.vo.ArchiveSyncLogVO">
+        select id,create_user_name,record_time,file_name,pdf_url,e_visa_pdf_url,create_user,create_time,
+               (select node_type from m_wbs_tree_private where p_key_id = ucl.wbs_node_id) as logType,
+               (select node_name from m_wbs_tree_private where p_key_id = ucl.wbs_node_id) as logName
+        from u_contract_log ucl
+        where contract_id = #{contractId} and is_deleted = 0
+    </select>
 </mapper>

blade-service/blade-manager/src/main/java/org/springblade/manager/service/IWbsTreePrivateService.java

@@ -104,4 +104,5 @@ public interface IWbsTreePrivateService extends BaseService<WbsTreePrivate> {
     //获取数据回显
     List<Long> linkNodeTreeBynodeId(String pkeyId);
 
+    List<ArchiveSyncLogVO> getContractAllLog(Long contractId);
 }

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

@@ -2,7 +2,6 @@ package org.springblade.manager.service.impl;
 
 import com.alibaba.nacos.common.utils.DateFormatUtils;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
-import com.google.protobuf.ServiceException;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang.StringUtils;
@@ -17,19 +16,19 @@ import org.springblade.business.feign.InformationQueryClient;
 import org.springblade.business.vo.TreeVoTwo;
 import org.springblade.common.utils.ForestNodeMergerEx;
 import org.springblade.common.utils.SnowFlakeUtil;
+import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.secure.utils.AuthUtil;
 import org.springblade.core.tool.utils.CollectionUtil;
 import org.springblade.core.tool.utils.ObjectUtil;
 import org.springblade.manager.entity.*;
+import org.springblade.manager.enums.AssociationTypeEnum;
 import org.springblade.manager.enums.StorageTypeEnum;
 import org.springblade.manager.enums.TreeStructureEnum;
 import org.springblade.manager.mapper.ArchiveTreeContractMapper;
-import org.springblade.manager.service.IContractInfoService;
-import org.springblade.manager.service.IImageClassificationConfigService;
-import org.springblade.manager.service.IProjectInfoService;
-import org.springblade.manager.service.IWbsTreeContractService;
+import org.springblade.manager.service.*;
 import org.springblade.manager.utils.ForestNodeMerger;
 import org.springblade.manager.vo.*;
+import org.springblade.system.entity.DictBiz;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -69,6 +68,8 @@ public class ArchiveTreeContractSyncImpl {
 
     private final IWbsTreeContractService wbsTreeContractService;
 
+    private final IWbsTreePrivateService wbsTreePrivateService;
+
 
 
     /**
@@ -764,6 +765,55 @@ public class ArchiveTreeContractSyncImpl {
         return groupedFiles;
     }
 
+    /**
+     * 同步合同段数据时，统一校验通道，3声像资料，6日志资料，2试验资料
+     */
+    public void syncDataCheck(Long projectId, Long contractId, Long nodeId,Integer associationType) {
+        // 合同信息
+        ContractInfo contractInfo = contractInfoService.getById(contractId);
+        // 判断是否正在同步
+        Integer isArchivesAuto = contractInfo.getIsArchivesAuto();
+        if(ObjectUtil.isNotEmpty(isArchivesAuto) && isArchivesAuto != 0) {
+            throw new ServiceException("当前合同段已经在同步中,请耐心等待");
+        }
+        // 获取当前节点信息
+        ArchiveTreeContract archiveTreeContract = archiveTreeContractMapper.selectById(nodeId);
+        if (archiveTreeContract == null || archiveTreeContract.getAssociationType() == null){
+            throw new ServiceException("未获取到当前同步节点关联信息");
+        }
+        //设置自动组卷中
+        contractInfoService.updateIsArchivesAutoById(contractId,1);
+        try {
+            switch (associationType){
+                case 3:
+                    if(!archiveTreeContract.getAssociationType().equals(AssociationTypeEnum.SOUND_IMAGE_DATA.getCode())){
+                        throw new ServiceException("当前节点关联类型不是声像,无法同步声像文件");
+                    }
+                    syncSoundImageData(projectId,contractInfo,archiveTreeContract);
+                    break;
+                case 6:
+                    if(!archiveTreeContract.getAssociationType().equals(AssociationTypeEnum.LOG_FILE.getCode())){
+                        throw new ServiceException("当前节点关联类型不是日志,无法同步日志文件");
+                    }
+                    syncContractLogData(projectId,contractInfo,archiveTreeContract);
+                    break;
+                case 2:
+                    if(!archiveTreeContract.getAssociationType().equals(AssociationTypeEnum.TRIAL_DATA.getCode())){
+                        throw new ServiceException("当前节点关联类型不是试验,无法同步试验文件");
+                    }
+                    syncContractTrialData(projectId,contractInfo,archiveTreeContract);
+                    break;
+                default:
+                    throw new ServiceException("传入文件类型错误");
+            }
+        }catch (Exception e){
+            throw new ServiceException(e.getMessage());
+        }finally {
+            //设置自动组卷结束
+            contractInfoService.updateIsArchivesAutoById(contractId, 0);
+        }
+    }
+
     /**
      * 同步合同段声像文件
      */
@@ -778,7 +828,7 @@ public class ArchiveTreeContractSyncImpl {
         // 判断节点存储类型是否为声像
         ArchiveTreeContract archiveTreeContract = archiveTreeContractMapper.selectById(nodeId);
         if(archiveTreeContract != null) {
-            if(!archiveTreeContract.getStorageType().equals(StorageTypeEnum.SOUND_IMAGE.getCode())){
+            if(!archiveTreeContract.getStorageType().equals(AssociationTypeEnum.SOUND_IMAGE_DATA.getCode())){
                 throw new ServiceException("当前节点存储类型不是声像,无法同步声像文件");
             }
         }else{
@@ -801,38 +851,6 @@ public class ArchiveTreeContractSyncImpl {
         }
     }
 
-//    /**
-//     * 同步某个合同段的声像资料到归档
-//     */
-//    public void syncSoundImageData(Long projectId, ContractInfo contractInfo, ArchiveTreeContract archiveTreeContract) {
-//        Long contractId = contractInfo.getId();
-//
-//        log.info("同步声像文件，projectId："+projectId+"，contractId:"+contractId+"，nodeId："+archiveTreeContract.getId());
-//
-//        //项目信息
-//        ProjectInfo projectInfo = projectInfoService.getOne(projectId);
-//
-//        //项目使用的wbs模板
-//        Long lWbsId = projectInfo.getReferenceWbsTemplateId();
-//
-//        //获取合同段wbs划分树，用来组织树
-//        List<WbsTreeContractVO6> wbsTrees = contractInfoService.tree8(lWbsId.toString(), projectId.toString(), contractId.toString());
-//        if (CollectionUtil.isEmpty(wbsTrees)) {
-//            return;
-//        }
-//
-//        // wbs转换archive树形集合
-//        List<ArchiveTreeContract> wbsCovertArchiveTreeContractList = new ArrayList<>();
-//
-//        // wbs转换archive,并初始化值
-//        getTreeList(AuthUtil.getTenantId(), wbsTrees.get(0), wbsCovertArchiveTreeContractList, archiveTreeContract, archiveTreeContract.getId());
-//
-//        log.info("同步声像文件树  imageClassificationFileList :"+wbsCovertArchiveTreeContractList.size());
-//
-//        //同步质检关联节点
-//        syncNodes(wbsCovertArchiveTreeContractList, contractInfo, archiveTreeContract);
-//    }
-
     private void buildWbsContractTree(List<ArchiveSyncWbsVO> parentNode, Long parentId,String ancestors,Map<Long, List<ArchiveSyncWbsVO>> childMap,List<ArchiveSyncWbsVO> wbsRealList) {
         if (parentNode != null && parentNode.size() > 0){
             for (ArchiveSyncWbsVO parent : parentNode) {
@@ -849,6 +867,76 @@ public class ArchiveTreeContractSyncImpl {
         }
     }
 
+    /**
+     * 同步某个合同段的试验资料到归档
+     */
+    @Transactional
+    public void syncContractTrialData(Long projectId, ContractInfo contractInfo, ArchiveTreeContract archiveTreeContract) {
+
+    }
+
+    /**
+     * 同步某个合同段的日志资料到归档
+     */
+    @Transactional
+    public void syncContractLogData(Long projectId, ContractInfo contractInfo, ArchiveTreeContract archiveTreeContract) {
+        //获取勾选的日志类型
+        String contractLogType = archiveTreeContract.getContractLogType();
+        if (StringUtils.isBlank(contractLogType)){
+            throw new ServiceException("当前节点未配置同步日志类型");
+        }
+        List<Integer> logType = Arrays.stream(contractLogType.split(","))
+                .map(Integer::parseInt) // 将每个字符串转换为Integer
+                .collect(Collectors.toList());
+        //获取日志类型字典
+        List<DictBiz> dict = archiveTreeContractMapper.getLogDict();
+        if (CollectionUtil.isEmpty(dict)){
+            throw new ServiceException("系统未配置日志类型");
+        }
+        Map<Integer, String> dictMap = dict.stream().collect(Collectors.toMap(l -> Integer.parseInt(l.getDictKey()), l -> l.getDictValue()));
+        Long contractId = contractInfo.getId();
+        String tenantId = AuthUtil.getTenantId();
+        log.info("同步声像文件，projectId："+projectId+"，contractId:"+contractId+"，nodeId："+archiveTreeContract.getId());
+        //先删除日志资料节点下的所有节点与文件
+        archiveTreeContractMapper.removeImageNodeFile(archiveTreeContract.getContractId(),archiveTreeContract.getId());
+        archiveTreeContractMapper.removeImageNodeChild(archiveTreeContract.getContractId(),archiveTreeContract.getId());
+        List<ArchiveTreeContract> addNode = new ArrayList<>();
+        List<ArchiveFile> addFile = new ArrayList<>();
+        //获取合同段所有的日志，并且附带类型
+        List<ArchiveSyncLogVO> logs = wbsTreePrivateService.getContractAllLog(contractId);
+        //日志按照类型分组
+        Map<Integer, List<ArchiveSyncLogVO>> logMap = logs.stream().collect(Collectors.groupingBy(ArchiveSyncLogVO::getLogType));
+        //循环选择的日志类型，生成子节点
+        for (Integer type : logType) {
+            String typeName = dictMap.get(type);
+            if (StringUtils.isBlank(typeName)){
+                throw new ServiceException("日志存在字典中未配置的类型，请检查后再同步");
+            }
+            ArchiveTreeContract logNode = createTypeNode(typeName, archiveTreeContract);
+            /** 如果到时候修改需求，只显示有日志的，则下面文件存在再add*/
+            addNode.add(logNode);
+            //然后再从分组中获取，如果存在值则转换为档案文件
+            List<ArchiveSyncLogVO> files = logMap.get(type);
+            if (CollectionUtil.isEmpty(files)){
+                continue;
+            }
+            //挂载到子节点下
+            List<ArchiveFile> newArchiveFileList = files.stream().map(file -> {
+                ArchiveFile archiveFile = logFileCovertArchiveFile(file, logNode);
+                return archiveFile;
+            }).collect(Collectors.toList());
+            addFile.addAll(newArchiveFileList);
+        }
+
+        if (addNode.size() > 0){
+            addNode.stream().forEach(l->l.setTenantId(tenantId));
+            archiveTreeContractMapper.batchInsertArchiveTreeContract(addNode);
+        }
+        if (addFile.size() > 0){
+            archiveFileClient.addArchiveFile(addFile);
+        }
+    }
+
 
     /**
      * 同步某个合同段的声像资料到归档
@@ -891,7 +979,7 @@ public class ArchiveTreeContractSyncImpl {
         //循环下级节点
         for (ImageClassificationConfig imageType : imageTypes) {
             //把分类生成为影像资料的下级节点
-            ArchiveTreeContract imageNode = createImageTypeNode(imageType,archiveTreeContract);
+            ArchiveTreeContract imageNode = createTypeNode(imageType.getClassfName(),archiveTreeContract);
             addNode.add(imageNode);
             //如果当前分类下存在文件，则根据类型生成树，还是日期
             List<ImageClassificationFileDTO> files = imageMap.get(imageType.getId());
@@ -971,9 +1059,7 @@ public class ArchiveTreeContractSyncImpl {
         if (addFile.size() > 0){
             archiveFileClient.addArchiveFile(addFile);
         }
-//        if (1==1){
-//            throw new org.springblade.core.log.exception.ServiceException("111");
-//        }
+
     }
 
 
@@ -1038,6 +1124,44 @@ public class ArchiveTreeContractSyncImpl {
         return archiveFile;
     }
 
+    /**
+     * 质检日志资料 转换为 档案文件
+     */
+    private ArchiveFile logFileCovertArchiveFile(ArchiveSyncLogVO vo,ArchiveTreeContract parentNode)
+    {
+        ArchiveFile archiveFile = new ArchiveFile();
+        archiveFile.setId(SnowFlakeUtil.getId());
+        archiveFile.setProjectId(String.valueOf(parentNode.getProjectId()));
+        archiveFile.setContractId(String.valueOf(parentNode.getContractId()));
+        archiveFile.setNodeId(parentNode.getId()+"");
+        archiveFile.setFileName(vo.getFileName());
+        archiveFile.setFileTime(vo.getRecordTime());
+        archiveFile.setFileUrl(vo.getPdfUrl());
+        archiveFile.setPdfFileUrl(vo.getEVisaPdfUrl());
+        archiveFile.setFilePage(1);
+        archiveFile.setIsApproval(0);
+        archiveFile.setIsCertification(1);
+        archiveFile.setIsNeedCertification(0);
+        archiveFile.setDutyUser(vo.getCreateUserName());
+        archiveFile.setCreateUser(vo.getCreateUser());
+        archiveFile.setStatus(0);
+        archiveFile.setIsDeleted(0);
+        archiveFile.setFileType(2L);
+        // 创建 LocalDateTime
+        LocalDateTime localDateTime = new Date().toInstant()
+                .atZone(ZoneId.systemDefault())
+                .toLocalDateTime();
+        archiveFile.setFtime(localDateTime);
+        archiveFile.setUtime(localDateTime);
+        archiveFile.setSort(0);
+        archiveFile.setPageNum("1");
+        archiveFile.setSourceType(1);
+        archiveFile.setIsElement(0);
+        archiveFile.setRectification(0);
+        archiveFile.setArchiveFileStorageType(StorageTypeEnum.SOUND_IMAGE.getCode());
+        return archiveFile;
+    }
+
     private void recursionCreateArchiveTree(ArchiveSyncWbsVO rootNode, List<ArchiveTreeContract> addNode, ArchiveTreeContract archiveTreeContract) {
         ArchiveTreeContract node = createImageWbsNode(rootNode, archiveTreeContract);
         addNode.add(node);
@@ -1050,66 +1174,6 @@ public class ArchiveTreeContractSyncImpl {
         }
     }
 
-//    /**
-//     * 将树形节点对象转换为普通的list集合
-//     */
-//    public void getTreeList(String tenantId, WbsTreeContractVO6 tree, List<ArchiveTreeContract> wbsCovertArchiveTreeContractList, ArchiveTreeContract archiveTreeContract, Long archiveTreeContractId) {
-//        if (ObjectUtil.isEmpty(tree)) {
-//            return;
-//        }
-//        // wbs树转archive树
-//        ArchiveTreeContract archiveTreeContractTemp = wbsTreeContractCovertArchiveTreeContract(tenantId, tree, archiveTreeContract, archiveTreeContractId);
-//        wbsCovertArchiveTreeContractList.add(archiveTreeContractTemp);
-//
-//        // 循环遍历，转换树对象
-//        List<WbsTreeContractVO6> childrenList = tree.getChildren();
-//        if (childrenList != null) {
-//            for (WbsTreeContractVO6 child : childrenList) {
-//                getTreeList(tenantId, child, wbsCovertArchiveTreeContractList, archiveTreeContractTemp, archiveTreeContractId);
-//            }
-//        }
-//    }
-
-    /**
-     * 将wbs树初始化为归档树
-     */
-    public ArchiveTreeContract wbsTreeContractCovertArchiveTreeContract(String tenantId, WbsTreeContractVO6 tree, ArchiveTreeContract archiveTreeContract, Long archiveTreeContractId) {
-        ArchiveTreeContract archiveTreeContractTemp = new ArchiveTreeContract();
-        //设置基本信息
-        archiveTreeContractTemp.setId(SnowFlakeUtil.getId());
-        archiveTreeContractTemp.setTenantId(tenantId);
-        archiveTreeContractTemp.setProjectId(archiveTreeContract.getProjectId());
-        archiveTreeContractTemp.setContractId(archiveTreeContract.getContractId());
-        archiveTreeContractTemp.setParentId(archiveTreeContract.getId());
-        archiveTreeContractTemp.setAncestors(archiveTreeContract.getAncestors()+","+archiveTreeContract.getId());
-        archiveTreeContractTemp.setNodeName(tree.getNodeName());
-        archiveTreeContractTemp.setNodeType(1);
-        archiveTreeContractTemp.setFullName(tree.getFullName());
-        archiveTreeContractTemp.setTreeCode(archiveTreeContract.getContractId().toString());
-        //设置关联
-        archiveTreeContractTemp.setExtType(1);
-        archiveTreeContractTemp.setExtId(tree.getId());
-        archiveTreeContractTemp.setExtKeyId(tree.getPKeyId());
-        archiveTreeContractTemp.setExtAttachId(archiveTreeContractId);
-        archiveTreeContractTemp.setSort(tree.getSort());
-        archiveTreeContractTemp.setStatus(1);
-        archiveTreeContractTemp.setIsDeleted(0);
-        archiveTreeContractTemp.setFromId(tree.getId());
-        if (StringUtils.isNotEmpty(tree.getOldId())) {
-            archiveTreeContractTemp.setFromId(Long.parseLong(tree.getOldId()));
-        }
-        archiveTreeContractTemp.setIsStorageNode(1);
-        //wbs_tree_contract与archive_tree_contract字段等存在差异，不清楚的字段值，我沿用同步节点的字段值进行初始化
-        archiveTreeContractTemp.setPostType(archiveTreeContract.getPostType());
-        archiveTreeContractTemp.setMajorDataType(archiveTreeContract.getMajorDataType());
-        archiveTreeContractTemp.setProjectType(archiveTreeContract.getProjectType());
-        archiveTreeContractTemp.setStorageType(archiveTreeContract.getStorageType());
-        archiveTreeContractTemp.setCreateUser(tree.getCreateUser());
-        archiveTreeContractTemp.setCreateDept(tree.getCreateDept());
-        archiveTreeContractTemp.setCreateTime(tree.getCreateTime());
-        archiveTreeContractTemp.setTreeStructure(TreeStructureEnum.ORDINARY_TREE.getCode());
-        return archiveTreeContractTemp;
-    }
 
     /**
      * 档案同步质检影像资料时，为影像资料节点下级分类节点，创建日期节点
@@ -1140,10 +1204,10 @@ public class ArchiveTreeContractSyncImpl {
     }
 
     /**
-     * 档案同步质检影像资料时，为影像资料节点下级创建分类节点
+     * 档案同步质检影像资料时，为影像资料-日志资料   节点下级创建分类节点
      * 传入分类名称
      */
-    public ArchiveTreeContract createImageTypeNode(ImageClassificationConfig imageType,ArchiveTreeContract archiveTreeContract){
+    public ArchiveTreeContract createTypeNode(String nodeName,ArchiveTreeContract archiveTreeContract){
         ArchiveTreeContract archiveTreeContractTemp = new ArchiveTreeContract();
         //设置基本信息
         archiveTreeContractTemp.setId(SnowFlakeUtil.getId());
@@ -1152,9 +1216,9 @@ public class ArchiveTreeContractSyncImpl {
         archiveTreeContractTemp.setContractId(archiveTreeContract.getContractId());
         archiveTreeContractTemp.setParentId(archiveTreeContract.getId());
         archiveTreeContractTemp.setAncestors(archiveTreeContract.getAncestors()+","+archiveTreeContract.getId());
-        archiveTreeContractTemp.setNodeName(imageType.getClassfName());
+        archiveTreeContractTemp.setNodeName(nodeName);
         archiveTreeContractTemp.setNodeType(1);
-        archiveTreeContractTemp.setFullName(imageType.getClassfName());
+        archiveTreeContractTemp.setFullName(nodeName);
         archiveTreeContractTemp.setStatus(1);
         archiveTreeContractTemp.setIsDeleted(0);
         //设置关联
@@ -1167,6 +1231,7 @@ public class ArchiveTreeContractSyncImpl {
         return archiveTreeContractTemp;
     }
 
+
     /**
      * 档案同步质检影像资料时，为影像资料节点下分类节点创建WBS树
      */
@@ -1195,435 +1260,6 @@ public class ArchiveTreeContractSyncImpl {
         return archiveTreeContractTemp;
     }
 
-
-
-
-
-//    private void syncNodes(List<ArchiveTreeContract> wbsCovertArchiveTreeContractList,
-//                           ContractInfo contractInfo, ArchiveTreeContract archiveTreeContract) {
-//        Long contractId = contractInfo.getId();
-//
-//        // 获取关联节点
-//        List<ArchiveTreeContract> associatedNodes = Arrays.asList(archiveTreeContract);
-//
-//        log.info("同步声像文件树节点  syncNodes："+associatedNodes.size());
-//
-//        // 新增的归档树聚合
-//        List<ArchiveTreeContract> saveArchiveTreeContractList = new ArrayList<>();
-//        // 新增的归档文件集合
-//        List<ArchiveFile> saveArchiveFileList = new ArrayList<>();
-//        // 修改的归档树聚合
-//        List<Map> updateArchiveTreeContractList = new ArrayList<>();
-//        // 修改的归档文件集合
-//        List<ArchiveFile> updateArchiveFileList = new ArrayList<>();
-//        // 删除的归档树聚合
-//        List<ArchiveTreeContract> deleteArchiveTreeContractList = new ArrayList<>();
-//        // 删除的归档文件集合
-//        List<ArchiveFile> deleteArchiveFileList = new ArrayList<>();
-//
-//        for (ArchiveTreeContract node : associatedNodes) {
-//            log.info("同步声像文件树节点  syncNode：" + node.getId() + "-" +  node.getNodeName());
-//
-//            /***同步树-开始*/
-//            // 获取该合同段下的wbs节点
-//            List<ArchiveTreeContract> originalArchiveTreeContractList = getArchiveTreeContractsWbs(contractId, node.getId(),null);
-//
-//            // 树形map
-//            Map<Long, ArchiveTreeContract> originalArchiveTreeContractMap = buildNodeMap(originalArchiveTreeContractList);
-//
-//            // 转换类型
-//            List<ArchiveTreeContractVO> archiveTreeContractVOList = wbsCovertArchiveTreeContractList.stream().map(tree -> {
-//                ArchiveTreeContractVO vo = new ArchiveTreeContractVO();
-//                BeanUtils.copyProperties(tree, vo);
-//                return vo;
-//            }).collect(Collectors.toList());
-//
-//            // list转换为树形
-//            List<ArchiveTreeContractVO> mergeList = org.springblade.core.tool.node.ForestNodeMerger.merge(archiveTreeContractVOList);
-//
-//            // 与已有数据做合并(目的是将已有的树信息复制到对应的树)
-//            archiveAndOldTreeMergeData(mergeList, originalArchiveTreeContractMap, TreeStructureEnum.ORDINARY_TREE);
-//
-//            // 重新刷新整个树结构(刷新整个树的父子节点id)
-//            for (ArchiveTreeContractVO archiveTreeContractVO : mergeList) {
-//                refreshTreeStructure(archiveTreeContractVO, node.getId(), node.getAncestors());
-//            }
-//
-//            // 将树转换为list
-//            List<ArchiveTreeContractVO> archiveTreeContractVOTempList = new ArrayList<>();
-//            ForestNodeMerger.getTreeList(mergeList.get(0), archiveTreeContractVOTempList);
-//
-//            List<ArchiveTreeContract> newArchiveTreeContractList = archiveTreeContractVOTempList.stream().map(vo -> {
-//                ArchiveTreeContract archiveTreeContractTemp = new ArchiveTreeContract();
-//                BeanUtils.copyProperties(vo, archiveTreeContractTemp);
-//                return vo;
-//            }).collect(Collectors.toList());
-//
-//            // 树形map
-//            Map<Long, ArchiveTreeContract> newArchiveTreeContractMap = buildNodeMap(newArchiveTreeContractList);
-//
-//            // 取两个树形集合中的差异，并输出新增、修改、删除三个集合
-//            diffTrees(originalArchiveTreeContractList, newArchiveTreeContractList, originalArchiveTreeContractMap,
-//                    newArchiveTreeContractMap, saveArchiveTreeContractList, deleteArchiveTreeContractList, updateArchiveTreeContractList);
-//            /***同步树-结束*/
-//
-//            /***同步树型文件数据准备-开始*/
-//            // 根据合同段id查询声像文件
-//            List<ImageClassificationFileDTO> imageClassificationFileList = getImageClassificationFileListByContractId(contractId);
-//
-//            // 声像文件转换
-//            List<ArchiveFile> newArchiveFileList = imageClassificationFileList.stream().map(file -> {
-//                ArchiveFile archiveFile = imageClassificationFileCovertArchiveFile(file, node, newArchiveTreeContractMap);
-//                return archiveFile;
-//            }).collect(Collectors.toList());
-//
-//            // 查询合同段下的声像文件
-//            List<ArchiveFile> originalArchiveFileList = archiveFileClient.getListByContractIdAndArchiveFileStorageType(contractId, StorageTypeEnum.SOUND_IMAGE.getCode());
-//
-//            // 构件原始文件TreeMap
-//            Map<Long, ArchiveFile> originalArchiveFileMap = buildArchiveFileMap(originalArchiveFileList);
-//
-//            // 与已有数据做合并(目的是将已有的树信息复制到对应的树)
-//            originalAndNewArchiveFileMergeData(newArchiveFileList, originalArchiveFileMap);
-//
-//            // 构件新文件TreeMap
-//            Map<Long, ArchiveFile> newArchiveFileMap = buildArchiveFileMap(newArchiveFileList);
-//
-//            // 将声像文件集合遍历，分为时间储存和树形储存两个集合
-//            List<ArchiveFile> newArchiveFileTreeList = new ArrayList<>();
-//            List<ArchiveFile> newArchiveFileDateList = new ArrayList<>();
-//            for (ArchiveFile archiveFile : newArchiveFileList) {
-//                if(archiveFile.getNodeTreeStructure() == 1) {
-//                    newArchiveFileTreeList.add(archiveFile);
-//                }else if(archiveFile.getNodeTreeStructure() == 2) {
-//                    newArchiveFileDateList.add(archiveFile);
-//                }
-//            }
-//
-//            // 将声像文件集合遍历，分为时间储存和树形储存两个集合
-//            List<ArchiveFile> originalArchiveFileTreeList = new ArrayList<>();
-//            List<ArchiveFile> originalArchiveFileDateList = new ArrayList<>();
-//            for (ArchiveFile archiveFile : originalArchiveFileList) {
-//                if(archiveFile.getNodeTreeStructure() == 1) {
-//                    originalArchiveFileTreeList.add(archiveFile);
-//                }else if(archiveFile.getNodeTreeStructure() == 2) {
-//                    originalArchiveFileDateList.add(archiveFile);
-//                }
-//            }
-//            /***同步树型文件数据准备-结束*/
-//
-//            /**同步树形文件-开始**/
-//            // 取两个树形集合中的差异，并输出新增、修改、删除三个集合
-//            diffFiles(originalArchiveFileTreeList, newArchiveFileTreeList, originalArchiveFileMap, newArchiveFileMap,
-//                    saveArchiveFileList, deleteArchiveFileList, updateArchiveFileList, newArchiveTreeContractMap, TreeStructureEnum.ORDINARY_TREE);
-//            /**同步树形文件-结束**/
-//
-//            /**同步时间树-开始**/
-//            // 获取该合同段下的时间型节点
-//            List<ArchiveTreeContract> originalDateArchiveTreeContractList = getArchiveTreeContractsByTreeStructure(contractId, node.getId(), TreeStructureEnum.DATE_TREE);
-//
-//            // 树形map
-//            Map<Long, ArchiveTreeContract> originalDateArchiveTreeContractMap = buildDateMap(originalDateArchiveTreeContractList);
-//
-//            // 将最新文件的时间取出，创建时间树
-//            List<String> dateList = newArchiveFileDateList.stream().map(archiveFile -> {
-//                String format = DateFormatUtils.format(archiveFile.getCreateTime(), "yyyy-MM-dd");
-//                return format;
-//            }).collect(Collectors.toList());
-//
-//            // 转时间树
-//            List<TreeVoTwo> dateTreeList = YearTreeUtils.yearMonthDayTree(dateList, "DESC");
-//
-//            // date转换archive树形集合
-//            List<ArchiveTreeContractVO> dateCovertArchiveTreeContractVoList = new ArrayList<>();
-//
-//            // date转换archive,并初始化值
-//            getTreeList(AuthUtil.getTenantId(), dateTreeList, dateCovertArchiveTreeContractVoList, archiveTreeContract, archiveTreeContract.getId());
-//
-//            // list转换为树形
-//            List<ArchiveTreeContractVO> mergeDateList = org.springblade.core.tool.node.ForestNodeMerger.merge(dateCovertArchiveTreeContractVoList);
-//
-//            // 与已有数据做合并(目的是将已有的树信息复制到对应的树)
-//            archiveAndOldTreeMergeData(mergeDateList, originalDateArchiveTreeContractMap, TreeStructureEnum.DATE_TREE);
-//
-//            // 重新刷新整个树结构(刷新整个树的父子节点id)
-//            for (ArchiveTreeContractVO dateArchiveTreeContractVO : mergeDateList) {
-//                refreshTreeStructure(dateArchiveTreeContractVO, node.getId(), node.getAncestors());
-//            }
-//
-//            // 将树转换为list
-//            List<ArchiveTreeContractVO> dateArchiveTreeContractVOTempList = new ArrayList<>();
-//            for (ArchiveTreeContractVO archiveTreeContractVO : mergeDateList) {
-//                ForestNodeMerger.getTreeList(archiveTreeContractVO, dateArchiveTreeContractVOTempList);
-//            }
-//            // 转实体类
-//            List<ArchiveTreeContract> newDateArchiveTreeContractList = dateArchiveTreeContractVOTempList.stream().map(vo -> {
-//                ArchiveTreeContract archiveTreeContractTemp = new ArchiveTreeContract();
-//                BeanUtils.copyProperties(vo, archiveTreeContractTemp);
-//                return vo;
-//            }).collect(Collectors.toList());
-//
-//            // 树形map
-//            Map<Long, ArchiveTreeContract> newDateArchiveTreeContractMap = buildDateMap(newDateArchiveTreeContractList);
-//
-//            // 取两个树形集合中的差异，并输出新增、修改、删除三个集合
-//            diffDateTrees(originalDateArchiveTreeContractList, newDateArchiveTreeContractList, originalDateArchiveTreeContractMap,
-//                    newDateArchiveTreeContractMap, saveArchiveTreeContractList, deleteArchiveTreeContractList, updateArchiveTreeContractList);
-//            /**同步时间树-结束**/
-//
-//            /**同步时间树形文件-开始**/
-//            // 取两个树形集合中的差异，并输出新增、修改、删除三个集合
-//            diffFiles(originalArchiveFileDateList, newArchiveFileDateList, originalArchiveFileMap, newArchiveFileMap,
-//                    saveArchiveFileList, deleteArchiveFileList, updateArchiveFileList, newDateArchiveTreeContractMap, TreeStructureEnum.DATE_TREE);
-//            /**同步时间树形文件-结束**/
-//
-//            /**统一刷新树与文件**/
-//            // 刷新树
-//            refreshArchiveTreeContract(saveArchiveTreeContractList, updateArchiveTreeContractList, deleteArchiveTreeContractList);
-//
-//            // 刷新文件
-//            refreshArchiveFile(saveArchiveFileList, updateArchiveFileList, deleteArchiveFileList);
-//        }
-//    }
-    /**
-     * 时间树中的差异
-     * 遍历循环，获取差异，并输出三个集合(归档树的fullName = 老树中的fullName)
-     */
-    private static void diffDateTrees(List<ArchiveTreeContract> originalDateArchiveTreeContractList, List<ArchiveTreeContract> newDateArchiveTreeContractList, Map<Long, ArchiveTreeContract> originalDateArchiveTreeContractMap,
-                                  Map<Long, ArchiveTreeContract> newDateArchiveTreeContractMap, List<ArchiveTreeContract> insertions,
-                                  List<ArchiveTreeContract> deletions, List<Map> modifications) {
-        for (ArchiveTreeContract originalDateArchiveTreeContract : originalDateArchiveTreeContractList) {
-            if (!newDateArchiveTreeContractMap.containsKey(Long.valueOf(originalDateArchiveTreeContract.getFullName()))) {
-                deletions.add(originalDateArchiveTreeContract);
-            } else {
-                ArchiveTreeContract node2 = newDateArchiveTreeContractMap.get(Long.valueOf(originalDateArchiveTreeContract.getFullName()));
-                if (originalDateArchiveTreeContract.getFullName().equals(node2.getFullName())) {
-                    Map map = new HashMap();
-                    map.put("id", originalDateArchiveTreeContract.getId());
-                    map.put("parentId", node2.getParentId());
-                    map.put("ancestors", node2.getAncestors());
-                    map.put("nodeName", node2.getNodeName());
-                    map.put("nodeType", node2.getNodeType());
-                    map.put("fullName", node2.getFullName());
-                    map.put("treeStructure", node2.getTreeStructure());
-                    modifications.add(map);
-                }
-            }
-        }
-        for (ArchiveTreeContract newArchiveTreeContract : newDateArchiveTreeContractList) {
-            if (!originalDateArchiveTreeContractMap.containsKey(Long.valueOf(newArchiveTreeContract.getFullName()))) {
-                insertions.add(newArchiveTreeContract);
-            }
-        }
-    }
-
-    /**
-     * 根据tree结构获取归档树
-     */
-    public List<ArchiveTreeContract>  getArchiveTreeContractsByTreeStructure(Long contractId,Long attachId, TreeStructureEnum treeStructure) {
-        List<ArchiveTreeContract> archiveTreeContracts = archiveTreeContractMapper.selectList(Wrappers.<ArchiveTreeContract>query().lambda()
-                .eq(ArchiveTreeContract::getContractId, contractId)
-                .eq(ArchiveTreeContract::getExtAttachId, attachId)
-                .eq(ArchiveTreeContract::getTreeStructure, treeStructure.getCode()));
-        return archiveTreeContracts;
-    }
-
-    /**
-     * 将时间树形节点对象转换为普通的list集合
-     */
-    public void getTreeList(String tenantId, List<TreeVoTwo> dateTreeList, List<ArchiveTreeContractVO> dateCovertArchiveTreeContractList, ArchiveTreeContract archiveTreeContract, Long archiveTreeContractId) {
-        if (CollectionUtil.isEmpty(dateTreeList)) {
-            return;
-        }
-        for (TreeVoTwo tree : dateTreeList) {
-            // wbs树转archive树
-            ArchiveTreeContractVO archiveTreeContractVoTemp = dateTreeCovertArchiveTreeContract(tenantId, tree, archiveTreeContract, archiveTreeContractId);
-            dateCovertArchiveTreeContractList.add(archiveTreeContractVoTemp);
-
-            // 循环遍历，转换树对象
-            List<TreeVoTwo> childrenList = tree.getChildren();
-            if (childrenList != null) {
-                getTreeList(tenantId, childrenList, dateCovertArchiveTreeContractList, archiveTreeContractVoTemp, archiveTreeContractId);
-            }
-        }
-    }
-
-    /**
-     * 将时间树初始化为归档树
-     */
-    public ArchiveTreeContractVO dateTreeCovertArchiveTreeContract(String tenantId, TreeVoTwo tree, ArchiveTreeContract archiveTreeContract, Long archiveTreeContractId) {
-        ArchiveTreeContractVO archiveTreeContractVoTemp = new ArchiveTreeContractVO();
-        //设置基本信息
-        archiveTreeContractVoTemp.setId(SnowFlakeUtil.getId());
-        archiveTreeContractVoTemp.setTenantId(tenantId);
-        archiveTreeContractVoTemp.setProjectId(archiveTreeContract.getProjectId());
-        archiveTreeContractVoTemp.setContractId(archiveTreeContract.getContractId());
-        archiveTreeContractVoTemp.setParentId(archiveTreeContract.getId());
-        archiveTreeContractVoTemp.setAncestors(archiveTreeContract.getAncestors()+","+archiveTreeContract.getId());
-        archiveTreeContractVoTemp.setNodeName(tree.getName());
-        archiveTreeContractVoTemp.setNodeType(1);
-        archiveTreeContractVoTemp.setFullName(tree.getHierarchy());
-        archiveTreeContractVoTemp.setTreeCode(archiveTreeContract.getContractId().toString());
-        //设置关联
-        archiveTreeContractVoTemp.setExtAttachId(archiveTreeContractId);
-        archiveTreeContractVoTemp.setSort(archiveTreeContract.getSort());
-        archiveTreeContractVoTemp.setStatus(1);
-        archiveTreeContractVoTemp.setIsDeleted(0);
-        archiveTreeContractVoTemp.setIsStorageNode(1);
-        //时间树不同于wbs树，不清楚的字段值，我沿用同步节点的字段值进行初始化
-        archiveTreeContractVoTemp.setPostType(archiveTreeContract.getPostType());
-        archiveTreeContractVoTemp.setMajorDataType(archiveTreeContract.getMajorDataType());
-        archiveTreeContractVoTemp.setProjectType(archiveTreeContract.getProjectType());
-        archiveTreeContractVoTemp.setStorageType(archiveTreeContract.getStorageType());
-        archiveTreeContractVoTemp.setCreateUser(archiveTreeContract.getCreateUser());
-        archiveTreeContractVoTemp.setCreateDept(archiveTreeContract.getCreateDept());
-        archiveTreeContractVoTemp.setCreateTime(archiveTreeContract.getCreateTime());
-        archiveTreeContractVoTemp.setTreeStructure(TreeStructureEnum.DATE_TREE.getCode());
-        return archiveTreeContractVoTemp;
-    }
-
-    /**
-     * 刷新归档文件
-     */
-    void refreshArchiveFile(List<ArchiveFile> saveArchiveFileList, List<ArchiveFile> updateArchiveFileList,
-                            List<ArchiveFile> deleteArchiveFileList) {
-        if (CollectionUtil.isNotEmpty(saveArchiveFileList)) {
-            archiveFileClient.addArchiveFile(saveArchiveFileList);
-        }
-        if (CollectionUtil.isNotEmpty(updateArchiveFileList)) {
-            archiveFileClient.updateArchiveFile(updateArchiveFileList);
-        }
-        if (CollectionUtil.isNotEmpty(deleteArchiveFileList)) {
-            List<Long> idList = deleteArchiveFileList.stream().map(ArchiveFile::getId).collect(Collectors.toList());
-            archiveFileClient.removeFile(idList);
-        }
-    }
-
-    /**
-     * 现有的树与wbs的树做合并
-     */
-    public void originalAndNewArchiveFileMergeData(List<ArchiveFile> mergeList, Map<Long, ArchiveFile> archiveFileMap) {
-        if (CollectionUtil.isEmpty(mergeList)) {
-            return;
-        }
-        // 循环遍历，将已有的赋值
-        for (ArchiveFile archiveFile : mergeList) {
-            ArchiveFile archiveFileTemp = archiveFileMap.get(archiveFile.getUImageClassificationFileId());
-            if(ObjectUtil.isNotEmpty(archiveFileTemp)){
-                archiveFile.setId(archiveFileTemp.getId());
-                archiveFile.setNodeId(archiveFileTemp.getNodeId());
-            }
-        }
-    }
-
-    /**
-     * 遍历循环，获取差异，并输出三个集合(archiveFile表的uImageClassificationFileId = ImageClassificationFile 的 id)
-     */
-    private static void diffFiles(List<ArchiveFile> originalArchiveFileList, List<ArchiveFile> newArchiveFileList, Map<Long, ArchiveFile> originalArchiveFileTreeMap,
-                                  Map<Long, ArchiveFile> newArchiveFileTreeMap, List<ArchiveFile> insertions, List<ArchiveFile> deletions, List<ArchiveFile> modifications,
-                                  Map<Long, ArchiveTreeContract> newArchiveTreeContractMap, TreeStructureEnum treeStructureEnum) {
-        for (ArchiveFile originalArchiveFile : originalArchiveFileList) {
-            if (!newArchiveFileTreeMap.containsKey(originalArchiveFile.getUImageClassificationFileId())) {
-                deletions.add(originalArchiveFile);
-            } else {
-                ArchiveFile node2 = newArchiveFileTreeMap.get(originalArchiveFile.getUImageClassificationFileId());
-                if (originalArchiveFile.getUImageClassificationFileId().equals(node2.getUImageClassificationFileId())) {
-                    modifications.add(node2);
-                }
-            }
-        }
-        for (ArchiveFile newArchiveFile : newArchiveFileList) {
-            if (!originalArchiveFileTreeMap.containsKey(newArchiveFile.getUImageClassificationFileId())) {
-                ArchiveTreeContract archiveTreeContract = null;
-                if(treeStructureEnum.getCode() == TreeStructureEnum.ORDINARY_TREE.getCode()){
-                    archiveTreeContract = newArchiveTreeContractMap.get(newArchiveFile.getMWbsTreeContractPKeyId());
-                } else if(treeStructureEnum.getCode() == TreeStructureEnum.DATE_TREE.getCode()) {
-                    archiveTreeContract = newArchiveTreeContractMap.get(Long.valueOf(newArchiveFile.getDateName()));
-                }
-                if(ObjectUtil.isNotEmpty(archiveTreeContract)){
-                    newArchiveFile.setNodeId(String.valueOf(archiveTreeContract.getId()));
-                }
-                insertions.add(newArchiveFile);
-            }
-        }
-    }
-
-    /**
-     * 构建节点map
-     */
-    private static Map<Long, ArchiveFile> buildArchiveFileMap(List<ArchiveFile> archiveFileList) {
-        Map<Long, ArchiveFile> map = new HashMap<>();
-        for (ArchiveFile archiveFile : archiveFileList) {
-            map.put(archiveFile.getUImageClassificationFileId(), archiveFile);
-        }
-        return map;
-    }
-
-    /**
-     * imageClassificationFile 转换为 archiveFile
-     */
-    private ArchiveFile imageClassificationFileCovertArchiveFile(ImageClassificationFileDTO file,
-                                                                 ArchiveTreeContract node,
-                                                                 Map<Long, ArchiveTreeContract> wbsCovertArchiveTreeContractMap)
-    {
-        ArchiveFile archiveFile = new ArchiveFile();
-        archiveFile.setId(SnowFlakeUtil.getId());
-        archiveFile.setProjectId(String.valueOf(node.getProjectId()));
-        archiveFile.setContractId(String.valueOf(node.getContractId()));
-        ArchiveTreeContract archiveTreeContractTemp = wbsCovertArchiveTreeContractMap.get(Long.valueOf(file.getWbsId()));
-        if(archiveTreeContractTemp != null){
-            archiveFile.setNodeId(String.valueOf(archiveTreeContractTemp.getId()));
-        }
-        archiveFile.setFileNumber(String.valueOf(file.getId()));
-        archiveFile.setFileName(file.getTitle());
-        archiveFile.setFileTime(file.getUploadTime());
-        archiveFile.setFileUrl(file.getImageUrl());
-        // 根据type判断，设置pdfUrl, 1=视频格式，取原本的视频地址就好，2=图片格式，就取合并后的pdfUrl
-        if(file.getType() == 1){
-            archiveFile.setPdfFileUrl(file.getImageUrl());
-        }else{
-            archiveFile.setPdfFileUrl(StringUtils.isNotEmpty(file.getMargePdfUrl()) ? file.getMargePdfUrl() : file.getPdfUrl());
-        }
-        archiveFile.setFilePage(file.getFilePage());
-        archiveFile.setIsApproval(0);
-        archiveFile.setIsCertification(1);
-        archiveFile.setIsNeedCertification(0);
-        archiveFile.setDutyUser(file.getShootingUser());
-        archiveFile.setCreateUser(file.getCreateUser());
-        archiveFile.setCreateDept(file.getCreateDept());
-        archiveFile.setCreateTime(file.getCreateTime());
-        archiveFile.setUpdateUser(file.getUpdateUser());
-        archiveFile.setUpdateTime(file.getUpdateTime());
-        archiveFile.setStatus(0);
-        archiveFile.setIsDeleted(0);
-        archiveFile.setFileType(Long.valueOf(file.getType()));
-        archiveFile.setFilmingTime(file.getShootingTime());
-        archiveFile.setFilmingorTime(file.getShootingTime());
-        archiveFile.setPicCode(file.getPhotoCode());
-        archiveFile.setFilmCode(file.getFilmCode());
-        archiveFile.setReferCode(file.getSeeAlsoCode());
-        archiveFile.setWidth(file.getFileWidth());
-        archiveFile.setHeight(file.getFileHeight());
-        // 创建 LocalDateTime 时间爱你
-        LocalDateTime localDateTime = new Date().toInstant()
-                .atZone(ZoneId.systemDefault())
-                .toLocalDateTime();
-        archiveFile.setFtime(localDateTime);
-        archiveFile.setUtime(localDateTime);
-        archiveFile.setSort(0);
-        archiveFile.setPageNum(String.valueOf(file.getFilePage()));
-        archiveFile.setFileSize(convertSizeToBytes(file.getFileSize()));
-        archiveFile.setSourceType(1);
-        archiveFile.setIsElement(0);
-        archiveFile.setRectification(0);
-        archiveFile.setMWbsTreeContractPKeyId(file.getWbsId());
-        archiveFile.setUImageClassificationFileId(file.getId());
-        archiveFile.setArchiveFileStorageType(StorageTypeEnum.SOUND_IMAGE.getCode());
-        archiveFile.setNodeTreeStructure(file.getStorageDirectoryFormat());
-        archiveFile.setDateName(DateFormatUtils.format(file.getCreateTime(), "yyyyMMdd"));
-        return archiveFile;
-    }
-
     /**
      * imageClassificationFile里面的fileSize，是已经转换过的(230.6MB)，是字符串
      * 而archiveFile里面的fileSize是纯数字大小，现在要转换回来
@@ -1645,121 +1281,6 @@ public class ArchiveTreeContractSyncImpl {
         }
     }
 
-    /**
-     * 重新刷新整个树结构
-     */
-    public void refreshTreeStructure(ArchiveTreeContractVO archiveTreeContractVO, Long id, String ancestors) {
-        archiveTreeContractVO.setParentId(id);
-        archiveTreeContractVO.setAncestors(ancestors+","+id);
-        List<ArchiveTreeContractVO> children = archiveTreeContractVO.getChildren();
-        if (CollectionUtil.isNotEmpty(children)) {
-            for (ArchiveTreeContractVO child : children) {
-                refreshTreeStructure(child, archiveTreeContractVO.getId(), archiveTreeContractVO.getAncestors());
-            }
-        }
-    }
 
-    /**
-     * 现有的树与老的树做合并
-     */
-    public void archiveAndOldTreeMergeData(List<ArchiveTreeContractVO> mergeList, Map<Long, ArchiveTreeContract> archiveTreeContractMap, TreeStructureEnum treeStructureEnum) {
-        if (CollectionUtil.isEmpty(mergeList)) {
-            return;
-        }
-        // 循环遍历，将已有的赋值，随后再次将整个树的上下节点，重新刷新
-        for (ArchiveTreeContractVO archiveTreeContractVO : mergeList) {
-            ArchiveTreeContract archiveTreeContract = null;
-            if(treeStructureEnum.getCode() == TreeStructureEnum.ORDINARY_TREE.getCode()){
-                archiveTreeContract = archiveTreeContractMap.get(archiveTreeContractVO.getExtKeyId());
-            } else if(treeStructureEnum.getCode() == TreeStructureEnum.DATE_TREE.getCode()) {
-                archiveTreeContract = archiveTreeContractMap.get(Long.valueOf(archiveTreeContractVO.getFullName()));
-            }
-            if(ObjectUtil.isNotEmpty(archiveTreeContract)){
-                archiveTreeContractVO.setId(archiveTreeContract.getId());
-                archiveTreeContractVO.setParentId(archiveTreeContract.getParentId());
-                archiveTreeContractVO.setAncestors(archiveTreeContract.getAncestors());
-            }
-            archiveAndOldTreeMergeData(archiveTreeContractVO.getChildren(), archiveTreeContractMap, treeStructureEnum);
-        }
-    }
-
-    /**
-     * 刷新归档树
-     */
-//    void refreshArchiveTreeContract(List<ArchiveTreeContract> saveArchiveTreeContractList, List<Map> updateArchiveTreeContractList,
-//                                    List<ArchiveTreeContract> deleteArchiveTreeContractList) {
-//        if (CollectionUtil.isNotEmpty(saveArchiveTreeContractList)) {
-//            archiveTreeContractMapper.batchInsertArchiveTreeContract(saveArchiveTreeContractList);
-//        }
-//        if (CollectionUtil.isNotEmpty(updateArchiveTreeContractList)) {
-//            archiveTreeContractMapper.batchUpdateArchiveTreeContract(updateArchiveTreeContractList);
-//        }
-//        if (CollectionUtil.isNotEmpty(deleteArchiveTreeContractList)) {
-//            List<Long> idList = deleteArchiveTreeContractList.stream().map(ArchiveTreeContract::getId).collect(Collectors.toList());
-//            archiveTreeContractMapper.batchDeleteArchiveTreeContractByIdList(idList, 1);
-//        }
-//    }
-
-    /**
-     * 根据合同段id查询声像文件
-     */
-    public List<ImageClassificationFileDTO> getImageClassificationFileListByContractId(Long contractId) {
-        return imageClassificationFileClient.getImageClassificationFileListByContractId(contractId);
-    }
-
-    /**
-     * 遍历循环，获取差异，并输出三个集合(归档树的ExtKeyId = Wbs树的pKeyId)
-     */
-    private static void diffTrees(List<ArchiveTreeContract> originalArchiveTreeContractList, List<ArchiveTreeContract> newArchiveTreeContractList, Map<Long, ArchiveTreeContract> originalArchiveTreeContractMap,
-                                  Map<Long, ArchiveTreeContract> newArchiveTreeContractMap, List<ArchiveTreeContract> insertions,
-                                  List<ArchiveTreeContract> deletions, List<Map> modifications) {
-        for (ArchiveTreeContract originalArchiveTreeContract : originalArchiveTreeContractList) {
-            if (!newArchiveTreeContractMap.containsKey(originalArchiveTreeContract.getExtKeyId())) {
-                deletions.add(originalArchiveTreeContract);
-            } else {
-                ArchiveTreeContract node2 = newArchiveTreeContractMap.get(originalArchiveTreeContract.getExtKeyId());
-                if (originalArchiveTreeContract.getExtKeyId().equals(node2.getExtKeyId())) {
-                    // 更新修改数据
-                    Map map = new HashMap();
-                    map.put("id", originalArchiveTreeContract.getId());
-                    map.put("parentId", node2.getParentId());
-                    map.put("ancestors", node2.getAncestors());
-                    map.put("nodeName", node2.getNodeName());
-                    map.put("nodeType", node2.getNodeType());
-                    map.put("fullName", node2.getFullName());
-                    map.put("treeStructure", node2.getTreeStructure());
-                    modifications.add(map);
-                }
-            }
-        }
-        for (ArchiveTreeContract newArchiveTreeContract : newArchiveTreeContractList) {
-            if (!originalArchiveTreeContractMap.containsKey(newArchiveTreeContract.getExtKeyId())) {
-                insertions.add(newArchiveTreeContract);
-            }
-        }
-    }
-
-    /**
-     * 构建节点map
-     */
-    private static Map<Long, ArchiveTreeContract> buildNodeMap(List<ArchiveTreeContract> tree) {
-        Map<Long, ArchiveTreeContract> map = new HashMap<>();
-        for (ArchiveTreeContract node : tree) {
-            map.put(node.getExtKeyId(), node);
-        }
-        return map;
-    }
-
-    /**
-     * 构建时间map
-     */
-    private static Map<Long, ArchiveTreeContract> buildDateMap(List<ArchiveTreeContract> tree) {
-        Map<Long, ArchiveTreeContract> map = new HashMap<>();
-        for (ArchiveTreeContract node : tree) {
-            // 时间树中，fullName表示该节点的详细时间，如20240109，唯一性
-            map.put(Long.valueOf(node.getFullName()), node);
-        }
-        return map;
-    }
 
 }

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

@@ -2942,4 +2942,9 @@ public class WbsTreePrivateServiceImpl extends BaseServiceImpl<WbsTreePrivateMap
         return baseMapper.linkNodeTreeBynodeId(pkeyId);
     }
 
+    @Override
+    public List<ArchiveSyncLogVO> getContractAllLog(Long contractId) {
+        return baseMapper.getContractAllLog(contractId);
+    }
+
 }