立卷规则编辑

blade-service-api/blade-manager-api/src/main/java/org/springblade/manager/dto/ArchiveTreeContractAutoRuleMapDTO.java

@@ -0,0 +1,18 @@
+package org.springblade.manager.dto;
+
+import lombok.Data;
+
+@Data
+public class ArchiveTreeContractAutoRuleMapDTO {
+
+    private Integer archiveAutoType;//规则类型
+
+    private Long nodeId;//节点id
+
+    private Long archiveAutoNodeId;//规则关联节点/分类
+
+    private Long archiveAutoGroupId;
+
+    private String selectNodeIds; //分类并卷设置选择的节点（鼠标点着的节点，不要父节点和子节点）
+
+}

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

@@ -128,18 +128,23 @@ public class ArchiveTreeContract extends BaseEntity {
 	*/
 	private Long extId;
 	/**
-	* 自动立卷类型
+	* 自动立卷类型 1最高 2分类并卷 3单独组卷   说明：1规则下可以有2或3；2和3两种规则互斥,2下不能有3,3下不能有2；
 	*/
 	private Integer archiveAutoType;
 	/**
-	* 自动立卷关联Id
+	* 默认组卷设置的最高并卷节点Id  当archiveAutoType不为2,和3时用来限制范围
 	*/
 	private Long archiveAutoNodeId;
 
 	/**
-	 * 是否自动立卷规则选择设置的节点 选中的节点设为1 方便页面显示列表
+	 * 分类并卷的分类ID，当archiveAutoType=2时，用来确定同一类型。新增时随机生成，一同提交设置的节点都是同一类。 编辑时 采用已有的
 	 */
-	private Integer archiveAutoSelect;
+	private Long archiveAutoGroupId;
+
+	/**
+	 * 设置分类并卷选择的节点设为1,其下范围内节点设为0
+	 */
+	private Integer archiveAutoGroupSelect;
 
 
 	public ArchiveTreeContract() {

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

@@ -1,27 +1,43 @@
 package org.springblade.manager.vo;
 
 import lombok.Data;
-import org.springblade.manager.entity.ArchiveTreeContract;
+import org.springblade.core.tool.node.INode;
+
+import java.util.ArrayList;
+import java.util.List;
 
 @Data
-public class ArchiveTreeContractAutoRuleVO implements Cloneable {
+public class ArchiveTreeContractAutoRuleVO implements INode<ArchiveTreeContractAutoRuleVO> {
 
     private Long nodeId;//节点id
 
+    private Long parentId; //父节点ID
+
+    private String nodeName; //节点名
+
     private String allName; //全路经名
 
-    private Integer selectVo; //页面勾选标志 0未勾选  1勾选
+    private Integer archiveAutoType; //规则类型
+    private Long archiveAutoNodeId;
+
+    private Long archiveAutoGroupId;
+
+    private Integer archiveAutoGroupSelect;
 
+    private List<ArchiveTreeContractAutoRuleVO> children=new ArrayList<>();
 
     @Override
-    public ArchiveTreeContractAutoRuleVO clone() {
-        try {
-            ArchiveTreeContractAutoRuleVO vo = (ArchiveTreeContractAutoRuleVO) super.clone();
-            return vo;
-        } catch (CloneNotSupportedException e) {
-            throw new AssertionError();
-        }
+    public Long getId() {
+        return nodeId;
     }
 
+    @Override
+    public Long getParentId() {
+        return parentId;
+    }
 
+    @Override
+    public List<ArchiveTreeContractAutoRuleVO> getChildren() {
+        return children;
+    }
 }

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

@@ -29,6 +29,7 @@ import org.springblade.core.mp.support.Query;
 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.entity.ArchiveTree;
 import org.springblade.manager.service.IArchiveTreeService;
 import org.springblade.manager.vo.ArchiveTreeContractAutoRuleVO;
@@ -238,9 +239,9 @@ public class ArchiveTreeContractController extends BladeController {
 	 */
 	@PostMapping("/getArchiveAutoRule")
 	@ApiOperationSupport(order = 9)
-	@ApiOperation(value = "修改立卷规则设置", notes = "传入节点id")
+	@ApiOperation(value = "查看立卷规则设置", notes = "传入节点id")
 	public R getArchiveAutoRule(@ApiParam(value = "主键", required = true) @RequestParam Long id) {
-		Map<Integer, List<ArchiveTreeContractAutoRuleVO>> ruleMap=archiveTreeContractService.getArchiveAutoRule(id);
+		Map<String, Object> ruleMap=archiveTreeContractService.getArchiveAutoRule(id);
 		return R.data(ruleMap);
 	}
 
@@ -248,11 +249,8 @@ public class ArchiveTreeContractController extends BladeController {
 	 * 修改立卷规则设置
 	 */
 	@PostMapping("/updateArchiveAutoRule")
-	@ApiOperationSupport(order = 9)
-	@ApiOperation(value = "修改立卷规则设置", notes = "传入修改的archiveAutoType规则类型,nodeIds逗号拼接选择节点id")
-	public R updateArchiveAutoRule(@ApiParam(value = "立卷规则", required = true) @RequestParam Integer archiveAutoType,
-					@ApiParam(value = "主键集合", required = true) @RequestParam String nodeIds) {
-		return R.status(archiveTreeContractService.updateArchiveAutoRule(archiveAutoType,nodeIds));
+	public R updateArchiveAutoRule(ArchiveTreeContractAutoRuleMapDTO dto) {
+		return R.status(archiveTreeContractService.updateArchiveAutoRule(dto));
 	}
 
 

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

@@ -19,6 +19,7 @@ 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;
@@ -58,9 +59,19 @@ public interface ArchiveTreeContractMapper extends BaseMapper<ArchiveTreeContrac
 	int updateAllSonNodeIdsForArchiveAutoRule(@Param("treeContract") ArchiveTreeContract treeContract);
 
 	/**
-	 * 获取节点下所有设置规则节点
+	 * 删除立卷规则设置
 	 * @param treeContract
 	 * @return
 	 */
-	List<ArchiveTreeContract> getAllSonNodeIdsForArchiveAutoRuleSelected(@Param("treeContract")ArchiveTreeContract treeContract);
+	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);
 }

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

@@ -36,7 +36,8 @@
         <result column="ext_id" property="extId"/>
         <result column="archive_auto_type" property="archiveAutoType"/>
         <result column="archive_auto_node_id" property="archiveAutoNodeId"/>
-        <result column="archive_auto_select" property="archiveAutoSelect"/>
+        <result column="archive_auto_group_select" property="archiveAutoGroupSelect"/>
+        <result column="archive_auto_group_id" property="archiveAutoGroupId"/>
     </resultMap>
 
 
@@ -88,6 +89,16 @@
         <result column="archive_auto_node_id" property="archiveAutoNodeId"/>
     </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
         d.id,
@@ -117,7 +128,6 @@
         ORDER BY d.sort
     </select>
 
-
     <select id="tree" resultMap="treeNodeResultMap">
         SELECT
         id,
@@ -182,7 +192,6 @@
         ORDER BY d.sort
     </select>
 
-
     <select id="tree2" resultMap="ArchiveTreeContractVO2ResultMap">
         SELECT
         id,
@@ -217,11 +226,24 @@
         OR parent_id = 0
         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},
-            archive_auto_node_id = #{treeContract.archive_auto_node_id}
+            <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}, '%')
             /*最高并卷规则不能覆盖 分类并卷规则，单独组卷规则*/
@@ -234,11 +256,79 @@
             </if>
     </update>
 
-    <select id="getAllSonNodeIdsForArchiveAutoRuleSelected" resultMap="archiveTreeContractResultMap">
-        select * from m_archive_tree_contract
-        where is_deleted = 0
+    <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_select=1
+        /*取消规则 只取消规则与自己一致的*/
+        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>
 

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

@@ -17,6 +17,7 @@
 package org.springblade.manager.service;
 
 import feign.Param;
+import org.springblade.manager.dto.ArchiveTreeContractAutoRuleMapDTO;
 import org.springblade.manager.entity.ArchiveTree;
 import org.springblade.manager.entity.ArchiveTreeContract;
 import org.springblade.manager.vo.ArchiveTreeContractAutoRuleVO;
@@ -72,13 +73,13 @@ public interface IArchiveTreeContractService extends BaseService<ArchiveTreeCont
 
 
 
-	Map<Integer, List<ArchiveTreeContractAutoRuleVO>> getArchiveAutoRule(Long id);
+	Map<String,Object> getArchiveAutoRule(Long id);
 
 	/**
 	 *项目级立卷规则更新
 	 * @return
 	 */
-	boolean updateArchiveAutoRule(Integer archiveAutoType,String nodeIds);
+	boolean updateArchiveAutoRule(ArchiveTreeContractAutoRuleMapDTO dto);
 
 
 }

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

@@ -22,6 +22,7 @@ import com.mixsmart.utils.StringUtils;
 import org.springblade.common.utils.SnowFlakeUtil;
 import org.springblade.core.secure.utils.AuthUtil;
 import org.springblade.core.tool.node.ForestNodeMerger;
+import org.springblade.manager.dto.ArchiveTreeContractAutoRuleMapDTO;
 import org.springblade.manager.entity.ArchiveTree;
 import org.springblade.manager.entity.ArchiveTreeContract;
 import org.springblade.manager.vo.ArchiveTreeContractAutoRuleVO;
@@ -137,28 +138,29 @@ public class ArchiveTreeContractServiceImpl extends BaseServiceImpl<ArchiveTreeC
 			//步骤1保存选择节点的立卷规则。
 			String[] ids = nodeIds.split(",");
 
-			Long archiveAutoNodeId=null;
+			Long archiveAutoGroupId=null;
 
 			//分类并卷规则的需要生成个随机数，作为同一个分类赋值archiveAutoNodeId
 			if(archiveAutoType==2){
 				double ran=(Math.random()*100000000) + 1;
-				archiveAutoNodeId=Long.parseLong(System.currentTimeMillis()+""+ran);
+				archiveAutoGroupId=Long.parseLong(System.currentTimeMillis()+""+ran);
 			}
 			for(String nodeId:ids){
 				long nodeIdLong = Long.parseLong(nodeId);
 				ArchiveTreeContract archiveTreeContract = baseMapper.selectById(nodeIdLong);
-				archiveTreeContract.setArchiveAutoSelect(1);
 				archiveTreeContract.setArchiveAutoType(archiveAutoType);
-				if(archiveAutoType==2){
-					//分类并卷规则 提交都是一个分类类型
-					archiveTreeContract.setArchiveAutoNodeId(archiveAutoNodeId);
-				}else{
+				if(archiveAutoType==1){
 					//最高并卷规则 选择节点的ID
 					archiveTreeContract.setArchiveAutoNodeId(nodeIdLong);
 				}
+				if(archiveAutoType==2){
+					//分类并卷规则 提交都是一个分类类型
+					archiveTreeContract.setArchiveAutoGroupId(archiveAutoGroupId);
+					archiveTreeContract.setArchiveAutoGroupSelect(1);
+				}
 				baseMapper.updateById(archiveTreeContract);
 
-				//TODO 步骤2保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
+				//步骤2保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
 				baseMapper.updateAllSonNodeIdsForArchiveAutoRule(archiveTreeContract);
 			}
 
@@ -177,145 +179,136 @@ public class ArchiveTreeContractServiceImpl extends BaseServiceImpl<ArchiveTreeC
 	 * @return
 	 */
 	@Override
-	public Map<Integer, List<ArchiveTreeContractAutoRuleVO>> getArchiveAutoRule(Long id) {
+	public Map<String,Object> getArchiveAutoRule(Long id) {
 
-		Map<Integer, List<ArchiveTreeContractAutoRuleVO>> map= new HashMap<>();
-		List<ArchiveTreeContractAutoRuleVO> voList_1 = new ArrayList<>();//最高规则显示节点及节点下有设置的节点（archive_auto_select=1）
-		List<ArchiveTreeContractAutoRuleVO> voList_2 = new ArrayList<>();//分类并卷的tab显示当前节点的相同分类节点
-		List<ArchiveTreeContractAutoRuleVO> voList_3 = new ArrayList<>();//单独组卷的显示节点及节点下有设置的节点（archive_auto_select=1）
+		Map<String,Object> map= new HashMap<>();
 
 		ArchiveTreeContract archiveTreeContract = baseMapper.selectById(id);
-
-		Map<Long,String> nodeNameMap = new HashMap<>();//单个节点名称缓存
-
-		//获取当前节点下所有设置的节点
-		List<ArchiveTreeContract> list=baseMapper.getAllSonNodeIdsForArchiveAutoRuleSelected(archiveTreeContract);
-		//找出最高规则和单独规则列表
-		for(ArchiveTreeContract node:list){
-			Integer archiveAutoType = node.getArchiveAutoType();
-			if(archiveAutoType !=null && archiveAutoType!=2){
-				ArchiveTreeContractAutoRuleVO vo = new ArchiveTreeContractAutoRuleVO();
-				vo.setNodeId(node.getId());
+		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 = node.getAncestors();
+				String ancestors = archiveAutoNode.getAncestors();
 				String[] ancestorssplit = ancestors.split(",");//全路径ID
 				for(String pId:ancestorssplit){
 					long pIdLong = Long.parseLong(pId);
-					if(nodeNameMap.containsKey(pIdLong)){
-						allName.append(nodeNameMap.get(pIdLong)+"/");
-					}else{
-						ArchiveTreeContract pIdNode = baseMapper.selectById(pIdLong);
-						nodeNameMap.put(pIdNode.getId(),pIdNode.getNodeName());
-						allName.append(pIdNode.getNodeName()+"/");
-					}
+					ArchiveTreeContract pIdNode = baseMapper.selectById(pIdLong);
+					allName.append(pIdNode.getNodeName()+"/");
 				}
-				allName.append(node.getNodeName());
+				allName.append(archiveAutoNode.getNodeName());
+				ArchiveTreeContractAutoRuleVO vo= new ArchiveTreeContractAutoRuleVO();
 				vo.setAllName(allName.toString());
-
-				if(archiveAutoType==3){
-					vo.setSelectVo(1);
-					voList_3.add(vo);
-
-					ArchiveTreeContractAutoRuleVO vo1 = vo.clone();
-					vo1.setSelectVo(0);
-					voList_1.add(vo1);
-				}
-
-				if(archiveAutoType==1){
-					vo.setSelectVo(0);
-					voList_3.add(vo);
-
-					ArchiveTreeContractAutoRuleVO vo1 = vo.clone();
-					vo1.setSelectVo(1);
-					voList_1.add(vo1);
+				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(archiveTreeContract.getArchiveAutoType()!=null && archiveTreeContract.getArchiveAutoType()==2){
-
-			//设置同一分类的节点 archiveAutoSelect=1的，不是范围内的所有子节点
-			List<ArchiveTreeContract> list2= baseMapper.selectList(Wrappers.<ArchiveTreeContract>lambdaQuery()
-					.eq(ArchiveTreeContract::getArchiveAutoNodeId, archiveTreeContract.getArchiveAutoNodeId())
-					.eq(ArchiveTreeContract::getArchiveAutoSelect, 1).orderByAsc(ArchiveTreeContract::getSort));
-			for(ArchiveTreeContract node:list2){
-				ArchiveTreeContractAutoRuleVO vo = new ArchiveTreeContractAutoRuleVO();
-				vo.setNodeId(node.getId());
+			if(archiveAutoType==3){
+				//单独组卷规则 显示当前节点
 				StringBuffer allName= new StringBuffer();
-				String ancestors = node.getAncestors();
+				String ancestors = archiveTreeContract.getAncestors();
 				String[] ancestorssplit = ancestors.split(",");//全路径ID
 				for(String pId:ancestorssplit){
 					long pIdLong = Long.parseLong(pId);
-					if(nodeNameMap.containsKey(pIdLong)){
-						allName.append(nodeNameMap.get(pIdLong)+"/");
-					}else{
-						ArchiveTreeContract pIdNode = baseMapper.selectById(pIdLong);
-						nodeNameMap.put(pIdNode.getId(),pIdNode.getNodeName());
-						allName.append(pIdNode.getNodeName()+"/");
-					}
+					ArchiveTreeContract pIdNode = baseMapper.selectById(pIdLong);
+					allName.append(pIdNode.getNodeName()+"/");
 				}
-				allName.append(node.getNodeName());
+				allName.append(archiveTreeContract.getNodeName());
+				ArchiveTreeContractAutoRuleVO vo= new ArchiveTreeContractAutoRuleVO();
 				vo.setAllName(allName.toString());
-				vo.setSelectVo(1);
-				voList_2.add(vo);
+				vo.setNodeId(archiveTreeContract.getId());
+				vo.setArchiveAutoType(archiveAutoType);
+				map.put("type",archiveAutoType);
+				map.put("data",vo);
+				return map;
 			}
 		}
-
-		map.put(1,voList_1);
-		map.put(2,voList_2);
-		map.put(3,voList_3);
 		return map;
 	}
 
 
-	@Override
-	public boolean updateArchiveAutoRule(Integer archiveAutoType, String nodeIds) {
-		//项目级不需要考虑是否为wbs节点，已经同步出来了都属于归档树节点，直接按归档树节点处理
+	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);
+			}
+		}
+
+	}
 
 
-		String[] ids = nodeIds.split(",");
-		Set<String> idsSet=new HashSet<>(Arrays.asList(ids));
-
-		//判断修改的原来是否是分类并卷规则类型
-		List<ArchiveTreeContract> archiveTreeContracts_db=null;
-		long nodeId_0_Long = Long.parseLong(ids[0]);
-		ArchiveTreeContract archiveTreeContract0 = baseMapper.selectById(nodeId_0_Long);
-		Integer archiveAutoType_db = archiveTreeContract0.getArchiveAutoType();
-		if(archiveAutoType_db==2){
-			//获取分类ID
-			Long archiveAutoNodeId_db = archiveTreeContract0.getArchiveAutoNodeId();
-			//获取该分类下的设置选择节点 archiveAutoSelect=1的，不是范围内的所有子节点
-			archiveTreeContracts_db = baseMapper.selectList(Wrappers.<ArchiveTreeContract>lambdaQuery()
-					.eq(ArchiveTreeContract::getArchiveAutoNodeId, archiveAutoNodeId_db)
-					.eq(ArchiveTreeContract::getArchiveAutoSelect, 1)
-			);
-		}else{
-			//原来是最高，单独规则类型的
+	@Override
+	public boolean updateArchiveAutoRule(ArchiveTreeContractAutoRuleMapDTO dto) {
+		//项目级不需要考虑是否为wbs节点，已经同步出来了都属于归档树节点，直接按归档树节点处理
 
+		Integer archiveAutoType = dto.getArchiveAutoType();
+		if(archiveAutoType!=null){
 			if(archiveAutoType==2){
-				//修改成分类并卷
-			}
-			if(archiveAutoType==1){
-				//修改成最高
-			}
-			if(archiveAutoType==3){
-				//修改成单独
-				for(String nodeId:ids){
-					//步骤1更新选择节点的立卷规则。
+				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.setArchiveAutoSelect(1);
 					archiveTreeContract.setArchiveAutoType(archiveAutoType);
-					archiveTreeContract.setArchiveAutoNodeId(nodeIdLong);//最高/单独规则 选择节点的ID
+					//分类并卷规则 提交都是一个分类类型
+					archiveTreeContract.setArchiveAutoGroupId(groupId);
+					archiveTreeContract.setArchiveAutoGroupSelect(1);
 					baseMapper.updateById(archiveTreeContract);
-					//步骤2保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
+					//保存选择节点下所有子节点的立卷规则。注意立卷规则优先级覆盖原则。（单独组卷>分类并卷>最高并卷）
 					baseMapper.updateAllSonNodeIdsForArchiveAutoRule(archiveTreeContract);
 				}
 			}
-		}
+			if(archiveAutoType==1){
 
+			}
+			if(archiveAutoType==3){
+
+			}
+
+		}
 
 		return false;
 	}