Merge branch 'master' of http://47.110.251.215:3000/java_org/bladex

blade-service-api/blade-manager-api/src/main/java/org/springblade/manager/vo/ArchiveTreeContractAutoRuleVO.java → blade-service-api/blade-manager-api/src/main/java/org/springblade/manager/vo/ArchiveTreeAutoRuleVO.java

@@ -7,7 +7,8 @@ import java.util.ArrayList;
 import java.util.List;
 
 @Data
-public class ArchiveTreeContractAutoRuleVO implements INode<ArchiveTreeContractAutoRuleVO> {
+public class ArchiveTreeAutoRuleVO implements INode<ArchiveTreeAutoRuleVO> {
+
 
     private Long nodeId;//节点id
 
@@ -24,7 +25,7 @@ public class ArchiveTreeContractAutoRuleVO implements INode<ArchiveTreeContractA
 
     private Integer archiveAutoGroupSelect;
 
-    private List<ArchiveTreeContractAutoRuleVO> children=new ArrayList<>();
+    private List<ArchiveTreeAutoRuleVO> children=new ArrayList<>();
 
     @Override
     public Long getId() {
@@ -37,7 +38,7 @@ public class ArchiveTreeContractAutoRuleVO implements INode<ArchiveTreeContractA
     }
 
     @Override
-    public List<ArchiveTreeContractAutoRuleVO> getChildren() {
+    public List<ArchiveTreeAutoRuleVO> getChildren() {
         return children;
     }
 }

blade-service/blade-business/src/main/java/org/springblade/business/controller/InformationWriteQueryController.java

@@ -38,6 +38,7 @@ import org.springblade.core.tool.api.R;
 import org.springblade.core.tool.node.ForestNodeMerger;
 import org.springblade.core.tool.utils.Func;
 import org.springblade.core.tool.utils.ObjectUtil;
+import org.springblade.core.tool.utils.StringUtil;
 import org.springblade.evisa.feign.EVisaClient;
 import org.springblade.evisa.vo.CertBeanVO;
 import org.springblade.manager.entity.*;
@@ -356,6 +357,15 @@ public class InformationWriteQueryController extends BladeController {
         if (StringUtils.isNotEmpty(copyVO.getNeedCopyPrimaryKeyId()) && copyVO.getCopyBatchToPaths().size() > 0) {
             //查询被复制节点
             WbsTreeContract wbsTreeContract = this.wbsTreeContractClient.getContractNodeByPrimaryKeyId(copyVO.getNeedCopyPrimaryKeyId());
+
+            //获取数据写入的节点信息
+            List<CopyContractTreeNodeVO.CopyBatch> batchPathList = copyVO.getCopyBatchToPaths();
+            //获取数据源节点
+            CopyContractTreeNodeVO.CopyBatch copyBatchResource = batchPathList.stream().filter(f -> f.getPrimaryKeyId().equals(wbsTreeContract.getPKeyId().toString())).findAny().orElse(null);
+            if (copyBatchResource != null) {
+                throw new ServiceException("请选择除【" + wbsTreeContract.getNodeName() + "】源节点之外的节点进行复制");
+            }
+
             String tabOwner;
             if (("1,2").equals(copyVO.getClassify()) || ("2,1").equals(copyVO.getClassify())) {
                 tabOwner = "1,2,3,4,5,6";
@@ -392,17 +402,27 @@ public class InformationWriteQueryController extends BladeController {
                     }
                 }
 
-                //获取数据写入的节点信息
-                List<CopyContractTreeNodeVO.CopyBatch> batchPathList = copyVO.getCopyBatchToPaths();
                 //删除数据SQL
                 List<String> removeSqlList = new ArrayList<>();
                 //新增数据SQL
                 List<String> saveSqlList = new ArrayList<>();
+                //已上报状态的节点名称
+                Map<String, String> taskStatusMap = new HashMap<>();
 
                 for (CopyContractTreeNodeVO.CopyBatch copyBatch : batchPathList) {
                     //获取选择的节点信息
                     WbsTreeContract selectNode = this.wbsTreeContractClient.getContractNodeByPrimaryKeyId(copyBatch.getPrimaryKeyId());
 
+                    //判断该节点是否已上报，1=待审批，2=已审批均属于已上报
+                    String sqlSb = "select classify from u_information_query where type = 1 and status in (1,2) and wbs_id = " + selectNode.getPKeyId() + " and classify in (" + copyVO.getClassify() + ")";
+                    List<InformationQuery> query = jdbcTemplate.query(sqlSb, new BeanPropertyRowMapper<>(InformationQuery.class));
+                    if (query.size() > 0) {
+                        for (InformationQuery informationQuery : query) {
+                            taskStatusMap.put((new Integer(1)).equals(informationQuery.getClassify()) ? "施工" : "监理", selectNode.getNodeName());
+                        }
+                        continue;
+                    }
+
                     //实际获取的数据
                     Map<String, List<List<Map<String, Object>>>> currentDataMap = new HashMap<>();
 
@@ -468,6 +488,16 @@ public class InformationWriteQueryController extends BladeController {
                         }
                     }
                 }
+
+                if (taskStatusMap.size() > 0) {
+                    List<String> str = new ArrayList<>();
+                    for (Map.Entry<String, String> map : taskStatusMap.entrySet()) {
+                        str.add("【" + map.getValue() + "-" + map.getKey() + "】");
+                    }
+                    String join = StringUtils.join(str, "、");
+                    throw new ServiceException(StringUtil.format("节点{}已上报，无法复制数据，请重新选择", join));
+                }
+
                 //删除原本填写的数据，覆盖
                 if (removeSqlList.size() > 0) {
                     for (String sql : removeSqlList) {
@@ -486,7 +516,7 @@ public class InformationWriteQueryController extends BladeController {
 
             //复制附件信息
             for (WbsTreeContract sourceDataObj : tableList) {
-                if (sourceDataObj.getTabFileType() == 2) {
+                if (ObjectUtils.isNotEmpty(sourceDataObj.getTabFileType()) && sourceDataObj.getTabFileType() == 2) {
                     //获取源表中的附件信息
                     String sql = "select * from m_table_file where is_deleted = 0 and type = 2 and tab_id =" + sourceDataObj.getPKeyId();
                     List<TableFile> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(TableFile.class));
@@ -1310,7 +1340,7 @@ public class InformationWriteQueryController extends BladeController {
                     String sql = "select sort from m_wbs_tree_contract where contract_id = '" + node.getContractId() + "' and (id = '" + node.getId() + "' or old_id = '" + node.getId() + "')";
                     List<WbsTreeContract> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(WbsTreeContract.class));
                     List<Integer> collect = query.stream().filter(f -> ObjectUtils.isNotEmpty(f.getSort())).collect(Collectors.toList()).stream().map(WbsTreeContract::getSort).collect(Collectors.toList());
-                    Integer max=1;
+                    Integer max = 1;
                     if (collect.size() > 0) {
                         max = collect.stream().reduce(collect.get(0), Integer::max);
                     } else {
@@ -1391,7 +1421,7 @@ public class InformationWriteQueryController extends BladeController {
                         String sql = "select sort from m_wbs_tree_contract where contract_id = '" + node.getContractId() + "' and (id = '" + node.getId() + "' or old_id = '" + node.getId() + "')";
                         List<WbsTreeContract> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(WbsTreeContract.class));
                         List<Integer> collect = query.stream().filter(f -> ObjectUtils.isNotEmpty(f.getSort())).collect(Collectors.toList()).stream().map(WbsTreeContract::getSort).collect(Collectors.toList());
-                        Integer max=1;
+                        Integer max = 1;
                         if (collect.size() > 0) {
                             max = collect.stream().reduce(collect.get(0), Integer::max);
                         } else {
@@ -1833,7 +1863,7 @@ public class InformationWriteQueryController extends BladeController {
                 String sql = "select sort from m_wbs_tree_contract where contract_id = '" + treeContract.getContractId() + "' and (id = '" + half.getId() + "' or old_id = '" + half.getId() + "')";
                 List<WbsTreeContract> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(WbsTreeContract.class));
                 List<Integer> collect = query.stream().filter(f -> ObjectUtils.isNotEmpty(f.getSort())).collect(Collectors.toList()).stream().map(WbsTreeContract::getSort).collect(Collectors.toList());
-                Integer max =1 ;
+                Integer max = 1;
                 if (collect.size() > 0) {
                     max = collect.stream().reduce(collect.get(0), Integer::max);
                 } else {
@@ -1912,7 +1942,7 @@ public class InformationWriteQueryController extends BladeController {
         if (saveList.size() > 0) {
             //保存施工日志
             if (saveLedger.size() > 0) {
-                this.constructionLedgerService.saveBatch(saveLedger,1000);
+                this.constructionLedgerService.saveBatch(saveLedger, 1000);
             }
 
             try {
@@ -2287,7 +2317,6 @@ public class InformationWriteQueryController extends BladeController {
                 contractIds.add(contractIdRelation);
             }
             if (contractIds.size() > 0) {
-                //原始classify=2时查不出数量统计，所以改成传1
                 if (StringUtils.isNotEmpty(parentId)) {
                     //子节点
                     rootTreeNode = this.informationQueryService.queryContractTreeSupervision(contractIds, parentId, Integer.parseInt(classifyType));

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

@@ -37,9 +37,8 @@ import org.springblade.manager.dto.ArchiveTreeDTO;
 import org.springblade.manager.dto.ArchiveTreeSortDTO;
 import org.springblade.manager.entity.ArchiveTree;
 import org.springblade.manager.service.IArchiveTreeService;
-import org.springblade.manager.vo.ArchiveTreeContractAutoRuleVO;
 import org.springblade.manager.vo.ArchiveTreeContractVO2;
-import org.springblade.manager.vo.ArchiveTreeVO;
+
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.bind.annotation.RequestParam;
 import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -230,36 +229,7 @@ public class ArchiveTreeContractController extends BladeController {
 	}
 
 
-	/**
-	 * 保存立卷规则设置
-	 */
-	@PostMapping("/saveArchiveAutoRule")
-	@ApiOperationSupport(order = 8)
-	@ApiOperation(value = "保存立卷规则设置", notes = "传入archiveAutoType规则类型,nodeIds逗号拼接选择节点id")
-	public R saveArchiveAutoRule(@ApiParam(value = "立卷规则", required = true) @RequestParam Integer archiveAutoType,
-					@ApiParam(value = "主键集合", required = true) @RequestParam String nodeIds) {
-		return R.status(archiveTreeContractService.saveArchiveAutoRule(archiveAutoType,nodeIds));
-	}
-
-
-	/**
-	 * 查看立卷规则设置
-	 */
-	@PostMapping("/getArchiveAutoRule")
-	@ApiOperationSupport(order = 9)
-	@ApiOperation(value = "查看立卷规则设置", notes = "传入节点id")
-	public R getArchiveAutoRule(@ApiParam(value = "主键", required = true) @RequestParam Long id) {
-		Map<String, Object> ruleMap=archiveTreeContractService.getArchiveAutoRule(id);
-		return R.data(ruleMap);
-	}
 
-	/**
-	 * 修改立卷规则设置
-	 */
-	@PostMapping("/updateArchiveAutoRule")
-	public R updateArchiveAutoRule(ArchiveTreeContractAutoRuleMapDTO dto) {
-		return R.status(archiveTreeContractService.updateArchiveAutoRule(dto));
-	}
 
 
 	/**

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

@@ -13,6 +13,7 @@ import org.springblade.core.secure.BladeUser;
 import org.springblade.core.secure.utils.AuthUtil;
 import org.springblade.core.tool.api.R;
 import org.springblade.core.tool.utils.Func;
+import org.springblade.manager.dto.ArchiveTreeContractAutoRuleMapDTO;
 import org.springblade.manager.dto.ArchiveTreeDTO;
 import org.springblade.manager.dto.ArchiveTreeSortDTO;
 import org.springblade.manager.vo.ArchiveTreeVO2;
@@ -24,6 +25,7 @@ import org.springblade.manager.service.IArchiveTreeService;
 import org.springblade.core.boot.ctrl.BladeController;
 
 import java.util.List;
+import java.util.Map;
 
 import static org.springblade.core.cache.constant.CacheConstant.SYS_CACHE;
 
@@ -195,4 +197,36 @@ public class ArchiveTreeController extends BladeController {
         return R.fail(200, "初始化创建失败");
     }
 
+
+    /**
+     * 保存立卷规则设置
+     */
+    @PostMapping("/saveArchiveAutoRule")
+    @ApiOperationSupport(order = 8)
+    @ApiOperation(value = "保存立卷规则设置", notes = "传入archiveAutoType规则类型,nodeIds逗号拼接选择节点id")
+    public R saveArchiveAutoRule(@ApiParam(value = "立卷规则", required = true) @RequestParam Integer archiveAutoType,
+                                 @ApiParam(value = "主键集合", required = true) @RequestParam String nodeIds) {
+        return R.status(archiveTreeService.saveArchiveAutoRule(archiveAutoType,nodeIds));
+    }
+
+
+    /**
+     * 查看立卷规则设置
+     */
+    @PostMapping("/getArchiveAutoRule")
+    @ApiOperationSupport(order = 9)
+    @ApiOperation(value = "查看立卷规则设置", notes = "传入节点id")
+    public R getArchiveAutoRule(@ApiParam(value = "主键", required = true) @RequestParam Long id) {
+        Map<String, Object> ruleMap=archiveTreeService.getArchiveAutoRule(id);
+        return R.data(ruleMap);
+    }
+
+    /**
+     * 修改立卷规则设置
+     */
+    @PostMapping("/updateArchiveAutoRule")
+    public R updateArchiveAutoRule(ArchiveTreeContractAutoRuleMapDTO dto) {
+        return R.status(archiveTreeService.updateArchiveAutoRule(dto));
+    }
+
 }

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

@@ -19,7 +19,6 @@ package org.springblade.manager.mapper;
 
 import org.apache.ibatis.annotations.Param;
 import org.springblade.manager.entity.ArchiveTreeContract;
-import org.springblade.manager.vo.ArchiveTreeContractAutoRuleVO;
 import org.springblade.manager.vo.ArchiveTreeContractVO;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -59,29 +58,7 @@ public interface ArchiveTreeContractMapper extends BaseMapper<ArchiveTreeContrac
 	List<ArchiveTreeContractVO2> lazyTree3(@Param("tenantId") String tenantId, @Param("parentId") Long parentId, @Param("projectId") Long projectId, @Param("treeCode") Long treeCode);
 
 	List<ArchiveTreeContractVO2> tree3(@Param("tenantId") String tenantId, @Param("disPlayTree") Integer disPlayTree, @Param("nodeType") Integer nodeType, @Param("projectId") Long projectId, @Param("treeCode") Long treeCode);
-	/**
-	 * 自动组卷规则设置节点下所有子节点
-	 * @param treeContract
-	 * @return
-	 */
-	int updateAllSonNodeIdsForArchiveAutoRule(@Param("treeContract") ArchiveTreeContract treeContract);
 
-	/**
-	 * 删除立卷规则设置
-	 * @param treeContract
-	 * @return
-	 */
-	int removeAllSonNodeIdsForArchiveAutoRule_1(@Param("treeContract") ArchiveTreeContract treeContract);
-	int removeAllSonNodeIdsForArchiveAutoRule_2(@Param("treeContract") ArchiveTreeContract treeContract);
-	int removeAllSonNodeIdsForArchiveAutoRule_3(@Param("treeContract") ArchiveTreeContract treeContract);
-	int removeNodeForArchiveAutoRule_Group(@Param("archiveAutoGroupId") Long archiveAutoGroupId);
-	/**
-	 * 查看分类并卷规则-获取大类所有节点
-	 * @param ancestors
-	 * @param groupId
-	 * @return
-	 */
-	List<ArchiveTreeContractAutoRuleVO> getAllSonNodeforGroupView(@Param("ancestors")String ancestors, @Param("groupId")Long groupId);
 
 	int updateBatch(@Param("diffRent") List<String> diffRent);
 

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

@@ -97,15 +97,7 @@
         <result column="archive_auto_group_id" property="archiveAutoGroupId"/>
     </resultMap>
 
-    <resultMap id="getAllSonNodeforGroupViewResultMap" type="org.springblade.manager.vo.ArchiveTreeContractAutoRuleVO">
-        <id column="id" property="nodeId"/>
-        <result column="parent_id" property="parentId"/>
-        <result column="node_name" property="nodeName"/>
-        <result column="archive_auto_type" property="archiveAutoType"/>
-        <result column="archive_auto_node_id" property="archiveAutoNodeId"/>
-        <result column="archive_auto_group_id" property="archiveAutoGroupId"/>
-        <result column="archive_auto_group_select" property="archiveAutoGroupSelect"/>
-    </resultMap>
+
 
     <select id="lazyTree" resultMap="treeNodeResultMap">
         SELECT
@@ -249,110 +241,7 @@
         ORDER BY sort
     </select>
 
-    <update id="updateAllSonNodeIdsForArchiveAutoRule">
-
-        <if test="treeContract.archiveAutoType ==1 ">
-            update m_archive_tree_contract
-            set
-            archive_auto_node_id = #{treeContract.archiveAutoNodeId}
-            where
-            is_deleted = 0 and ancestors like concat('', #{treeContract.ancestors}, '%');
-        </if>
-
-        update m_archive_tree_contract
-        set
-            archive_auto_type= #{treeContract.archiveAutoType},
-            <if test="treeContract.archiveAutoType ==2 ">
-                archive_auto_group_id=#{treeContract.archiveAutoGroupId},
-                archive_auto_group_select=0
-            </if>
-        where
-            is_deleted = 0 and ancestors like concat('', #{treeContract.ancestors}, '%')
-            /*最高并卷规则不能覆盖 分类并卷规则，单独组卷规则*/
-            <if test="treeContract.archiveAutoType ==1 ">
-                and archive_auto_type != 2 and archive_auto_type != 3
-            </if>
-            /*分类并卷规则不能覆盖单独组卷规则*/
-            <if test="treeContract.archiveAutoType ==2 ">
-                and archive_auto_type != 3
-            </if>
-    </update>
-
-    <update id="removeAllSonNodeIdsForArchiveAutoRule_1">
-        update m_archive_tree_contract
-        set
-        archive_auto_node_id = NULL
-        where
-        is_deleted = 0
-        and ancestors like concat('', #{treeContract.ancestors}, '%');
-
-
-        update m_archive_tree_contract
-        set
-            archive_auto_type = NULL
-        where
-        is_deleted = 0
-        and ancestors like concat('', #{treeContract.ancestors}, '%')
-        /*取消规则 只取消规则与自己一致的*/
-        and archive_auto_type = #{treeContract.archiveAutoType} ;
-    </update>
-
-    <update id="removeAllSonNodeIdsForArchiveAutoRule_3">
-        update m_archive_tree_contract
-        set
-            /*取消规则 恢复默认规则 不需要设置为null，如果最高并卷节点取消规则，archive_auto_node_id会为空，相当于无规则不会进到自动组卷流程*/
-            archive_auto_type = 1
-        where
-        is_deleted = 0
-        and ancestors like concat('', #{treeContract.ancestors}, '%')
-        /*取消规则 只取消规则与自己一致的*/
-        and archive_auto_type = #{treeContract.archiveAutoType}
-    </update>
-    <update id="removeAllSonNodeIdsForArchiveAutoRule_2">
-        /*取消单个节点的分类并卷规则*/
-        update m_archive_tree_contract
-        set
-            /*取消规则 恢复默认规则 不需要设置为null，如果最高并卷节点取消规则，archive_auto_node_id会为空，相当于无规则不会进到自动组卷流程*/
-            archive_auto_type = 1 ,
-            archive_auto_group_id = NULL,
-            archive_auto_group_select =NULL
-        where
-          is_deleted = 0
-          and ancestors like concat('', #{treeContract.ancestors}, '%')
-            /*取消规则 只取消规则与自己一致的*/
-          and archive_auto_type = #{treeContract.archiveAutoType}
-    </update>
-
-    <update id="removeNodeForArchiveAutoRule_Group">
-        /**取消同一组的分类并卷规则*/
-        update m_archive_tree_contract
-        set
-            archive_auto_type = 1 ,
-            archive_auto_group_id = NULL,
-            archive_auto_group_select =NULL
-        where
-            is_deleted = 0
-            and archive_auto_group_id = #{archiveAutoGroupId}
-    </update>
 
-    <select id="getAllSonNodeforGroupView" resultMap="getAllSonNodeforGroupViewResultMap">
-        SELECT
-            id,
-            parent_id,
-            node_name,
-            archive_auto_type,
-            archive_auto_node_id,
-            archive_auto_group_id,
-            archive_auto_group_select
-        FROM m_archive_tree_contract
-        where is_deleted = 0
-          and ancestors like concat('', #{ancestors}, '%')
-          and archive_auto_type !=3
-          and id not in (
-                select id from m_archive_tree_contract where archive_auto_type=2 and archive_auto_group_id != #{groupId}
-          )
-        order by ancestors asc,sort asc
-    </select>
 
     <update id="updateBatch">
         UPDATE m_archive_tree_contract

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

@@ -2,9 +2,9 @@ package org.springblade.manager.mapper;
 
 import feign.Param;
 import org.springblade.manager.entity.ArchiveTree;
+import org.springblade.manager.vo.ArchiveTreeAutoRuleVO;
 import org.springblade.manager.vo.ArchiveTreeVO;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
 import org.springblade.manager.vo.ArchiveTreeVO2;
 
 import java.util.List;
@@ -23,4 +23,28 @@ public interface ArchiveTreeMapper extends BaseMapper<ArchiveTree> {
 
     int updateBatch3();
 
+    /**
+     * 自动组卷规则设置节点下所有子节点
+     * @param tree
+     * @return
+     */
+    int updateAllSonNodeIdsForArchiveAutoRule(@Param("treeContract") ArchiveTree tree);
+
+    /**
+     * 删除立卷规则设置
+     * @param tree
+     * @return
+     */
+    int removeAllSonNodeIdsForArchiveAutoRule_1(@Param("tree") ArchiveTree tree);
+    int removeAllSonNodeIdsForArchiveAutoRule_2(@Param("tree") ArchiveTree tree);
+    int removeAllSonNodeIdsForArchiveAutoRule_3(@Param("tree") ArchiveTree tree);
+    int removeNodeForArchiveAutoRule_Group(@Param("archiveAutoGroupId") Long archiveAutoGroupId);
+    /**
+     * 查看分类并卷规则-获取大类所有节点
+     * @param ancestors
+     * @param groupId
+     * @return
+     */
+    List<ArchiveTreeAutoRuleVO> getAllSonNodeforGroupView(@Param("ancestors")String ancestors, @Param("groupId")Long groupId);
+
 }

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

@@ -94,6 +94,16 @@
         <result column="postType" property="postType"/>
     </resultMap>
 
+    <resultMap id="getAllSonNodeforGroupViewResultMap" type="org.springblade.manager.vo.ArchiveTreeAutoRuleVO">
+        <id column="id" property="nodeId"/>
+        <result column="parent_id" property="parentId"/>
+        <result column="node_name" property="nodeName"/>
+        <result column="archive_auto_type" property="archiveAutoType"/>
+        <result column="archive_auto_node_id" property="archiveAutoNodeId"/>
+        <result column="archive_auto_group_id" property="archiveAutoGroupId"/>
+        <result column="archive_auto_group_select" property="archiveAutoGroupSelect"/>
+    </resultMap>
+
     <update id="updateBatch">
         UPDATE m_archive_tree
         SET is_upload_file_display_configuration_tree = 1
@@ -271,4 +281,109 @@
         ORDER BY sort
     </select>
 
+    <update id="updateAllSonNodeIdsForArchiveAutoRule">
+
+        <if test="tree.archiveAutoType ==1 ">
+            update m_archive_tree
+            set
+            archive_auto_node_id = #{tree.archiveAutoNodeId}
+            where
+            is_deleted = 0 and ancestors like concat('', #{tree.ancestors}, '%');
+        </if>
+
+        update m_archive_tree
+        set
+        archive_auto_type= #{tree.archiveAutoType},
+        <if test="tree.archiveAutoType ==2 ">
+            archive_auto_group_id=#{tree.archiveAutoGroupId},
+            archive_auto_group_select=0
+        </if>
+        where
+        is_deleted = 0 and ancestors like concat('', #{tree.ancestors}, '%')
+        /*最高并卷规则不能覆盖 分类并卷规则，单独组卷规则*/
+        <if test="tree.archiveAutoType ==1 ">
+            and archive_auto_type != 2 and archive_auto_type != 3
+        </if>
+        /*分类并卷规则不能覆盖单独组卷规则*/
+        <if test="tree.archiveAutoType ==2 ">
+            and archive_auto_type != 3
+        </if>
+    </update>
+
+    <update id="removeAllSonNodeIdsForArchiveAutoRule_1">
+        update m_archive_tree
+        set
+            archive_auto_node_id = NULL
+        where
+            is_deleted = 0
+          and ancestors like concat('', #{tree.ancestors}, '%');
+
+
+        update m_archive_tree
+        set
+            archive_auto_type = NULL
+        where
+            is_deleted = 0
+          and ancestors like concat('', #{tree.ancestors}, '%')
+            /*取消规则 只取消规则与自己一致的*/
+          and archive_auto_type = #{tree.archiveAutoType} ;
+    </update>
+
+    <update id="removeAllSonNodeIdsForArchiveAutoRule_3">
+        update m_archive_tree
+        set
+            /*取消规则 恢复默认规则 不需要设置为null，如果最高并卷节点取消规则，archive_auto_node_id会为空，相当于无规则不会进到自动组卷流程*/
+            archive_auto_type = 1
+        where
+            is_deleted = 0
+          and ancestors like concat('', #{tree.ancestors}, '%')
+            /*取消规则 只取消规则与自己一致的*/
+          and archive_auto_type = #{tree.archiveAutoType}
+    </update>
+    <update id="removeAllSonNodeIdsForArchiveAutoRule_2">
+        /*取消单个节点的分类并卷规则*/
+        update m_archive_tree
+        set
+            /*取消规则 恢复默认规则 不需要设置为null，如果最高并卷节点取消规则，archive_auto_node_id会为空，相当于无规则不会进到自动组卷流程*/
+            archive_auto_type = 1 ,
+            archive_auto_group_id = NULL,
+            archive_auto_group_select =NULL
+        where
+            is_deleted = 0
+          and ancestors like concat('', #{tree.ancestors}, '%')
+            /*取消规则 只取消规则与自己一致的*/
+          and archive_auto_type = #{tree.archiveAutoType}
+    </update>
+
+    <update id="removeNodeForArchiveAutoRule_Group">
+        /**取消同一组的分类并卷规则*/
+        update m_archive_tree
+        set
+            archive_auto_type = 1 ,
+            archive_auto_group_id = NULL,
+            archive_auto_group_select =NULL
+        where
+            is_deleted = 0
+          and archive_auto_group_id = #{archiveAutoGroupId}
+    </update>
+
+    <select id="getAllSonNodeforGroupView" resultMap="getAllSonNodeforGroupViewResultMap">
+        SELECT
+            id,
+            parent_id,
+            node_name,
+            archive_auto_type,
+            archive_auto_node_id,
+            archive_auto_group_id,
+            archive_auto_group_select
+        FROM m_archive_tree
+        where is_deleted = 0
+          and ancestors like concat('', #{ancestors}, '%')
+          and archive_auto_type !=3
+          and id not in (
+                select id from m_archive_tree where archive_auto_type=2 and archive_auto_group_id != #{groupId}
+            )
+        order by ancestors asc,sort asc
+    </select>
+
 </mapper>

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

@@ -22,7 +22,6 @@ import org.springblade.manager.dto.ArchiveTreeContractDTO;
 import org.springblade.manager.dto.ArchiveTreeDTO;
 import org.springblade.manager.entity.ArchiveTree;
 import org.springblade.manager.entity.ArchiveTreeContract;
-import org.springblade.manager.vo.ArchiveTreeContractAutoRuleVO;
 import org.springblade.manager.vo.ArchiveTreeContractVO;
 import org.springblade.core.mp.base.BaseService;
 import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -68,21 +67,7 @@ public interface IArchiveTreeContractService extends BaseService<ArchiveTreeCont
 
 	List<ArchiveTreeContractVO2> tree2(String tenantI,Integer disPlayTree,Integer nodeType,Long projectId);
 
-	/**
-	 *项目级立卷规则新增
-	 * @return
-	 */
-	boolean saveArchiveAutoRule(Integer archiveAutoType,String nodeIds);
-
-
 
-	Map<String,Object> getArchiveAutoRule(Long id);
-
-	/**
-	 *项目级立卷规则更新
-	 * @return
-	 */
-	boolean updateArchiveAutoRule(ArchiveTreeContractAutoRuleMapDTO dto);
 
 	List<ArchiveTreeContract> selectByParentIdOrId(String id);
 

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

@@ -1,5 +1,6 @@
 package org.springblade.manager.service;
 
+import org.springblade.manager.dto.ArchiveTreeContractAutoRuleMapDTO;
 import org.springblade.manager.dto.ArchiveTreeDTO;
 import org.springblade.manager.dto.ArchiveTreeSortDTO;
 import org.springblade.manager.entity.ArchiveTree;
@@ -9,6 +10,7 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
 import org.springblade.manager.vo.ArchiveTreeVO2;
 
 import java.util.List;
+import java.util.Map;
 
 public interface IArchiveTreeService extends BaseService<ArchiveTree> {
 
@@ -31,10 +33,24 @@ public interface IArchiveTreeService extends BaseService<ArchiveTree> {
 	boolean submitArchiveTreeSort(List<ArchiveTreeSortDTO> listSort);
 
 	List<ArchiveTree> treeList(String tenantId,Long projectId, Integer disPlayTree,Integer nodeType);
-	
 
 
-	boolean saveAechiveAutoRule(Integer archiveAutoType,String nodeIds);
-
 	boolean initArchiveProjectTree(Long projectId);
+
+
+	/**
+	 *项目级立卷规则新增
+	 * @return
+	 */
+	boolean saveArchiveAutoRule(Integer archiveAutoType,String nodeIds);
+
+
+
+	Map<String,Object> getArchiveAutoRule(Long id);
+
+	/**
+	 *项目级立卷规则更新
+	 * @return
+	 */
+	boolean updateArchiveAutoRule(ArchiveTreeContractAutoRuleMapDTO dto);
 }

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

@@ -133,193 +133,7 @@ public class ArchiveTreeContractServiceImpl extends BaseServiceImpl<ArchiveTreeC
 		return ForestNodeMerger.merge(baseMapper.tree2(tenantId, disPlayTree, nodeType,projectId,getAuthCode(),getAuthContractId()));
 	}
 
-	/**
-	 * 保存组卷规则设置
-	 * @param archiveAutoType
-	 * @param nodeIds
-	 * @return
-	 */
-	@Override
-	public boolean saveArchiveAutoRule(Integer archiveAutoType, String nodeIds) {
-		//项目级不需要考虑是否为wbs节点，已经同步出来了都属于归档树节点，直接按归档树节点处理
-		try{
-			//步骤1保存选择节点的立卷规则。
-			String[] ids = nodeIds.split(",");
-
-			Long archiveAutoGroupId=null;
-
-			//分类并卷规则的需要生成个随机数，作为同一个分类赋值archiveAutoNodeId
-			if(archiveAutoType==2){
-				double ran=(Math.random()*100000000) + 1;
-				archiveAutoGroupId=Long.parseLong(System.currentTimeMillis()+""+ran);
-			}
-			for(String nodeId:ids){
-				long nodeIdLong = Long.parseLong(nodeId);
-				ArchiveTreeContract archiveTreeContract = baseMapper.selectById(nodeIdLong);
-				archiveTreeContract.setArchiveAutoType(archiveAutoType);
-				if(archiveAutoType==1){
-					//最高并卷规则 选择节点的ID
-					archiveTreeContract.setArchiveAutoNodeId(nodeIdLong);
-				}
-				if(archiveAutoType==2){
-					//分类并卷规则 提交都是一个分类类型
-					archiveTreeContract.setArchiveAutoGroupId(archiveAutoGroupId);
-					archiveTreeContract.setArchiveAutoGroupSelect(1);
-				}
-				baseMapper.updateById(archiveTreeContract);
 
-				//步骤2保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
-				baseMapper.updateAllSonNodeIdsForArchiveAutoRule(archiveTreeContract);
-			}
-
-			return true;
-
-		}catch (Exception e){
-			e.printStackTrace();
-			return false;
-		}
-	}
-
-
-	/**
-	 * 获取节点规则查看
-	 * @param id
-	 * @return
-	 */
-	@Override
-	public Map<String,Object> getArchiveAutoRule(Long id) {
-
-		Map<String,Object> map= new HashMap<>();
-
-		ArchiveTreeContract archiveTreeContract = baseMapper.selectById(id);
-		Integer archiveAutoType = archiveTreeContract.getArchiveAutoType();
-		if(archiveAutoType!=null){
-			if(archiveAutoType==1){
-				//最高并卷层级 默认规则的节点 显示最高并卷层级节点
-				Long archiveAutoNodeId = archiveTreeContract.getArchiveAutoNodeId();
-				ArchiveTreeContract archiveAutoNode = baseMapper.selectById(archiveAutoNodeId);
-				StringBuffer allName= new StringBuffer();
-				String ancestors = archiveAutoNode.getAncestors();
-				String[] ancestorssplit = ancestors.split(",");//全路径ID
-				for(String pId:ancestorssplit){
-					long pIdLong = Long.parseLong(pId);
-					ArchiveTreeContract pIdNode = baseMapper.selectById(pIdLong);
-					allName.append(pIdNode.getNodeName()+"/");
-				}
-				allName.append(archiveAutoNode.getNodeName());
-				ArchiveTreeContractAutoRuleVO vo= new ArchiveTreeContractAutoRuleVO();
-				vo.setAllName(allName.toString());
-				vo.setNodeId(archiveAutoNode.getId());
-				vo.setArchiveAutoType(archiveAutoType);
-				map.put("type",archiveAutoType);
-				map.put("data",vo);
-				return map;
-			}
-			if(archiveAutoType==2){
-				//分类并卷显示所在大类下树结构，过滤单独规则，其他分类并卷规则组节点 本节点分类组显示打钩
-				//找出当前节点大类
-				String ancestors = archiveTreeContract.getAncestors();
-				String[] ancestorssplit = ancestors.split(",");//全路径ID
-				String nodeAncestors = ancestorssplit[0]+","+ancestorssplit[1]; //大类的ancestors
-				//获取大类下所有节点,过滤单独规则，其他分类并卷规则组节点
-				List<ArchiveTreeContractAutoRuleVO> nodetree = ForestNodeMerger.merge(baseMapper.getAllSonNodeforGroupView(nodeAncestors, archiveTreeContract.getArchiveAutoNodeId()));
-				//获取与当前节点同一分类的节点
-				List<ArchiveTreeContract> listGroup= baseMapper.selectList(Wrappers.<ArchiveTreeContract>lambdaQuery()
-						.eq(ArchiveTreeContract::getArchiveAutoGroupId, archiveTreeContract.getArchiveAutoGroupId())
-						.orderByAsc(ArchiveTreeContract::getSort));
-				StringBuffer nodeSelect = new StringBuffer();
-
-				for(ArchiveTreeContract node:listGroup){
-					nodeSelect.append(node.getId()+",");
-				}
-				map.put("type",archiveAutoType);
-				map.put("tree",nodetree);
-				map.put("data",nodeSelect.toString());
-				return map;
-			}
-			if(archiveAutoType==3){
-				//单独组卷规则 显示当前节点
-				StringBuffer allName= new StringBuffer();
-				String ancestors = archiveTreeContract.getAncestors();
-				String[] ancestorssplit = ancestors.split(",");//全路径ID
-				for(String pId:ancestorssplit){
-					long pIdLong = Long.parseLong(pId);
-					ArchiveTreeContract pIdNode = baseMapper.selectById(pIdLong);
-					allName.append(pIdNode.getNodeName()+"/");
-				}
-				allName.append(archiveTreeContract.getNodeName());
-				ArchiveTreeContractAutoRuleVO vo= new ArchiveTreeContractAutoRuleVO();
-				vo.setAllName(allName.toString());
-				vo.setNodeId(archiveTreeContract.getId());
-				vo.setArchiveAutoType(archiveAutoType);
-				map.put("type",archiveAutoType);
-				map.put("data",vo);
-				return map;
-			}
-		}
-		return map;
-	}
-
-
-	public void removeArchiveAutoRule(Long nodeId){
-		ArchiveTreeContract node = baseMapper.selectById(nodeId);
-		Integer archiveAutoType = node.getArchiveAutoType();
-		if(archiveAutoType!=null){
-			//删除默认规则
-			if(archiveAutoType==1){
-				baseMapper.removeAllSonNodeIdsForArchiveAutoRule_1(node);
-			}
-			//删除节点及所有子节点 分类并卷规则
-			if(archiveAutoType==2){
-				//删除规则
-				baseMapper.removeAllSonNodeIdsForArchiveAutoRule_2(node);
-				//TODO 验证节点的父节点是否为分类并卷规则，如是则取消。若无其他兄弟节点，继续往上验证。
-			}
-			//删除节点及所有子节点 单独并卷规则
-			if(archiveAutoType==3){
-				baseMapper.removeAllSonNodeIdsForArchiveAutoRule_3(node);
-			}
-		}
-
-	}
-
-
-	@Override
-	public boolean updateArchiveAutoRule(ArchiveTreeContractAutoRuleMapDTO dto) {
-		//项目级不需要考虑是否为wbs节点，已经同步出来了都属于归档树节点，直接按归档树节点处理
-
-		Integer archiveAutoType = dto.getArchiveAutoType();
-		if(archiveAutoType!=null){
-			if(archiveAutoType==2){
-				Long groupId = dto.getArchiveAutoGroupId();
-				String selectNodeIds = dto.getSelectNodeIds();
-				List<String> selectNodeIdlist = Arrays.asList(selectNodeIds);
-				//先将同一分类的节点删除配置，。
-				baseMapper.removeNodeForArchiveAutoRule_Group(groupId);
-				//然后再按照选择节点保存新的设置
-				for(String nodeId:selectNodeIdlist){
-					long nodeIdLong = Long.parseLong(nodeId);
-					ArchiveTreeContract archiveTreeContract = baseMapper.selectById(nodeIdLong);
-					archiveTreeContract.setArchiveAutoType(archiveAutoType);
-					//分类并卷规则 提交都是一个分类类型
-					archiveTreeContract.setArchiveAutoGroupId(groupId);
-					archiveTreeContract.setArchiveAutoGroupSelect(1);
-					baseMapper.updateById(archiveTreeContract);
-					//保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
-					baseMapper.updateAllSonNodeIdsForArchiveAutoRule(archiveTreeContract);
-				}
-			}
-			if(archiveAutoType==1){
-
-			}
-			if(archiveAutoType==3){
-
-			}
-
-		}
-
-		return false;
-	}
 
 	@Override
 	public List<ArchiveTreeContract> selectByParentIdOrId(String id) {

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

@@ -11,6 +11,7 @@ import org.springblade.core.secure.utils.AuthUtil;
 import org.springblade.core.tool.constant.BladeConstant;
 
 import org.springblade.core.tool.utils.Func;
+import org.springblade.manager.dto.ArchiveTreeContractAutoRuleMapDTO;
 import org.springblade.manager.dto.ArchiveTreeDTO;
 import org.springblade.manager.dto.ArchiveTreeSortDTO;
 import org.springblade.manager.entity.ArchiveTree;
@@ -21,13 +22,10 @@ import org.springblade.manager.service.IWbsTreePrivateService;
 import org.springblade.manager.service.IWbsTreeService;
 import org.springblade.manager.utils.DiffListUtil;
 import org.springblade.manager.utils.ForestNodeMerger;
-import org.springblade.manager.vo.ArchiveTreeContractVO2;
-import org.springblade.manager.vo.ArchiveTreeVO;
+import org.springblade.manager.vo.*;
 import org.springblade.manager.mapper.ArchiveTreeMapper;
 import org.springblade.manager.service.IArchiveTreeService;
 import org.springblade.core.mp.base.BaseServiceImpl;
-import org.springblade.manager.vo.ArchiveTreeVO2;
-import org.springblade.manager.vo.WbsTreeVO2;
 import org.springframework.stereotype.Service;
 
 import java.util.*;
@@ -428,18 +426,192 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
     }
 
 
+    /**
+     * 保存组卷规则设置
+     * @param archiveAutoType
+     * @param nodeIds
+     * @return
+     */
+    @Override
+    public boolean saveArchiveAutoRule(Integer archiveAutoType, String nodeIds) {
+        //项目级不需要考虑是否为wbs节点，已经同步出来了都属于归档树节点，直接按归档树节点处理
+        try{
+            //步骤1保存选择节点的立卷规则。
+            String[] ids = nodeIds.split(",");
+
+            Long archiveAutoGroupId=null;
+
+            //分类并卷规则的需要生成个随机数，作为同一个分类赋值archiveAutoNodeId
+            if(archiveAutoType==2){
+                double ran=(Math.random()*100000000) + 1;
+                archiveAutoGroupId=Long.parseLong(System.currentTimeMillis()+""+ran);
+            }
+            for(String nodeId:ids){
+                long nodeIdLong = Long.parseLong(nodeId);
+                ArchiveTree archiveTree = baseMapper.selectById(nodeIdLong);
+                archiveTree.setArchiveAutoType(archiveAutoType);
+                if(archiveAutoType==1){
+                    //最高并卷规则 选择节点的ID
+                    archiveTree.setArchiveAutoNodeId(nodeIdLong);
+                }
+                if(archiveAutoType==2){
+                    //分类并卷规则 提交都是一个分类类型
+                    archiveTree.setArchiveAutoGroupId(archiveAutoGroupId);
+                    archiveTree.setArchiveAutoGroupSelect(1);
+                }
+                baseMapper.updateById(archiveTree);
+
+                //步骤2保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
+                baseMapper.updateAllSonNodeIdsForArchiveAutoRule(archiveTree);
+            }
+
+            return true;
+
+        }catch (Exception e){
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+
+    /**
+     * 获取节点规则查看
+     * @param id
+     * @return
+     */
+    @Override
+    public Map<String,Object> getArchiveAutoRule(Long id) {
+
+        Map<String,Object> map= new HashMap<>();
+
+        ArchiveTree archiveTree = baseMapper.selectById(id);
+        Integer archiveAutoType = archiveTree.getArchiveAutoType();
+        if(archiveAutoType!=null){
+            if(archiveAutoType==1){
+                //最高并卷层级 默认规则的节点 显示最高并卷层级节点
+                Long archiveAutoNodeId = archiveTree.getArchiveAutoNodeId();
+                ArchiveTree archiveAutoNode = baseMapper.selectById(archiveAutoNodeId);
+                StringBuffer allName= new StringBuffer();
+                String ancestors = archiveAutoNode.getAncestors();
+                String[] ancestorssplit = ancestors.split(",");//全路径ID
+                for(String pId:ancestorssplit){
+                    long pIdLong = Long.parseLong(pId);
+                    ArchiveTree pIdNode = baseMapper.selectById(pIdLong);
+                    allName.append(pIdNode.getNodeName()+"/");
+                }
+                allName.append(archiveAutoNode.getNodeName());
+                ArchiveTreeAutoRuleVO vo= new ArchiveTreeAutoRuleVO();
+                vo.setAllName(allName.toString());
+                vo.setNodeId(archiveAutoNode.getId());
+                vo.setArchiveAutoType(archiveAutoType);
+                map.put("type",archiveAutoType);
+                map.put("data",vo);
+                return map;
+            }
+            if(archiveAutoType==2){
+                //分类并卷显示所在大类下树结构，过滤单独规则，其他分类并卷规则组节点 本节点分类组显示打钩
+                //找出当前节点大类
+                String ancestors = archiveTree.getAncestors();
+                String[] ancestorssplit = ancestors.split(",");//全路径ID
+                String nodeAncestors = ancestorssplit[0]+","+ancestorssplit[1]; //大类的ancestors
+                //获取大类下所有节点,过滤单独规则，其他分类并卷规则组节点
+                List<ArchiveTreeAutoRuleVO> nodetree = ForestNodeMerger.merge(baseMapper.getAllSonNodeforGroupView(nodeAncestors, archiveTree.getArchiveAutoNodeId()));
+                //获取与当前节点同一分类的节点
+                List<ArchiveTree> listGroup= baseMapper.selectList(Wrappers.<ArchiveTree>lambdaQuery()
+                        .eq(ArchiveTree::getArchiveAutoGroupId, archiveTree.getArchiveAutoGroupId())
+                        .orderByAsc(ArchiveTree::getSort));
+                StringBuffer nodeSelect = new StringBuffer();
+
+                for(ArchiveTree node:listGroup){
+                    nodeSelect.append(node.getId()+",");
+                }
+                map.put("type",archiveAutoType);
+                map.put("tree",nodetree);
+                map.put("data",nodeSelect.toString());
+                return map;
+            }
+            if(archiveAutoType==3){
+                //单独组卷规则 显示当前节点
+                StringBuffer allName= new StringBuffer();
+                String ancestors = archiveTree.getAncestors();
+                String[] ancestorssplit = ancestors.split(",");//全路径ID
+                for(String pId:ancestorssplit){
+                    long pIdLong = Long.parseLong(pId);
+                    ArchiveTree pIdNode = baseMapper.selectById(pIdLong);
+                    allName.append(pIdNode.getNodeName()+"/");
+                }
+                allName.append(archiveTree.getNodeName());
+                ArchiveTreeAutoRuleVO vo= new ArchiveTreeAutoRuleVO();
+                vo.setAllName(allName.toString());
+                vo.setNodeId(archiveTree.getId());
+                vo.setArchiveAutoType(archiveAutoType);
+                map.put("type",archiveAutoType);
+                map.put("data",vo);
+                return map;
+            }
+        }
+        return map;
+    }
+
+
+    public void removeArchiveAutoRule(Long nodeId){
+        ArchiveTree node = baseMapper.selectById(nodeId);
+        Integer archiveAutoType = node.getArchiveAutoType();
+        if(archiveAutoType!=null){
+            //删除默认规则
+            if(archiveAutoType==1){
+                baseMapper.removeAllSonNodeIdsForArchiveAutoRule_1(node);
+            }
+            //删除节点及所有子节点 分类并卷规则
+            if(archiveAutoType==2){
+                //删除规则
+                baseMapper.removeAllSonNodeIdsForArchiveAutoRule_2(node);
+                //TODO 验证节点的父节点是否为分类并卷规则，如是则取消。若无其他兄弟节点，继续往上验证。
+            }
+            //删除节点及所有子节点 单独并卷规则
+            if(archiveAutoType==3){
+                baseMapper.removeAllSonNodeIdsForArchiveAutoRule_3(node);
+            }
+        }
+
+    }
+
+
     @Override
-    public boolean saveAechiveAutoRule(Integer archiveAutoType, String nodeIds) {
-        //步骤1：判断选择节点是否为wbs节点。
-        //步骤2：归档树原始节点，
-            //2.1保存选择节点的立卷规则。
-                //2.1.1 最高并卷规则的需要将选择节点的ID赋值archiveAutoNodeId
-                //2.1.2 分类并卷规则的需要生成个随机数，作为同一个分类赋值archiveAutoNodeId
-            //2.2保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
-        //步骤3：归档树关联wbs节点
-            //TODO 关联wbs节点的立卷规则保存，涉及到能否正确同步出来。再议
-            //3.1保存选择节点的立卷规则。
-            //3.2保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
+    public boolean updateArchiveAutoRule(ArchiveTreeContractAutoRuleMapDTO dto) {
+        //项目级不需要考虑是否为wbs节点，已经同步出来了都属于归档树节点，直接按归档树节点处理
+
+        Integer archiveAutoType = dto.getArchiveAutoType();
+        if(archiveAutoType!=null){
+            if(archiveAutoType==2){
+                Long groupId = dto.getArchiveAutoGroupId();
+                String selectNodeIds = dto.getSelectNodeIds();
+                List<String> selectNodeIdlist = Arrays.asList(selectNodeIds);
+                //先将同一分类的节点删除配置，。
+                baseMapper.removeNodeForArchiveAutoRule_Group(groupId);
+                //然后再按照选择节点保存新的设置
+                for(String nodeId:selectNodeIdlist){
+                    long nodeIdLong = Long.parseLong(nodeId);
+                    ArchiveTree archiveTree = baseMapper.selectById(nodeIdLong);
+                    archiveTree.setArchiveAutoType(archiveAutoType);
+                    //分类并卷规则 提交都是一个分类类型
+                    archiveTree.setArchiveAutoGroupId(groupId);
+                    archiveTree.setArchiveAutoGroupSelect(1);
+                    baseMapper.updateById(archiveTree);
+                    //保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
+                    baseMapper.updateAllSonNodeIdsForArchiveAutoRule(archiveTree);
+                }
+            }
+            if(archiveAutoType==1){
+
+            }
+            if(archiveAutoType==3){
+
+            }
+
+        }
+
         return false;
     }
+
 }