自动组卷

blade-service-api/blade-archive-api/src/main/java/org/springblade/archive/entity/ArchivesAuto.java

@@ -157,4 +157,6 @@ public class ArchivesAuto extends BaseEntity {
 	 * 立卷单位
 	 * **/
 	private String filingUnit;
+
+	private Integer isLock;  //案卷锁定  0未锁  1已锁定    （已锁定的案卷，自动归档执行不再拆卷重新组卷）
 }

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

@@ -41,4 +41,8 @@ public class ArchiveTreeAutoRuleVO implements INode<ArchiveTreeAutoRuleVO> {
     public List<ArchiveTreeAutoRuleVO> getChildren() {
         return children;
     }
+
+    private boolean iswbsNode;  //是否为关联的wbs节点
+
+    private Long wbsNode2ArchiveTreeNodeId;  //wbs节点关联归档树节点ID
 }

blade-service/blade-archive/src/main/java/org/springblade/archive/mapper/ArchivesAutoMapper.java

@@ -45,4 +45,10 @@ public interface ArchivesAutoMapper extends BaseMapper<ArchivesAuto> {
 	List<ArchivesAuto> selectArchivesAutoFilePage(@Param("current") Integer current, @Param("size") Integer size, @Param("vo")  ArchivesAutoVO vo);
 
 	Integer updateArchivesAutoFileByNodeId(@Param("ids") List<Long> ids,@Param("nodeId") String nodeId,@Param("nodeSort") String nodeSort);
+
+	/**
+	 * 自动归档前 将未锁定的案卷拆卷
+	 * @param projectId
+	 */
+    Integer splitArchvies(@Param("projectId") Long projectId);
 }

blade-service/blade-archive/src/main/java/org/springblade/archive/mapper/ArchivesAutoMapper.xml

@@ -102,4 +102,22 @@
         </foreach>
     </update>
 
+    <update id="splitArchvies" >
+        /**把未锁定案卷的文件关联去掉*/
+        update u_archive_file set archive_id = null where
+            is_deleted=0 and
+            archive_id in(
+                select id u_archives_auto where project_id=#{projectId}
+                  and is_auto_file!=1
+                  and is_deleted=0
+                  and is_lock=0
+            );
+        /**把未锁定案卷去掉*/
+        update u_archives_auto set is_deleted=1 where project_id=#{projectId}
+            and is_auto_file!=1
+            and is_deleted=0
+            and is_lock=0;
+    </update>
+
+
 </mapper>

blade-service/blade-archive/src/main/java/org/springblade/archive/service/IArchivesAutoService.java

@@ -41,4 +41,6 @@ public interface IArchivesAutoService extends BaseService<ArchivesAuto> {
 	IPage<ArchivesAutoVO> selectArchivesAutoFilePage(ArchivesAutoVO queryVo);
 
 	boolean updateArchivesAutoFileByNodeId(String ids, String nodeId,String nodeSort);
+
+	void splitArchvies(Long projectId);
 }

blade-service/blade-archive/src/main/java/org/springblade/archive/service/impl/ArchivesAutoServiceImpl.java

@@ -18,22 +18,26 @@ package org.springblade.archive.service.impl;
 
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import lombok.AllArgsConstructor;
 import org.apache.commons.lang.StringUtils;
 import org.springblade.archive.entity.ArchivesAuto;
 import org.springblade.archive.vo.ArchivesAutoVO;
 import org.springblade.archive.mapper.ArchivesAutoMapper;
 import org.springblade.archive.service.IArchivesAutoService;
+import org.springblade.business.entity.ArchiveFile;
+import org.springblade.business.feign.ArchiveFileClient;
 import org.springblade.core.mp.base.BaseServiceImpl;
 import org.springblade.core.mp.support.Condition;
 import org.springblade.core.mp.support.Query;
 import org.springblade.core.tool.utils.Func;
+import org.springblade.manager.entity.ArchiveTreeContract;
 import org.springblade.system.entity.DictBiz;
 import org.springblade.system.feign.IDictBizClient;
 import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 
-import java.util.List;
+import java.util.*;
 
 /**
  *  服务实现类
@@ -46,6 +50,7 @@ import java.util.List;
 public class ArchivesAutoServiceImpl extends BaseServiceImpl<ArchivesAutoMapper, ArchivesAuto> implements IArchivesAutoService {
 
 	private final IDictBizClient iDictBizClient;
+	private ArchiveFileClient archiveFileClient;
 	@Override
 	public IPage<ArchivesAutoVO> selectArchivesAutoPage(IPage<ArchivesAutoVO> page, ArchivesAutoVO archivesAuto) {
 		return page.setRecords(baseMapper.selectArchivesAutoPage(page, archivesAuto));
@@ -106,4 +111,369 @@ public class ArchivesAutoServiceImpl extends BaseServiceImpl<ArchivesAutoMapper,
 		return true;
 	}
 
+
+	/**
+	 * 自动归档前 将未锁定的案卷拆卷
+	 * @param projectId
+	 */
+	@Override
+	public void splitArchvies(Long projectId){
+		try{
+			baseMapper.splitArchvies(projectId);
+		}catch (Exception e){
+			e.printStackTrace();
+		}
+	}
+
+
+
+	public void archiveAutoMethod(){
+		//步骤一：把项目下未锁定的案卷拆卷。
+		//步骤二：查询归档树节点。存在未归档文件的节点。
+		//步骤三：遍历归档树节点整理出 默认规则节点，分类并卷节点，单独组卷节点 三个集合。
+		//步骤四：按照单独，分类，默认的顺序执行组卷流程。
+	}
+
+
+	/**
+	 * 检查当前案卷的文件集合是否在规格内，能否开始组卷。
+	 * 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(List<ArchiveTreeContract> list){
+		//步骤1：遍历节点集合
+		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 走分盒组卷流程
+						if(archiveFilesSize==archiveFiles.size()){
+							//TODO 最后一个文件直接将waitArchiveFiles组卷
+						}
+					}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){
+							//如果waitArchiveFiles集合size>0,先将集合中文件组卷。再将当前文件放入集合
+							if(waitArchiveFiles.size()>0){
+								//TODO 将waitArchiveFiles组卷，然后将待组卷文件集合，总页数还原初始值，
+								waitArchiveFiles.clear();
+								//保存当前文件进入待组卷集合，待组卷页数=当前文件页数
+								waitArchiveFiles.add(file);
+								archivesSize=filePage;
+
+								//判断是否最后一个文件
+								if(archiveFilesSize==archiveFiles.size()){
+									//TODO 如果当前文件最后一个文件直接将waitArchiveFiles组卷
+									waitArchiveFiles.clear();
+									archivesSize=0;
+								}
+							}else{
+								//步骤6.3.2如果waitArchiveFiles集合size=0,说明当前文件已经超过规格，直接将当前文件组卷
+								waitArchiveFiles.add(file);
+								//TODO 直接将waitArchiveFiles组卷
+								waitArchiveFiles.clear();
+								archivesSize=0;
+							}
+						}
+					}
+				}
+			}
+
+		}
+
+
+
+
+
+	}
+
+	/**
+	 * 分类并卷组卷  设置分类的节点下只有一个案卷，节点下的所有文件都组成这个案卷。如果设置分类节点（select=1的）多个，案卷归属排序第一个节点。
+	 */
+	private void archiveAutoMethod2(List<ArchiveTreeContract> list){
+
+		//分类并卷集合<groupId,List<文件>>
+		Map<Long,List<ArchiveFile>> archiveMap = new HashMap<>();
+		//记录同个分组id的第一个节点ID 案卷归属于这个节点
+		Map<Long,Long> groupId2NodeIdMap = new HashMap<>();
+
+		//步骤1：遍历节点集合
+		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){
+						//TODO 走分盒流程
+					}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);
+							groupId2NodeIdMap.put(archiveAutoGroupId,node.getId());
+						}
+					}
+				}
+			}
+		}
+		//步骤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的第一个groupId2NodeIdMap
+
+		}
+
+	}
+
+	/**
+	 * 默认组卷流程 文件可以跨节点组卷，受最高并卷节点限制范围，跨节点文件组卷时，案卷规格按照第一个文件所在的节点规格 组卷。
+	 */
+	private void archiveAutoMethod1(List<ArchiveTreeContract> list){
+		//最高并卷节点
+		Long archiveAutoNodeId=null;
+
+		//当前待组卷规格大小
+		int specificationSize=0;
+		//待组卷文件总页数
+		int archivesSize=0;
+		//待组卷文件集合
+		List<ArchiveFile> waitArchiveFiles = new ArrayList<>();
+
+		//步骤1：遍历节点集合
+		int nodeSize=0;
+		for(ArchiveTreeContract node:list){
+			nodeSize++;
+			if(archiveAutoNodeId==null){
+				archiveAutoNodeId=node.getArchiveAutoNodeId();
+			}
+			//当前节点的的archiveAutoNodeId
+			Long archiveAutoNodeId_current = node.getArchiveAutoNodeId();
+
+
+			//步骤2：判断当前节点是否超出最高节点
+			if(!archiveAutoNodeId.equals(archiveAutoNodeId_current)) {
+				//超过最高并卷节点(节点是排序好的，只要不相等就超过了)
+				if(waitArchiveFiles.size()>0){
+					//TODO 将待组卷集合里的文件组卷
+				}
+				waitArchiveFiles.clear();
+				archivesSize=0;
+				archiveAutoNodeId=node.getArchiveAutoNodeId();//更新当前最高并卷节点
+			}
+
+			//步骤3.1：获取节点规格
+			if(waitArchiveFiles.size()==0){
+				//waitArchiveFiles待组卷文件为空时，按当前节点的规格
+				specificationSize=300;//TODO
+			}
+
+			//步骤3.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.3：遍历未组卷文件
+			int archiveFilesSize=0;
+			for(ArchiveFile file:archiveFiles){
+				archiveFilesSize++;
+				//步骤3.4：判断文件是否存在分盒设置
+				if(file.getBoxNumber()!=null) {
+					//TODO 走分盒组卷流程
+					if(nodeSize==list.size() && archiveFilesSize==archiveFiles.size()){
+						//TODO 如果当前是最后一个文件直接将waitArchiveFiles组卷
+					}
+				}else{
+					//步骤3.5 计算和判断待组卷文件集合是否达到组卷要求，达到要求创建案卷，案卷归属当前节点，案卷下文件改为已组卷
+					Integer filePage = file.getFilePage();
+					archivesSize=archivesSize+filePage;
+					Integer checkStatus = checkSpecificationSize(specificationSize, archivesSize);
+					//步骤3.6未到规格 不组卷
+					if(checkStatus==0){
+						waitArchiveFiles.add(file);
+						//判断是否最后一个节点，最后一个文件
+						if(nodeSize==list.size() && archiveFilesSize==archiveFiles.size()){
+							//TODO 直接将waitArchiveFiles待组卷集合组卷，归属集合第一个文件所在节点
+							//将待组卷文件集合，总页数还原初始值，
+							waitArchiveFiles.clear();
+							archivesSize=0;
+						}else{
+							continue;
+						}
+					}
+					//步骤3.7达到规格 可以组一卷
+					if(checkStatus==1){
+						waitArchiveFiles.add(file);
+						//TODO 将waitArchiveFiles待组卷集合组卷，归属集合第一个文件所在节点
+						//将待组卷文件集合，总页数还原初始值，
+						waitArchiveFiles.clear();
+						archivesSize=0;
+						specificationSize=300;//TODO 更新specificationSize待组卷规格为 当前节点的组卷规格
+					}
+					//步骤3.8超出规格
+					if(checkStatus==-1){
+						//步骤3.9如果waitArchiveFiles集合size>0,先将集合中文件组卷。再将当前文件加入集合
+						if(waitArchiveFiles.size()>0){
+							//3.9.1 TODO 将waitArchiveFiles组卷，归属集合第一个文件所在节点
+							//将待组卷文件集合，总页数还原初始值，
+							waitArchiveFiles.clear();
+							//3.9.2保存当前文件进入待组卷集合，
+							waitArchiveFiles.add(file);
+							//3.9.3待组卷页数=当前文件页数
+							archivesSize=filePage;
+							specificationSize=300;//TODO 更新specificationSize待组卷规格为 当前节点的组卷规格
+							//3.9.4 判断当前文件是不是最后一个节点，最后一个文件
+							if(nodeSize==list.size() && archiveFilesSize==archiveFiles.size()){
+								//TODO 最后一个文件再将waitArchiveFiles组卷
+							}
+						}else{
+							//步骤3.10 如果waitArchiveFiles集合size=0,说明当前文件已经超过规格，直接将当前文件组卷
+							waitArchiveFiles.add(file);
+							//TODO 直接将waitArchiveFiles组卷
+							waitArchiveFiles.clear();
+							archivesSize=0;
+							specificationSize=300;//TODO 更新specificationSize待组卷规格为 当前节点的组卷规格
+						}
+					}
+
+				}
+			}
+
+		}
+
+	}
+
+
 }

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

@@ -22,7 +22,10 @@ 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.ArchiveTree;
 import org.springblade.manager.entity.ArchiveTreeContract;
+import org.springblade.manager.entity.WbsTreePrivate;
+import org.springblade.manager.mapper.ArchiveTreeContractMapper;
 import org.springblade.manager.vo.ArchiveAutoRuleWbsVO;
 import org.springblade.manager.mapper.ArchiveAutoRuleWbsMapper;
 import org.springblade.manager.service.IArchiveAutoRuleWbsService;
@@ -43,259 +46,12 @@ public class ArchiveAutoRuleWbsServiceImpl extends BaseServiceImpl<ArchiveAutoRu
 
 	private ArchiveFileClient archiveFileClient;
 
+	private ArchiveTreeContractMapper archiveTreeContractMapper;
+
 	@Override
 	public IPage<ArchiveAutoRuleWbsVO> selectArchiveAutoRuleWbsPage(IPage<ArchiveAutoRuleWbsVO> page, ArchiveAutoRuleWbsVO archiveAutoRuleWbs) {
 		return page.setRecords(baseMapper.selectArchiveAutoRuleWbsPage(page, archiveAutoRuleWbs));
 	}
 
-	public void archiveAutoMethod(){
-		//步骤一：把项目下未锁定的案卷拆卷。
-		//步骤二：查询归档树节点。存在未归档文件的节点。
-		//步骤三：遍历归档树节点整理出 默认规则节点，分类并卷节点，单独组卷节点 三个集合。
-		//步骤四：按照单独，分类，默认的顺序执行组卷流程。
-	}
-
-
-	/**
-	 * 检查当前案卷的文件集合是否在规格内，能否开始组卷。
-	 * 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(List<ArchiveTreeContract> list){
-		//步骤1：遍历节点集合
-		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(List<ArchiveTreeContract> list){
-
-		//分类并卷集合<groupId,List<文件>>
-		Map<Long,List<ArchiveFile>> archiveMap = new HashMap<>();
-
-		//步骤1：遍历节点集合
-		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的第一个
-		}
-
-	}
-
-	/**
-	 * 默认组卷流程 文件可以跨节点组卷，受最高并卷节点限制范围，跨节点文件组卷时，案卷规格按照第一个文件所在的节点规格 组卷。
-	 */
-	private void archiveAutoMethod1(){
-		//步骤1：遍历节点集合
-		//步骤2：保存当前节点的最高并卷节点archiveAutoNodeId到变量A，用来限制向上级跨节点组卷。
-		//步骤3：判断变量A是否与当前节点archiveAutoNodeId相同，不同的话（相当于当前节点已跳出最高并卷节点）直接将内存中文件集合List中的文件组卷（这些是属于上一个最高并卷节点的文件），并清空list文件集合
-		//步骤4：获取当前节点的组卷规格
-		//步骤5：查询节点下的未归档文件
-		//步骤6：遍历未归档文件
-		//步骤7：判断文件是否存在分盒设置-》走分盒组卷流程
-		//步骤8：计算和判断文件集合list里是否达到组卷规格，达到创建案卷 并清空集合list。 跨节点文件组卷，案卷归属于当前list中第一个文件所在节点
-	}
 
 }

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

@@ -710,7 +710,7 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                     String nodeAncestors = ancestorssplit[0]+","+ancestorssplit[1]+","+ancestorssplit[2]; //大类的ancestors
                     Long bigNodeID =Long.parseLong(ancestorssplit[2]); //大类节点ID
                     //获取大类下所有节点,过滤单独规则，其他分类并卷规则组节点
-                    List<ArchiveTreeAutoRuleVO> nodetree = ForestNodeMerger.merge(baseMapper.getAllSonNodeforGroupView(nodeAncestors, archiveTree.getArchiveAutoNodeId(),bigNodeID));
+                    List<ArchiveTreeAutoRuleVO> nodetree = ForestNodeMerger.merge(baseMapper.getAllSonNodeforGroupView(nodeAncestors, archiveTree.getArchiveAutoGroupId(),bigNodeID));
                     //获取与当前节点设置同一分类分组的节点
                     List<ArchiveTree> listGroup= baseMapper.selectList(Wrappers.<ArchiveTree>lambdaQuery()
                             .eq(ArchiveTree::getArchiveAutoGroupId, archiveTree.getArchiveAutoGroupId())
@@ -830,6 +830,8 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                                             vo.setNodeId(vo2.getId());
                                             vo.setParentId(vo2.getParentId());
                                             vo.setNodeName(vo2.getTitle());
+                                            vo.setIswbsNode(true);
+                                            vo.setWbsNode2ArchiveTreeNodeId(wbsNode2ArchiveTreeNodeId);
                                             nodetree.add(vo);
                                         }
                                         //如有规则，需过滤不同组的分类规则节点
@@ -838,6 +840,8 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                                             vo.setNodeId(vo2.getId());
                                             vo.setParentId(vo2.getParentId());
                                             vo.setNodeName(vo2.getTitle());
+                                            vo.setIswbsNode(true);
+                                            vo.setWbsNode2ArchiveTreeNodeId(wbsNode2ArchiveTreeNodeId);
                                             nodetree.add(vo);
                                         }
                                     }
@@ -847,6 +851,8 @@ public class ArchiveTreeServiceImpl extends BaseServiceImpl<ArchiveTreeMapper, A
                                     vo.setNodeId(vo2.getId());
                                     vo.setParentId(vo2.getParentId());
                                     vo.setNodeName(vo2.getTitle());
+                                    vo.setIswbsNode(true);
+                                    vo.setWbsNode2ArchiveTreeNodeId(wbsNode2ArchiveTreeNodeId);
                                     nodetree.add(vo);
                                 }
                             }