Merge branch 'lk20230410'

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

@@ -157,7 +157,7 @@ public class ArchiveTree extends BaseEntity {
     private Long archiveAutoGroupId;
 
     /**
-     * 是否自动立卷规则选择设置的节点 选中的节点设为1 方便页面显示列表
+     * 是否自动立卷规则选择设置的节点 选中的节点设为1 方便页面显示列表,方便同步判断
      */
     @ApiModelProperty(value = "是否为设置的节点")
     private Integer archiveAutoGroupSelect;

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

@@ -233,7 +233,7 @@ public class ArTreeContractInitServiceImpl {
      *
      * @param archiveTreeContracts
      */
-    public void InitTreeSort(List<ArchiveTreeContract> archiveTreeContracts) {
+    public void InitTreeSort(List<ArchiveTreeContract> archiveTreeContracts,List<ArchiveTreeVO2> proVo2Trees) {
         List<ArchiveTreeContractVO2> archiveTreeContractVO2List = new ArrayList<>();
 
         Map<Long,ArchiveTreeContractVO2> vo2Map = new LinkedHashMap<>();
@@ -245,7 +245,7 @@ public class ArTreeContractInitServiceImpl {
 
         InitTreeSort(trees.get(0), "");
 
-        archiveAutoRuleSync.syncArchiveTreeContractList(vo2Map);
+        archiveAutoRuleSync.syncArchiveTreeContractList(vo2Map,proVo2Trees);
 
         List<ArchiveTreeContract> upList = new ArrayList<>();
 

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

@@ -22,7 +22,7 @@ public class ArchiveAutoRuleSyncImpl {
 
     }
 
-    public void syncArchiveTreeList(Map<Long,ArchiveTreeVO2> vo2Map){
+    public void syncArchiveTreeList(Map<Long,ArchiveTreeVO2> vo2Map,List<ArchiveTreeVO2> sysVo2Trees){
 
         List<ArchiveTreeVO2> normalList = new ArrayList<>();
         List<ArchiveTreeVO2> wbsList = new ArrayList<>();
@@ -32,19 +32,19 @@ public class ArchiveAutoRuleSyncImpl {
         }
 
 
-        ForestNodeMergerEx.setPropertyfromId(normalList,syncPropertyMap);
-
-
+        /*ForestNodeMergerEx.setPropertyfromId(normalList,syncPropertyMap);
         for (ArchiveTreeVO2 archiveTreeVO2 : vo2Map.values()) {
             if (archiveTreeVO2.getArchiveAutoNodeId() != null) {
                 archiveTreeVO2.setFlag(1);
             }
-        }
-        //todo group type
+        }*/
+
+        //组卷规则同步
+        //syncRuleSysToProject(vo2Map,sysVo2Trees);
 
     }
 
-    public void syncArchiveTreeContractList(Map<Long,ArchiveTreeContractVO2> vo2Map){
+    public void syncArchiveTreeContractList(Map<Long,ArchiveTreeContractVO2> vo2Map,List<ArchiveTreeVO2> proVo2Trees){
 
         List<ArchiveTreeContractVO2> normalList = new ArrayList<>();
         List<ArchiveTreeContractVO2> wbsList = new ArrayList<>();
@@ -60,7 +60,7 @@ public class ArchiveAutoRuleSyncImpl {
         }
 
         //根据formId
-        ForestNodeMergerEx.setPropertyfromId(normalList,syncPropertyMap);
+        //ForestNodeMergerEx.setPropertyfromId(normalList,syncPropertyMap);
 
         //todo,这里补充上获取对应的wbsid
         List<Long> wbsIds = new ArrayList<>();
@@ -95,12 +95,256 @@ public class ArchiveAutoRuleSyncImpl {
         }
 
         //设置修改标识
-        for (ArchiveTreeContractVO2 archiveTreeContractVO2 : vo2Map.values()) {
+       /* for (ArchiveTreeContractVO2 archiveTreeContractVO2 : vo2Map.values()) {
             if (archiveTreeContractVO2.getArchiveAutoNodeId() != null) {
                 archiveTreeContractVO2.setFlag(1);
             }
+        }*/
+        //组卷规则同步
+        //syncRuleProToContract(vo2Map,proVo2Trees);
+    }
+
+    /**
+     *
+     * @param vo2Map 项目级节点集合
+     * @param sysVo2Trees  系统级节点集合
+     */
+    private void syncRuleSysToProject(Map<Long,ArchiveTreeVO2> vo2Map,List<ArchiveTreeVO2> sysVo2Trees){
+        //同步规则
+        // archiveAutoType  与系统级一致  不用处理
+        // archiveAutoNodeId   需替换成对应项目级节点id
+        // archiveAutoGroupId     与系统级一致 不用处理
+        // archiveAutoGroupSelect  与系统级一致 不用处理
+        //系统初始化项目 vo2Map.values()里的规则字段值都是系统级的值
+        //初始化后项目级再次同步  vo2Map.values()里的规则字段值新加的是系统级的值，原来的是项目级的值
+
+        //准备系统级节点map
+        Map<Long,ArchiveTreeVO2> sysMap = new HashMap<>();
+        for(ArchiveTreeVO2 sysVo2:sysVo2Trees){
+            sysMap.put(sysVo2.getId(),sysVo2);
         }
-        //todo group type
+        //准备在页面勾选设置的系统级节点ID_项目级节点Map   用于映射archiveAutoNodeId同步
+        Map<Long,List<ArchiveTreeVO2>> sysIdToPro_Map = new HashMap<>();
+        for(ArchiveTreeVO2 proVO2 : vo2Map.values()){
+            //只提取设置的节点，也就是select=1的节点
+            if(proVO2.getArchiveAutoGroupSelect()==1){
+                Long fromId = proVO2.getFromId();
+                if(sysIdToPro_Map.containsKey(fromId)){
+                    List<ArchiveTreeVO2> archiveTreeVO2s = sysIdToPro_Map.get(fromId);
+                    archiveTreeVO2s.add(proVO2);
+                    sysIdToPro_Map.put(fromId,archiveTreeVO2s);
+                }else{
+                    List<ArchiveTreeVO2> archiveTreeVO2s = new ArrayList<>();
+                    archiveTreeVO2s.add(proVO2);
+                    sysIdToPro_Map.put(fromId,archiveTreeVO2s);
+                }
+            }
+        }
+        //同步规则设置
+        for (ArchiveTreeVO2 archiveTreeVO2: vo2Map.values()) {
+            Integer archiveAutoType = archiveTreeVO2.getArchiveAutoType();
+            //过滤没有任何规则的节点
+            if(archiveAutoType!=null){
+                //步骤一：处理archiveAutoNodeId同步
+                Long archiveAutoNodeId = archiveTreeVO2.getArchiveAutoNodeId();
+                if(archiveAutoNodeId!=null){
+                    //判断规则值是系统级的还是项目级的
+                    if(sysMap.containsKey(archiveAutoNodeId)){
+                        //这个节点是刚从系统级同步过来，规则值还是系统级的。而这个archiveAutoNodeId是系统级设置的最高并卷节点的ID
+                        //用archiveAutoNodeId通过sysIdToPro_Map找出对应的项目级节点
+                        List<ArchiveTreeVO2> pro_select_vo2s = sysIdToPro_Map.get(archiveAutoNodeId);
+                        if(pro_select_vo2s.size()==1){
+                            //一个系统级节点对应了一个项目级节点
+                            Long pro_archiveAutoNodeId = pro_select_vo2s.get(0).getId();
+                            archiveTreeVO2.setArchiveAutoNodeId(pro_archiveAutoNodeId);//设置项目级的archiveAutoNodeId
+                            archiveTreeVO2.setFlag(1);
+                        }else{
+                            //一个系统级节点对应了多个项目级节点（项目级添加加节点的情况）
+                            for(ArchiveTreeVO2 pro_select_vo2:pro_select_vo2s){
+                                //系统级对应多个节点时,用当前节点的ancestors去对比pro_select_vo2中的id，当前节点的ancestors必有上级节点的id。或当前节点id=pro_select_vo2中的id
+                                String ancestorsPid = pro_select_vo2.getId().toString();
+                                String ancestors = archiveTreeVO2.getAncestors();
+                                Long pro_id = archiveTreeVO2.getId();
 
+                                if(ancestors.contains(ancestorsPid) ||  pro_id.equals(ancestorsPid)){
+                                    archiveTreeVO2.setArchiveAutoNodeId(pro_select_vo2.getId());//设置项目级的archiveAutoNodeId
+                                    archiveTreeVO2.setFlag(1);
+                                    break;
+                                }
+                            }
+                        }
+                    }else{
+                        //TODO 这个节点是已经初始化出来的节点，规则值是项目级的   已经是项目级好像不用处理了
+                        //Long fromId = archiveTreeVO2.getFromId();
+                        //ArchiveTreeVO2 sys_vo2 = sysMap.get(fromId);
+                        //ArchiveTreeVO2 sys_select_vo2 = sysMap.get(sys_vo2.getArchiveAutoNodeId());
+                    }
+                }
+            }
+
+
+            //archiveAutoType  与系统级一致  不用处理
+            //archiveAutoGroupSelect  与系统级一致 不用处理
+            //archiveAutoGroupId 与系统级一致 不用处理
+        }
     }
+
+
+    /**
+     * 项目级同步客户级 组卷规则处理
+     * @param vo2Map  客户级节点集合
+     * @param proVo2Trees  项目级节点集合
+     */
+    private void syncRuleProToContract(Map<Long,ArchiveTreeContractVO2> vo2Map,List<ArchiveTreeVO2> proVo2Trees){
+        //同步规则
+        // archiveAutoType  与系统级一致  不用处理
+        // archiveAutoNodeId   需替换成对应项目级节点id
+        // archiveAutoGroupId     项目级同组的在 客户级有合同段的要按合同段分开
+        // archiveAutoGroupSelect  与系统级一致 不用处理
+        //系统初始化客户级 vo2Map.values()里的规则字段值都是项目级的值
+        //初始化后客户级再次同步  vo2Map.values()里的规则字段值新加的是项目的值，原来的是客户级的值
+
+
+        //准备项目级节点map
+        Map<Long,ArchiveTreeVO2> proMap = new HashMap<>();
+        for(ArchiveTreeVO2 proVo2:proVo2Trees){
+            proMap.put(proVo2.getId(),proVo2);
+        }
+        //准备在页面勾选设置的项目级节点ID_客户级节点Map   用于映射archiveAutoNodeId同步
+        Map<Long,List<ArchiveTreeContractVO2>> proIdToContact_Map = new HashMap<>();
+        for(ArchiveTreeContractVO2 contractVO2 : vo2Map.values()){
+            //只提取设置的节点，也就是select=1的节点
+            if(contractVO2.getArchiveAutoGroupSelect()==1){
+                Long fromId = contractVO2.getFromId();
+                if(proIdToContact_Map.containsKey(fromId)){
+                    List<ArchiveTreeContractVO2> contractTreeVO2s = proIdToContact_Map.get(fromId);
+                    contractTreeVO2s.add(contractVO2);
+                    proIdToContact_Map.put(fromId,contractTreeVO2s);
+                }else{
+                    List<ArchiveTreeContractVO2> archiveTreeVO2s = new ArrayList<>();
+                    archiveTreeVO2s.add(contractVO2);
+                    proIdToContact_Map.put(fromId,archiveTreeVO2s);
+                }
+            }
+        }
+
+        //构建 合同段ID_项目级groupID,客户级groupID> 集合   用于映射archiveAutoGroupId同步
+        Map<String,Long> groupMap = new HashMap<>();
+        for(ArchiveTreeContractVO2 contractVO2 : vo2Map.values()){
+            Integer archiveAutoType = contractVO2.getArchiveAutoType();
+            Long fromId = contractVO2.getFromId();
+            //只处理普通节点，规则时分类并卷类型的
+            if (contractVO2.getExtType()== null && fromId!=null && archiveAutoType==2){
+                Long contract_groupId = contractVO2.getArchiveAutoGroupId();
+                //如果当前contractVO2的groupID是客户级（19位数）,需要先保存关联集合
+                if(contract_groupId.toString().length()==19){
+                    //1.通过fromid找出项目级
+                    ArchiveTreeVO2 proTreeVO2 = proMap.get(fromId);
+                    //2.获取项目级groupID
+                    Long pro_groupId = proTreeVO2.getArchiveAutoGroupId();
+                    //3.，那么保存到集合  合同段ID_项目级groupID,客户级groupID
+                    Long contractId = contractVO2.getContractId();
+                    if(contractId!=null){
+                        String key =contractId+"_"+pro_groupId;
+                        if(!groupMap.containsKey(key)){
+                            groupMap.put(key,contract_groupId);
+                        }
+                    }else{
+                        String key = pro_groupId.toString();
+                        if(!groupMap.containsKey(key)){
+                            groupMap.put(key,contract_groupId);
+                        }
+                    }
+                }
+            }
+        }
+
+        //同步规则设置
+        for (ArchiveTreeContractVO2 contractVO2: vo2Map.values()) {
+
+            //只处理普通节点，wbs节点待客户级同步入库后，再根据项目级保存规则来设置
+            if (contractVO2.getExtType()== null){
+                Integer archiveAutoType = contractVO2.getArchiveAutoType();
+                //过滤没有任何规则的节点
+                //步骤一：处理archiveAutoNodeId同步
+                if(archiveAutoType!=null){
+
+                    Long archiveAutoNodeId = contractVO2.getArchiveAutoNodeId();
+                    if(archiveAutoNodeId!=null){
+                        //判断规则值是项目级的还是客户级的
+                        if(proMap.containsKey(archiveAutoNodeId)){
+                            //这个节点是刚从项目级同步过来，规则值还是项目级的。而这个archiveAutoNodeId是项目级设置的最高并卷节点的ID
+                            //用archiveAutoNodeId通过proIdToContact_Map找出对应的客户级节点
+                            List<ArchiveTreeContractVO2> pro_select_vo2s = proIdToContact_Map.get(archiveAutoNodeId);
+                            if(pro_select_vo2s.size()==1){
+                                //一个系统级节点对应了一个项目级节点
+                                Long pro_archiveAutoNodeId = pro_select_vo2s.get(0).getId();
+                                contractVO2.setArchiveAutoNodeId(pro_archiveAutoNodeId);//设置项目级的archiveAutoNodeId
+                                contractVO2.setFlag(1);
+                            }else{
+                                //一个系统级节点对应了多个项目级节点（项目级添加加节点的情况）
+                                for(ArchiveTreeContractVO2 contract_select_vo2:pro_select_vo2s){
+                                    //系统级对应多个节点时,用当前节点的ancestors去对比pro_select_vo2中的id，当前节点的ancestors必有上级节点的id。或当前节点id=pro_select_vo2中的id
+                                    String ancestorsPid = contract_select_vo2.getId().toString();
+                                    String ancestors = contractVO2.getAncestors();
+                                    Long contract_id = contractVO2.getId();
+
+                                    if(ancestors.contains(ancestorsPid) ||  contract_id.equals(ancestorsPid)){
+                                        contractVO2.setArchiveAutoNodeId(contract_select_vo2.getId());//设置客户级的archiveAutoNodeId
+                                        contractVO2.setFlag(1);
+                                        break;
+                                    }
+                                }
+                            }
+                        }else{
+                            //TODO 这个节点是已经初始化出来的节点，规则值是项目级的   已经是项目级好像不用处理了
+                            //Long fromId = archiveTreeVO2.getFromId();
+                            //ArchiveTreeVO2 sys_vo2 = sysMap.get(fromId);
+                            //ArchiveTreeVO2 sys_select_vo2 = sysMap.get(sys_vo2.getArchiveAutoNodeId());
+                        }
+                    }
+                }
+
+                //步骤二：处理archiveAutoGroupId同步
+                if(archiveAutoType==2){
+                    Long contractId = contractVO2.getContractId();
+                    //分合同段的 给archiveAutoGroupId
+                    Long groupId = contractVO2.getArchiveAutoGroupId();
+                    //客户级的groupID用19位数字  系统级和项目级用16位数字
+                    if(groupId.toString().length()==16){
+                        String key ="";
+                        if(contractId==null) {
+                            key =groupId+"";
+                        }else {
+                            key =contractId+"_"+groupId;
+                        }
+
+                        if(groupMap.containsKey(key)){
+                            Long contractGroupId = groupMap.get(key);
+                            contractVO2.setArchiveAutoGroupId(contractGroupId);
+                            contractVO2.setFlag(1);
+                        }else{
+                            //客户级的group用19位，在同步的时候方便判断是值是客户级还是项目级
+                            double v = Math.random();
+                            if(v<0.1){
+                                v=v+0.1;
+                            }
+                            v=v*1000000;
+                            long ran = (long)v;
+                            Long contractGroupId=Long.parseLong(System.currentTimeMillis()+""+ran);
+                            groupMap.put(key,contractGroupId);
+                            contractVO2.setArchiveAutoGroupId(contractGroupId);
+                            contractVO2.setFlag(1);
+                        }
+                    }else {
+                        //已经是客户级了不用理
+                    }
+                }
+            }
+            //archiveAutoType  与项目级一致  不用处理
+            //archiveAutoGroupSelect  与项目级一致 不用处理
+        }
+    }
+
+
 }

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

@@ -147,7 +147,7 @@ public class ArchiveTreeContractServiceImpl extends BaseServiceImpl<ArchiveTreeC
 		archiveTreeContracts.addAll(addNodes);
 
 		//初始化祖先节点和排序
-		arTreeContractInitService.InitTreeSort(archiveTreeContracts);
+		arTreeContractInitService.InitTreeSort(archiveTreeContracts,tree);
 		//todo 同步质检资料动态节点，处理文件提名
 
 		//todo 同步立卷规则
@@ -450,7 +450,7 @@ public class ArchiveTreeContractServiceImpl extends BaseServiceImpl<ArchiveTreeC
 		}
 
 		//更新排序，把排序，自动组卷这种变化，刷新到新增节点和修改节点上
-		archiveTreeContractSync.InitTreeSort(dstTree,saveContractList,upList);
+		archiveTreeContractSync.InitTreeSort(dstTree,saveContractList,upList,srcTrees);
 
 		saveList.addAll(saveContractList);
 		//同步生成案卷

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

@@ -102,7 +102,7 @@ public class ArchiveTreeContractSyncImpl {
      * @param dstTree
      * @param addList
      */
-    public void InitTreeSort(ArchiveTreeContractVO2  dstTree,List<ArchiveTreeContract> addList,List<ArchiveTreeContract> upList)
+    public void InitTreeSort(ArchiveTreeContractVO2  dstTree,List<ArchiveTreeContract> addList,List<ArchiveTreeContract> upList,List<ArchiveTreeVO2> proVo2Trees)
     {
         Map<Long,ArchiveTreeContractVO2> vo2Map = new LinkedHashMap<>();
 
@@ -115,7 +115,7 @@ public class ArchiveTreeContractSyncImpl {
         ForestNodeMergerEx.InitTreeSort(tree, "");
 
         //更新自动组卷节点
-        archiveAutoRuleSync.syncArchiveTreeContractList(vo2Map);
+        archiveAutoRuleSync.syncArchiveTreeContractList(vo2Map,proVo2Trees);
 
         //根据vo的排序和自动组卷信息，刷新新增节点，根据修改标识生成更新节点
         arTreeContractInitService.handleAddAndUpList(vo2Map,addList,upList);

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

@@ -98,9 +98,20 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
 
         Map<Long,ArchiveTree> archiveMap = new LinkedHashMap<>();
 
+        List<ArchiveTreeVO2> sysVo2Trees = new ArrayList<>();//用于规则同步
+
         for (ArchiveTree archiveTree :sysTrees) {
             oldNewMap.put(archiveTree.getId(), SnowFlakeUtil.getId());
             archiveMap.put(archiveTree.getId(), archiveTree);
+
+            //用于规则同步 ArchiveTree转换成ArchiveTreeVO2
+            ArchiveTreeVO2  vo2 = new ArchiveTreeVO2();
+            vo2.setId(archiveTree.getId());
+            vo2.setArchiveAutoType(archiveTree.getArchiveAutoType());
+            vo2.setArchiveAutoNodeId(archiveTree.getArchiveAutoNodeId());
+            vo2.setArchiveAutoGroupId(archiveTree.getArchiveAutoGroupId());
+            vo2.setArchiveAutoGroupSelect(archiveTree.getArchiveAutoGroupSelect());
+            sysVo2Trees.add(vo2);
         }
         oldNewMap.put(0L,0L);
 
@@ -138,7 +149,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
         }
 
         //todo 同步立卷规则
-        InitAncestors(archiveTrees);
+        InitAncestors(archiveTrees,sysVo2Trees);
 
         this.saveBatch(archiveTrees);
 
@@ -444,7 +455,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
             Long archiveAutoGroupId=null;
             //分类并卷规则的需要生成个随机数，作为同一个分类赋值archiveAutoNodeId
             if(archiveAutoType==2){
-                double v = Math.random() * 10000;
+                double v = Math.random() * 1000;
                 long ran = (long)v;
                 archiveAutoGroupId=Long.parseLong(System.currentTimeMillis()+""+ran);
             }
@@ -454,6 +465,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                 long nodeIdLong = Long.parseLong(nodeId);
                 ArchiveTree archiveTree = baseMapper.selectById(nodeIdLong);
                 archiveTree.setArchiveAutoType(archiveAutoType);
+                archiveTree.setArchiveAutoGroupSelect(1);
                 if(archiveAutoType==1){
                     //最高并卷规则 选择节点的ID
                     archiveTree.setArchiveAutoNodeId(nodeIdLong);
@@ -461,7 +473,6 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                 if(archiveAutoType==2){
                     //分类并卷规则 提交都是一个分类类型
                     archiveTree.setArchiveAutoGroupId(archiveAutoGroupId);
-                    archiveTree.setArchiveAutoGroupSelect(1);
                 }
                 baseMapper.updateById(archiveTree);
 
@@ -493,7 +504,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
             Long archiveAutoGroupId=null;
             //分类并卷规则的需要生成个随机数，作为同一个分类赋值archiveAutoNodeId
             if(archiveAutoType==2){
-                double v = Math.random() * 10000;
+                double v = Math.random() * 1000;
                 long ran = (long)v;
                 archiveAutoGroupId=Long.parseLong(System.currentTimeMillis()+""+ran);
             }
@@ -544,7 +555,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                     Long groupId = dto.getArchiveAutoGroupId();
                     String selectNodeIds = dto.getSelectNodeIds();
                     List<String> selectNodeIdlist = Arrays.asList(selectNodeIds.split(","));
-                    //先将同一分组的节点删除配置，。
+                    //先将同一分组的节点删除配置
                     baseMapper.removeNodeForArchiveAutoRule_Group(groupId);
                     //然后再按照选择节点保存新的设置
                     for(String nodeId:selectNodeIdlist){
@@ -962,7 +973,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
         modifyBySrcTree(srcTree,dstTree);
 
         //刷新treeCode
-        InitAncestors(dstTree,saveList,upList);
+        InitAncestors(dstTree,saveList,upList,srcTrees);
 
         //相同的属性刷新？
         //updateDstArchiveTrees(srcTree,dstTree);
@@ -973,7 +984,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
     }
 
 
-    public void InitAncestors(ArchiveTreeVO2  dstTree,List<ArchiveTree> addList,List<ArchiveTree> upList)
+    public void InitAncestors(ArchiveTreeVO2  dstTree,List<ArchiveTree> addList,List<ArchiveTree> upList,List<ArchiveTreeVO2> sysTrees)
     {
         Map<Long,ArchiveTreeVO2> vo2Map = new LinkedHashMap<>();
 
@@ -984,13 +995,13 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
         ForestNodeMergerEx.InitAncestors(tree,"0");
 
         //更新自动组卷节点
-        archiveAutoRuleSync.syncArchiveTreeList(vo2Map);
+        archiveAutoRuleSync.syncArchiveTreeList(vo2Map,sysTrees);
 
         //根据vo的排序和自动组卷信息，刷新新增节点，根据修改标识生成更新节点
         this.handleAddAndUpList(vo2Map,addList,upList);
     }
 
-    public void InitAncestors(List<ArchiveTree> archiveTrees) {
+    public void InitAncestors(List<ArchiveTree> archiveTrees,List<ArchiveTreeVO2> sysVo2Trees) {
         List<ArchiveTreeVO2> archiveTreeVO2List = new ArrayList<>();
 
         Map<Long,ArchiveTreeVO2> vo2Map = new LinkedHashMap<>();
@@ -1001,7 +1012,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
         //重复
         //ForestNodeMergerEx.InitAncestors(trees.get(0),"0");
 
-        archiveAutoRuleSync.syncArchiveTreeList(vo2Map);
+        archiveAutoRuleSync.syncArchiveTreeList(vo2Map,sysVo2Trees);
 
         List<ArchiveTree> upList = new ArrayList<>();
 
@@ -1130,6 +1141,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
             treeContractVO2.setArchiveAutoType(archiveTree.getArchiveAutoType());
             treeContractVO2.setArchiveAutoGroupId(archiveTree.getArchiveAutoGroupId());
             treeContractVO2.setArchiveAutoGroupSelect(archiveTree.getArchiveAutoGroupSelect());
+            treeContractVO2.setAncestors(archiveTree.getAncestors());
             vos.add(treeContractVO2);
             vo2Map.put(treeContractVO2.getId(),treeContractVO2);
         }