添加对应节点id

lyh

2025-06-12 77eff86ec113e5dc86c9e1433e52bd8a67865340

 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
@@ -53,14 +61,16 @@
    @Autowired
    private IPartsPermissionService partsPermissionService;
    @Autowired
    private IProcessSpecVersionPermissionService processSpecVersionPermissionService;
    @Autowired
    private IProcessSpecVersionDepartmentService processSpecVersionDepartmentService;
    @Autowired
    private ISysUserService userService;
    @Autowired
    @Lazy
    private IProcessStreamService processStreamService;
    @Autowired
    private IWorkStepService workStepService;
    @Autowired
    private INcLogInfoService iNcLogInfoService;
    @Autowired
    private IWorkStepDepartmentService workStepDepartmentService;
    @Autowired
@@ -73,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})
@@ -96,17 +115,36 @@
        if (!b) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
        }
        ProductPermission permission = new ProductPermission();
        permission.setProductId(productInfo.getProductId());
        permission.setUserId(userId);
        b = productPermissionService.save(permission);
        b = productPermissionService.add(productInfo.getProductId(), userId,"1");
        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
@@ -124,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);
@@ -136,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;
    }
@@ -160,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)
@@ -168,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
@@ -215,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);
        }
@@ -224,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);
@@ -241,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;
@@ -281,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;
@@ -300,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;
@@ -319,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;
        }
@@ -340,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;
@@ -360,6 +422,7 @@
     * @param paramId      产品树节点id
     * @param relativeFlag 1 是 2 否
     * @param userIds      添加用户ids
     * todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
     * @return
     */
    @Override
@@ -372,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;
        }
@@ -392,6 +458,7 @@
     * @param paramId       产品树节点id
     * @param relativeFlag  1 是 2 否
     * @param departmentIds 添加部门ids
     * todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
     * @return
     */
    @Override
@@ -400,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;
        }
@@ -423,6 +494,7 @@
     * @param paramId      产品树节点id
     * @param relativeFlag 1 是 2 否
     * @param userIds      移除用户ids
     * todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
     * @return
     */
    @Override
@@ -433,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;
        }
@@ -455,26 +529,31 @@
     * @param paramId       产品树节点id
     * @param relativeFlag  1 是 2 否
     * @param departmentIds 移除部门ids
     * todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
     * @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;
        }
@@ -486,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) {
@@ -495,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);
            }
        });
@@ -510,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);
            }
@@ -524,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);
            }
@@ -546,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);
            }
@@ -560,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) {
@@ -569,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);
            }
        });
@@ -584,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);
            }
@@ -598,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);
            }
@@ -616,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);
            }
@@ -628,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 -> {
@@ -692,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();
@@ -705,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;
@@ -723,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);
@@ -740,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);
@@ -757,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<>();
@@ -884,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
@@ -899,6 +972,9 @@
            //零件
            case 3:
                return partsInfoService.deletePartsInfo(id);
            //工艺规程版本
            case 4:
                return processSpecVersionService.deleteProcessSpecVersion(id);
            //工序
            case 5:
                return processStreamService.deleteProcessStream(id);
@@ -908,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<>();
                // 明确条件：仅当attributionType为1且attributionId非空时添加条件
                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){
        //产品、部件、零件、工艺规程版本都没有对应的NC文件，直接查询子结构
        switch (treeInfoRequest.getAttributionType()){
            case 1:
                LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>();
                // 明确条件：仅当attributionType为1且attributionId非空时添加条件
                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<>();
                // 明确条件：仅当attributionType为1且attributionId非空时添加条件
                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){
        //对所属id进行翻译
        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){
        //对所属id进行翻译
        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;
    }

    /**
@@ -945,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);
@@ -961,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);
        }

        // 处理工序权限
@@ -977,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);
@@ -996,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)
@@ -1017,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;
@@ -1039,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;
@@ -1070,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;
@@ -1102,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;
@@ -1135,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);
        }
@@ -1182,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);
@@ -1190,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;
@@ -1212,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);
@@ -1247,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 {
@@ -1286,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);
@@ -1300,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()) {
@@ -1328,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<>();
@@ -1393,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);
        }
@@ -1411,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);
        });
    }

@@ -1468,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);
        }
@@ -1484,7 +1904,7 @@
            componentDepartmentService.saveBatch(newComponentPermissions);
        }
        if (!newPermissionStreams.isEmpty()) {
            permissionStreamService.saveBatch(newPermissionStreams);
            permissionStreamNewService.saveBatch(newPermissionStreams);
        }
    }

@@ -1542,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);
            }
@@ -1558,7 +1978,7 @@
                componentDepartmentService.saveBatch(newComponentPermissions);
            }
            if (!newPermissionStreams.isEmpty()) {
                permissionStreamService.saveBatch(newPermissionStreams);
                permissionStreamNewService.saveBatch(newPermissionStreams);
            }
        }
    }
@@ -1569,6 +1989,7 @@
            return;
        }
        for (PartsInfo partsInfo : partsInfoList) {
            partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
            handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
        }
    }
@@ -1584,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);
@@ -1710,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()) {
@@ -1722,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()) {
@@ -1744,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();
@@ -1775,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);
        }
    }

@@ -1791,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);
        }
    }

@@ -1805,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");
            });
        }
    }
@@ -1814,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");
            });
        }
    }
@@ -1825,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) {
@@ -1835,7 +2305,7 @@
        handleComponentDepartmentRemovals(componentIds, mdcProductionList);
        handlePartsDepartmentRemovals(productInfo.getProductId(), componentIds, mdcProductionList);
        componentInfoList.forEach(item->{
            handlePartsRelatedDepartmentRemovals(item,null, mdcProductionList);
            handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
        });
    }

@@ -1845,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()) {
@@ -1861,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) {
@@ -1898,7 +2404,7 @@
            handlePartsDepartmentRemovals(componentInfo.getProductId(), componentIds, mdcProductionList);
            if (childrenList != null) {
                childrenList.forEach(item->{
                    handlePartsRelatedDepartmentRemovals(item,null, mdcProductionList);
                    handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
                });
            }
        }else {
@@ -1906,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);