From 77eff86ec113e5dc86c9e1433e52bd8a67865340 Mon Sep 17 00:00:00 2001
From: lyh <925863403@qq.com>
Date: 星期四, 12 六月 2025 11:46:44 +0800
Subject: [PATCH] 添加对应节点id

---
 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java | 1101 ++++++++++++++++++++++++++++++++++++++++++---------------
 1 files changed, 806 insertions(+), 295 deletions(-)

diff --git a/lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java b/lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java
index 0e8b19d..f1c9ad0 100644
--- a/lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java
+++ b/lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java
@@ -1,31 +1,37 @@
 package org.jeecg.modules.dnc.service.impl;
 
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.util.StrUtil;
-import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.shiro.SecurityUtils;
+import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.system.vo.LoginUser;
+import org.jeecg.modules.dnc.constant.DocAttributionTypeEnum;
 import org.jeecg.modules.dnc.dto.ComponentExt;
+import org.jeecg.modules.dnc.entity.*;
 import org.jeecg.modules.dnc.exception.ExceptionCast;
 import org.jeecg.modules.dnc.mapper.ProductInfoMapper;
+import org.jeecg.modules.dnc.request.DocInfoQueryRequest;
+import org.jeecg.modules.dnc.request.TreeInfoRequest;
 import org.jeecg.modules.dnc.response.*;
 import org.jeecg.modules.dnc.service.*;
 import org.jeecg.modules.dnc.service.support.ProductTreeWrapper;
 import org.jeecg.modules.dnc.ucenter.UserDepartExt;
 import org.jeecg.modules.dnc.utils.ValidateUtil;
-import org.jeecg.modules.dnc.entity.*;
 import org.jeecg.modules.system.entity.MdcProduction;
 import org.jeecg.modules.system.entity.SysUser;
 import org.jeecg.modules.system.service.IMdcProductionService;
 import org.jeecg.modules.system.service.ISysUserService;
-import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -39,11 +45,13 @@
     @Lazy
     private IPartsInfoService partsInfoService;
     @Autowired
+    private IProcessSpecVersionService processSpecVersionService;
+    @Autowired
     private IProductPermissionService productPermissionService;
     @Autowired
     private IProductDepartmentService productDepartmentService;
     @Autowired
-    private IPermissionStreamService permissionStreamService;
+    private IPermissionStreamNewService permissionStreamNewService;
     @Autowired
     private IComponentDepartmentService componentDepartmentService;
     @Autowired
@@ -52,6 +60,10 @@
     private IPartsDepartmentService partsDepartmentService;
     @Autowired
     private IPartsPermissionService partsPermissionService;
+    @Autowired
+    private IProcessSpecVersionPermissionService processSpecVersionPermissionService;
+    @Autowired
+    private IProcessSpecVersionDepartmentService processSpecVersionDepartmentService;
     @Autowired
     private ISysUserService userService;
     @Autowired
@@ -71,6 +83,15 @@
     private IProcessStreamPermissionService iProcessStreamPermissionService;
     @Autowired
     private IWorkStepPermissionService iWorkStepPermissionService;
+    @Autowired
+    private IProductMixService productMixService;
+    @Autowired
+    @Lazy
+    private IDocInfoService docInfoService;
+    @Autowired
+    private IDeviceTypeService deviceTypeService;
+    @Autowired
+    private IDeviceManagementService deviceManagementService;
 
     @Override
     @Transactional(rollbackFor = {Exception.class})
@@ -98,10 +119,32 @@
         if (!b) {
             ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
         }
-        PermissionStream stream = new PermissionStream();
-        stream.setProductId(productInfo.getProductId());
+        //娣诲姞缁撴瀯鏍�
+        ProductMix productMix = new ProductMix(Long.parseLong(productInfo.getProductId()),0L,
+                productInfo.getProductName(),productInfo.getProductNo(),1,new Date());
+        productMixService.save(productMix);
+        //娣诲姞鐢ㄦ埛閮ㄩ棬
+        if(StrUtil.isNotBlank(user.getProductionIds())){
+            String[] split = user.getProductionIds().split(",");
+            String[] departIds = split;
+            for (String departId : departIds) {
+                ProductDepartment productDepartment = new ProductDepartment();
+                productDepartment.setProductId(productInfo.getProductId());
+                productDepartment.setDepartId(departId);
+                productDepartmentService.save(productDepartment);
+                PermissionStreamNew stream = new PermissionStreamNew();
+                stream.setBusinessId(productInfo.getProductId());
+                stream.setDepartId(departId);
+                stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
+                permissionStreamNewService.save(stream);
+            }
+        }
+        //娣诲姞鐢ㄦ埛鏉冮檺
+        PermissionStreamNew stream = new PermissionStreamNew();
+        stream.setBusinessId(productInfo.getProductId());
         stream.setUserId(userId);
-        return permissionStreamService.save(stream);
+        stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
+        return permissionStreamNewService.addPermissionStreamNew(stream);
     }
 
     @Override
@@ -119,6 +162,11 @@
         productInfo.setProductId(id);
         productInfo.setProductStatus(null);
         boolean b = super.updateById(productInfo);
+        //鍚屾淇敼缁撴瀯鏍�
+        ProductMix productMix = productMixService.getById(Long.parseLong(id));
+        productMix.setName(productInfo.getProductName());
+        productMix.setCode(productInfo.getProductNo());
+        productMixService.updateById(productMix);
         if (!b)
             return false;
         ProductPermission permission = productPermissionService.getByProductIdAndUserId(id, userId);
@@ -131,12 +179,13 @@
                 return false;
             }
         }
-        PermissionStream stream = permissionStreamService.getByProductIdAndUserId(id, userId);
+        PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(id, userId, DocAttributionTypeEnum.PRODUCT.getCode().toString());
         if (stream == null) {
-            stream = new PermissionStream();
-            stream.setProductId(id);
+            stream = new PermissionStreamNew();
+            stream.setBusinessId(productInfo.getProductId());
             stream.setUserId(userId);
-            return permissionStreamService.save(stream);
+            stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
+            return permissionStreamNewService.save(stream);
         }
         return b;
     }
@@ -155,6 +204,10 @@
         List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId);
         if (partsInfos == null)
             partsInfos = Collections.emptyList();
+        //宸ヨ壓瑙勭▼鐗堟湰
+        List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByUserPerms(userId);
+        if (processSpecVersions == null)
+            processSpecVersions = Collections.emptyList();
         //宸ュ簭
         List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId);
         if (processStreams == null)
@@ -163,7 +216,7 @@
         List<WorkStep> workStepList = workStepService.getByUserPerms(userId);
         if (workStepList == null)
             workStepList = Collections.emptyList();
-        return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos, processStreams, workStepList);
+        return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos, processSpecVersions,processStreams, workStepList);
     }
 
     @Override
@@ -210,7 +263,7 @@
             ExceptionCast.cast(ProductInfoCode.PRODUCT_PROCESS_EXIST);
         boolean b = productPermissionService.deleteByProductId(id);
         //楠岃瘉鏄惁瀛樺湪鏂囨。
-        List<DocRelative> docRelativeList = iDocRelativeService.list(new QueryWrapper<DocRelative>().eq("attribution_type", "1").eq("attribution_id", id));
+        List<DocRelative> docRelativeList = iDocRelativeService.list(new QueryWrapper<DocRelative>().eq("attribution_type", DocAttributionTypeEnum.PRODUCT.getCode() ).eq("attribution_id", id));
         if (!docRelativeList.isEmpty()) {
             ExceptionCast.cast(ProductInfoCode.PRODUCT_DOC_EXIST);
         }
@@ -219,10 +272,13 @@
         b = productDepartmentService.deleteByProductId(id);
         if (!b)
             ExceptionCast.cast(CommonCode.FAIL);
-        b = permissionStreamService.deleteUserPermsByProductId(id);
+        b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, DocAttributionTypeEnum.PRODUCT.getCode().toString(),"0");
         if (!b)
             ExceptionCast.cast(CommonCode.FAIL);
-        b = permissionStreamService.deleteDepartPermsByProductId(id);
+        b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, DocAttributionTypeEnum.PRODUCT.getCode().toString(),"1");
+        if (!b)
+            ExceptionCast.cast(CommonCode.FAIL);
+        b = productMixService.removeById(id);
         if (!b)
             ExceptionCast.cast(CommonCode.FAIL);
         return super.removeById(id);
@@ -236,37 +292,41 @@
         String userId = user.getId();
         if (!ValidateUtil.validateString(userId))
             ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
-        if (nodeType == 1) {
+        if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
             ProductInfo productInfo = super.getById(paramId);
             if (productInfo == null)
                 ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
-            PermissionStream permission = permissionStreamService.getByProductIdAndUserId(paramId, userId);
+            PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(paramId, userId,"1");
             return permission != null;
-        } else if (nodeType == 2) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())) {
             ComponentInfo componentInfo = componentInfoService.getById(paramId);
             if (componentInfo == null)
                 ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
-            PermissionStream permission = permissionStreamService.getByComponentIdAndUserId(componentInfo.getProductId(), paramId, userId);
+            PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(componentInfo.getComponentId(), userId,"2");
             return permission != null;
-        } else if (nodeType == 3) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
             PartsInfo partsInfo = partsInfoService.getById(paramId);
             if (partsInfo == null)
                 ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
-            PermissionStream permission = permissionStreamService.getByPartsIdAndUserId(partsInfo.getProductId(), partsInfo.getComponentId(), paramId, userId);
+            PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(partsInfo.getPartsId(), userId, "3");
             return permission != null;
-        } else if (nodeType == 5) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
+            ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
+            if (processSpecVersion == null)
+                ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
+            PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processSpecVersion.getId(),userId,"4");
+            return permission != null;
+        } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
             ProcessStream processStream = processStreamService.getById(paramId);
             if (processStream == null)
                 ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
-            PermissionStream permission = permissionStreamService.getByProcessIdAndUserId(processStream.getProductId(), processStream.getComponentId()
-                    , processStream.getPartsId(), processStream.getProcessId(), userId);
+            PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processStream.getProcessId(), userId,"5");
             return permission != null;
-        } else if (nodeType == 6) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
             WorkStep workStep = workStepService.getById(paramId);
             if (workStep == null)
                 ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
-            PermissionStream permission = permissionStreamService.getByStepIdAndUserId(workStep.getProductId(), workStep.getComponentId()
-                    , workStep.getPartsId(), workStep.getProcessId(), workStep.getId(), userId);
+            PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(workStep.getId(), userId,"6");
             return permission != null;
         }
         return false;
@@ -276,15 +336,17 @@
     public List<UserDepartExt> getUserPermsList(Integer nodeType, String paramId) {
         if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
             return null;
-        if (nodeType == 1) {
+        if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
             return productPermissionService.getUserPermsByProductId(paramId);
-        } else if (nodeType == 2) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())) {
             return componentPermissionService.getUserPermsByComponentId(paramId);
-        } else if (nodeType == 3) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
             return partsPermissionService.getUserPermsByProductId(paramId);
-        } else if (nodeType == 5) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
+            return processSpecVersionPermissionService.getUserPermsByProductId(paramId);
+        } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
             return iProcessStreamPermissionService.getUserPermsByProductId(paramId);
-        } else if (nodeType == 6) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
             return iWorkStepPermissionService.getUserPermsByProductId(paramId);
         } else {
             return null;
@@ -295,15 +357,17 @@
     public List<SysUser> getUserNonPermsList(Integer nodeType, String paramId) {
         if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
             return null;
-        if (nodeType == 1) {
+        if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
             return productPermissionService.getUserNonPermsByProductId(paramId);
-        } else if (nodeType == 2) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){
             return componentPermissionService.getUserNonPermsByComponentId(paramId);
-        } else if (nodeType == 3) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
             return partsPermissionService.getUserNonPermsByProductId(paramId);
-        } else if (nodeType == 5) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
+            return processSpecVersionPermissionService.getUserNonPermsByProductId(paramId);
+        } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
             return iProcessStreamPermissionService.getUserNonPermsByProductId(paramId);
-        } else if (nodeType == 6) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
             return iWorkStepPermissionService.getUserNonPermsByProductId(paramId);
         } else {
             return null;
@@ -314,18 +378,19 @@
     public List<MdcProduction> getDepartPermsList(Integer nodeType, String paramId) {
         if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
             return null;
-        if (nodeType == 1) {
+        if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
             return productDepartmentService.getDepartPermsByProductId(paramId);
-        } else if (nodeType == 2) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){
             return componentDepartmentService.getDepartPermsByComponentId(paramId);
-        } else if (nodeType == 3) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
             return partsDepartmentService.getDepartPermsByPartsId(paramId);
-        } else if (nodeType == 5) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
+            return processSpecVersionDepartmentService.getDepartPermsByPsvId(paramId);
+        } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
             return processionDepartmentService.getDepartPermsByProcessId(paramId);
-        } else if (nodeType == 6) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
             return workStepDepartmentService.getDepartPermsByStepId(paramId);
         }
-        //todo 灏佽鏍戠姸缁撴瀯
         else {
             return null;
         }
@@ -335,15 +400,17 @@
     public List<MdcProduction> getDepartNonPermsList(Integer nodeType, String paramId) {
         if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
             return null;
-        if (nodeType == 1) {
+        if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
             return productDepartmentService.getDepartNonPermsByProductId(paramId);
-        } else if (nodeType == 2) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){
             return componentDepartmentService.getDepartNonPermsByComponentId(paramId);
-        } else if (nodeType == 3) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
             return partsDepartmentService.getDepartNonPermsByProductId(paramId);
-        } else if (nodeType == 5) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
             return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
-        } else if (nodeType == 6) {
+        } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
+            return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
+        } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
             return workStepDepartmentService.getDepartNonPermsByStepId(paramId);
         } else {
             return null;
@@ -355,6 +422,7 @@
      * @param paramId      浜у搧鏍戣妭鐐筰d
      * @param relativeFlag 1 鏄� 2 鍚�
      * @param userIds      娣诲姞鐢ㄦ埛ids
+     * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛�
      * @return
      */
     @Override
@@ -367,16 +435,19 @@
         Collection<SysUser> userList = userService.listByIds(ids);
         validateSysUserList(userList, ids);
         switch (nodeType) {
-            case 6:
-                return handleWorkStep(paramId, null,userList);
-            case 5:
-                return handleProcessStream(paramId, relativeFlag, null,userList);
-            case 3:
-                return handlePartsInfo(paramId, relativeFlag, null,userList);
             case 1:
                 return handleProductInfo(paramId, relativeFlag, null,userList);
             case 2:
                 return handleComponentInfo(paramId, relativeFlag, null,userList);
+            case 3:
+                return handlePartsInfo(paramId, relativeFlag, null,userList);
+            case 4:
+                return handleProcessSpecVersion(paramId, relativeFlag, null,userList);
+            case 5:
+                return handleProcessStream(paramId, relativeFlag, null,userList);
+            case 6:
+                return handleWorkStep(paramId, null,userList);
+
             default:
                 return false;
         }
@@ -387,6 +458,7 @@
      * @param paramId       浜у搧鏍戣妭鐐筰d
      * @param relativeFlag  1 鏄� 2 鍚�
      * @param departmentIds 娣诲姞閮ㄩ棬ids
+     * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛�
      * @return
      */
     @Override
@@ -395,19 +467,23 @@
         validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds);
         List<String> ids = new ArrayList<>(departmentIds.length);
         Collections.addAll(ids, departmentIds);
-        Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(ids);
-        validateMdcProductionList(mdcProductionList, ids);
+        List<String> deps=mdcProductionService.findAllProductionIds(ids);
+        Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(deps);
+        validateMdcProductionList(mdcProductionList, deps);
         switch (nodeType) {
-            case 6:
-                return handleWorkStep(paramId, mdcProductionList,null);
-            case 5:
-                return handleProcessStream(paramId, relativeFlag, mdcProductionList,null);
-            case 3:
-                return handlePartsInfo(paramId, relativeFlag, mdcProductionList,null);
             case 1:
                 return handleProductInfo(paramId, relativeFlag, mdcProductionList,null);
             case 2:
                 return handleComponentInfo(paramId, relativeFlag, mdcProductionList,null);
+            case 3:
+                return handlePartsInfo(paramId, relativeFlag, mdcProductionList,null);
+            case 4:
+                return handleProcessSpecVersion(paramId, relativeFlag, mdcProductionList,null);
+            case 5:
+                return handleProcessStream(paramId, relativeFlag, mdcProductionList,null);
+            case 6:
+                return handleWorkStep(paramId, mdcProductionList,null);
+
             default:
                 return false;
         }
@@ -418,6 +494,7 @@
      * @param paramId      浜у搧鏍戣妭鐐筰d
      * @param relativeFlag 1 鏄� 2 鍚�
      * @param userIds      绉婚櫎鐢ㄦ埛ids
+     * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛�
      * @return
      */
     @Override
@@ -428,16 +505,18 @@
         Collection<SysUser> userList = userService.listByIds(userIdsList);
         validateSysUserList(userList, userIdsList);
         switch (nodeType) {
-            case 6:
-                return handleWorkStepRemoval(paramId, userList,null);
-            case 5:
-                return handleProcessStreamRemoval(paramId, relativeFlag, userList,null);
-            case 3:
-                return handlePartsInfoRemoval(paramId, relativeFlag, userList,null);
             case 1:
                 return handleProductInfoRemoval(paramId, relativeFlag, userList,null);
             case 2:
                 return handleComponentInfoRemoval(paramId, relativeFlag, userList,null);
+            case 3:
+                return handlePartsInfoRemoval(paramId, relativeFlag, userList,null);
+            case 4:
+                return handleProcessSpecVersionRemoval(paramId, relativeFlag, userList,null);
+            case 5:
+                return handleProcessStreamRemoval(paramId, relativeFlag, userList,null);
+            case 6:
+                return handleWorkStepRemoval(paramId, userList,null);
             default:
                 return false;
         }
@@ -450,26 +529,31 @@
      * @param paramId       浜у搧鏍戣妭鐐筰d
      * @param relativeFlag  1 鏄� 2 鍚�
      * @param departmentIds 绉婚櫎閮ㄩ棬ids
+     * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛�
      * @return
      */
     @Override
     @Transactional(rollbackFor = {Exception.class})
     public boolean assignRemoveDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
         validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds);
-        List<String> departmentIdList = Arrays.asList(departmentIds);
-        Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(departmentIdList);
-        validateMdcProductionList(mdcProductionList, departmentIdList);
+        List<String> ids = new ArrayList<>(departmentIds.length);
+        Collections.addAll(ids, departmentIds);
+        List<String> deps=mdcProductionService.findAllProductionIds(ids);
+        Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(deps);
+        validateMdcProductionList(mdcProductionList, deps);
         switch (nodeType) {
-            case 6:
-                return handleWorkStepRemoval(paramId,null,mdcProductionList);
-            case 5:
-                return handleProcessStreamRemoval(paramId, relativeFlag, null,mdcProductionList);
-            case 3:
-                return handlePartsInfoRemoval(paramId, relativeFlag,null, mdcProductionList);
             case 1:
                 return handleProductInfoRemoval(paramId, relativeFlag,null, mdcProductionList);
             case 2:
                 return handleComponentInfoRemoval(paramId, relativeFlag, null,mdcProductionList);
+            case 3:
+                return handlePartsInfoRemoval(paramId, relativeFlag,null, mdcProductionList);
+            case 4:
+                return handleProcessSpecVersionRemoval(paramId, relativeFlag, null,mdcProductionList);
+            case 5:
+                return handleProcessStreamRemoval(paramId, relativeFlag, null,mdcProductionList);
+            case 6:
+                return handleWorkStepRemoval(paramId,null,mdcProductionList);
             default:
                 return false;
         }
@@ -481,7 +565,7 @@
         if (productInfo == null || userList == null || userList.isEmpty())
             ExceptionCast.cast(CommonCode.INVALID_PARAM);
         List<ProductPermission> permissionList = new ArrayList<>();
-        List<PermissionStream> permissionStreamList = new ArrayList<>();
+        List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
         userList.forEach(item -> {
             ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
             if (en == null) {
@@ -490,11 +574,12 @@
                 en.setProductId(productInfo.getProductId());
                 permissionList.add(en);
             }
-            PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
+            PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(productInfo.getProductId(), item.getId(),"1");
             if (stream == null) {
-                stream = new PermissionStream();
+                stream = new PermissionStreamNew();
                 stream.setUserId(item.getId());
-                stream.setProductId(productInfo.getProductId());
+                stream.setBusinessId(productInfo.getProductId());
+                stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
                 permissionStreamList.add(stream);
             }
         });
@@ -505,7 +590,7 @@
             }
         }
         if (!permissionStreamList.isEmpty()) {
-            boolean b = permissionStreamService.saveBatch(permissionStreamList);
+            boolean b =permissionStreamNewService.saveBatch(permissionStreamList);
             if (!b) {
                 ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
             }
@@ -519,13 +604,13 @@
         if (productInfo == null || userList == null || userList.isEmpty())
             ExceptionCast.cast(CommonCode.INVALID_PARAM);
         List<ProductPermission> permissionList = new ArrayList<>();
-        List<PermissionStream> permissionStreamList = new ArrayList<>();
+        List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
         userList.forEach(item -> {
             ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
             if (en != null) {
                 permissionList.add(en);
             }
-            PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
+            PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(productInfo.getProductId(), item.getId(),"1");
             if (stream != null) {
                 permissionStreamList.add(stream);
             }
@@ -541,7 +626,7 @@
             }
         }
         if (!permissionStreamList.isEmpty()) {
-            boolean b = permissionStreamService.removeByCollection(permissionStreamList);
+            boolean b = permissionStreamNewService.deletePermissionStreamNewByList(permissionStreamList);
             if (!b) {
                 ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
             }
@@ -555,7 +640,7 @@
         if (productInfo == null || departmentList == null || departmentList.isEmpty())
             ExceptionCast.cast(CommonCode.INVALID_PARAM);
         List<ProductDepartment> productDepartmentList = new ArrayList<>();
-        List<PermissionStream> permissionStreamList = new ArrayList<>();
+        List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
         departmentList.forEach(item -> {
             ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
             if (en == null) {
@@ -564,11 +649,12 @@
                 en.setProductId(productInfo.getProductId());
                 productDepartmentList.add(en);
             }
-            PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
+            PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1");
             if (stream == null) {
-                stream = new PermissionStream();
+                stream = new PermissionStreamNew();
                 stream.setDepartId(item.getId());
-                stream.setProductId(productInfo.getProductId());
+                stream.setBusinessId(productInfo.getProductId());
+                stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
                 permissionStreamList.add(stream);
             }
         });
@@ -579,7 +665,7 @@
             }
         }
         if (!permissionStreamList.isEmpty()) {
-            boolean b = permissionStreamService.saveBatch(permissionStreamList);
+            boolean b = permissionStreamNewService.saveBatch(permissionStreamList);
             if (!b) {
                 ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
             }
@@ -593,13 +679,13 @@
         if (productInfo == null || departmentList == null || departmentList.isEmpty())
             ExceptionCast.cast(CommonCode.INVALID_PARAM);
         List<ProductDepartment> productDepartmentList = new ArrayList<>();
-        List<PermissionStream> permissionStreamList = new ArrayList<>();
+        List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
         departmentList.forEach(item -> {
             ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
             if (en != null) {
                 productDepartmentList.add(en);
             }
-            PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
+            PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1");
             if (stream != null) {
                 permissionStreamList.add(stream);
             }
@@ -611,7 +697,7 @@
             }
         }
         if (!permissionStreamList.isEmpty()) {
-            boolean b = permissionStreamService.removeByCollection(permissionStreamList);
+            boolean b = permissionStreamNewService.deletePermissionStreamNewByList(permissionStreamList);
             if (!b) {
                 ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
             }
@@ -623,31 +709,22 @@
     public List<String> getDepartIdsByParams(Integer nodeType, String paramId) {
         List<String> departIds = new ArrayList<>();
         //5-宸ュ簭
-        if (nodeType == 5) {
+        if (Objects.equals(nodeType, DocAttributionTypeEnum.PROCESS.getCode())) {
             ProcessStream processStream = processStreamService.getById(paramId);
             if (processStream == null)
                 return null;
-            List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
-                    .eq(StrUtil.isNotEmpty(processStream.getProductId()), "product_id", processStream.getProductId())
-                    .eq(StrUtil.isNotEmpty(processStream.getComponentId()), "component_id", processStream.getComponentId())
-                    .eq(StrUtil.isNotEmpty(processStream.getPartsId()), "parts_id", processStream.getPartsId())
-                    .eq(StrUtil.isNotEmpty(processStream.getProcessId()), "process_id", processStream.getProcessId()));
+            List<PermissionStreamNew> permissionStreamList = permissionStreamNewService.loadProductMixByBusinessId(processStream.getProcessId(),"5");
             if (permissionStreamList == null || permissionStreamList.isEmpty())
                 return null;
             permissionStreamList.forEach(item -> {
                 departIds.add(item.getDepartId());
             });
             //6-宸ユ
-        } else if (nodeType == 6) {
+        } else if (Objects.equals(nodeType, DocAttributionTypeEnum.WORKSITE.getCode())) {
             WorkStep workStep = workStepService.getById(paramId);
             if (workStep == null)
                 return null;
-            List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
-                    .eq(StrUtil.isNotEmpty(workStep.getProductId()), "product_id", workStep.getProductId())
-                    .eq(StrUtil.isNotEmpty(workStep.getComponentId()), "component_id", workStep.getComponentId())
-                    .eq(StrUtil.isNotEmpty(workStep.getPartsId()), "parts_id", workStep.getPartsId())
-                    .eq(StrUtil.isNotEmpty(workStep.getProcessId()), "process_id", workStep.getProcessId())
-                    .eq(StrUtil.isNotEmpty(workStep.getId()), "step_id", workStep.getId()));
+            List<PermissionStreamNew> permissionStreamList = permissionStreamNewService.loadProductMixByBusinessId(workStep.getId(),"6");
             if (permissionStreamList == null || permissionStreamList.isEmpty())
                 return null;
             permissionStreamList.forEach(item -> {
@@ -687,7 +764,7 @@
 
     @Override
     public List<CommonGenericTree> loadTree(String userId, Integer nodeType, String paramId) {
-        if (nodeType == 1) {
+        if (Objects.equals(nodeType, DocAttributionTypeEnum.PRODUCT.getCode())) {
             List<ComponentInfo> componentInfoList = componentInfoService.getByProductIdAndUserId(paramId, userId);
             if (componentInfoList == null || componentInfoList.isEmpty())
                 return Collections.emptyList();
@@ -700,13 +777,13 @@
                 node.setLabel(c.getComponentName());
                 node.setParentId(c.getProductId());
                 node.setIconClass("");
-                node.setType(2);
+                node.setType(DocAttributionTypeEnum.COMPONENT.getCode());
                 node.setRField(c.getProductId());
                 node.setEntity(c);
                 list.add(node);
             }
             return list;
-        } else if (nodeType == 2) {
+        } else if (Objects.equals(nodeType, DocAttributionTypeEnum.COMPONENT.getCode())) {
             List<ComponentInfo> componentInfoList = componentInfoService.getByParentIdAndUserId(paramId, userId);
             List<CommonGenericTree> list = new ArrayList<>();
             CommonGenericTree<ComponentInfo> componentNode;
@@ -718,7 +795,7 @@
                     componentNode.setLabel(c.getComponentName());
                     componentNode.setParentId(c.getParentId());
                     componentNode.setIconClass("");
-                    componentNode.setType(2);
+                    componentNode.setType(DocAttributionTypeEnum.COMPONENT.getCode());
                     componentNode.setRField(c.getProductId());
                     componentNode.setEntity(c);
                     list.add(componentNode);
@@ -735,7 +812,7 @@
                 partNode.setLabel(part.getPartsName());
                 partNode.setParentId(part.getComponentId());
                 partNode.setIconClass("");
-                partNode.setType(3);
+                partNode.setType(DocAttributionTypeEnum.PARTS.getCode());
                 partNode.setRField(part.getComponentId());
                 partNode.setEntity(part);
                 partNode.setLeaf(true);
@@ -752,6 +829,7 @@
         List<ProductInfo> productInfos = this.getByUserPerms(userId, queryParam);
         List<ComponentInfo> componentInfos = componentInfoService.getByUserPerms(userId, queryParam);
         List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, null, queryParam);
+        List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByUserPerms(userId, queryParam);
         List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId, queryParam);
         List<WorkStep> workSteps = workStepService.getByUserPerms(userId, queryParam);
         List<ComponentInfo> componentInfoList = new ArrayList<>();
@@ -879,7 +957,7 @@
         //杞崲鏁版嵁
         List<ComponentExt> componentExtList = ComponentExt.convertToExtList(componentInfoList);
 
-        return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos, processStreams, workSteps);
+        return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos,processSpecVersions, processStreams, workSteps);
     }
 
     @Override
@@ -894,6 +972,9 @@
             //闆朵欢
             case 3:
                 return partsInfoService.deletePartsInfo(id);
+            //宸ヨ壓瑙勭▼鐗堟湰
+            case 4:
+                return processSpecVersionService.deleteProcessSpecVersion(id);
             //宸ュ簭
             case 5:
                 return processStreamService.deleteProcessStream(id);
@@ -903,6 +984,268 @@
             default:
         }
         return false;
+    }
+
+    @Override
+    public Result<?> getTreeById(String id, Integer type){
+        if (StrUtil.isNotEmpty(id)||type!=null){
+            switch (type){
+                case 1:
+                    //浜у搧
+                    QueryWrapper<ProductInfo> productInfoQueryWrapper = new QueryWrapper<>();
+                    productInfoQueryWrapper.eq("product_id",id);
+                    List<ProductInfo> productInfos = this.list(productInfoQueryWrapper);
+                    return Result.OK(productInfos);
+                case 2:
+                    //缁勪欢
+                    QueryWrapper<ComponentInfo> componentInfoQueryWrapper = new QueryWrapper<>();
+                    componentInfoQueryWrapper.eq("component_id",id);
+                    List<ComponentInfo> componentInfos = componentInfoService.list(componentInfoQueryWrapper);
+                    return Result.OK(componentInfos);
+                case 3:
+                    //闆朵欢
+                    QueryWrapper<PartsInfo> partsInfoQueryWrapper = new QueryWrapper<>();
+                    partsInfoQueryWrapper.eq("parts_id",id);
+                    List<PartsInfo> partsInfos = partsInfoService.list(partsInfoQueryWrapper);
+                    return Result.OK(partsInfos);
+                case 4:
+                    //宸ヨ壓瑙勫垝鐗堟湰
+                    QueryWrapper<ProcessSpecVersion> processSpecVersionQueryWrapper = new QueryWrapper<>();
+                    processSpecVersionQueryWrapper.eq("id",id);
+                    List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.list(processSpecVersionQueryWrapper);
+                    return Result.OK(processSpecVersions);
+                case 5:
+                    //宸ュ簭
+                    QueryWrapper<ProcessStream> processStreamQueryWrapper = new QueryWrapper<>();
+                    processStreamQueryWrapper.eq("process_id",id);
+                    List<ProcessStream> processStreams = processStreamService.list(processStreamQueryWrapper);
+                    return Result.OK(processStreams);
+                case 6:
+                    //宸ユ
+                    QueryWrapper<WorkStep> workStepQueryWrapper = new QueryWrapper<>();
+                    workStepQueryWrapper.eq("id",id);
+                    List<WorkStep> workSteps = workStepService.list(workStepQueryWrapper);
+                    return Result.OK(workSteps);
+            }
+        }
+        return Result.error("鍙傛暟閿欒");
+    }
+
+    /**
+     * 閫氳繃浠ｅ彿銆佸悕绉般�佹潗璐ㄧ瓑鏌ヨ瀵瑰簲鐢靛瓙鏍锋澘
+     * @param treeInfoRequest
+     * @return
+     */
+    @Override
+    public List<DocInfo> getByTreeOtherFileInfo(TreeInfoRequest treeInfoRequest){
+        switch (treeInfoRequest.getAttributionType()){
+            case 1:
+                LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>();
+                // 鏄庣‘鏉′欢锛氫粎褰揳ttributionType涓�1涓攁ttributionId闈炵┖鏃舵坊鍔犳潯浠�
+                if (treeInfoRequest.getAttributionType() == 1 && StrUtil.isNotBlank(treeInfoRequest.getAttributionId())) {
+                    queryWrapper.eq(ProductInfo::getProductId, treeInfoRequest.getAttributionId());
+                }
+                queryWrapper.like(StrUtil.isNotBlank(treeInfoRequest.getTreeCode()), ProductInfo::getProductNo, treeInfoRequest.getTreeCode())
+                        .like(StrUtil.isNotBlank(treeInfoRequest.getTreeName()), ProductInfo::getProductName, treeInfoRequest.getTreeName());
+                List<ProductInfo> productInfoList = super.list(queryWrapper);
+                List<DocInfo> docInfos = new ArrayList<>();
+                if (StrUtil.isNotBlank(treeInfoRequest.getStructureType())){
+                    productInfoList=new ArrayList<>();
+                }
+                if (CollectionUtil.isNotEmpty(productInfoList)) {
+                    String ids=productInfoList.stream().map(ProductInfo::getProductId).collect(Collectors.joining(","));
+                    DocInfoQueryRequest docQuery = new DocInfoQueryRequest();
+                    BeanUtil.copyProperties(treeInfoRequest, docQuery);
+                    docQuery.setAttributionIds(ids);
+                    docQuery.setDocClassCode("OTHER");
+                    docQuery.setAttributionType(DocAttributionTypeEnum.PRODUCT.getCode());
+                    docInfos = docInfoService.findListByDocQuery(docQuery);
+                }
+                // 鍒涘缓鏂拌姹傚璞￠伩鍏嶆薄鏌撳師鍙傛暟
+                TreeInfoRequest componentRequest = new TreeInfoRequest();
+                BeanUtil.copyProperties(treeInfoRequest, componentRequest);
+                componentRequest.setProductIds(Collections.singletonList(treeInfoRequest.getAttributionId()));
+                // 鍚堝苟鏌ヨ缁撴灉
+                docInfos.addAll(componentInfoService.getByComponentInfo(componentRequest));
+                docInfos.addAll(partsInfoService.getByPartsInfo(componentRequest));
+                docInfos.addAll(processSpecVersionService.getByProcessSpecVersion(componentRequest));
+                docInfos.addAll(processStreamService.getByProcessStreamOtherFile(componentRequest));
+                docInfos.addAll(workStepService.getByWorkStepOtherFile(componentRequest));
+                return getByTreeOtherFileInfo(docInfos);
+            case 2:
+                return getByTreeOtherFileInfo(componentInfoService.getByComponentInfo(treeInfoRequest));
+            case 3:
+                return getByTreeOtherFileInfo(partsInfoService.getByPartsInfo(treeInfoRequest));
+            case 4:
+                return getByTreeOtherFileInfo(processSpecVersionService.getByProcessSpecVersion(treeInfoRequest));
+            case 5:
+                return getByTreeOtherFileInfo(processStreamService.getByProcessStreamOtherFile(treeInfoRequest));
+            case 6:
+                return getByTreeOtherFileInfo(workStepService.getByWorkStepOtherFile(treeInfoRequest));
+        }
+        return new ArrayList<>();
+    }
+
+    /**
+     * 閫氳繃浠ｅ彿銆佸悕绉般�佹潗璐ㄧ瓑鏌ヨ瀵瑰簲NC鏂囦欢
+     * @param treeInfoRequest
+     * @return
+     */
+    @Override
+    public List<DocInfo> getByTreeNcFileInfo(TreeInfoRequest treeInfoRequest){
+        //浜у搧銆侀儴浠躲�侀浂浠躲�佸伐鑹鸿绋嬬増鏈兘娌℃湁瀵瑰簲鐨凬C鏂囦欢锛岀洿鎺ユ煡璇㈠瓙缁撴瀯
+        switch (treeInfoRequest.getAttributionType()){
+            case 1:
+                LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>();
+                // 鏄庣‘鏉′欢锛氫粎褰揳ttributionType涓�1涓攁ttributionId闈炵┖鏃舵坊鍔犳潯浠�
+                if (StrUtil.isNotBlank(treeInfoRequest.getAttributionId())) {
+                    queryWrapper.eq(ProductInfo::getProductId, treeInfoRequest.getAttributionId());
+                }
+                // 绠�鍖栨潯浠跺垽鏂�
+                queryWrapper.like(StrUtil.isNotBlank(treeInfoRequest.getTreeCode()), ProductInfo::getProductNo, treeInfoRequest.getTreeCode())
+                        .like(StrUtil.isNotBlank(treeInfoRequest.getTreeName()), ProductInfo::getProductName, treeInfoRequest.getTreeName());
+                List<ProductInfo> productInfoList = super.list(queryWrapper);
+                if (CollectionUtil.isNotEmpty(productInfoList)) {
+                    treeInfoRequest.setProductIds(productInfoList.stream().map(ProductInfo::getProductId).collect(Collectors.toList()));
+                }
+                return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
+            case 2:
+                LambdaQueryWrapper<ComponentInfo> componentInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
+                // 鏄庣‘鏉′欢锛氫粎褰揳ttributionType涓�1涓攁ttributionId闈炵┖鏃舵坊鍔犳潯浠�
+                if (StrUtil.isNotBlank(treeInfoRequest.getAttributionId())) {
+                    componentInfoLambdaQueryWrapper.eq(ComponentInfo::getComponentId, treeInfoRequest.getAttributionId());
+                }
+                componentInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeCode()),ComponentInfo::getComponentCode, treeInfoRequest.getTreeCode());
+                componentInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeName()),ComponentInfo::getComponentName, treeInfoRequest.getTreeName());
+                componentInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getStructureType()),ComponentInfo::getStructureType, treeInfoRequest.getStructureType());
+                componentInfoLambdaQueryWrapper.orderByDesc(ComponentInfo::getCreateTime);
+                List<ComponentInfo> componentInfoList = componentInfoService.list(componentInfoLambdaQueryWrapper);
+                if (CollectionUtil.isNotEmpty(componentInfoList)) {
+                    treeInfoRequest.setComponentIds(componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList()));
+                }
+                return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
+            case 3:
+                LambdaQueryWrapper<PartsInfo> partsInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
+                if (treeInfoRequest.getProductIds() != null && !treeInfoRequest.getProductIds().isEmpty()) {
+                    partsInfoLambdaQueryWrapper.in(PartsInfo::getProductId, treeInfoRequest.getProductIds());
+                }
+                if (treeInfoRequest.getComponentIds() != null && !treeInfoRequest.getComponentIds().isEmpty()) {
+                    partsInfoLambdaQueryWrapper.in(PartsInfo::getComponentId, treeInfoRequest.getComponentIds());
+                }
+                if (Objects.equals(treeInfoRequest.getAttributionType(), DocAttributionTypeEnum.PARTS.getCode())){
+                    partsInfoLambdaQueryWrapper.eq(StrUtil.isNotEmpty(treeInfoRequest.getAttributionId()),PartsInfo::getPartsId,treeInfoRequest.getAttributionId());
+                }
+                partsInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeCode()),PartsInfo::getPartsCode, treeInfoRequest.getTreeCode());
+                partsInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeName()),PartsInfo::getPartsName, treeInfoRequest.getTreeName());
+                partsInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getStructureType()),PartsInfo::getStructureType, treeInfoRequest.getStructureType());
+                partsInfoLambdaQueryWrapper.orderByDesc(PartsInfo::getCreateTime);
+                List<PartsInfo> list = partsInfoService.list(partsInfoLambdaQueryWrapper);
+                if (CollectionUtil.isNotEmpty(list)) {
+                    treeInfoRequest.setPartsIds(list.stream().map(PartsInfo::getPartsId).collect(Collectors.toList()));
+                }
+                return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
+            case 4:
+                LambdaQueryWrapper<ProcessSpecVersion> processSpecVersionLambdaQueryWrapper = new LambdaQueryWrapper<>();
+                if (treeInfoRequest.getProductIds() != null && !treeInfoRequest.getProductIds().isEmpty()) {
+                    processSpecVersionLambdaQueryWrapper.in(ProcessSpecVersion::getProductId, treeInfoRequest.getProductIds());
+                }
+                if (treeInfoRequest.getComponentIds() != null && !treeInfoRequest.getComponentIds().isEmpty()) {
+                    processSpecVersionLambdaQueryWrapper.in(ProcessSpecVersion::getComponentId, treeInfoRequest.getComponentIds());
+                }
+                if (treeInfoRequest.getPartsIds() != null && !treeInfoRequest.getPartsIds().isEmpty()) {
+                    processSpecVersionLambdaQueryWrapper.in(ProcessSpecVersion::getPartsId, treeInfoRequest.getPartsIds());
+                }
+                if (Objects.equals(treeInfoRequest.getAttributionType(), DocAttributionTypeEnum.OPERATION.getCode())){
+                    processSpecVersionLambdaQueryWrapper.eq(StrUtil.isNotEmpty(treeInfoRequest.getAttributionId()),ProcessSpecVersion::getId,treeInfoRequest.getAttributionId());
+                }
+                processSpecVersionLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeName()),ProcessSpecVersion::getProcessSpecVersionName, treeInfoRequest.getTreeName());
+                processSpecVersionLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeCode()),ProcessSpecVersion::getProcessSpecVersionCode, treeInfoRequest.getTreeName());
+                processSpecVersionLambdaQueryWrapper.orderByDesc(ProcessSpecVersion::getCreateTime);
+                List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.list(processSpecVersionLambdaQueryWrapper);
+                if (CollectionUtil.isNotEmpty(processSpecVersions)) {
+                    treeInfoRequest.setPsvIds(processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList()));
+                }
+                return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
+            case 5:
+                return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
+            case 6:
+                return getByTreeNcFileInfo(workStepService.getByWorkStepNCFile(treeInfoRequest));
+        }
+        return new ArrayList<>();
+    }
+
+    private List<DocInfo> getByTreeOtherFileInfo(List<DocInfo> docInfos){
+        //瀵规墍灞瀒d杩涜缈昏瘧
+        if (docInfos != null && !docInfos.isEmpty()) {
+            docInfos.forEach(docInfo -> {
+                switch (docInfo.getAttributionType()){
+                    case 1:
+                        ProductInfo productInfo=this.getById(docInfo.getAttributionId());
+                        docInfo.setNodeName(productInfo.getProductName());
+                        docInfo.setNodeCode(productInfo.getProductNo());
+                        docInfo.setNodeId(productInfo.getProductId());
+                        break;
+                    case 2:
+                        ComponentInfo componentInfo=componentInfoService.getById(docInfo.getAttributionId());
+                        docInfo.setNodeName(componentInfo.getComponentName());
+                        docInfo.setNodeCode(componentInfo.getComponentCode());
+                        docInfo.setNodeId(componentInfo.getComponentId());
+                        break;
+                    case 3:
+                        PartsInfo partsInfo=partsInfoService.getById(docInfo.getAttributionId());
+                        docInfo.setNodeCode(partsInfo.getPartsCode());
+                        docInfo.setNodeName(partsInfo.getPartsName());
+                        docInfo.setNodeId(partsInfo.getPartsId());
+                        break;
+                    case 4:
+                        ProcessSpecVersion processSpecVersion=processSpecVersionService.getById(docInfo.getAttributionId());
+                        docInfo.setNodeName(processSpecVersion.getProcessSpecVersionName());
+                        docInfo.setNodeCode(processSpecVersion.getProcessSpecVersionCode());
+                        docInfo.setNodeId(processSpecVersion.getId());
+                        break;
+                    case 5:
+                        ProcessStream processStream=processStreamService.getById(docInfo.getAttributionId());
+                        docInfo.setNodeName(processStream.getProcessName());
+                        docInfo.setNodeCode(processStream.getProcessCode());
+                        docInfo.setNodeId(processStream.getProcessId());
+                        break;
+                    case 6:
+                        WorkStep workStep=workStepService.getById(docInfo.getAttributionId());
+                        docInfo.setNodeName(workStep.getStepName());
+                        docInfo.setNodeCode(workStep.getStepName());
+                        docInfo.setNodeId(workStep.getId());
+                        break;
+                }
+            });
+        }
+        return docInfos;
+    }
+
+    private List<DocInfo> getByTreeNcFileInfo(List<DocInfo> docInfos){
+        //瀵规墍灞瀒d杩涜缈昏瘧
+        if (docInfos != null && !docInfos.isEmpty()) {
+            docInfos.forEach(docInfo -> {
+                //NC鏂囦欢瀛樺湪璁惧绫讳笅
+                DeviceType deviceType=deviceTypeService.getById(docInfo.getAttributionId());
+                DeviceManagement deviceManagement= deviceManagementService.getById(deviceType.getDeviceManagementId());
+                docInfo.setDeviceName(deviceManagement.getDeviceManagementName());
+                docInfo.setDeviceCode(deviceManagement.getDeviceManagementCode());
+                if (deviceType.getAttributionType().equals(DocAttributionTypeEnum.PROCESS.getCode())){
+                    //宸ュ簭涓嬬殑璁惧绫�
+                    ProcessStream processStream=processStreamService.getById(deviceType.getAttributionId());
+                    docInfo.setNodeName(processStream.getProcessName());
+                    docInfo.setNodeCode(processStream.getProcessCode());
+                    docInfo.setNodeId(processStream.getProcessId());
+                }else {
+                    //宸ユ涓嬬殑璁惧绫�
+                    WorkStep workStep=workStepService.getById(deviceType.getAttributionId());
+                    docInfo.setNodeName(workStep.getStepName());
+                    docInfo.setNodeCode(workStep.getStepName());
+                    docInfo.setNodeId(workStep.getId());
+                }
+            });
+        }
+        return docInfos;
     }
 
     /**
@@ -940,13 +1283,13 @@
         }
     }
 
-    private void handleRelativePermissions(String productId, List<String> componentIds, String processId, String partsId, Collection<SysUser> userList) {
+    private void handleRelativePermissions(String productId, List<String> componentIds, String processId, String partsId,String psvId ,Collection<SysUser> userList) {
         List<ComponentPermission> componentPermissionList = new ArrayList<>();
         List<PartsPermission> partsPermissionList = new ArrayList<>();
+        List<ProcessSpecVersionPermission> processSpecVersionPermissionList = new ArrayList<>();
         List<ProcessionPermission> processionPermissionList = new ArrayList<>();
         List<WorkStepPermission> workStepPermissionList = new ArrayList<>();
-        List<PermissionStream> permissionStreamList = new ArrayList<>();
-
+        List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
         // 澶勭悊閮ㄤ欢鏉冮檺
         if (componentIds != null && !componentIds.isEmpty()) {
             handleComponentPermissions(componentIds, userList, componentPermissionList, permissionStreamList);
@@ -956,9 +1299,31 @@
                         .map(PartsInfo::getPartsId)
                         .collect(Collectors.toList());
                 handlePartsPermissions(partsIds, userList, partsPermissionList, permissionStreamList);
+                List<ProcessSpecVersion> processSpecVersionList = processSpecVersionService.getByPartsIds(partsIds);
+                if (processSpecVersionList!= null &&!processSpecVersionList.isEmpty()) {
+                    List<String> psvIds = processSpecVersionList.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
+                    handlePsvPermissions(psvIds, userList, processSpecVersionPermissionList, permissionStreamList);
+                }
                 List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productId, componentIds, partsIds);
                 processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
             }
+        }
+
+        // 澶勭悊闆朵欢鏉冮檺
+        if (partsId != null) {
+            List<ProcessSpecVersion> processStreamList = processSpecVersionService.list(new QueryWrapper<ProcessSpecVersion>().eq("id", psvId));
+            if (processStreamList != null && !processStreamList.isEmpty()) {
+                List<String> psvIds = processStreamList.stream()
+                        .map(ProcessSpecVersion::getId)
+                        .collect(Collectors.toList());
+                handlePsvPermissions(psvIds,userList,processSpecVersionPermissionList,permissionStreamList);
+            }
+        }
+
+        // 澶勭悊宸ヨ壓瑙勭▼鐗堟湰鏉冮檺
+        if (psvId!= null) {
+            List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", psvId));
+            processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
         }
 
         // 澶勭悊宸ュ簭鏉冮檺
@@ -972,17 +1337,14 @@
             }
         }
 
-        // 澶勭悊闆朵欢鏉冮檺
-        if (partsId != null) {
-            List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsId));
-            processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
-        }
-
         if (!componentPermissionList.isEmpty()) {
             componentPermissionService.saveBatch(componentPermissionList);
         }
         if (!partsPermissionList.isEmpty()) {
             partsPermissionService.saveBatch(partsPermissionList);
+        }
+        if (!processSpecVersionPermissionList.isEmpty()) {
+            processSpecVersionPermissionService.saveBatch(processSpecVersionPermissionList);
         }
         if (!processionPermissionList.isEmpty()) {
             iProcessStreamPermissionService.saveBatch(processionPermissionList);
@@ -991,11 +1353,12 @@
             iWorkStepPermissionService.saveBatch(workStepPermissionList);
         }
         if (!permissionStreamList.isEmpty()) {
-            permissionStreamService.saveBatch(permissionStreamList);
+            permissionStreamNewService.saveBatch(permissionStreamList);
         }
     }
 
-    private void processStreamApi(String productId, Collection<SysUser> userList, List<ProcessionPermission> processionPermissionList, List<WorkStepPermission> workStepPermissionList, List<PermissionStream> permissionStreamList, List<ProcessStream> processStreamList) {
+    private void processStreamApi(String productId, Collection<SysUser> userList, List<ProcessionPermission> processionPermissionList,
+                                  List<WorkStepPermission> workStepPermissionList, List<PermissionStreamNew> permissionStreamList, List<ProcessStream> processStreamList) {
         if (processStreamList != null && !processStreamList.isEmpty()) {
             List<String> processIds = processStreamList.stream()
                     .map(ProcessStream::getProcessId)
@@ -1012,7 +1375,7 @@
     }
 
     private void handleComponentPermissions(List<String> componentIds, Collection<SysUser> userList,
-                                            List<ComponentPermission> componentPermissionList, List<PermissionStream> permissionStreamList) {
+                                            List<ComponentPermission> componentPermissionList, List<PermissionStreamNew> permissionStreamList) {
         Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
         Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
         String key;
@@ -1034,16 +1397,16 @@
             ComponentPermission cp = entry.getValue();
             componentPermissionList.add(cp);
             ComponentInfo cpInfo = componentInfoMap.get(cp.getComponentId());
-            PermissionStream s = new PermissionStream();
-            s.setProductId(cpInfo.getProductId());
-            s.setComponentId(cpInfo.getComponentId());
+            PermissionStreamNew s = new PermissionStreamNew();
+            s.setBusinessId(cpInfo.getComponentId());
+            s.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
             s.setUserId(cp.getUserId());
             permissionStreamList.add(s);
         }
     }
 
     private void handlePartsPermissions(List<String> partsIds, Collection<SysUser> userList,
-                                        List<PartsPermission> partsPermissionList, List<PermissionStream> permissionStreamList) {
+                                        List<PartsPermission> partsPermissionList, List<PermissionStreamNew> permissionStreamList) {
         Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
         Map<String, PartsInfo> partsInfoMap = new HashMap<>();
         String key;
@@ -1065,17 +1428,47 @@
             PartsPermission pp = entry.getValue();
             partsPermissionList.add(pp);
             PartsInfo ptInfo = partsInfoMap.get(pp.getPartsId());
-            PermissionStream s = new PermissionStream();
-            s.setProductId(ptInfo.getProductId());
-            s.setComponentId(ptInfo.getComponentId());
-            s.setPartsId(ptInfo.getPartsId());
+            PermissionStreamNew s = new PermissionStreamNew();
+            s.setBusinessId(ptInfo.getPartsId());
+            s.setBusinessType(DocAttributionTypeEnum.PARTS.getCode().toString());
+            s.setUserId(pp.getUserId());
+            permissionStreamList.add(s);
+        }
+    }
+
+    private void handlePsvPermissions(List<String> psvIds, Collection<SysUser> userList,
+                                        List<ProcessSpecVersionPermission> processSpecVersionPermissionList, List<PermissionStreamNew> permissionStreamList) {
+        Map<String, ProcessSpecVersionPermission> processSpecVersionPermissionMap = new HashMap<>();
+        Map<String, ProcessSpecVersion> processStreamMap = new HashMap<>();
+        String key;
+        for (ProcessSpecVersion p : processSpecVersionService.listByIds(psvIds)) {
+            processStreamMap.put(p.getId(), p);
+            for (SysUser u : userList) {
+                key = p.getId() + "," + u.getId();
+                processSpecVersionPermissionMap.put(key, new ProcessSpecVersionPermission(p.getId(), u.getId()));
+            }
+        }
+        List<ProcessSpecVersionPermission> processSpecVersionPermissions = processSpecVersionPermissionService.getByPsvIdsAndUserIds(psvIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
+        if (processSpecVersionPermissions != null && !processSpecVersionPermissions.isEmpty()) {
+            for (ProcessSpecVersionPermission processionPermission : processSpecVersionPermissions) {
+                key = processionPermission.getPsvId() + "," + processionPermission.getUserId();
+                processSpecVersionPermissionMap.remove(key);
+            }
+        }
+        for (Map.Entry<String, ProcessSpecVersionPermission> entry : processSpecVersionPermissionMap.entrySet()) {
+            ProcessSpecVersionPermission pp = entry.getValue();
+            processSpecVersionPermissionList.add(pp);
+            ProcessSpecVersion processSpecVersion = processStreamMap.get(pp.getPsvId());
+            PermissionStreamNew s = new PermissionStreamNew();
+            s.setBusinessId(processSpecVersion.getId());
+            s.setBusinessType(DocAttributionTypeEnum.OPERATION.getCode().toString());
             s.setUserId(pp.getUserId());
             permissionStreamList.add(s);
         }
     }
 
     private void handleProcessPermissions(List<String> processIds, Collection<SysUser> userList,
-                                          List<ProcessionPermission> processionPermissionList, List<PermissionStream> permissionStreamList) {
+                                          List<ProcessionPermission> processionPermissionList, List<PermissionStreamNew> permissionStreamList) {
         Map<String, ProcessionPermission> processionPermissionHashMap = new HashMap<>();
         Map<String, ProcessStream> processStreamMap = new HashMap<>();
         String key;
@@ -1097,18 +1490,16 @@
             ProcessionPermission pp = entry.getValue();
             processionPermissionList.add(pp);
             ProcessStream processStream = processStreamMap.get(pp.getProcessId());
-            PermissionStream s = new PermissionStream();
-            s.setProductId(processStream.getProductId());
-            s.setComponentId(processStream.getComponentId());
-            s.setPartsId(processStream.getPartsId());
-            s.setProcessId(processStream.getProcessId());
+            PermissionStreamNew s = new PermissionStreamNew();
+            s.setBusinessId(processStream.getProcessId());
+            s.setBusinessType(DocAttributionTypeEnum.PROCESS.getCode().toString());
             s.setUserId(pp.getUserId());
             permissionStreamList.add(s);
         }
     }
 
     private void handleWorkStepPermissions(List<String> workStepIds, Collection<SysUser> userList,
-                                           List<WorkStepPermission> workStepPermissionList, List<PermissionStream> permissionStreamList) {
+                                           List<WorkStepPermission> workStepPermissionList, List<PermissionStreamNew> permissionStreamList) {
         Map<String, WorkStepPermission> workStepPermissionHashMap = new HashMap<>();
         Map<String, WorkStep> workStepHashMap = new HashMap<>();
         String key;
@@ -1130,12 +1521,9 @@
             WorkStepPermission ws = entry.getValue();
             workStepPermissionList.add(ws);
             WorkStep workStep = workStepHashMap.get(ws.getStepId());
-            PermissionStream s = new PermissionStream();
-            s.setProductId(workStep.getProductId());
-            s.setComponentId(workStep.getComponentId());
-            s.setPartsId(workStep.getPartsId());
-            s.setProcessId(workStep.getProcessId());
-            s.setStepId(workStep.getId());
+            PermissionStreamNew s = new PermissionStreamNew();
+            s.setBusinessId(workStep.getId());
+            s.setBusinessType(DocAttributionTypeEnum.WORKSITE.getCode().toString());
             s.setUserId(ws.getUserId());
             permissionStreamList.add(s);
         }
@@ -1177,7 +1565,7 @@
                 ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
             }
             if (relativeFlag == 1) {
-                handleRelativePermissions(processStream.getProductId(), null, processStream.getProcessId(), null, userList);
+                handleRelativePermissions(processStream.getProductId(), null, processStream.getProcessId(), null,null, userList);
             }
         }else {
             result = processStreamService.assignAddDepart(processStream, mdcProductionList);
@@ -1185,7 +1573,37 @@
                 ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
             }
             if (relativeFlag == 1) {
-                handleRelatedPermissions(processStream, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService);
+                handleRelatedPermissions(processStream, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
+            }
+        }
+        return true;
+    }
+
+    private boolean handleProcessSpecVersion(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
+        ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
+        if (processSpecVersion == null) {
+            ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
+        }
+        boolean hasPerm = checkProductPerm(4, processSpecVersion.getId());
+        if (!hasPerm) {
+            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+        }
+        boolean result;
+        if (userList!=null){
+            result = processSpecVersionService.assignAddUser(processSpecVersion, userList);
+            if (!result) {
+                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+            }
+            if (relativeFlag == 1) {
+                handleRelativePermissions(processSpecVersion.getProductId(), null, null,null, processSpecVersion.getId(), userList);
+            }
+        }else {
+            result = processSpecVersionService.assignAddDepart(processSpecVersion, mdcProductionList);
+            if (!result) {
+                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+            }
+            if (relativeFlag == 1) {
+                handleRelatedPermissionsForProcessSpecVersion(processSpecVersion, mdcProductionList);
             }
         }
         return true;
@@ -1207,7 +1625,7 @@
                 ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
             }
             if (relativeFlag == 1) {
-                handleRelativePermissions(partsInfo.getProductId(), null, null, partsInfo.getPartsId(), userList);
+                handleRelativePermissions(partsInfo.getProductId(), null, null, partsInfo.getPartsId(),null, userList);
             }
         }else {
             result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
@@ -1242,7 +1660,7 @@
                     List<String> componentIds = componentInfoList.stream()
                             .map(ComponentInfo::getComponentId)
                             .collect(Collectors.toList());
-                    handleRelativePermissions(productInfo.getProductId(), componentIds, null, null, userList);
+                    handleRelativePermissions(productInfo.getProductId(), componentIds, null, null, null,userList);
                 }
             }
         }else {
@@ -1281,7 +1699,9 @@
                             .collect(Collectors.toList());
                 }
                 componentIds.add(componentInfo.getComponentId());
-                handleRelativePermissions(componentInfo.getProductId(), componentIds, null, null, userList);
+
+
+                handleRelativePermissions(componentInfo.getProductId(), componentIds, null, null,null, userList);
             }
         }else {
             result = componentInfoService.assignAddDepart(componentInfo, mdcProductionList);
@@ -1295,7 +1715,8 @@
         return true;
     }
 
-    private void handleRelatedPermissions(Object parentEntity, Collection<MdcProduction> mdcProductionList, IWorkStepService workStepService, IWorkStepDepartmentService workStepDepartmentService, IPermissionStreamService permissionStreamService) {
+    private void handleRelatedPermissions(Object parentEntity, Collection<MdcProduction> mdcProductionList, IWorkStepService workStepService,
+                                          IWorkStepDepartmentService workStepDepartmentService, IPermissionStreamNewService permissionStreamNewService) {
         String parentId = getParentId(parentEntity);
         List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", parentId));
         if (workStepList == null || workStepList.isEmpty()) {
@@ -1323,48 +1744,54 @@
         }
 
         List<WorkStepDepartment> newWorkStepDepartments = new ArrayList<>();
-        List<PermissionStream> newPermissionStreams = new ArrayList<>();
+        List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
         for (Map.Entry<String, WorkStepDepartment> entry : allPermissions.entrySet()) {
             WorkStepDepartment wsDep = entry.getValue();
             newWorkStepDepartments.add(wsDep);
             WorkStep workStep = workStepMap.get(wsDep.getStepId());
-            PermissionStream permStream = new PermissionStream();
-            permStream.setProductId(workStep.getProductId());
-            permStream.setComponentId(workStep.getComponentId());
-            permStream.setPartsId(workStep.getPartsId());
-            permStream.setProcessId(workStep.getProcessId());
-            permStream.setStepId(workStep.getId());
+            PermissionStreamNew permStream = new PermissionStreamNew();
+            permStream.setBusinessId(workStep.getId());
+            permStream.setBusinessType(DocAttributionTypeEnum.WORKSITE.getCode().toString());
             permStream.setDepartId(wsDep.getDepartId());
             newPermissionStreams.add(permStream);
         }
-
         if (!newWorkStepDepartments.isEmpty()) {
             workStepDepartmentService.saveBatch(newWorkStepDepartments);
         }
         if (!newPermissionStreams.isEmpty()) {
-            permissionStreamService.saveBatch(newPermissionStreams);
+            permissionStreamNewService.saveBatch(newPermissionStreams);
         }
     }
 
     private void handleRelatedPermissionsForParts(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
-        // 澶勭悊宸ュ簭鏉冮檺
-        handleProcessPermissions(partsInfo,null, mdcProductionList);
-        // 澶勭悊宸ユ鏉冮檺
-        handleWorkStepPermissions(partsInfo, mdcProductionList);
+        // 澶勭悊宸ヨ壓瑙勭▼鐗堟湰
+        List<ProcessSpecVersion> processSpecVersionList = processSpecVersionService.list(new QueryWrapper<ProcessSpecVersion>().eq("parts_id", partsInfo.getPartsId()));
+        processSpecVersionList.forEach(item->{
+            processSpecVersionService.assignAddDepart(item, mdcProductionList);
+            handleRelatedPermissionsForProcessSpecVersion(item, mdcProductionList);
+        });
     }
 
-    private void handleProcessPermissions(PartsInfo partsInfo,ComponentInfo componentInfo,Collection<MdcProduction> mdcProductionList) {
+    private void handleRelatedPermissionsForProcessSpecVersion(ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
+        // 澶勭悊宸ュ簭鏉冮檺
+        handleProcessPermissions(processSpecVersion,null, mdcProductionList);
+        // 澶勭悊宸ユ鏉冮檺
+        handleWorkStepPermissions(processSpecVersion, mdcProductionList);
+
+    }
+
+    private void handleProcessPermissions(ProcessSpecVersion processSpecVersion,ComponentInfo componentInfo,Collection<MdcProduction> mdcProductionList) {
         List<ProcessStream> processStreamList=new ArrayList<>();
         if (componentInfo != null) {
             processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
         }else {
-            processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
+            processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
         }
         if (processStreamList == null || processStreamList.isEmpty()) {
             return;
         }
         processStreamList.forEach(item->{
-            handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService);
+            handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
         });
         Map<String, ProcessionDepartment> allProcessPermissions = new HashMap<>();
         Map<String, ProcessStream> processStreamMap = new HashMap<>();
@@ -1388,16 +1815,14 @@
         }
 
         List<ProcessionDepartment> newProcessPermissions = new ArrayList<>();
-        List<PermissionStream> newPermissionStreams = new ArrayList<>();
+        List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
         for (Map.Entry<String, ProcessionDepartment> entry : allProcessPermissions.entrySet()) {
             ProcessionDepartment procDep = entry.getValue();
             newProcessPermissions.add(procDep);
             ProcessStream processStream = processStreamMap.get(procDep.getProcessId());
-            PermissionStream permStream = new PermissionStream();
-            permStream.setProductId(processStream.getProductId());
-            permStream.setComponentId(processStream.getComponentId());
-            permStream.setPartsId(processStream.getPartsId());
-            permStream.setProcessId(processStream.getProcessId());
+            PermissionStreamNew permStream = new PermissionStreamNew();
+            permStream.setBusinessId(processStream.getProcessId());
+            permStream.setBusinessType(DocAttributionTypeEnum.PROCESS.getCode().toString());
             permStream.setDepartId(procDep.getDepartId());
             newPermissionStreams.add(permStream);
         }
@@ -1406,22 +1831,22 @@
             processionDepartmentService.saveBatch(newProcessPermissions);
         }
         if (!newPermissionStreams.isEmpty()) {
-            permissionStreamService.saveBatch(newPermissionStreams);
+            permissionStreamNewService.saveBatch(newPermissionStreams);
         }
     }
 
-    private void handleWorkStepPermissions(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
-        List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
+    private void handleWorkStepPermissions(ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
+        List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
         if (processStreamList == null || processStreamList.isEmpty()) {
             return;
         }
         List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
-        List<WorkStep> workStepList = workStepService.getByProcessIds(partsInfo.getProductId(), processIds);
+        List<WorkStep> workStepList = workStepService.getByProcessIds(processSpecVersion.getProductId(), processIds);
         if (workStepList == null || workStepList.isEmpty()) {
             return;
         }
         workStepList.forEach(item->{
-            handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService);
+            handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
         });
     }
 
@@ -1463,14 +1888,14 @@
         }
 
         List<ComponentDepartment> newComponentPermissions = new ArrayList<>();
-        List<PermissionStream> newPermissionStreams = new ArrayList<>();
+        List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
         for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
             ComponentDepartment compDep = entry.getValue();
             newComponentPermissions.add(compDep);
             ComponentInfo componentInfo = componentInfoMap.get(compDep.getComponentId());
-            PermissionStream permStream = new PermissionStream();
-            permStream.setProductId(componentInfo.getProductId());
-            permStream.setComponentId(componentInfo.getComponentId());
+            PermissionStreamNew permStream = new PermissionStreamNew();
+            permStream.setBusinessId(componentInfo.getComponentId());
+            permStream.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
             permStream.setDepartId(compDep.getDepartId());
             newPermissionStreams.add(permStream);
         }
@@ -1479,7 +1904,7 @@
             componentDepartmentService.saveBatch(newComponentPermissions);
         }
         if (!newPermissionStreams.isEmpty()) {
-            permissionStreamService.saveBatch(newPermissionStreams);
+            permissionStreamNewService.saveBatch(newPermissionStreams);
         }
     }
 
@@ -1537,14 +1962,14 @@
             }
 
             List<ComponentDepartment> newComponentPermissions = new ArrayList<>();
-            List<PermissionStream> newPermissionStreams = new ArrayList<>();
+            List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
             for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
                 ComponentDepartment compDep = entry.getValue();
                 newComponentPermissions.add(compDep);
                 childComponent = componentInfoMap.get(compDep.getComponentId());
-                PermissionStream permStream = new PermissionStream();
-                permStream.setProductId(childComponent.getProductId());
-                permStream.setComponentId(childComponent.getComponentId());
+                PermissionStreamNew permStream = new PermissionStreamNew();
+                permStream.setBusinessId(childComponent.getComponentId());
+                permStream.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
                 permStream.setDepartId(compDep.getDepartId());
                 newPermissionStreams.add(permStream);
             }
@@ -1553,7 +1978,7 @@
                 componentDepartmentService.saveBatch(newComponentPermissions);
             }
             if (!newPermissionStreams.isEmpty()) {
-                permissionStreamService.saveBatch(newPermissionStreams);
+                permissionStreamNewService.saveBatch(newPermissionStreams);
             }
         }
     }
@@ -1564,6 +1989,7 @@
             return;
         }
         for (PartsInfo partsInfo : partsInfoList) {
+            partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
             handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
         }
     }
@@ -1579,77 +2005,6 @@
 
 
     /**绉婚櫎鏉冮檺*/
-
-    private boolean handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
-        WorkStep workStep = workStepService.getById(paramId);
-        if (workStep == null) {
-            ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
-        }
-        checkProductPerm(6, workStep.getId());
-        if (userList!=null){
-            return workStepService.assignRemoveUser(workStep, userList);
-        }else {
-            return workStepService.assignRemoveDepart(workStep, mdcProductionList);
-        }
-    }
-
-    private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
-        ProcessStream processStream = processStreamService.getById(paramId);
-        if (processStream == null) {
-            ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
-        }
-        checkProductPerm(5, processStream.getProcessId());
-        boolean result;
-        if (userList!=null){
-            result = processStreamService.assignRemoveUser(processStream, userList);
-            if (!result) {
-                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
-            }
-            if (relativeFlag == 1) {
-                handleRelatedRemovals(processStream.getProcessId(), userList,
-                        workStepService, iWorkStepPermissionService, permissionStreamService,
-                        "process_id");
-            }
-        }else {
-            result = processStreamService.assignRemoveDepart(processStream, mdcProductionList);
-            if (!result) {
-                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
-            }
-            if (relativeFlag == 1) {
-                handleRelatedDepartmentRemovals(processStream.getProcessId(), mdcProductionList,
-                        workStepService, workStepDepartmentService, permissionStreamService,
-                        "process_id");
-            }
-        }
-        return true;
-    }
-
-    private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
-        PartsInfo partsInfo = partsInfoService.getById(paramId);
-        if (partsInfo == null) {
-            ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
-        }
-        checkProductPerm(3, partsInfo.getPartsId());
-        boolean result;
-        if (userList!=null){
-            result = partsInfoService.assignRemoveUser(partsInfo, userList);
-            if (!result) {
-                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
-            }
-            if (relativeFlag == 1) {
-                handlePartsRelatedRemovals(null,partsInfo, userList);
-            }
-        }else {
-            result = partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList);
-            if (!result) {
-                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
-            }
-            if (relativeFlag == 1) {
-                handlePartsRelatedDepartmentRemovals(null,partsInfo, mdcProductionList);
-            }
-        }
-        return true;
-    }
 
     private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
         ProductInfo productInfo = super.getById(paramId);
@@ -1705,10 +2060,108 @@
         return true;
     }
 
+    private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+        PartsInfo partsInfo = partsInfoService.getById(paramId);
+        if (partsInfo == null) {
+            ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
+        }
+        checkProductPerm(3, partsInfo.getPartsId());
+        boolean result;
+        if (userList!=null){
+            result = partsInfoService.assignRemoveUser(partsInfo, userList);
+            if (!result) {
+                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+            }
+            if (relativeFlag == 1) {
+                handlePartRelatedRemovals(partsInfo, userList);
+            }
+        }else {
+            result = partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList);
+            if (!result) {
+                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+            }
+            if (relativeFlag == 1) {
+                handlePartRelatedDepartmentRemovals(partsInfo, mdcProductionList);
+            }
+        }
+        return true;
+    }
+
+    private boolean handleProcessSpecVersionRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+        ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
+        if (processSpecVersion == null) {
+            ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
+        }
+        checkProductPerm(4, processSpecVersion.getPartsId());
+        boolean result;
+        if (userList!=null){
+            result = processSpecVersionService.assignRemoveUser(processSpecVersion, userList);
+            if (!result) {
+                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+            }
+            if (relativeFlag == 1) {
+                handleProcessSpecVersionRelatedRemovals(null,processSpecVersion, userList);
+            }
+        }else {
+            result = processSpecVersionService.assignRemoveDepart(processSpecVersion, mdcProductionList);
+            if (!result) {
+                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+            }
+            if (relativeFlag == 1) {
+                handleProcessSpecVersionRelatedDepartmentRemovals(null,processSpecVersion, mdcProductionList);
+            }
+        }
+        return true;
+    }
+
+    private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+        ProcessStream processStream = processStreamService.getById(paramId);
+        if (processStream == null) {
+            ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
+        }
+        checkProductPerm(5, processStream.getProcessId());
+        boolean result;
+        if (userList!=null){
+            result = processStreamService.assignRemoveUser(processStream, userList);
+            if (!result) {
+                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+            }
+            if (relativeFlag == 1) {
+                handleRelatedRemovals(processStream.getProcessId(), userList,
+                        workStepService, iWorkStepPermissionService, permissionStreamNewService,
+                        "process_id");
+            }
+        }else {
+            result = processStreamService.assignRemoveDepart(processStream, mdcProductionList);
+            if (!result) {
+                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+            }
+            if (relativeFlag == 1) {
+                handleRelatedDepartmentRemovals(processStream.getProcessId(), mdcProductionList,
+                        workStepService, workStepDepartmentService, permissionStreamNewService,
+                        "process_id");
+            }
+        }
+        return true;
+    }
+
+    private boolean handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+        WorkStep workStep = workStepService.getById(paramId);
+        if (workStep == null) {
+            ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
+        }
+        checkProductPerm(6, workStep.getId());
+        if (userList!=null){
+            return workStepService.assignRemoveUser(workStep, userList);
+        }else {
+            return workStepService.assignRemoveDepart(workStep, mdcProductionList);
+        }
+    }
+
     private void handleRelatedRemovals(String parentId, Collection<SysUser> userList,
                                        IWorkStepService workStepService,
                                        IWorkStepPermissionService workStepPermissionService,
-                                       IPermissionStreamService permissionStreamService,
+                                       IPermissionStreamNewService permissionStreamNewService,
                                        String queryField) {
         List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
         if (workStepList.isEmpty()) {
@@ -1717,20 +2170,20 @@
         List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
         List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
         List<WorkStepPermission> workStepPermissions = workStepPermissionService.getByStepIdsAndUserIds(workStepIds, userIdList);
-        List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, userIdList);
+        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(workStepIds, userIdList,"6");
 
         if (!workStepPermissions.isEmpty()) {
             workStepPermissionService.removeByCollection(workStepPermissions);
         }
         if (!permissionStreams.isEmpty()) {
-            permissionStreamService.removeByCollection(permissionStreams);
+            permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
         }
     }
 
     private void handleRelatedDepartmentRemovals(String parentId, Collection<MdcProduction> mdcProductionList,
                                                  IWorkStepService workStepService,
                                                  IWorkStepDepartmentService workStepDepartmentService,
-                                                 IPermissionStreamService permissionStreamService,
+                                                 IPermissionStreamNewService permissionStreamNewService,
                                                  String queryField) {
         List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
         if (workStepList.isEmpty()) {
@@ -1739,22 +2192,22 @@
         List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
         List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
         List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIdList);
-        List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, departmentIdList);
+        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(workStepIds, departmentIdList,"6");
 
         if (!workStepDepartments.isEmpty()) {
             workStepDepartmentService.removeByCollection(workStepDepartments);
         }
         if (!permissionStreams.isEmpty()) {
-            permissionStreamService.removeByCollection(permissionStreams);
+            permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
         }
     }
 
-    private void handlePartsRelatedRemovals(ComponentInfo componentInfo,PartsInfo partsInfo,Collection<SysUser> userList) {
+    private void handleProcessSpecVersionRelatedRemovals(ComponentInfo componentInfo,ProcessSpecVersion processSpecVersion,Collection<SysUser> userList) {
         List<ProcessStream> processStreamList =new ArrayList<>();
         String productId="";
-        if (partsInfo!=null){
-            processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
-            productId=partsInfo.getProductId();
+        if (processSpecVersion!=null){
+            processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
+            productId=processSpecVersion.getProductId();
         }else {
             processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()).isNull("parts_id"));
             productId=componentInfo.getProductId();
@@ -1770,13 +2223,13 @@
         }
         List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
         List<ProcessionPermission> processionPermissions = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userIdList);
-        List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndUserIds(processIds, userIdList);
+        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(processIds, userIdList,"5");
 
         if (!processionPermissions.isEmpty()) {
             iProcessStreamPermissionService.removeByCollection(processionPermissions);
         }
         if (!permissionStreams.isEmpty()) {
-            permissionStreamService.removeByCollection(permissionStreams);
+            permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
         }
     }
 
@@ -1786,13 +2239,13 @@
         }
         List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
         List<ProcessionDepartment> processionDepartments = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIdList);
-        List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(processIds, departmentIdList);
+        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(processIds, departmentIdList,"5");
 
         if (!processionDepartments.isEmpty()) {
             processionDepartmentService.removeByCollection(processionDepartments);
         }
         if (!permissionStreams.isEmpty()) {
-            permissionStreamService.removeByCollection(permissionStreams);
+            permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
         }
     }
 
@@ -1800,7 +2253,7 @@
         List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
         if (workStepList!=null){
             workStepList.forEach(item->{
-                handleRelatedRemovals(item.getProcessId(), userList, workStepService, iWorkStepPermissionService, permissionStreamService, "process_id");
+                handleRelatedRemovals(item.getProcessId(), userList, workStepService, iWorkStepPermissionService, permissionStreamNewService, "process_id");
             });
         }
     }
@@ -1809,7 +2262,7 @@
         List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
         if (workStepList!=null){
             workStepList.forEach(item->{
-                handleRelatedDepartmentRemovals(item.getProcessId(), mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService, "process_id");
+                handleRelatedDepartmentRemovals(item.getProcessId(), mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService, "process_id");
             });
         }
     }
@@ -1820,8 +2273,30 @@
         handleComponentRemovals(componentIds, userList);
         handlePartsRemovals(productInfo.getProductId(), componentIds, userList);
         componentInfoList.forEach(item->{
-            handlePartsRelatedRemovals(item,null, userList);
+            handleProcessSpecVersionRelatedRemovals(item,null, userList);
         });
+    }
+
+    private void handlePartRelatedRemovals(PartsInfo partsInfo, Collection<SysUser> userList) {
+        List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByPartsId(partsInfo.getPartsId());
+        if (processSpecVersions!=null){
+            List<String> psvIds = processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
+            handleProcessSpecVersionRemovals(psvIds, userList);
+            processSpecVersions.forEach(item->{
+                handleProcessSpecVersionRelatedRemovals(null,item, userList);
+            });
+        }
+    }
+
+    private void handlePartRelatedDepartmentRemovals(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
+        List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByPartsId(partsInfo.getPartsId());
+        if (processSpecVersions!=null){
+            List<String> psvIds = processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
+            handleProcessSpecVersionDepartmentRemovals(psvIds, mdcProductionList);
+            processSpecVersions.forEach(item->{
+                handleProcessSpecVersionRelatedDepartmentRemovals(null,item, mdcProductionList);
+            });
+        }
     }
 
     private void handleProductRelatedDepartmentRemovals(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
@@ -1830,7 +2305,7 @@
         handleComponentDepartmentRemovals(componentIds, mdcProductionList);
         handlePartsDepartmentRemovals(productInfo.getProductId(), componentIds, mdcProductionList);
         componentInfoList.forEach(item->{
-            handlePartsRelatedDepartmentRemovals(item,null, mdcProductionList);
+            handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
         });
     }
 
@@ -1840,15 +2315,46 @@
         }
         List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
         List<ComponentPermission> componentPermissions = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userIdList);
-        List<PermissionStream> permissionStreams = permissionStreamService.getByComponentIdsAndUserIds(componentIds, userIdList);
+        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(componentIds, userIdList,"2");
 
         if (!componentPermissions.isEmpty()) {
             componentPermissionService.removeByCollection(componentPermissions);
         }
         if (!permissionStreams.isEmpty()) {
-            permissionStreamService.removeByCollection(permissionStreams);
+            permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
         }
     }
+
+    private void handleProcessSpecVersionRemovals(List<String> psvIds, Collection<SysUser> userList) {
+        if (psvIds.isEmpty()) {
+            return;
+        }
+        List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
+        List<ProcessSpecVersionPermission> processSpecVersionPermissions = processSpecVersionPermissionService.getByPsvIdsAndUserIds(psvIds, userIdList);
+        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(psvIds, userIdList,"4");
+        if (!processSpecVersionPermissions.isEmpty()) {
+            processSpecVersionPermissionService.removeByCollection(processSpecVersionPermissions);
+        }
+        if (!permissionStreams.isEmpty()) {
+            permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+        }
+    }
+
+    private void handleProcessSpecVersionDepartmentRemovals(List<String> psvIds, Collection<MdcProduction> mdcProductionList) {
+        if (psvIds.isEmpty()) {
+            return;
+        }
+        List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
+        List<ProcessSpecVersionDepartment> processSpecVersionDepartments =processSpecVersionDepartmentService.getByPsvIdsAndDepartIds(psvIds, departmentIdList);
+        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(psvIds, departmentIdList,"4");
+        if (!processSpecVersionDepartments.isEmpty()) {
+            processSpecVersionDepartmentService.removeByCollection(processSpecVersionDepartments);
+        }
+        if (!permissionStreams.isEmpty()) {
+            permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+        }
+    }
+
 
     private void handleComponentDepartmentRemovals(List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
         if (componentIds.isEmpty()) {
@@ -1856,29 +2362,34 @@
         }
         List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
         List<ComponentDepartment> componentDepartments = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIdList);
-        List<PermissionStream> permissionStreams = permissionStreamService.getByComponentIdsAndDepartIds(componentIds, departmentIdList);
+        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(componentIds, departmentIdList,"2");
 
         if (!componentDepartments.isEmpty()) {
             componentDepartmentService.removeByCollection(componentDepartments);
         }
         if (!permissionStreams.isEmpty()) {
-            permissionStreamService.removeByCollection(permissionStreams);
+            permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
         }
     }
 
-    private void handlePartsRemovals(String productId, List<String> componentIds, Collection<SysUser> userList) {
+    private void handlePartsRemovals(String productId, List<String> componentIds,Collection<SysUser> userList) {
         List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
-        partsInfoList.forEach(item->{
-            partsInfoService.assignRemoveUser(item,userList);
-            handlePartsRelatedRemovals(null,item, userList);
-        });
+        if (partsInfoList!=null){
+            partsInfoList.forEach(item->{
+                partsInfoService.assignRemoveUser(item,userList);
+                //鍒犻櫎
+                handlePartRelatedRemovals(item, userList);
+            });
+        }
     }
     private void handlePartsDepartmentRemovals(String productId, List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
         List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
-        partsInfoList.forEach(item->{
-            partsInfoService.assignRemoveDepart(item,mdcProductionList);
-            handlePartsRelatedDepartmentRemovals(null,item, mdcProductionList);
-        });
+        if (partsInfoList!=null) {
+            partsInfoList.forEach(item->{
+                partsInfoService.assignRemoveDepart(item,mdcProductionList);
+                handlePartRelatedDepartmentRemovals(item, mdcProductionList);
+            });
+        }
     }
 
     private void handleComponentRelatedRemovals(ComponentInfo componentInfo, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
@@ -1893,7 +2404,7 @@
             handlePartsDepartmentRemovals(componentInfo.getProductId(), componentIds, mdcProductionList);
             if (childrenList != null) {
                 childrenList.forEach(item->{
-                    handlePartsRelatedDepartmentRemovals(item,null, mdcProductionList);
+                    handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
                 });
             }
         }else {
@@ -1901,21 +2412,21 @@
             handlePartsRemovals(componentInfo.getProductId(), componentIds, userList);
             if (childrenList != null) {
                 childrenList.forEach(item->{
-                    handlePartsRelatedRemovals(item,null, userList);
+                    handleProcessSpecVersionRelatedRemovals(item,null, userList);
                 });
             }
         }
     }
 
-    private void handlePartsRelatedDepartmentRemovals(ComponentInfo componentInfo,PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
+    private void handleProcessSpecVersionRelatedDepartmentRemovals(ComponentInfo componentInfo,ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
         List<ProcessStream> processStreamList=new ArrayList<>();
         String productId="";
         if (componentInfo!=null){
             processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
             productId=componentInfo.getProductId();
         }else {
-            processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
-            productId=partsInfo.getProductId();
+            processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
+            productId=processSpecVersion.getProductId();
         }
         List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
         handleProcessDepartmentRemovals(processIds, mdcProductionList);

--
Gitblit v1.9.3