Merge branch 'lk20230324'

# Conflicts:
#	blade-service-api/blade-business-api/src/main/java/org/springblade/business/entity/ArchiveFile.java
#	blade-service/blade-business/src/main/java/org/springblade/business/mapper/ArchiveFileMapper.xml

blade-service-api/blade-business-api/src/main/java/org/springblade/business/entity/ArchiveFile.java

@@ -243,4 +243,14 @@ public class ArchiveFile extends BaseEntity {
 	//是否案卷收集上传的案卷
 	@ApiModelProperty("是否案卷收集上传的案卷")
 	private Integer isAutoFile;
+
+
+	/**
+	 * 是否已组卷  0或null 未组卷  1已组卷
+	 */
+	@ApiModelProperty("是否组卷")
+	private Integer isArchive;
+
+
+
 }

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

@@ -15,4 +15,6 @@ public class ArchiveTreeContractAutoRuleMapDTO {
 
     private String selectNodeIds; //分类并卷设置选择的节点（鼠标点着的节点，不要父节点和子节点）
 
+    private Long projectId;
+
 }

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

@@ -55,10 +55,6 @@ public class ArchiveAutoRuleWbs extends BaseEntity {
 	* 项目id 系统级的为0
 	*/
 		private Long projectId;
-	/**
-	* 1删除  0正常
-	*/
-		private Integer delete;
 
 
 }

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

@@ -187,4 +187,6 @@ public class ArchiveTreeVO2 implements INodeEx<ArchiveTreeVO2> {
 
     private boolean iswbsNode;  //是否为关联的wbs节点
 
+    private Long wbsNode2ArchiveTreeNodeId;  //wbs节点关联归档树节点ID
+
 }

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

@@ -50,6 +50,7 @@
         <result column="box_name" property="boxName"/>
         <result column="box_number" property="boxNumber"/>
         <result column="is_auto_file" property="isAutoFile"/>
+        <result column="is_archive" property="isArchive"/>
     </resultMap>
     <update id="recoveryByIds">
         update u_archive_file set is_deleted = 0 where

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

@@ -210,8 +210,9 @@ public class ArchiveTreeController extends BladeController {
     @ApiOperation(value = "保存立卷规则设置", notes = "传入archiveAutoType规则类型,nodeIds逗号拼接选择节点id")
     public R saveArchiveAutoRule(@ApiParam(value = "立卷规则", required = true) @RequestParam Integer archiveAutoType,
                                  @ApiParam(value = "主键集合", required = true) @RequestParam String selectNodeIds,
-                                 @ApiParam(value = "是否wbs节点", required = true) @RequestParam Boolean iswbsNode) {
-        return R.status(archiveTreeService.saveArchiveAutoRule(archiveAutoType,selectNodeIds,iswbsNode));
+                                 @ApiParam(value = "是否wbs节点", required = true) @RequestParam Boolean iswbsNode,
+                                 Long projectId) {
+        return R.status(archiveTreeService.saveArchiveAutoRule(archiveAutoType,selectNodeIds,iswbsNode,projectId));
     }
 
 
@@ -227,8 +228,8 @@ public class ArchiveTreeController extends BladeController {
      * 取消立卷规则设置
      */
     @PostMapping("/removeArchiveAutoRule")
-    public R removeArchiveAutoRule(Long nodeId,boolean iswbsNode) {
-        Map<String, String> map = archiveTreeService.removeArchiveAutoRule(nodeId, iswbsNode);
+    public R removeArchiveAutoRule(Long nodeId,boolean iswbsNode,Long projectId) {
+        Map<String, String> map = archiveTreeService.removeArchiveAutoRule(nodeId, iswbsNode,projectId);
         return R.data(map);
     }
 
@@ -236,8 +237,8 @@ public class ArchiveTreeController extends BladeController {
      * 查看立卷规则设置
      */
     @PostMapping("/getArchiveAutoRule")
-    public R getArchiveAutoRule(Long nodeId,boolean iswbsNode) {
-        Map<String, Object> ruleMap=archiveTreeService.getArchiveAutoRule(nodeId,iswbsNode);
+    public R getArchiveAutoRule(Long nodeId,boolean iswbsNode,Long projectId,Long wbsNode2ArchiveTreeNodeId,String wbsId) {
+        Map<String, Object> ruleMap=archiveTreeService.getArchiveAutoRule(nodeId,iswbsNode,projectId,wbsNode2ArchiveTreeNodeId,wbsId);
         return R.data(ruleMap);
     }
 

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

@@ -21,6 +21,8 @@ import org.springblade.manager.entity.ArchiveAutoRuleWbs;
 import org.springblade.manager.vo.ArchiveAutoRuleWbsVO;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+
+import java.util.Date;
 import java.util.List;
 
 /**
@@ -43,4 +45,6 @@ public interface ArchiveAutoRuleWbsMapper extends BaseMapper<ArchiveAutoRuleWbs>
 	int removeNodeForArchiveAutoRule_Group(@Param("archiveAutoGroupId") Long archiveAutoGroupId,
 										   @Param("projectId") Long projectId);
 
+	int removeArchiveAutoRule(@Param("id") Long id, @Param("time") Date time);
+
 }

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

@@ -14,7 +14,7 @@
         <result column="archive_auto_type" property="archiveAutoType"/>
         <result column="archive_auto_group_id" property="archiveAutoGroupId"/>
         <result column="project_id" property="projectId"/>
-        <result column="delete" property="delete"/>
+        <result column="is_deleted" property="isDeleted"/>
     </resultMap>
 
 
@@ -33,4 +33,14 @@
           and archive_auto_group_id = #{archiveAutoGroupId}
     </update>
 
+    <update id="removeArchiveAutoRule">
+        /**取消同一组的分类并卷规则*/
+        update m_archive_auto_rule_wbs
+        set
+            is_deleted = 1,
+            update_time = #{time}
+        where
+            id = #{id}
+    </update>
+
 </mapper>

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

@@ -39,11 +39,14 @@ public interface ArchiveTreeMapper extends BaseMapper<ArchiveTree> {
      * @return
      */
     int removeAllSonNodeIdsForArchiveAutoRule_1(@Param("archiveAutoType") Integer archiveAutoType,
-                                                @Param("ancestors") String ancestors);
+                                                @Param("ancestors") String ancestors,
+                                                @Param("nodeId") Long nodeId);
     int removeAllSonNodeIdsForArchiveAutoRule_2(@Param("archiveAutoType") Integer archiveAutoType,
-                                                @Param("ancestors") String ancestors);
+                                                @Param("ancestors") String ancestors,
+                                                @Param("nodeId") Long nodeId);
     int removeAllSonNodeIdsForArchiveAutoRule_3(@Param("archiveAutoType") Integer archiveAutoType,
-                                                @Param("ancestors") String ancestors);
+                                                @Param("ancestors") String ancestors,
+                                                @Param("nodeId") Long nodeId);
     int removeNodeForArchiveAutoRule_Group(@Param("archiveAutoGroupId") Long archiveAutoGroupId);
     /**
      * 查看分类并卷规则-获取大类所有节点

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

@@ -315,8 +315,9 @@
         set
             archive_auto_node_id = NULL
         where
-            is_deleted = 0
-          and ancestors like concat('', #{ancestors}, '%');
+          is_deleted = 0
+          and ancestors like concat('', #{ancestors}, '%')
+          or id=#{nodeId} ;
 
 
         update m_archive_tree
@@ -326,7 +327,8 @@
             is_deleted = 0
           and ancestors like concat('', #{ancestors}, '%')
             /*取消规则 只取消规则与自己一致的*/
-          and archive_auto_type = #{archiveAutoType} ;
+          and archive_auto_type = #{archiveAutoType}
+          or id=#{nodeId} ;
     </update>
 
     <update id="removeAllSonNodeIdsForArchiveAutoRule_3">
@@ -339,6 +341,7 @@
           and ancestors like concat('', #{ancestors}, '%')
             /*取消规则 只取消规则与自己一致的*/
           and archive_auto_type = #{archiveAutoType}
+          or id=#{nodeId} ;
     </update>
     <update id="removeAllSonNodeIdsForArchiveAutoRule_2">
         /*取消单个节点的分类并卷规则*/
@@ -353,6 +356,7 @@
           and ancestors like concat('', #{ancestors}, '%')
             /*取消规则 只取消规则与自己一致的*/
           and archive_auto_type = #{archiveAutoType}
+          or id=#{nodeId} ;
     </update>
 
     <update id="removeNodeForArchiveAutoRule_Group">

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

@@ -44,11 +44,11 @@ public interface IArchiveTreeService extends BaseService<ArchiveTree> {
 	 *项目级立卷规则新增
 	 * @return
 	 */
-	boolean saveArchiveAutoRule(Integer archiveAutoType,String nodeIds,boolean iswbsNode);
+	boolean saveArchiveAutoRule(Integer archiveAutoType,String nodeIds,boolean iswbsNode,Long projectId);
 
 
 
-	Map<String,Object> getArchiveAutoRule(Long id,boolean iswbsNode);
+	Map<String,Object> getArchiveAutoRule(Long id,boolean iswbsNode,Long projectId,Long wbsNode2ArchiveTreeNodeId,String wbsId);
 
 	/**
 	 *项目级立卷规则更新
@@ -63,5 +63,5 @@ public interface IArchiveTreeService extends BaseService<ArchiveTree> {
 	 * @param iswbsNode
 	 * @return
 	 */
-	Map<String,String> removeArchiveAutoRule(Long nodeId,boolean iswbsNode);
+	Map<String,String> removeArchiveAutoRule(Long nodeId,boolean iswbsNode,Long projectId);
 }

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

@@ -16,7 +16,13 @@
  */
 package org.springblade.manager.service.impl;
 
+import com.alibaba.druid.sql.dialect.h2.visitor.H2ASTVisitor;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import org.springblade.archive.entity.ArchivesAuto;
+import org.springblade.business.entity.ArchiveFile;
+import org.springblade.business.feign.ArchiveFileClient;
 import org.springblade.manager.entity.ArchiveAutoRuleWbs;
+import org.springblade.manager.entity.ArchiveTreeContract;
 import org.springblade.manager.vo.ArchiveAutoRuleWbsVO;
 import org.springblade.manager.mapper.ArchiveAutoRuleWbsMapper;
 import org.springblade.manager.service.IArchiveAutoRuleWbsService;
@@ -24,6 +30,8 @@ import org.springblade.core.mp.base.BaseServiceImpl;
 import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 
+import java.util.*;
+
 /**
  *  服务实现类
  *
@@ -33,6 +41,8 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
 @Service
 public class ArchiveAutoRuleWbsServiceImpl extends BaseServiceImpl<ArchiveAutoRuleWbsMapper, ArchiveAutoRuleWbs> implements IArchiveAutoRuleWbsService {
 
+	private ArchiveFileClient archiveFileClient;
+
 	@Override
 	public IPage<ArchiveAutoRuleWbsVO> selectArchiveAutoRuleWbsPage(IPage<ArchiveAutoRuleWbsVO> page, ArchiveAutoRuleWbsVO archiveAutoRuleWbs) {
 		return page.setRecords(baseMapper.selectArchiveAutoRuleWbsPage(page, archiveAutoRuleWbs));
@@ -45,29 +55,233 @@ public class ArchiveAutoRuleWbsServiceImpl extends BaseServiceImpl<ArchiveAutoRu
 		//步骤四：按照单独，分类，默认的顺序执行组卷流程。
 	}
 
+
+	/**
+	 * 检查当前案卷的文件集合是否在规格内，能否开始组卷。
+	 * return
+	 * 0不能组卷，当前文件入待组卷集合，还能试加文件。
+	 * 1可以组卷，当前文件加入待组卷集合后开始组卷。
+	 * -1 不可组卷，当前文件不能加入待组卷集合, 待组卷集合要组卷了。
+	 * null 程序出错了
+	 */
+	private Integer checkSpecificationSize(int SpecificationSize,int archivesSize){
+		//按照当前目录节点的参数（卷盒规格）进行页数组合，
+		// 30MM默认为300页组成一卷、400MM默认为400页组成一卷、50MM默认为500页组成一卷、60MM默认为600组成一卷。
+		//注意：允许组卷上浮区间为100页
+		//意思是如果A\B两个文件进行并卷组卷，总页数规格为300页，但是A+B的文件数为350页，已经超过固定规格，但是上浮区间在100以内，则允许这样组卷。
+		//超过300之后，则不在继续与其他文件进行并卷组卷了。
+		int SpecificationSizeMax =SpecificationSize+100;
+
+		if(archivesSize<SpecificationSize){
+			//小于规格的 返回true ，当前文件加入待组卷集合，还可以试加文件，未到组卷规格
+			return 0;
+		}
+		if(archivesSize==SpecificationSize){
+			//等于规则的  当前文件加入待组卷集合,待组卷集合可以组卷了。
+			return 1;
+		}
+		if(archivesSize<=SpecificationSizeMax){
+			//小于等于规格上浮区间，当前文件加入待组卷集合,当前文件集合可以组卷了
+			return 1;
+		}
+		if(archivesSize>SpecificationSizeMax){
+			//大于规格上浮区间，当前文件不能加入当前待组卷集合，先把当前待组卷集合的文件先组卷完成，清空待组卷集合后再重新计算检查当前文件。
+			return -1;
+		}
+
+		return null;
+	}
+
+	/**
+	 * 单独组卷规则组卷
+	 * @param waitArchiveFiles
+	 * @param node
+	 */
+	private void createArchive3(List<ArchiveFile> waitArchiveFiles,ArchiveTreeContract node){
+		//1.创建新案卷
+		ArchivesAuto archivesAuto = new ArchivesAuto();
+		//archivesAuto.setProjectId();
+		//archivesAuto.setContractId();
+		//archivesAuto.setName();//案卷题名
+		//archivesAuto.setFileNumber();//档号
+		//archivesAuto.setMicron();//微缩号
+		//archivesAuto.setUnit();//单位
+		//archivesAuto.setQuantity();//数量/单位
+		//archivesAuto.setSpecification();//规格
+		//archivesAuto.setStartDate();
+		//archivesAuto.setEndDate();
+		//archivesAuto.setStorageTime();//保管时间
+		//archivesAuto.setSecretLevel();//保密级别
+		//archivesAuto.setCarrierType();//载体类型
+		//archivesAuto.setKeywords();//主题词
+		//archivesAuto.setStorageLocation();//存放位置
+		//archivesAuto.setIsArchive(1);//已归档
+		//archivesAuto.setRemark();//备注
+		//archivesAuto.setRollDate();//立卷日期
+		//archivesAuto.setRollor();//立卷人
+		//archivesAuto.setNodeId();//归档树节点
+		//archivesAuto.setOutUrl();
+		//archivesAuto.setFileN();//文件数量
+		//archivesAuto.setPageN();//案卷页数
+		//archivesAuto.setMileage();
+		//archivesAuto.setFileType();
+		//archivesAuto.setSize();
+		//archivesAuto.setTreeSort();
+		//archivesAuto.setIsOpen();
+		//archivesAuto.setIscheck();
+		//archivesAuto.setIsAutoFile();
+
+		//2.设置文件所属案卷，组卷状态
+	}
+
+
 	/**
 	 * 单租组卷流程  节点下的文件只在当前节点下组卷
 	 */
-	private void archiveAutoMethod3(){
+	private void archiveAutoMethod3(List<ArchiveTreeContract> list){
 		//步骤1：遍历节点集合
-		//步骤2：获取当前节点的案卷规格
-		//步骤3：查询节点下的未归档文件
-		//步骤4：遍历未归档文件
-		//步骤5：判断文件是否存在分盒设置-》走分盒组卷流程
-		//步骤6：计算和判断待组卷文件集合是否达到组卷要求，达到要求创建案卷，案卷归属当前节点，案卷下文件改为已组卷
+		for(ArchiveTreeContract node:list){
+			//步骤2：获取当前节点的案卷规格
+			int specificationSize=300;//TODO
+			//步骤3：查询节点下的未归档文件
+			List<ArchiveFile> archiveFiles = archiveFileClient.listWrappers(Wrappers.<ArchiveFile>lambdaQuery()
+					.eq(ArchiveFile::getNodeId, node)
+					.eq(ArchiveFile::getIsArchive, 0)
+					.eq(ArchiveFile::getIsDeleted,0)
+					.orderByAsc(ArchiveFile::getSort));
+			//步骤4：遍历未归档文件
+			//待组卷文件集合
+			List<ArchiveFile> waitArchiveFiles = new ArrayList<>();
+			//待组卷文件总页数
+			int archivesSize=0;
+			if(archiveFiles!=null){
+				int archiveFilesSize=0;
+				for(ArchiveFile file:archiveFiles){
+					archiveFilesSize++;
+					//步骤5：判断文件是否存在分盒设置
+					if(file.getBoxNumber()!=null){
+						//TODO 走分盒组卷流程
+					}else{
+						//单独组卷流程
+						//步骤6：计算和判断待组卷文件集合是否达到组卷要求，达到要求创建案卷，案卷归属当前节点，案卷下文件改为已组卷
+						Integer filePage = file.getFilePage();
+						archivesSize=archivesSize+filePage;
+						Integer checkStatus = checkSpecificationSize(specificationSize, archivesSize);
+						//步骤6.1未到规格 不组卷
+						if(checkStatus==0){
+							waitArchiveFiles.add(file);
+							//判断是否最后一个文件
+							if(archiveFilesSize==archiveFiles.size()){
+								//TODO 最后一个文件直接将waitArchiveFiles组卷
+							}else{
+								continue;
+							}
+						}
+						//步骤6.2达到规格 可以组一卷
+						if(checkStatus==1){
+							waitArchiveFiles.add(file);
+							//TODO 将waitArchiveFiles组卷
+							//将待组卷文件集合，总页数还原初始值，
+							waitArchiveFiles.clear();
+							archivesSize=0;
+						}
+						//步骤6.3超出规格---开始
+						if(checkStatus==-1){
+							//步骤6.3.1如果waitArchiveFiles集合size>0,先将集合中文件组卷。再重新计算当前文件
+							if(waitArchiveFiles.size()>0){
+								//步骤6.3.1_1 TODO 将waitArchiveFiles组卷，然后将待组卷文件集合，总页数还原初始值，
+								waitArchiveFiles.clear();
+								//步骤6.3.1_2保存当前文件进入待组卷集合，待组卷页数=当前文件页数
+								waitArchiveFiles.add(file);
+								archivesSize=filePage;
+								//步骤6.3.1_3当前文件再次检查规格
+								Integer checkStatusAgain = checkSpecificationSize(specificationSize, archivesSize);
+								//步骤6.3.1_3_1未到规格
+								if(checkStatusAgain==0){
+									//判断是否最后一个文件
+									if(archiveFilesSize==archiveFiles.size()){
+										//TODO 最后一个文件直接将waitArchiveFiles组卷
+									}else{
+										continue;
+									}
+								}else{
+									//步骤6.3.1_3_2单个文件 就达到规格或超出规格 直接组卷
+									if(checkStatusAgain!=null){
+										//TODO 直接将waitArchiveFiles组卷
+										//将待组卷文件集合，总页数还原初始值，
+										waitArchiveFiles.clear();
+										archivesSize=0;
+									}
+								}
+							}else{
+								//步骤6.3.2如果waitArchiveFiles集合size=0,说明当前文件已经超过规格，直接将当前文件组卷
+								waitArchiveFiles.add(file);
+								//TODO 直接将waitArchiveFiles组卷
+								waitArchiveFiles.clear();
+								archivesSize=0;
+							}
+						}
+						//步骤6.3超出规格---结束
+					}
+				}
+			}
+
+		}
+
+
+
+
+
 	}
 
 	/**
 	 * 分类并卷组卷  设置分类的节点下只有一个案卷，节点下的所有文件都组成这个案卷。如果设置分类节点（select=1的）多个，案卷归属排序第一个节点。
 	 */
-	private void archiveAutoMethod2(){
+	private void archiveAutoMethod2(List<ArchiveTreeContract> list){
+
+		//分类并卷集合<groupId,List<文件>>
+		Map<Long,List<ArchiveFile>> archiveMap = new HashMap<>();
+
 		//步骤1：遍历节点集合
-		//步骤2：查询节点下的未归档文件
-		//步骤4：遍历未归档文件
-		//步骤5：判断文件是否存在分盒设置-》走分盒组卷流程
-		//步骤6：将文件按照<groupId,List<文件>>放入集合
-		//步骤7：将文件按照<groupId,List<文件>>放入集合
-		//步骤8：按集合创建案卷，每个group类的案卷归属顺序排第一个节点
+		for(ArchiveTreeContract node:list) {
+			//根据分组ID来创建唯一案卷
+			Long archiveAutoGroupId=node.getArchiveAutoGroupId();
+			//步骤2：查询节点下的未归档文件
+			List<ArchiveFile> archiveFiles = archiveFileClient.listWrappers(Wrappers.<ArchiveFile>lambdaQuery()
+					.eq(ArchiveFile::getNodeId, node)
+					.eq(ArchiveFile::getIsArchive, 0)
+					.eq(ArchiveFile::getIsDeleted,0)
+					.orderByAsc(ArchiveFile::getSort));
+			//步骤3：遍历未归档文件
+			if(archiveFiles!=null){
+				for(ArchiveFile file:archiveFiles){
+					//步骤4：判断文件是否存在分盒设置
+					if(file.getBoxNumber()!=null){
+						//走分盒流程
+					}else{
+						//分类并卷流程
+						//步骤5：将文件按照<groupId,List<文件>>放入集合
+						if(archiveMap.containsKey(archiveAutoGroupId)){
+							List<ArchiveFile> groupList = archiveMap.get(archiveAutoGroupId);
+							groupList.add(file);
+							archiveMap.put(archiveAutoGroupId,groupList);
+						}else{
+							List<ArchiveFile> groupList= new ArrayList<>();
+							groupList.add(file);
+							archiveMap.put(archiveAutoGroupId,groupList);
+						}
+					}
+				}
+			}
+		}
+		//步骤6：按集合创建案卷，每个group类的案卷归属顺序排第一个节点
+		Set<Map.Entry<Long, List<ArchiveFile>>> entries = archiveMap.entrySet();
+		for(Map.Entry<Long, List<ArchiveFile>> entry:entries){
+			Long key = entry.getKey();
+			List<ArchiveFile> archiveFiles = entry.getValue();
+			//TODO 一个key 组成一个案卷  案卷归属同个key的归档树节点select=1的第一个
+		}
+
 	}
 
 	/**

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

@@ -380,6 +380,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
             archiveTree.setTitle(wbsTreeVO2.getTitle());
 
             archiveTree.setIswbsNode(true);
+            archiveTree.setWbsNode2ArchiveTreeNodeId(parentId);
             archiveTree.setId(wbsTreeVO2.getId());
             archiveTree.setParentId(wbsTreeVO2.getParentId());
             archiveTree.setExtId(wbsTreeVO2.getId());
@@ -414,9 +415,9 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
      * @return
      */
     @Override
-    public boolean saveArchiveAutoRule(Integer archiveAutoType, String nodeIds,boolean iswbsNode) {
+    public boolean saveArchiveAutoRule(Integer archiveAutoType, String nodeIds,boolean iswbsNode,Long projectId) {
         if(iswbsNode){
-            return saveArchiveAutoRule_WbsTreeNode(archiveAutoType, nodeIds);
+            return saveArchiveAutoRule_WbsTreeNode(archiveAutoType, nodeIds,projectId);
         }else{
             return saveArchiveAutoRule_ArchiveTreeNode(archiveAutoType, nodeIds);
         }
@@ -477,7 +478,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
      * @param nodeIds
      * @return
      */
-    private Boolean saveArchiveAutoRule_WbsTreeNode(Integer archiveAutoType, String nodeIds){
+    private Boolean saveArchiveAutoRule_WbsTreeNode(Integer archiveAutoType, String nodeIds,Long projectId){
         try{
             String[] ids = nodeIds.split(",");
             Long archiveAutoGroupId=null;
@@ -492,14 +493,14 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                 //步骤1:保存选择节点的立卷规则。
                 long nodeIdLong = Long.parseLong(nodeId);
                 //1.1最高规则和单独规则 将选择的wbs节点ID（wbsId），规则类型(archive_auto_type), 保存表m_archive_auto_rule_wbs
-                WbsTree wbsTree = wbsTreeService.getById(nodeIdLong);
+                //WbsTree wbsTree = wbsTreeService.getById(nodeIdLong);
                 ArchiveAutoRuleWbs autoRuleWbs = new ArchiveAutoRuleWbs();
                 autoRuleWbs.setWbsId(nodeIdLong);
                 autoRuleWbs.setArchiveAutoType(archiveAutoType);
                 if(archiveAutoType==2){
                     autoRuleWbs.setArchiveAutoGroupId(archiveAutoGroupId);
                 }
-                autoRuleWbs.setProjectId(0L);//TODO
+                autoRuleWbs.setProjectId(projectId);//项目ID  系统级为0
                 autoRuleWbs.setWbsRootId(null);//TODO
                 archiveAutoRuleWbsMapper.insert(autoRuleWbs);
             }
@@ -577,7 +578,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                     String selectNodeIds = dto.getSelectNodeIds();
                     List<String> selectNodeIdlist = Arrays.asList(selectNodeIds);
                     //先将同一分组的节点删除配置，。
-                    archiveAutoRuleWbsMapper.removeNodeForArchiveAutoRule_Group(groupId,0L);
+                    archiveAutoRuleWbsMapper.removeNodeForArchiveAutoRule_Group(groupId,dto.getProjectId());
                     //然后再按照选择节点保存新的设置
                     for(String nodeId:selectNodeIdlist){
                         long nodeIdLong = Long.parseLong(nodeId);
@@ -587,8 +588,8 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                         if(archiveAutoType==2){
                             autoRuleWbs.setArchiveAutoGroupId(groupId);
                         }
-                        autoRuleWbs.setProjectId(0L);//TODO
-                        autoRuleWbs.setWbsRootId(null);//TODO
+                        autoRuleWbs.setProjectId(dto.getProjectId()==null?0L:dto.getProjectId());
+                        autoRuleWbs.setWbsRootId(null);//TODO 不懂有没有这个东西
                         archiveAutoRuleWbsMapper.insert(autoRuleWbs);
                     }
                 }
@@ -604,22 +605,24 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
      * 移除节点规则
      * @param nodeId
      */
-    public Map<String,String> removeArchiveAutoRule(Long nodeId,boolean iswbsNode){
+    public Map<String,String> removeArchiveAutoRule(Long nodeId,boolean iswbsNode,Long projectId){
         Map<String,String> returnMap= new HashMap<>();
         returnMap.put("code","1");
         try{
             if(iswbsNode){
-                ArchiveAutoRuleWbs archiveAutoRuleWbs = archiveAutoRuleWbsMapper.selectById(nodeId);
-                archiveAutoRuleWbs.setDelete(1);
-                archiveAutoRuleWbs.setUpdateTime(new Date());
-                archiveAutoRuleWbsMapper.updateById(archiveAutoRuleWbs);
+                ArchiveAutoRuleWbs autoRuleWbs = archiveAutoRuleWbsMapper.selectOne(Wrappers.<ArchiveAutoRuleWbs>lambdaQuery()
+                        .eq(ArchiveAutoRuleWbs::getWbsId, nodeId)
+                        .eq(ArchiveAutoRuleWbs::getIsDeleted, 0)
+                        .eq(ArchiveAutoRuleWbs::getProjectId, projectId));
+                archiveAutoRuleWbsMapper.removeArchiveAutoRule(autoRuleWbs.getId(),new Date());
             }else{
                 ArchiveTree node = baseMapper.selectById(nodeId);
                 Integer archiveAutoType = node.getArchiveAutoType();
                 if(archiveAutoType!=null){
                     //删除默认规则
                     if(archiveAutoType==1){
-                        baseMapper.removeAllSonNodeIdsForArchiveAutoRule_1(node.getArchiveAutoType(),node.getAncestors());
+                        String ancestors = node.getAncestors()+","+nodeId;
+                        baseMapper.removeAllSonNodeIdsForArchiveAutoRule_1(node.getArchiveAutoType(),ancestors,nodeId);
                     }
                     //删除节点及所有子节点 分类并卷规则
                     if(archiveAutoType==2){
@@ -627,7 +630,8 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                             //删除规则  只能修改archive_auto_group_select=1的节点，
                             // 因为分类并卷规则影响范围包括下面所有子节点，如果给archive_auto_group_select=0的节点也就是范围内的子节点单独取消规则，会造成案卷归属节点错乱。
                             // （不理那么多，就这样限制先 。如业务非要发神经就要 TODO 验证节点的父节点是否为分类并卷规则，如是则取消。若无其他兄弟节点，继续往上验证。）
-                            baseMapper.removeAllSonNodeIdsForArchiveAutoRule_2(node.getArchiveAutoType(),node.getAncestors());
+                            String ancestors = node.getAncestors()+","+nodeId;
+                            baseMapper.removeAllSonNodeIdsForArchiveAutoRule_2(node.getArchiveAutoType(),ancestors,nodeId);
                         }else{
                             returnMap.put("code","0");
                             returnMap.put("msg","只能取消设置的节点，不能取消设置节点范围下节点");
@@ -635,7 +639,8 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                     }
                     //删除节点及所有子节点 单独并卷规则
                     if(archiveAutoType==3){
-                        baseMapper.removeAllSonNodeIdsForArchiveAutoRule_3(node.getArchiveAutoType(),node.getAncestors());
+                        String ancestors = node.getAncestors()+","+nodeId;
+                        baseMapper.removeAllSonNodeIdsForArchiveAutoRule_3(node.getArchiveAutoType(),ancestors,nodeId);
                     }
                 }
             }
@@ -653,10 +658,10 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
      * @return
      */
     @Override
-    public Map<String,Object> getArchiveAutoRule(Long id,boolean iswbsNode) {
+    public Map<String,Object> getArchiveAutoRule(Long id,boolean iswbsNode,Long projectId,Long wbsNode2ArchiveTreeNodeId,String wbsId) {
 
         if(iswbsNode){
-            return getArchiveAutoRule_WbsTreeNode(id);
+            return getArchiveAutoRule_WbsTreeNode(id,projectId,wbsNode2ArchiveTreeNodeId,wbsId);
         }else{
             return getArchiveAutoRule_ArchiveTreeNode(id);
         }
@@ -757,10 +762,137 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
      * @param id
      * @return
      */
-    private Map<String,Object> getArchiveAutoRule_WbsTreeNode(Long id) {
+    private Map<String,Object> getArchiveAutoRule_WbsTreeNode(Long id,Long projectId,Long wbsNode2ArchiveTreeNodeId,String wbsId) {
         Map<String,Object> map= new HashMap<>();
         try{
-            //TODO 需要了解关联的wbs节点
+            ArchiveTree archiveTree = baseMapper.selectById(wbsNode2ArchiveTreeNodeId);
+
+            //步骤1：找出wbs的规则设置
+                ArchiveAutoRuleWbs autoRuleWbs = archiveAutoRuleWbsMapper.selectOne(Wrappers.<ArchiveAutoRuleWbs>lambdaQuery()
+                        .eq(ArchiveAutoRuleWbs::getWbsId, id)
+                        .eq(ArchiveAutoRuleWbs::getIsDeleted, 0)
+                        .eq(ArchiveAutoRuleWbs::getProjectId, projectId));
+
+                if(autoRuleWbs!=null){
+                    Integer archiveAutoType = autoRuleWbs.getArchiveAutoType();
+
+
+                    if(archiveAutoType!=null){
+
+                        //获取wbs关联树
+                        ArchiveTreeVO2 archiveTreeVO2 = getWbsArchiveTree(AuthUtil.getTenantId(),projectId,wbsNode2ArchiveTreeNodeId,wbsId,"1",Long.parseLong(archiveTree.getDisplayHierarchy()));
+                        List<ArchiveTreeVO2> archiveTreeVO2List = new ArrayList<>();
+                        ForestNodeMerger.getTreeListEx(archiveTreeVO2,archiveTreeVO2List);
+                        Map<Long,ArchiveTreeVO2> ArchiveTreeVO2Map = new HashMap<>();
+                        for(ArchiveTreeVO2 vo2:archiveTreeVO2List){
+                            ArchiveTreeVO2Map.put(vo2.getId(),vo2);
+                        }
+
+                        if(archiveAutoType==1){
+                            //最高并卷层级 默认规则的节点 显示最高并卷层级节点
+                            StringBuffer allName= new StringBuffer();
+                            ArchiveTreeVO2 nameVo2 = ArchiveTreeVO2Map.get(id);
+                            while (nameVo2.getParentId()!=0L){
+                                allName.insert(0,nameVo2.getTitle());
+                                allName.insert(0,"/");
+                                Long parentId = nameVo2.getParentId();
+                                nameVo2 = ArchiveTreeVO2Map.get(parentId);
+                            }
+                            //nameVo2.getParentId()==0L时加上名字
+                            allName.insert(0,nameVo2.getTitle());
+
+                            ArchiveTreeAutoRuleVO vo= new ArchiveTreeAutoRuleVO();
+                            vo.setAllName(allName.toString());
+                            vo.setNodeId(id);
+                            vo.setArchiveAutoType(archiveAutoType);
+                            map.put("type",archiveAutoType);
+                            map.put("data",vo);
+                            return map;
+                        }
+                        if(archiveAutoType==2){
+                            Long archiveAutoGroupId = autoRuleWbs.getArchiveAutoGroupId();
+                            //用于分类并卷编辑树
+                            List<ArchiveTreeAutoRuleVO> nodetree = new ArrayList<>();
+
+                            //遍历wbs关联树 生成分类并将编辑树
+                            for(ArchiveTreeVO2 vo2:archiveTreeVO2List){
+                                //查询wbs节点是否有规则设置
+                                ArchiveAutoRuleWbs autoRuleWbs2 = archiveAutoRuleWbsMapper.selectOne(Wrappers.<ArchiveAutoRuleWbs>lambdaQuery()
+                                        .eq(ArchiveAutoRuleWbs::getWbsId, vo2.getId())
+                                        .eq(ArchiveAutoRuleWbs::getIsDeleted, 0)
+                                        .eq(ArchiveAutoRuleWbs::getProjectId, projectId));
+                                if(autoRuleWbs2!=null){
+                                    //如有规则，需过滤单独规则节点，和不同组的分类规则节点
+                                    if(autoRuleWbs2.getArchiveAutoType()!=3){
+
+                                        if(autoRuleWbs2.getArchiveAutoType()==1){
+                                            ArchiveTreeAutoRuleVO vo=new ArchiveTreeAutoRuleVO();
+                                            vo.setNodeId(vo2.getId());
+                                            vo.setParentId(vo2.getParentId());
+                                            vo.setNodeName(vo2.getTitle());
+                                            nodetree.add(vo);
+                                        }
+                                        //如有规则，需过滤不同组的分类规则节点
+                                        if(autoRuleWbs2.getArchiveAutoType()==2 && autoRuleWbs2.getArchiveAutoGroupId().equals(archiveAutoGroupId)){
+                                            ArchiveTreeAutoRuleVO vo=new ArchiveTreeAutoRuleVO();
+                                            vo.setNodeId(vo2.getId());
+                                            vo.setParentId(vo2.getParentId());
+                                            vo.setNodeName(vo2.getTitle());
+                                            nodetree.add(vo);
+                                        }
+                                    }
+                                }else{
+                                    //没有规则的直接加上
+                                    ArchiveTreeAutoRuleVO vo=new ArchiveTreeAutoRuleVO();
+                                    vo.setNodeId(vo2.getId());
+                                    vo.setParentId(vo2.getParentId());
+                                    vo.setNodeName(vo2.getTitle());
+                                    nodetree.add(vo);
+                                }
+                            }
+
+                            List<ArchiveTreeAutoRuleVO> merge = ForestNodeMerger.merge(nodetree);
+                            //获取与当前节点设置同一分类分组的节点
+                            List<ArchiveAutoRuleWbs> archiveAutoRuleWbs = archiveAutoRuleWbsMapper.selectList(Wrappers.<ArchiveAutoRuleWbs>lambdaQuery()
+                                    .eq(ArchiveAutoRuleWbs::getArchiveAutoGroupId,archiveAutoGroupId)
+                                    .eq(ArchiveAutoRuleWbs::getIsDeleted, 0)
+                                    .eq(ArchiveAutoRuleWbs::getProjectId, projectId));
+                            StringBuffer nodeSelect = new StringBuffer();
+
+                            for(ArchiveAutoRuleWbs node:archiveAutoRuleWbs){
+                                nodeSelect.append(node.getWbsId()+",");
+                            }
+
+                            map.put("archiveAutoType",archiveAutoType);
+                            map.put("archiveAutoGroupId",archiveAutoGroupId);
+                            map.put("tree",merge);
+                            map.put("selectNodeIds",nodeSelect.toString());
+                            return map;
+                        }
+                        if(archiveAutoType==3){
+                            StringBuffer allName= new StringBuffer();
+                            ArchiveTreeVO2 nameVo2 = ArchiveTreeVO2Map.get(id);
+                            while (nameVo2.getParentId()!=0L){
+                                allName.insert(0,nameVo2.getTitle());
+                                allName.insert(0,"/");
+                                Long parentId = nameVo2.getParentId();
+                                nameVo2 = ArchiveTreeVO2Map.get(parentId);
+                            }
+                            //nameVo2.getParentId()==0L时加上名字
+                            allName.insert(0,nameVo2.getTitle());
+
+                            ArchiveTreeAutoRuleVO vo= new ArchiveTreeAutoRuleVO();
+                            vo.setAllName(allName.toString());
+                            vo.setNodeId(id);
+                            vo.setArchiveAutoType(archiveAutoType);
+                            map.put("type",archiveAutoType);
+                            map.put("data",vo);
+                            return map;
+                        }
+                    }
+                }
+
+
         }catch (Exception e){
             e.printStackTrace();
             return map;

blade-service/blade-manager/src/main/java/org/springblade/manager/utils/ForestNodeMerger.java

@@ -1,5 +1,6 @@
 package org.springblade.manager.utils;
 
+import org.springblade.common.utils.INodeEx;
 import org.springblade.core.tool.node.ForestNodeManager;
 import org.springblade.core.tool.node.INode;
 
@@ -37,5 +38,20 @@ public class ForestNodeMerger {
         }
     }
 
+    public static <T extends INodeEx<T>> void getTreeListEx(T tree, List<T> nodes){
+        if (tree == null) {
+            return;
+        }
+
+        nodes.add(tree);
+
+        List<T> childrens = tree.getChildren();
+        if (childrens!= null) {
+            for (T child :childrens) {
+                getTreeListEx(child,nodes);
+            }
+        }
+    }
+
 
 }