hy/mdc_hyjs_gk_new.git

			@@ -1,39 +1,39 @@
			package org.jeecg.modules.dnc.service.impl;

			import com.alibaba.fastjson.JSONObject;
			import cn.hutool.core.bean.BeanUtil;
			import cn.hutool.core.collection.CollectionUtil;
			import cn.hutool.core.util.StrUtil;
			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.Department;
			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 org.jeecg.modules.dnc.response.ComponentInfoCode;
			import org.jeecg.modules.dnc.response.PartsInfoCode;
			import org.jeecg.modules.dnc.response.ProductInfoCode;
			import org.jeecg.modules.dnc.response.UcenterCode;
			import org.jeecg.modules.dnc.response.CommonCode;
			import org.jeecg.modules.dnc.response.CommonGenericTree;
			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;

			@Service
			@Slf4j
			@@ -45,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
			@@ -59,136 +61,178 @@
			@Autowired
			private IPartsPermissionService partsPermissionService;
			@Autowired
			private IDepartmentService departmentService;
			private IProcessSpecVersionPermissionService processSpecVersionPermissionService;
			@Autowired
			private IProcessSpecVersionDepartmentService processSpecVersionDepartmentService;
			@Autowired
			private ISysUserService userService;
			@Autowired
			@Lazy
			private IProcessStreamService processStreamService;
			@Autowired
			private IWorkStepService workStepService;
			@Autowired
			private IWorkStepDepartmentService workStepDepartmentService;
			@Autowired
			private IProcessionDepartmentService processionDepartmentService;
			@Autowired
			private IMdcProductionService mdcProductionService;
			@Autowired
			private IDocRelativeService iDocRelativeService;
			@Autowired
			private IProcessStreamPermissionService iProcessStreamPermissionService;
			@Autowired
			private IWorkStepPermissionService iWorkStepPermissionService;
			@Autowired
			private IProductMixService productMixService;
			@Autowired
			@Lazy
			private IDocInfoService docInfoService;
			@Autowired
			private INcLogInfoService iNcLogInfoService;
			private IDeviceTypeService deviceTypeService;
			@Autowired
			private IDeviceManagementService deviceManagementService;

			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean addProductInfo(ProductInfo productInfo) {
			if(productInfo == null)
			if (productInfo == null)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(!ValidateUtil.validateString(productInfo.getProductName()))
			if (!ValidateUtil.validateString(productInfo.getProductName()))
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NAME_NONE);
			if(!ValidateUtil.validateString(productInfo.getProductNo())) {
			if (!ValidateUtil.validateString(productInfo.getProductNo())) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NO_NONE);
			}
			ProductInfo en = getByProductNo(productInfo.getProductNo());
			if(en != null)
			if (en != null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_IS_EXIST);
			LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
			String userId = user.getId();
			if(!ValidateUtil.validateString(userId))
			if (!ValidateUtil.validateString(userId))
			ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
			productInfo.setProductStatus(1);
			//添加日志
			NcLogInfo ncLogInfo = new NcLogInfo();
			//模块
			ncLogInfo.setModuleInfo("产品结构树");
			//类型
			ncLogInfo.setOperateType(2);
			//日志内容
			ncLogInfo.setLogContent("产品名称："+productInfo.getProductName()+"，产品编号："+productInfo.getProductNo());
			iNcLogInfoService.saveLogNcInfos(ncLogInfo);
			boolean b = super.save(productInfo);
			if(!b) {
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
			}
			ProductPermission permission = new ProductPermission();
			permission.setProductId(productInfo.getProductId());
			permission.setUserId(userId);
			b = productPermissionService.save(permission);
			if(!b) {
			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
			@Transactional(rollbackFor = {Exception.class})
			public boolean editProductInfo(String id ,ProductInfo productInfo) {
			if(!ValidateUtil.validateString(id) \|\| productInfo == null)
			public boolean editProductInfo(String id, ProductInfo productInfo) {
			if (!ValidateUtil.validateString(id) \|\| productInfo == null)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
			String userId = user.getId();
			if(!ValidateUtil.validateString(userId))
			if (!ValidateUtil.validateString(userId))
			ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
			ProductInfo en = super.getById(id);
			if(en == null)
			if (en == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			productInfo.setProductId(id);
			productInfo.setProductStatus(null);
			//添加日志
			NcLogInfo ncLogInfo = new NcLogInfo();
			//模块
			ncLogInfo.setModuleInfo("产品结构树");
			//类型
			ncLogInfo.setOperateType(3);
			//日志内容
			ncLogInfo.setLogContent("产品名称："+productInfo.getProductName());
			ncLogInfo.setRemark(JSONObject.toJSONString(en));
			iNcLogInfoService.saveLogNcInfos(ncLogInfo);
			boolean b = super.updateById(productInfo);
			if(!b)
			//同步修改结构树
			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);
			if(permission == null) {
			if (permission == null) {
			permission = new ProductPermission();
			permission.setProductId(id);
			permission.setUserId(userId);
			b = productPermissionService.save(permission);
			if(!b) {
			if (!b) {
			return false;
			}
			}
			PermissionStream stream = permissionStreamService.getByProductIdAndUserId(id, userId);
			if(stream == null) {
			stream = new PermissionStream();
			stream.setProductId(id);
			PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(id, userId, DocAttributionTypeEnum.PRODUCT.getCode().toString());
			if (stream == null) {
			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;
			}

			@Override
			public List<CommonGenericTree> loadProductTree(String userId) {
			//产品
			List<ProductInfo> productInfoList = getByUserPerms(userId);
			if(productInfoList == null \|\| productInfoList.isEmpty())
			if (productInfoList == null \|\| productInfoList.isEmpty())
			return Collections.emptyList();
			//部件
			List<ComponentExt> componentInfoList = componentInfoService.getByUserPermsAs(userId);
			if(componentInfoList == null)
			if (componentInfoList == null)
			componentInfoList = Collections.emptyList();
			//零件
			List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId);
			if(partsInfos == null)
			if (partsInfos == null)
			partsInfos = Collections.emptyList();
			return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos);
			//工艺规程版本
			List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByUserPerms(userId);
			if (processSpecVersions == null)
			processSpecVersions = Collections.emptyList();
			//工序
			List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId);
			if (processStreams == null)
			processStreams = Collections.emptyList();
			//工步
			List<WorkStep> workStepList = workStepService.getByUserPerms(userId);
			if (workStepList == null)
			workStepList = Collections.emptyList();
			return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos, processSpecVersions,processStreams, workStepList);
			}

			@Override
			public List<ProductInfo> getByUserPerms(String userId) {
			if(!ValidateUtil.validateString(userId))
			if (!ValidateUtil.validateString(userId))
			return Collections.emptyList();
			return super.getBaseMapper().getByUserPerms(userId);
			}

			@Override
			public List<ProductInfo> getByUserPerms(String userId, String queryParam) {
			if(!ValidateUtil.validateString(userId))
			if (!ValidateUtil.validateString(userId))
			return Collections.emptyList();
			//去除权限 TODO
			LambdaQueryWrapper<ProductInfo> queryWrapper = Wrappers.lambdaQuery();
			if(ValidateUtil.validateString(queryParam)) {
			if (ValidateUtil.validateString(queryParam)) {
			queryWrapper.and(wrapper -> wrapper.like(ProductInfo::getProductNo, queryParam)
			.or()
			.like(ProductInfo::getProductName, queryParam));
			@@ -199,1004 +243,355 @@
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean deleteProductInfo(String id) {
			if(!ValidateUtil.validateString(id))
			if (!ValidateUtil.validateString(id))
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			ProductInfo productInfo = super.getById(id);
			if(productInfo == null)
			if (productInfo == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			//验证产品下是否有部件
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			if(componentInfoList != null && !componentInfoList.isEmpty()) {
			if (componentInfoList != null && !componentInfoList.isEmpty()) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_COMPONENT_EXIST);
			}
			//验证产品下是否有零件
			List<PartsInfo> partsInfoList = partsInfoService.getByProductId(productInfo.getProductId());
			if(partsInfoList != null && !partsInfoList.isEmpty()) {
			if (partsInfoList != null && !partsInfoList.isEmpty()) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_PARTS_EXIST);
			}
			List<ProcessStream> processStreams = processStreamService.findByProductId(id);
			if(processStreams != null && !processStreams.isEmpty())
			if (processStreams != null && !processStreams.isEmpty())
			ExceptionCast.cast(ProductInfoCode.PRODUCT_PROCESS_EXIST);
			boolean b = productPermissionService.deleteByProductId(id);
			if(!b)
			//验证是否存在文档
			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);
			}
			if (!b)
			ExceptionCast.cast(CommonCode.FAIL);
			b = productDepartmentService.deleteByProductId(id);
			if(!b)
			if (!b)
			ExceptionCast.cast(CommonCode.FAIL);
			b = permissionStreamService.deleteUserPermsByProductId(id);
			if(!b)
			b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, DocAttributionTypeEnum.PRODUCT.getCode().toString(),"0");
			if (!b)
			ExceptionCast.cast(CommonCode.FAIL);
			b = permissionStreamService.deleteDepartPermsByProductId(id);
			if(!b)
			b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, DocAttributionTypeEnum.PRODUCT.getCode().toString(),"1");
			if (!b)
			ExceptionCast.cast(CommonCode.FAIL);
			b = docInfoService.deleteByProductId(id);
			if(!b)
			b = productMixService.removeById(id);
			if (!b)
			ExceptionCast.cast(CommonCode.FAIL);
			//添加日志
			NcLogInfo ncLogInfo = new NcLogInfo();
			//模块
			ncLogInfo.setModuleInfo("产品结构树");
			//类型
			ncLogInfo.setOperateType(4);
			//日志内容
			ncLogInfo.setLogContent("产品名称："+productInfo.getProductName());
			iNcLogInfoService.saveLogNcInfos(ncLogInfo);
			return super.removeById(id);
			}

			@Override
			public boolean checkProductPerm(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			if (!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
			String userId = user.getId();
			if(!ValidateUtil.validateString(userId))
			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)
			if (productInfo == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			PermissionStream permission = permissionStreamService.getByProductIdAndUserId(paramId, userId);
			if(permission == null)
			return false;
			return true;
			}else if(nodeType == 2) {
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(paramId, userId,"1");
			return permission != null;
			} else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())) {
			ComponentInfo componentInfo = componentInfoService.getById(paramId);
			if(componentInfo == null)
			if (componentInfo == null)
			ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
			PermissionStream permission = permissionStreamService.getByComponentIdAndUserId(componentInfo.getProductId(), paramId, userId);
			if(permission == null)
			return false;
			return true;
			}else if(nodeType == 3) {
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(componentInfo.getComponentId(), userId,"2");
			return permission != null;
			} else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
			PartsInfo partsInfo = partsInfoService.getById(paramId);
			if(partsInfo == null)
			if (partsInfo == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			PermissionStream permission = permissionStreamService.getByPartsIdAndUserId(partsInfo.getProductId(), partsInfo.getComponentId(), paramId, userId);
			if(permission == null)
			return false;
			return true;
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(partsInfo.getPartsId(), userId, "3");
			return permission != null;
			} 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);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processStream.getProcessId(), userId,"5");
			return permission != null;
			} else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
			WorkStep workStep = workStepService.getById(paramId);
			if (workStep == null)
			ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(workStep.getId(), userId,"6");
			return permission != null;
			}
			return false;
			}

			@Override
			public List<UserDepartExt> getUserPermsList(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(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 {
			} 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.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
			return iWorkStepPermissionService.getUserPermsByProductId(paramId);
			} else {
			return null;
			}
			}

			@Override
			public List<SysUser> getUserNonPermsList(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(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 {
			} 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.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
			return iWorkStepPermissionService.getUserNonPermsByProductId(paramId);
			} else {
			return null;
			}
			}

			@Override
			public List<Department> getDepartPermsList(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			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 {
			} 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.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
			return workStepDepartmentService.getDepartPermsByStepId(paramId);
			}
			else {
			return null;
			}
			}

			@Override
			public List<Department> getDepartNonPermsList(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			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 {
			} else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
			return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
			} 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;
			}
			}

			/**
			* 1、循环插入优化
			* 2、查询优化
			* 3、封装优化 TODO
			* @param nodeType 1 产品 2 部件 3 零件
			* @param paramId 产品树节点id
			* @param nodeType 1 产品 2 部件 3 零件
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			* @param userIds 添加用户ids
			* @param userIds 添加用户ids
			* todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
			* @return
			*/
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignAddUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
			//参数校验
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId) \|\|
			!ValidateUtil.validateInteger(relativeFlag))
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(userIds == null \|\| userIds.length < 1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
			public boolean assignAddUserAll(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
			// 参数校验
			validateInputParameters(nodeType, paramId, relativeFlag, "1", userIds);
			List<String> ids = new ArrayList<>(userIds.length);
			Collections.addAll(ids, userIds);
			Collection<SysUser> userList = userService.listByIds(ids);
			if(userList == null \|\| userList.isEmpty() \|\| userList.size() != userIds.length)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			//节点类型判定
			if(nodeType == 3) {
			//处理零件
			PartsInfo partsInfo = partsInfoService.getById(paramId);
			if(partsInfo == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			boolean b = checkProductPerm(3, partsInfo.getPartsId());
			if(!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			return partsInfoService.assignAddUser(partsInfo, userList);
			}else if(nodeType == 1) {
			//处理产品
			ProductInfo productInfo = super.getById(paramId);
			if(productInfo == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			boolean b1 = checkProductPerm(1, productInfo.getProductId());
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			b1 = this.assignAddUser(productInfo, userList);
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			if(relativeFlag == 1) {
			validateSysUserList(userList, ids);
			switch (nodeType) {
			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);

			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			if(componentInfoList == null \|\| componentInfoList.isEmpty()){
			//没有可添加的零部件权限
			return true;
			}

			//最终保存权限数据初始化
			List<ComponentPermission> componentPermissionList = new ArrayList<>();
			List<PartsPermission> partsPermissionList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			//处理子部件
			List<String> componentIds = new ArrayList<>();
			PermissionStream s;

			Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
			Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

			//初始化全体数据
			String key;
			ComponentPermission cp;
			ComponentInfo cpInfo;
			for(ComponentInfo c : componentInfoList){
			componentIds.add(c.getComponentId());
			componentInfoMap.put(c.getComponentId(), c);
			for(SysUser u : userList){
			key = c.getComponentId() + "," + u.getId();
			cp = new ComponentPermission(c.getComponentId(), u.getId());
			componentPermissionMap.put(key, cp);
			}
			}
			//查询已存在的权限数据
			List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
			if(existList != null && !existList.isEmpty()){
			//踢出权限数据
			for(ComponentPermission permission : existList){
			key = permission.getComponentId() + "," + permission.getUserId();
			if(componentPermissionMap.containsKey(key)){
			componentPermissionMap.remove(key);
			}
			}
			}
			for(Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()){
			cp = entry.getValue();
			componentPermissionList.add(cp);
			cpInfo = componentInfoMap.get(cp.getComponentId());
			s = new PermissionStream();
			s.setProductId(cpInfo.getProductId());
			s.setComponentId(cpInfo.getComponentId());
			s.setUserId(cp.getUserId());
			permissionStreamList.add(s);
			}

			//处理子零件
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
			if(partsInfoList != null && !partsInfoList.isEmpty()) {
			Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
			Map<String, PartsInfo> partsInfoMap = new HashMap<>();
			List<String> partsIds = new ArrayList<>();
			PartsPermission pp;
			PartsInfo ptInfo;
			for(PartsInfo p : partsInfoList){
			partsIds.add(p.getPartsId());
			partsInfoMap.put(p.getPartsId(), p);
			for(SysUser u : userList){
			key = p.getPartsId() + "," + u.getId();
			pp = new PartsPermission(p.getPartsId(), u.getId());
			partsPermissionHashMap.put(key, pp);
			}
			}

			//查询已存在的权限数据
			List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
			if(existPartsList != null && !existPartsList.isEmpty()){
			//踢出权限数据
			for(PartsPermission permission : existPartsList){
			key = permission.getPartsId() + "," + permission.getUserId();
			if(partsPermissionHashMap.containsKey(key)){
			partsPermissionHashMap.remove(key);
			}
			}
			}

			for(Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()){
			pp = entry.getValue();
			partsPermissionList.add(pp);
			ptInfo = partsInfoMap.get(pp.getPartsId());
			s = new PermissionStream();
			s.setProductId(ptInfo.getProductId());
			s.setComponentId(ptInfo.getComponentId());
			s.setPartsId(ptInfo.getPartsId());
			s.setUserId(pp.getUserId());
			permissionStreamList.add(s);
			}
			}

			if(!componentPermissionList.isEmpty()){
			componentPermissionService.saveBatch(componentPermissionList);
			}
			if(!partsPermissionList.isEmpty()){
			partsPermissionService.saveBatch(partsPermissionList);
			}
			if(!permissionStreamList.isEmpty()){
			permissionStreamService.saveBatch(permissionStreamList);
			}
			}
			return true;
			}else if(nodeType == 2) {
			//处理部件
			ComponentInfo componentInfo = componentInfoService.getById(paramId);
			if(componentInfo == null)
			ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
			boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
			if(!b1){
			//没有当前部件的权限
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			b1 = componentInfoService.assignAddUser(componentInfo, userList);
			if(!b1){
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if(relativeFlag == 1) {
			//最终保存权限数据初始化
			List<ComponentPermission> componentPermissionList = new ArrayList<>();
			List<PartsPermission> partsPermissionList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();

			List<String> componentIds = new ArrayList<>();
			PermissionStream s;
			String key;
			//处理子部件
			List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
			if(childrenList != null && !childrenList.isEmpty()) {
			Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
			Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

			//初始化全体数据
			ComponentPermission cp;
			ComponentInfo cpInfo;
			for(ComponentInfo c : childrenList){
			componentIds.add(c.getComponentId());
			componentInfoMap.put(c.getComponentId(), c);
			for(SysUser u : userList){
			key = c.getComponentId() + "," + u.getId();
			cp = new ComponentPermission(c.getComponentId(), u.getId());
			componentPermissionMap.put(key, cp);
			}
			}
			//查询已存在的权限数据
			List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
			if(existList != null && !existList.isEmpty()){
			//踢出权限数据
			for(ComponentPermission permission : existList){
			key = permission.getComponentId() + "," + permission.getUserId();
			if(componentPermissionMap.containsKey(key)){
			componentPermissionMap.remove(key);
			}
			}
			}
			for(Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()){
			cp = entry.getValue();
			componentPermissionList.add(cp);
			cpInfo = componentInfoMap.get(cp.getComponentId());
			s = new PermissionStream();
			s.setProductId(cpInfo.getProductId());
			s.setComponentId(cpInfo.getComponentId());
			s.setUserId(cp.getUserId());
			permissionStreamList.add(s);
			}
			}
			//处理零件
			componentIds.add(componentInfo.getComponentId());
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIds);
			if(partsInfoList != null && !partsInfoList.isEmpty()) {
			Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
			Map<String, PartsInfo> partsInfoMap = new HashMap<>();
			List<String> partsIds = new ArrayList<>();
			PartsPermission pp;
			PartsInfo ptInfo;
			for(PartsInfo p : partsInfoList){
			partsIds.add(p.getPartsId());
			partsInfoMap.put(p.getPartsId(), p);
			for(SysUser u : userList){
			key = p.getPartsId() + "," + u.getId();
			pp = new PartsPermission(p.getPartsId(), u.getId());
			partsPermissionHashMap.put(key, pp);
			}
			}

			//查询已存在的权限数据
			List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
			if(existPartsList != null && !existPartsList.isEmpty()){
			//踢出权限数据
			for(PartsPermission permission : existPartsList){
			key = permission.getPartsId() + "," + permission.getUserId();
			if(partsPermissionHashMap.containsKey(key)){
			partsPermissionHashMap.remove(key);
			}
			}
			}

			for(Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()){
			pp = entry.getValue();
			partsPermissionList.add(pp);
			ptInfo = partsInfoMap.get(pp.getPartsId());
			s = new PermissionStream();
			s.setProductId(ptInfo.getProductId());
			s.setComponentId(ptInfo.getComponentId());
			s.setPartsId(ptInfo.getPartsId());
			s.setUserId(pp.getUserId());
			permissionStreamList.add(s);
			}
			}
			if(!componentPermissionList.isEmpty()){
			componentPermissionService.saveBatch(componentPermissionList);
			}
			if(!partsPermissionList.isEmpty()){
			partsPermissionService.saveBatch(partsPermissionList);
			}
			if(!permissionStreamList.isEmpty()){
			permissionStreamService.saveBatch(permissionStreamList);
			}
			}
			return true;
			default:
			return false;
			}
			return false;
			}

			/**
			* 待优化 TODO
			* @param nodeType 1 产品 2 部件 3 零件
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			* @param userIds 移除用户ids
			* @return
			*/
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignRemoveUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId) \|\|
			!ValidateUtil.validateInteger(relativeFlag))
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(userIds == null \|\| userIds.length < 1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
			List<String> ids = new ArrayList<>(userIds.length);
			Collections.addAll(ids, userIds);
			Collection<SysUser> userList = userService.listByIds(ids);
			if(userList == null \|\| userList.isEmpty() \|\| userList.size() != userIds.length)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(nodeType == 3) {
			//处理零件
			PartsInfo partsInfo = partsInfoService.getById(paramId);
			if(partsInfo == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			boolean b = checkProductPerm(3, partsInfo.getPartsId());
			if(!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			return partsInfoService.assignRemoveUser(partsInfo, userList);
			}else if(nodeType == 1) {
			//处理产品
			ProductInfo productInfo = super.getById(paramId);
			if(productInfo == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			boolean b1 = checkProductPerm(1, productInfo.getProductId());
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			b1 = this.assignRemoveUser(productInfo, userList);
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			if(relativeFlag == 1) {
			//处理产品下的部件
			List<String> componentIds = new ArrayList<>();
			//总计需要删除的数据信息
			List<ComponentPermission> componentPermissionList = new ArrayList<>();
			List<PartsPermission> partsPermissionList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			if(componentInfoList != null && !componentInfoList.isEmpty()) {
			for(ComponentInfo componentInfo : componentInfoList){
			componentIds.add(componentInfo.getComponentId());
			}
			componentPermissionList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndUserIds(componentIds, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

			//处理产品下的零件
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
			List<String> partsIds = new ArrayList<>();
			if(partsInfoList != null && !partsInfoList.isEmpty()) {
			for(PartsInfo partsInfo : partsInfoList){
			partsIds.add(partsInfo.getPartsId());
			}
			partsPermissionList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndUserIds(partsIds, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

			if(componentPermissionList != null && !componentPermissionList.isEmpty()){
			componentPermissionService.removeByCollection(componentPermissionList);
			}
			if(partsPermissionList != null && !partsPermissionList.isEmpty()){
			partsPermissionService.removeByCollection(partsPermissionList);
			}
			if(permissionStreamList != null && !permissionStreamList.isEmpty()){
			permissionStreamService.removeByCollection(permissionStreamList);
			}
			}
			return true;
			}else if(nodeType == 2) {
			ComponentInfo componentInfo = componentInfoService.getById(paramId);
			if(componentInfo == null)
			ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
			boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			b1 = componentInfoService.assignRemoveUser(componentInfo, userList);
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			if(relativeFlag == 1) {
			List<String> componentIdList = new ArrayList<>();
			//最终需要删除的数据
			List<ComponentPermission> componentPermissionList = new ArrayList<>();
			List<PartsPermission> partsPermissionList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
			if(childrenList != null && !childrenList.isEmpty()) {
			for(ComponentInfo component : childrenList){
			componentIdList.add(component.getComponentId());
			}
			componentPermissionList = componentPermissionService.getByComponentIdsAndUserIds(componentIdList, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndUserIds(componentIdList, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

			componentIdList.add(componentInfo.getComponentId());
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
			List<String> partsIds = new ArrayList<>();
			if(partsInfoList != null && !partsInfoList.isEmpty()) {
			for(PartsInfo partsInfo : partsInfoList){
			partsIds.add(partsInfo.getPartsId());
			}
			partsPermissionList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndUserIds(partsIds, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}
			if(componentPermissionList != null && !componentPermissionList.isEmpty()){
			componentPermissionService.removeByCollection(componentPermissionList);
			}
			if(partsPermissionList != null && !partsPermissionList.isEmpty()){
			partsPermissionService.removeByCollection(partsPermissionList);
			}
			if(permissionStreamList != null && !permissionStreamList.isEmpty()){
			permissionStreamService.removeByCollection(permissionStreamList);
			}
			}
			return true;
			}
			return false;
			}

			/**
			* 待优化 TODO
			* @param nodeType 1 产品 2 部件 3 零件
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			* @param nodeType 1 产品 2 部件 3 零件 5 工序 6 工步
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			* @param departmentIds 添加部门ids
			* todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
			* @return
			*/
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignAddDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId) \|\|
			!ValidateUtil.validateInteger(relativeFlag))
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(departmentIds == null \|\| departmentIds.length < 1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
			public boolean assignAddDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
			validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds);
			List<String> ids = new ArrayList<>(departmentIds.length);
			Collections.addAll(ids, departmentIds);
			Collection<Department> departList = departmentService.listByIds(ids);
			if(departList == null \|\| departList.isEmpty() \|\| departList.size() != departmentIds.length)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(nodeType == 3) {
			//处理零件
			PartsInfo partsInfo = partsInfoService.getById(paramId);
			if(partsInfo == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			boolean b = checkProductPerm(3, partsInfo.getPartsId());
			if(!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			return partsInfoService.assignAddDepart(partsInfo, departList);
			}else if(nodeType == 1) {
			//处理产品
			ProductInfo productInfo = super.getById(paramId);
			if(productInfo == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			boolean b1 = checkProductPerm(1, productInfo.getProductId());
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			b1 = this.assignAddDepartment(productInfo, departList);
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			if(relativeFlag == 1) {
			//处理产品下的部件
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			//最终保存权限数据初始化
			List<ComponentDepartment> componentPermissionList = new ArrayList<>();
			List<PartsDepartment> partsPermissionList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			//处理子部件
			List<String> componentIds = new ArrayList<>();
			PermissionStream s;
			List<String> deps=mdcProductionService.findAllProductionIds(ids);
			Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(deps);
			validateMdcProductionList(mdcProductionList, deps);
			switch (nodeType) {
			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);

			Map<String, ComponentDepartment> componentPermissionMap = new HashMap<>();
			Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

			//初始化全体数据
			String key;
			ComponentDepartment cp;
			ComponentInfo cpInfo;
			for(ComponentInfo c : componentInfoList){
			componentIds.add(c.getComponentId());
			componentInfoMap.put(c.getComponentId(), c);
			for(Department u : departList){
			key = c.getComponentId() + "," + u.getDepartId();
			cp = new ComponentDepartment(c.getComponentId(), u.getDepartId());
			componentPermissionMap.put(key, cp);
			}
			}
			//查询已存在的权限数据
			List<ComponentDepartment> existList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, ids);
			if(existList != null && !existList.isEmpty()){
			//踢出权限数据
			for(ComponentDepartment permission : existList){
			key = permission.getComponentId() + "," + permission.getDepartId();
			if(componentPermissionMap.containsKey(key)){
			componentPermissionMap.remove(key);
			}
			}
			}
			for(Map.Entry<String, ComponentDepartment> entry : componentPermissionMap.entrySet()){
			cp = entry.getValue();
			componentPermissionList.add(cp);
			cpInfo = componentInfoMap.get(cp.getComponentId());
			s = new PermissionStream();
			s.setProductId(cpInfo.getProductId());
			s.setComponentId(cpInfo.getComponentId());
			s.setDepartId(cp.getDepartId());
			permissionStreamList.add(s);
			}

			//处理子零件
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
			if(partsInfoList != null && !partsInfoList.isEmpty()) {
			Map<String, PartsDepartment> partsPermissionHashMap = new HashMap<>();
			Map<String, PartsInfo> partsInfoMap = new HashMap<>();
			List<String> partsIds = new ArrayList<>();
			PartsDepartment pp;
			PartsInfo ptInfo;
			for(PartsInfo p : partsInfoList){
			partsIds.add(p.getPartsId());
			partsInfoMap.put(p.getPartsId(), p);
			for(Department u : departList){
			key = p.getPartsId() + "," + u.getDepartId();
			pp = new PartsDepartment(p.getPartsId(), u.getDepartId());
			partsPermissionHashMap.put(key, pp);
			}
			}

			//查询已存在的权限数据
			List<PartsDepartment> existPartsList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
			if(existPartsList != null && !existPartsList.isEmpty()){
			//踢出权限数据
			for(PartsDepartment permission : existPartsList){
			key = permission.getPartsId() + "," + permission.getDepartId();
			if(partsPermissionHashMap.containsKey(key)){
			partsPermissionHashMap.remove(key);
			}
			}
			}

			for(Map.Entry<String, PartsDepartment> entry : partsPermissionHashMap.entrySet()){
			pp = entry.getValue();
			partsPermissionList.add(pp);
			ptInfo = partsInfoMap.get(pp.getPartsId());
			s = new PermissionStream();
			s.setProductId(ptInfo.getProductId());
			s.setComponentId(ptInfo.getComponentId());
			s.setPartsId(ptInfo.getPartsId());
			s.setDepartId(pp.getDepartId());
			permissionStreamList.add(s);
			}
			}

			if(!componentPermissionList.isEmpty()){
			componentDepartmentService.saveBatch(componentPermissionList);
			}
			if(!partsPermissionList.isEmpty()){
			partsDepartmentService.saveBatch(partsPermissionList);
			}
			if(!permissionStreamList.isEmpty()){
			permissionStreamService.saveBatch(permissionStreamList);
			}
			}
			return true;
			}else if(nodeType == 2) {
			ComponentInfo componentInfo = componentInfoService.getById(paramId);
			if(componentInfo == null)
			ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
			boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			b1 = componentInfoService.assignAddDepart(componentInfo, departList);
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			if(relativeFlag == 1) {
			List<String> componentIdList = new ArrayList<>();
			List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());

			//最终保存权限数据初始化
			List<ComponentDepartment> componentPermissionList = new ArrayList<>();
			List<PartsDepartment> partsPermissionList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			//处理子部件
			PermissionStream s;

			Map<String, ComponentDepartment> componentPermissionMap = new HashMap<>();
			Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

			//初始化全体数据
			String key;
			ComponentDepartment cp;
			ComponentInfo cpInfo;
			for(ComponentInfo c : childrenList){
			componentIdList.add(c.getComponentId());
			componentInfoMap.put(c.getComponentId(), c);
			for(Department u : departList){
			key = c.getComponentId() + "," + u.getDepartId();
			cp = new ComponentDepartment(c.getComponentId(), u.getDepartId());
			componentPermissionMap.put(key, cp);
			}
			}
			//查询已存在的权限数据
			List<ComponentDepartment> existList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIdList, ids);
			if(existList != null && !existList.isEmpty()){
			//踢出权限数据
			for(ComponentDepartment permission : existList){
			key = permission.getComponentId() + "," + permission.getDepartId();
			if(componentPermissionMap.containsKey(key)){
			componentPermissionMap.remove(key);
			}
			}
			}
			for(Map.Entry<String, ComponentDepartment> entry : componentPermissionMap.entrySet()){
			cp = entry.getValue();
			componentPermissionList.add(cp);
			cpInfo = componentInfoMap.get(cp.getComponentId());
			s = new PermissionStream();
			s.setProductId(cpInfo.getProductId());
			s.setComponentId(cpInfo.getComponentId());
			s.setDepartId(cp.getDepartId());
			permissionStreamList.add(s);
			}

			//处理子零件
			componentIdList.add(componentInfo.getComponentId());
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
			if(partsInfoList != null && !partsInfoList.isEmpty()) {
			Map<String, PartsDepartment> partsPermissionHashMap = new HashMap<>();
			Map<String, PartsInfo> partsInfoMap = new HashMap<>();
			List<String> partsIds = new ArrayList<>();
			PartsDepartment pp;
			PartsInfo ptInfo;
			for(PartsInfo p : partsInfoList){
			partsIds.add(p.getPartsId());
			partsInfoMap.put(p.getPartsId(), p);
			for(Department u : departList){
			key = p.getPartsId() + "," + u.getDepartId();
			pp = new PartsDepartment(p.getPartsId(), u.getDepartId());
			partsPermissionHashMap.put(key, pp);
			}
			}

			//查询已存在的权限数据
			List<PartsDepartment> existPartsList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
			if(existPartsList != null && !existPartsList.isEmpty()){
			//踢出权限数据
			for(PartsDepartment permission : existPartsList){
			key = permission.getPartsId() + "," + permission.getDepartId();
			if(partsPermissionHashMap.containsKey(key)){
			partsPermissionHashMap.remove(key);
			}
			}
			}

			for(Map.Entry<String, PartsDepartment> entry : partsPermissionHashMap.entrySet()){
			pp = entry.getValue();
			partsPermissionList.add(pp);
			ptInfo = partsInfoMap.get(pp.getPartsId());
			s = new PermissionStream();
			s.setProductId(ptInfo.getProductId());
			s.setComponentId(ptInfo.getComponentId());
			s.setPartsId(ptInfo.getPartsId());
			s.setDepartId(pp.getDepartId());
			permissionStreamList.add(s);
			}
			}

			if(!componentPermissionList.isEmpty()){
			componentDepartmentService.saveBatch(componentPermissionList);
			}
			if(!partsPermissionList.isEmpty()){
			partsDepartmentService.saveBatch(partsPermissionList);
			}
			if(!permissionStreamList.isEmpty()){
			permissionStreamService.saveBatch(permissionStreamList);
			}
			}
			return true;
			default:
			return false;
			}
			return false;
			}

			/**
			* 待优化 TODO
			* @param nodeType 1 产品 2 部件 3 零件
			* @param paramId 产品树节点id
			* @param nodeType 1 产品 2 部件 3 零件
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			* @param departmentIds 移除部门ids
			* @param userIds 移除用户ids
			* todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
			* @return
			*/
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignRemoveDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId) \|\|
			!ValidateUtil.validateInteger(relativeFlag))
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(departmentIds == null \|\| departmentIds.length < 1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
			public boolean assignRemoveUserAll(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
			validateInputParameters(nodeType, paramId, relativeFlag, "1", userIds);
			List<String> userIdsList = Arrays.asList(userIds);
			Collection<SysUser> userList = userService.listByIds(userIdsList);
			validateSysUserList(userList, userIdsList);
			switch (nodeType) {
			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;
			}
			}


			/**
			*
			* @param nodeType 1 产品 2 部件 3 零件 5 工序 6 工步
			* @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> ids = new ArrayList<>(departmentIds.length);
			Collections.addAll(ids, departmentIds);
			Collection<Department> departList = departmentService.listByIds(ids);
			if(departList == null \|\| departList.isEmpty() \|\| departList.size() != departmentIds.length)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(nodeType == 3) {
			//处理零件
			PartsInfo partsInfo = partsInfoService.getById(paramId);
			if(partsInfo == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			boolean b = checkProductPerm(3, partsInfo.getPartsId());
			if(!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			return partsInfoService.assignRemoveDepart(partsInfo, departList);
			}else if(nodeType == 1) {
			//处理产品
			ProductInfo productInfo = super.getById(paramId);
			if(productInfo == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			boolean b1 = checkProductPerm(1, productInfo.getProductId());
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			b1 = this.assignRemoveDepartment(productInfo, departList);
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			if(relativeFlag == 1) {
			//处理产品下的部件
			List<String> componentIds = new ArrayList<>();
			//总计需要删除的数据信息
			List<ComponentDepartment> componentPermissionList = new ArrayList<>();
			List<PartsDepartment> partsPermissionList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			if(componentInfoList != null && !componentInfoList.isEmpty()) {
			for(ComponentInfo componentInfo : componentInfoList){
			componentIds.add(componentInfo.getComponentId());
			}
			componentPermissionList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndDepartIds(componentIds, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

			//处理产品下的零件
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
			List<String> partsIds = new ArrayList<>();
			if(partsInfoList != null && !partsInfoList.isEmpty()) {
			for(PartsInfo partsInfo : partsInfoList){
			partsIds.add(partsInfo.getPartsId());
			}
			partsPermissionList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(partsIds, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

			if(componentPermissionList != null && !componentPermissionList.isEmpty()){
			componentDepartmentService.removeByCollection(componentPermissionList);
			}
			if(partsPermissionList != null && !partsPermissionList.isEmpty()){
			partsDepartmentService.removeByCollection(partsPermissionList);
			}
			if(permissionStreamList != null && !permissionStreamList.isEmpty()){
			permissionStreamService.removeByCollection(permissionStreamList);
			}
			}
			return true;
			}else if(nodeType == 2) {
			ComponentInfo componentInfo = componentInfoService.getById(paramId);
			if(componentInfo == null)
			ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
			boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			b1 = componentInfoService.assignRemoveDepart(componentInfo, departList);
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			if(relativeFlag == 1) {
			List<String> componentIdList = new ArrayList<>();
			//总计需要删除的数据信息
			List<ComponentDepartment> componentPermissionList = new ArrayList<>();
			List<PartsDepartment> partsPermissionList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();

			List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
			if(childrenList != null && !childrenList.isEmpty()) {
			for(ComponentInfo cpn : childrenList){
			componentIdList.add(cpn.getComponentId());
			}
			componentPermissionList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIdList, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndDepartIds(componentIdList, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

			//处理产品下的零件
			componentIdList.add(componentInfo.getComponentId());
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
			List<String> partsIds = new ArrayList<>();
			if(partsInfoList != null && !partsInfoList.isEmpty()) {
			for(PartsInfo partsInfo : partsInfoList){
			partsIds.add(partsInfo.getPartsId());
			}
			partsPermissionList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(partsIds, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

			if(componentPermissionList != null && !componentPermissionList.isEmpty()){
			componentDepartmentService.removeByCollection(componentPermissionList);
			}
			if(partsPermissionList != null && !partsPermissionList.isEmpty()){
			partsDepartmentService.removeByCollection(partsPermissionList);
			}
			if(permissionStreamList != null && !permissionStreamList.isEmpty()){
			permissionStreamService.removeByCollection(permissionStreamList);
			}
			}
			return true;
			List<String> deps=mdcProductionService.findAllProductionIds(ids);
			Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(deps);
			validateMdcProductionList(mdcProductionList, deps);
			switch (nodeType) {
			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;
			}
			return false;
			}

			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignAddUser(ProductInfo productInfo, Collection<SysUser> userList) {
			if(productInfo == null \|\| userList == null \|\| userList.isEmpty())
			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) {
			if (en == null) {
			en = new ProductPermission();
			en.setUserId(item.getId());
			en.setProductId(productInfo.getProductId());
			permissionList.add(en);
			}
			PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
			if(stream == null) {
			stream = new PermissionStream();
			PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(productInfo.getProductId(), item.getId(),"1");
			if (stream == null) {
			stream = new PermissionStreamNew();
			stream.setUserId(item.getId());
			stream.setProductId(productInfo.getProductId());
			stream.setBusinessId(productInfo.getProductId());
			stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
			permissionStreamList.add(stream);
			}
			});
			if(!permissionList.isEmpty()) {
			if (!permissionList.isEmpty()) {
			boolean b = productPermissionService.saveBatch(permissionList);
			if(!b) {
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			if(!permissionStreamList.isEmpty()) {
			boolean b = permissionStreamService.saveBatch(permissionStreamList);
			if(!b) {
			if (!permissionStreamList.isEmpty()) {
			boolean b =permissionStreamNewService.saveBatch(permissionStreamList);
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			@@ -1206,33 +601,33 @@
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignRemoveUser(ProductInfo productInfo, Collection<SysUser> userList) {
			if(productInfo == null \|\| userList == null \|\| userList.isEmpty())
			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) {
			if (en != null) {
			permissionList.add(en);
			}
			PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
			if(stream != null) {
			PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(productInfo.getProductId(), item.getId(),"1");
			if (stream != null) {
			permissionStreamList.add(stream);
			}
			});
			//移除用户权限清空校验
			List<ProductPermission> existList = productPermissionService.getByProductId(productInfo.getProductId());
			if(existList.size() <= permissionList.size())
			if (existList.size() <= permissionList.size())
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_NONE);
			if(!permissionList.isEmpty()) {
			if (!permissionList.isEmpty()) {
			boolean b = productPermissionService.removeByCollection(permissionList);
			if(!b) {
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			if(!permissionStreamList.isEmpty()) {
			boolean b = permissionStreamService.removeByCollection(permissionStreamList);
			if(!b) {
			if (!permissionStreamList.isEmpty()) {
			boolean b = permissionStreamNewService.deletePermissionStreamNewByList(permissionStreamList);
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			@@ -1241,36 +636,37 @@

			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignAddDepartment(ProductInfo productInfo, Collection<Department> departmentList) {
			if(productInfo == null \|\| departmentList == null \|\| departmentList.isEmpty())
			public boolean assignAddDepartment(ProductInfo productInfo, Collection<MdcProduction> departmentList) {
			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.getDepartId());
			if(en == null) {
			ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
			if (en == null) {
			en = new ProductDepartment();
			en.setDepartId(item.getDepartId());
			en.setDepartId(item.getId());
			en.setProductId(productInfo.getProductId());
			productDepartmentList.add(en);
			}
			PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getDepartId());
			if(stream == null) {
			stream = new PermissionStream();
			stream.setDepartId(item.getDepartId());
			stream.setProductId(productInfo.getProductId());
			PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1");
			if (stream == null) {
			stream = new PermissionStreamNew();
			stream.setDepartId(item.getId());
			stream.setBusinessId(productInfo.getProductId());
			stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
			permissionStreamList.add(stream);
			}
			});
			if(!productDepartmentList.isEmpty()) {
			if (!productDepartmentList.isEmpty()) {
			boolean b = productDepartmentService.saveBatch(productDepartmentList);
			if(!b) {
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			if(!permissionStreamList.isEmpty()) {
			boolean b = permissionStreamService.saveBatch(permissionStreamList);
			if(!b) {
			if (!permissionStreamList.isEmpty()) {
			boolean b = permissionStreamNewService.saveBatch(permissionStreamList);
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			@@ -1279,30 +675,30 @@

			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignRemoveDepartment(ProductInfo productInfo, Collection<Department> departmentList) {
			if(productInfo == null \|\| departmentList == null \|\| departmentList.isEmpty())
			public boolean assignRemoveDepartment(ProductInfo productInfo, Collection<MdcProduction> departmentList) {
			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.getDepartId());
			if(en != null) {
			ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
			if (en != null) {
			productDepartmentList.add(en);
			}
			PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getDepartId());
			if(stream != null) {
			PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1");
			if (stream != null) {
			permissionStreamList.add(stream);
			}
			});
			if(!productDepartmentList.isEmpty()) {
			if (!productDepartmentList.isEmpty()) {
			boolean b = productDepartmentService.removeByCollection(productDepartmentList);
			if(!b) {
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			if(!permissionStreamList.isEmpty()) {
			boolean b = permissionStreamService.removeByCollection(permissionStreamList);
			if(!b) {
			if (!permissionStreamList.isEmpty()) {
			boolean b = permissionStreamNewService.deletePermissionStreamNewByList(permissionStreamList);
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			@@ -1312,37 +708,43 @@
			@Override
			public List<String> getDepartIdsByParams(Integer nodeType, String paramId) {
			List<String> departIds = new ArrayList<>();
			if(nodeType == 2) {
			ComponentInfo en = componentInfoService.getById(paramId);
			if(en == null)
			//5-工序
			if (Objects.equals(nodeType, DocAttributionTypeEnum.PROCESS.getCode())) {
			ProcessStream processStream = processStreamService.getById(paramId);
			if (processStream == null)
			return null;
			List<PermissionStream> permissionStreamList = permissionStreamService.getByComponentId(en.getProductId(), en.getComponentId());
			if(permissionStreamList == null \|\| permissionStreamList.isEmpty())
			List<PermissionStreamNew> permissionStreamList = permissionStreamNewService.loadProductMixByBusinessId(processStream.getProcessId(),"5");
			if (permissionStreamList == null \|\| permissionStreamList.isEmpty())
			return null;
			permissionStreamList.forEach(item -> {
			departIds.add(item.getDepartId());
			});
			}else if(nodeType == 3) {
			PartsInfo en = partsInfoService.getById(paramId);
			if(en == null)
			//6-工步
			} else if (Objects.equals(nodeType, DocAttributionTypeEnum.WORKSITE.getCode())) {
			WorkStep workStep = workStepService.getById(paramId);
			if (workStep == null)
			return null;
			List<PermissionStream> permissionStreamList = permissionStreamService.getByPartsId(en.getProductId(), en.getComponentId(), en.getPartsId());
			if(permissionStreamList == null \|\| permissionStreamList.isEmpty())
			List<PermissionStreamNew> permissionStreamList = permissionStreamNewService.loadProductMixByBusinessId(workStep.getId(),"6");
			if (permissionStreamList == null \|\| permissionStreamList.isEmpty())
			return null;
			permissionStreamList.forEach(item -> {
			departIds.add(item.getDepartId());
			});
			}else {
			} else {
			return null;
			}
			//去重
			Set<String> set = new HashSet<>(departIds);
			departIds.clear();
			departIds.addAll(set);
			return departIds;
			}

			@Override
			public ProductInfo getByProductNo(String productNo) {
			if(ValidateUtil.validateString(productNo)) {
			if (ValidateUtil.validateString(productNo)) {
			List<ProductInfo> list = super.lambdaQuery().eq(ProductInfo::getProductNo, productNo).list();
			if(list == null \|\| list.isEmpty())
			if (list == null \|\| list.isEmpty())
			return null;
			return list.get(0);
			}
			@@ -1352,7 +754,7 @@
			@Override
			public List<CommonGenericTree> loadBaseTree(String userId) {
			List<ProductInfo> productInfoList = getByUserPerms(userId);
			if(productInfoList == null \|\| productInfoList.isEmpty())
			if (productInfoList == null \|\| productInfoList.isEmpty())
			return Collections.emptyList();
			// List<ComponentExt> componentInfoList = componentInfoService.getByUserPermsAs(userId);
			// if(componentInfoList == null)
			@@ -1362,62 +764,62 @@

			@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())
			if (componentInfoList == null \|\| componentInfoList.isEmpty())
			return Collections.emptyList();
			List<CommonGenericTree> list = new ArrayList<>();
			CommonGenericTree<ComponentInfo> node;
			for(ComponentInfo c : componentInfoList) {
			for (ComponentInfo c : componentInfoList) {
			node = new CommonGenericTree();
			node.setId(c.getComponentId());
			// node.setLabel("[" + c.getComponentCode()+ "]" + c.getComponentName());
			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;
			if(componentInfoList != null && !componentInfoList.isEmpty()) {
			for(ComponentInfo c : componentInfoList) {
			if (componentInfoList != null && !componentInfoList.isEmpty()) {
			for (ComponentInfo c : componentInfoList) {
			componentNode = new CommonGenericTree();
			componentNode.setId(c.getComponentId());
			// componentNode.setLabel("[" + c.getComponentCode()+ "]" + c.getComponentName());
			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);
			}
			}
			List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, paramId, null);
			if(partsInfos == null \|\| partsInfos.isEmpty())
			if (partsInfos == null \|\| partsInfos.isEmpty())
			return list;
			CommonGenericTree<PartsInfo> partNode;
			for(PartsInfo part : partsInfos) {
			for (PartsInfo part : partsInfos) {
			partNode = new CommonGenericTree();
			partNode.setId(part.getPartsId());
			// partNode.setLabel("[" + part.getPartsCode()+ "]" + part.getPartsName());
			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);
			list.add(partNode);
			}
			return list;
			}else {
			} else {
			return Collections.emptyList();
			}
			}
			@@ -1427,7 +829,9 @@
			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<>();
			List<ProductInfo> productInfoList = new ArrayList<>();

			@@ -1437,32 +841,70 @@
			ProductInfo product;
			ComponentInfo component;

			if(productInfos != null && !productInfos.isEmpty()){
			for(ProductInfo p : productInfos){
			if (productInfos != null && !productInfos.isEmpty()) {
			for (ProductInfo p : productInfos) {
			productInfoList.add(p);
			productInfoMap.put(p.getProductId(), p);
			}
			}

			if(componentInfos != null && !componentInfos.isEmpty()){
			for(ComponentInfo c : componentInfos){
			if (componentInfos != null && !componentInfos.isEmpty()) {
			for (ComponentInfo c : componentInfos) {
			componentInfoList.add(c);
			componentInfoMap.put(c.getComponentId(), c);
			}
			}

			for(PartsInfo p : partsInfos) {
			if(!productInfoMap.containsKey(p.getProductId())) {
			product = super.getById(p.getProductId());
			if(product != null) {
			for (PartsInfo p : partsInfos) {
			if (!productInfoMap.containsKey(p.getProductId())) {
			product = super.getById(p.getProductId());
			if (product != null) {
			productInfoMap.put(product.getProductId(), product);
			productInfoList.add(product);
			}
			}

			if(!componentInfoMap.containsKey(p.getComponentId())) {
			if (!componentInfoMap.containsKey(p.getComponentId())) {
			component = componentInfoService.getById(p.getComponentId());
			if(component != null) {
			if (component != null) {
			componentInfoMap.put(component.getComponentId(), component);
			componentInfoList.add(component);
			}

			}
			}

			for (ProcessStream processStream : processStreams) {
			if (!productInfoMap.containsKey(processStream.getProductId())) {
			product = super.getById(processStream.getProductId());
			if (product != null) {
			productInfoMap.put(product.getProductId(), product);
			productInfoList.add(product);
			}
			}

			if (!componentInfoMap.containsKey(processStream.getComponentId())) {
			component = componentInfoService.getById(processStream.getComponentId());
			if (component != null) {
			componentInfoMap.put(component.getComponentId(), component);
			componentInfoList.add(component);
			}

			}
			}

			for (WorkStep workStep : workSteps) {
			if (!productInfoMap.containsKey(workStep.getProductId())) {
			product = super.getById(workStep.getProductId());
			if (product != null) {
			productInfoMap.put(product.getProductId(), product);
			productInfoList.add(product);
			}
			}

			if (!componentInfoMap.containsKey(workStep.getComponentId())) {
			component = componentInfoService.getById(workStep.getComponentId());
			if (component != null) {
			componentInfoMap.put(component.getComponentId(), component);
			componentInfoList.add(component);
			}
			@@ -1475,30 +917,30 @@
			long start = System.currentTimeMillis();
			log.info("开始循环执行时间={}", start);
			String pid;
			for(ComponentInfo c : componentInfoList){
			for (ComponentInfo c : componentInfoList) {
			int rankLevel = c.getRankLevel();
			component = c;
			if(!productInfoMap.containsKey(c.getProductId())) {
			product = super.getById(c.getProductId());
			if(product != null) {
			if (!productInfoMap.containsKey(c.getProductId())) {
			product = super.getById(c.getProductId());
			if (product != null) {
			productInfoMap.put(product.getProductId(), product);
			productInfoList.add(product);
			}
			}
			while((rankLevel - 1) > 0) {
			while ((rankLevel - 1) > 0) {
			pid = component.getParentId();
			if(componentInfoMap.containsKey(pid)) {
			if (componentInfoMap.containsKey(pid)) {
			component = componentInfoMap.get(pid);
			rankLevel = component.getRankLevel();
			continue;
			}
			component = componentInfoService.getById(pid);
			if(component != null) {
			if (component != null) {
			log.info("addList添加了新的部件id={}", component.getComponentId());
			componentInfoMap.put(component.getComponentId(), component);
			addList.add(component);
			rankLevel = component.getRankLevel();
			}else {
			} else {
			log.info("查询不到部件id={}", pid);
			break;
			}
			@@ -1508,13 +950,1487 @@
			long end = System.currentTimeMillis();
			log.info("循环执行总耗时={}", (end - start));

			if(!addList.isEmpty()){
			if (!addList.isEmpty()) {
			componentInfoList.addAll(addList);
			}

			//转换数据
			List<ComponentExt> componentExtList = ComponentExt.convertToExtList(componentInfoList);

			return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos);
			return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos,processSpecVersions, processStreams, workSteps);
			}

			@Override
			public boolean deleteProductTree(String id, Integer type) {
			switch (type) {
			//产品
			case 1:
			return deleteProductInfo(id);
			//部门
			case 2:
			return componentInfoService.deleteComponentInfo(id);
			//零件
			case 3:
			return partsInfoService.deletePartsInfo(id);
			//工艺规程版本
			case 4:
			return processSpecVersionService.deleteProcessSpecVersion(id);
			//工序
			case 5:
			return processStreamService.deleteProcessStream(id);
			//工步
			case 6:
			return workStepService.deleteWorkStep(id);
			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;
			}

			/**
			* 验证输入参数
			*/
			private void validateInputParameters(Integer nodeType, String paramId, Integer relativeFlag, String type, String[] paramIds) {
			if (!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId) \|\|
			!ValidateUtil.validateInteger(relativeFlag)) {
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			}
			if (paramIds == null \|\| paramIds.length < 1) {
			if (("1").equals(type)) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
			} else {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_DEPART_PERM_NONE);
			}
			}
			}

			/**
			* 验证 SysUser 列表
			*/
			private void validateSysUserList(Collection<SysUser> sysUserList, List<String> userIds) {
			if (sysUserList == null \|\| sysUserList.isEmpty() \|\| sysUserList.size() != userIds.size()) {
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			}
			}

			/**
			* 验证 MdcProduction 列表
			*/
			private void validateMdcProductionList(Collection<MdcProduction> mdcProductionList, List<String> departmentIds) {
			if (mdcProductionList == null \|\| mdcProductionList.isEmpty() \|\| mdcProductionList.size() != departmentIds.size()) {
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			}
			}

			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<PermissionStreamNew> permissionStreamList = new ArrayList<>();
			// 处理部件权限
			if (componentIds != null && !componentIds.isEmpty()) {
			handleComponentPermissions(componentIds, userList, componentPermissionList, permissionStreamList);
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
			if (partsInfoList != null && !partsInfoList.isEmpty()) {
			List<String> partsIds = partsInfoList.stream()
			.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);
			}

			// 处理工序权限
			if (processId != null) {
			List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", processId));
			if (workStepList != null && !workStepList.isEmpty()) {
			List<String> workStepIds = workStepList.stream()
			.map(WorkStep::getId)
			.collect(Collectors.toList());
			handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList);
			}
			}

			if (!componentPermissionList.isEmpty()) {
			componentPermissionService.saveBatch(componentPermissionList);
			}
			if (!partsPermissionList.isEmpty()) {
			partsPermissionService.saveBatch(partsPermissionList);
			}
			if (!processSpecVersionPermissionList.isEmpty()) {
			processSpecVersionPermissionService.saveBatch(processSpecVersionPermissionList);
			}
			if (!processionPermissionList.isEmpty()) {
			iProcessStreamPermissionService.saveBatch(processionPermissionList);
			}
			if (!workStepPermissionList.isEmpty()) {
			iWorkStepPermissionService.saveBatch(workStepPermissionList);
			}
			if (!permissionStreamList.isEmpty()) {
			permissionStreamNewService.saveBatch(permissionStreamList);
			}
			}

			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)
			.collect(Collectors.toList());
			handleProcessPermissions(processIds, userList, processionPermissionList, permissionStreamList);
			List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
			if (workStepList != null && !workStepList.isEmpty()) {
			List<String> workStepIds = workStepList.stream()
			.map(WorkStep::getId)
			.collect(Collectors.toList());
			handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList);
			}
			}
			}

			private void handleComponentPermissions(List<String> componentIds, Collection<SysUser> userList,
			List<ComponentPermission> componentPermissionList, List<PermissionStreamNew> permissionStreamList) {
			Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
			Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
			String key;
			for (ComponentInfo c : componentInfoService.listByIds(componentIds)) {
			componentInfoMap.put(c.getComponentId(), c);
			for (SysUser u : userList) {
			key = c.getComponentId() + "," + u.getId();
			componentPermissionMap.put(key, new ComponentPermission(c.getComponentId(), u.getId()));
			}
			}
			List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
			if (existList != null && !existList.isEmpty()) {
			for (ComponentPermission permission : existList) {
			key = permission.getComponentId() + "," + permission.getUserId();
			componentPermissionMap.remove(key);
			}
			}
			for (Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()) {
			ComponentPermission cp = entry.getValue();
			componentPermissionList.add(cp);
			ComponentInfo cpInfo = componentInfoMap.get(cp.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<PermissionStreamNew> permissionStreamList) {
			Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
			Map<String, PartsInfo> partsInfoMap = new HashMap<>();
			String key;
			for (PartsInfo p : partsInfoService.listByIds(partsIds)) {
			partsInfoMap.put(p.getPartsId(), p);
			for (SysUser u : userList) {
			key = p.getPartsId() + "," + u.getId();
			partsPermissionHashMap.put(key, new PartsPermission(p.getPartsId(), u.getId()));
			}
			}
			List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
			if (existPartsList != null && !existPartsList.isEmpty()) {
			for (PartsPermission permission : existPartsList) {
			key = permission.getPartsId() + "," + permission.getUserId();
			partsPermissionHashMap.remove(key);
			}
			}
			for (Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()) {
			PartsPermission pp = entry.getValue();
			partsPermissionList.add(pp);
			PartsInfo ptInfo = partsInfoMap.get(pp.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<PermissionStreamNew> permissionStreamList) {
			Map<String, ProcessionPermission> processionPermissionHashMap = new HashMap<>();
			Map<String, ProcessStream> processStreamMap = new HashMap<>();
			String key;
			for (ProcessStream p : processStreamService.listByIds(processIds)) {
			processStreamMap.put(p.getProcessId(), p);
			for (SysUser u : userList) {
			key = p.getProcessId() + "," + u.getId();
			processionPermissionHashMap.put(key, new ProcessionPermission(p.getProcessId(), u.getId()));
			}
			}
			List<ProcessionPermission> processionDepartmentList = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
			if (processionDepartmentList != null && !processionDepartmentList.isEmpty()) {
			for (ProcessionPermission processionPermission : processionDepartmentList) {
			key = processionPermission.getProcessId() + "," + processionPermission.getUserId();
			processionPermissionHashMap.remove(key);
			}
			}
			for (Map.Entry<String, ProcessionPermission> entry : processionPermissionHashMap.entrySet()) {
			ProcessionPermission pp = entry.getValue();
			processionPermissionList.add(pp);
			ProcessStream processStream = processStreamMap.get(pp.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<PermissionStreamNew> permissionStreamList) {
			Map<String, WorkStepPermission> workStepPermissionHashMap = new HashMap<>();
			Map<String, WorkStep> workStepHashMap = new HashMap<>();
			String key;
			for (WorkStep w : workStepService.listByIds(workStepIds)) {
			workStepHashMap.put(w.getId(), w);
			for (SysUser u : userList) {
			key = w.getId() + "," + u.getId();
			workStepPermissionHashMap.put(key, new WorkStepPermission(w.getId(), u.getId()));
			}
			}
			List<WorkStepPermission> workStepPermissions = iWorkStepPermissionService.getByStepIdsAndUserIds(workStepIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
			if (workStepPermissions != null && !workStepPermissions.isEmpty()) {
			for (WorkStepPermission workStepPermission : workStepPermissions) {
			key = workStepPermission.getStepId() + "," + workStepPermission.getUserId();
			workStepPermissionHashMap.remove(key);
			}
			}
			for (Map.Entry<String, WorkStepPermission> entry : workStepPermissionHashMap.entrySet()) {
			WorkStepPermission ws = entry.getValue();
			workStepPermissionList.add(ws);
			WorkStep workStep = workStepHashMap.get(ws.getStepId());
			PermissionStreamNew s = new PermissionStreamNew();
			s.setBusinessId(workStep.getId());
			s.setBusinessType(DocAttributionTypeEnum.WORKSITE.getCode().toString());
			s.setUserId(ws.getUserId());
			permissionStreamList.add(s);
			}
			}

			/**
			* 添加权限
			*/

			private boolean handleWorkStep(String paramId, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			WorkStep workStep = workStepService.getById(paramId);
			if (workStep == null) {
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			}
			boolean hasPerm = checkProductPerm(6, workStep.getId());
			if (!hasPerm) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (userList!=null){
			return workStepService.assignAddUser(workStep, userList);
			}else {
			return workStepService.assignAddDepart(workStep, mdcProductionList);
			}
			}

			private boolean handleProcessStream(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			ProcessStream processStream = processStreamService.getById(paramId);
			if (processStream == null) {
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			}
			boolean hasPerm = checkProductPerm(5, processStream.getProcessId());
			if (!hasPerm) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			boolean result;
			if (userList!=null){
			boolean processResult = processStreamService.assignAddUser(processStream, userList);
			if (!processResult) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleRelativePermissions(processStream.getProductId(), null, processStream.getProcessId(), null,null, userList);
			}
			}else {
			result = processStreamService.assignAddDepart(processStream, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			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;
			}

			private boolean handlePartsInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			PartsInfo partsInfo = partsInfoService.getById(paramId);
			if (partsInfo == null) {
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			}
			boolean hasPerm = checkProductPerm(3, partsInfo.getPartsId());
			if (!hasPerm) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			boolean result;
			if (userList!=null){
			result = partsInfoService.assignAddUser(partsInfo, userList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleRelativePermissions(partsInfo.getProductId(), null, null, partsInfo.getPartsId(),null, userList);
			}
			}else {
			result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
			}
			}
			return true;
			}

			private boolean handleProductInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			ProductInfo productInfo = super.getById(paramId);
			if (productInfo == null) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			}
			boolean hasPerm = checkProductPerm(1, productInfo.getProductId());
			if (!hasPerm) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			boolean result;
			if (userList!=null){
			result = this.assignAddUser(productInfo, userList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			if (componentInfoList != null && !componentInfoList.isEmpty()) {
			List<String> componentIds = componentInfoList.stream()
			.map(ComponentInfo::getComponentId)
			.collect(Collectors.toList());
			handleRelativePermissions(productInfo.getProductId(), componentIds, null, null, null,userList);
			}
			}
			}else {
			result = this.assignAddDepartment(productInfo, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleRelatedPermissionsForProduct(productInfo, mdcProductionList);
			}
			}
			return true;
			}

			private boolean handleComponentInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			ComponentInfo componentInfo = componentInfoService.getById(paramId);
			if (componentInfo == null) {
			ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
			}
			boolean hasPerm = checkProductPerm(2, componentInfo.getComponentId());
			if (!hasPerm) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			boolean result;
			if (userList!=null){
			result = componentInfoService.assignAddUser(componentInfo, userList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
			List<String> componentIds = new ArrayList<>();
			if (childrenList != null && !childrenList.isEmpty()) {
			componentIds = childrenList.stream()
			.map(ComponentInfo::getComponentId)
			.collect(Collectors.toList());
			}
			componentIds.add(componentInfo.getComponentId());


			handleRelativePermissions(componentInfo.getProductId(), componentIds, null, null,null, userList);
			}
			}else {
			result = componentInfoService.assignAddDepart(componentInfo, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleRelatedPermissionsForComponent(componentInfo, mdcProductionList);
			}
			}
			return true;
			}

			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()) {
			return;
			}
			Map<String, WorkStepDepartment> allPermissions = new HashMap<>();
			Map<String, WorkStep> workStepMap = new HashMap<>();
			for (WorkStep workStep : workStepList) {
			workStepMap.put(workStep.getId(), workStep);
			for (MdcProduction mdcProduction : mdcProductionList) {
			String key = workStep.getId() + "," + mdcProduction.getId();
			WorkStepDepartment wsDep = new WorkStepDepartment(workStep.getId(), mdcProduction.getId());
			allPermissions.put(key, wsDep);
			}
			}

			List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
			List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
			List<WorkStepDepartment> existingPermissions = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIds);
			if (existingPermissions != null && !existingPermissions.isEmpty()) {
			for (WorkStepDepartment existing : existingPermissions) {
			String key = existing.getStepId() + "," + existing.getDepartId();
			allPermissions.remove(key);
			}
			}

			List<WorkStepDepartment> newWorkStepDepartments = 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());
			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()) {
			permissionStreamNewService.saveBatch(newPermissionStreams);
			}
			}

			private void handleRelatedPermissionsForParts(PartsInfo partsInfo, Collection<MdcProduction> 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 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("psv_id", processSpecVersion.getId()));
			}
			if (processStreamList == null \|\| processStreamList.isEmpty()) {
			return;
			}
			processStreamList.forEach(item->{
			handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
			});
			Map<String, ProcessionDepartment> allProcessPermissions = new HashMap<>();
			Map<String, ProcessStream> processStreamMap = new HashMap<>();
			for (ProcessStream processStream : processStreamList) {
			processStreamMap.put(processStream.getProcessId(), processStream);
			for (MdcProduction mdcProduction : mdcProductionList) {
			String key = processStream.getProcessId() + "," + mdcProduction.getId();
			ProcessionDepartment procDep = new ProcessionDepartment(processStream.getProcessId(), mdcProduction.getId());
			allProcessPermissions.put(key, procDep);
			}
			}

			List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
			List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
			List<ProcessionDepartment> existingProcessPermissions = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIds);
			if (existingProcessPermissions != null && !existingProcessPermissions.isEmpty()) {
			for (ProcessionDepartment existing : existingProcessPermissions) {
			String key = existing.getProcessId() + "," + existing.getDepartId();
			allProcessPermissions.remove(key);
			}
			}

			List<ProcessionDepartment> newProcessPermissions = 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());
			PermissionStreamNew permStream = new PermissionStreamNew();
			permStream.setBusinessId(processStream.getProcessId());
			permStream.setBusinessType(DocAttributionTypeEnum.PROCESS.getCode().toString());
			permStream.setDepartId(procDep.getDepartId());
			newPermissionStreams.add(permStream);
			}

			if (!newProcessPermissions.isEmpty()) {
			processionDepartmentService.saveBatch(newProcessPermissions);
			}
			if (!newPermissionStreams.isEmpty()) {
			permissionStreamNewService.saveBatch(newPermissionStreams);
			}
			}

			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(processSpecVersion.getProductId(), processIds);
			if (workStepList == null \|\| workStepList.isEmpty()) {
			return;
			}
			workStepList.forEach(item->{
			handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
			});
			}

			private void handleRelatedPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
			// 处理组件权限
			handleComponentPermissionsForProduct(productInfo, mdcProductionList);
			// 处理零件权限
			handlePartsPermissionsForProduct(productInfo, mdcProductionList);
			List<ComponentInfo> componentInfoList=componentInfoService.list(new QueryWrapper<ComponentInfo>().eq("product_id", productInfo.getProductId()));
			componentInfoList.forEach(item->{
			handleProcessPermissions(null,item, mdcProductionList);
			});
			}

			private void handleComponentPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			if (componentInfoList == null \|\| componentInfoList.isEmpty()) {
			return;
			}
			Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>();
			Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
			for (ComponentInfo componentInfo : componentInfoList) {
			componentInfoMap.put(componentInfo.getComponentId(), componentInfo);
			for (MdcProduction mdcProduction : mdcProductionList) {
			String key = componentInfo.getComponentId() + "," + mdcProduction.getId();
			ComponentDepartment compDep = new ComponentDepartment(componentInfo.getComponentId(), mdcProduction.getId());
			allComponentPermissions.put(key, compDep);
			}
			}

			List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
			List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
			List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds);
			if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) {
			for (ComponentDepartment existing : existingComponentPermissions) {
			String key = existing.getComponentId() + "," + existing.getDepartId();
			allComponentPermissions.remove(key);
			}
			}

			List<ComponentDepartment> newComponentPermissions = 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());
			PermissionStreamNew permStream = new PermissionStreamNew();
			permStream.setBusinessId(componentInfo.getComponentId());
			permStream.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
			permStream.setDepartId(compDep.getDepartId());
			newPermissionStreams.add(permStream);
			}

			if (!newComponentPermissions.isEmpty()) {
			componentDepartmentService.saveBatch(newComponentPermissions);
			}
			if (!newPermissionStreams.isEmpty()) {
			permissionStreamNewService.saveBatch(newPermissionStreams);
			}
			}

			private void handlePartsPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			if (componentInfoList == null \|\| componentInfoList.isEmpty()) {
			return;
			}
			List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
			if (partsInfoList == null \|\| partsInfoList.isEmpty()) {
			return;
			}
			for (PartsInfo partsInfo : partsInfoList) {
			boolean result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
			}
			}

			private void handleRelatedPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
			// 处理子组件权限
			handleChildComponentPermissions(componentInfo, mdcProductionList);
			// 处理零件权限
			handlePartsPermissionsForComponent(componentInfo, mdcProductionList);
			// 处理工序权限
			handleProcessPermissions(null,componentInfo, mdcProductionList);
			}

			private void handleChildComponentPermissions(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
			List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
			if (childrenList == null \|\| childrenList.isEmpty()) {
			return;
			}
			Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>();
			Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
			for (ComponentInfo childComponent : childrenList) {
			componentInfoMap.put(childComponent.getComponentId(), childComponent);
			for (MdcProduction mdcProduction : mdcProductionList) {
			String key = childComponent.getComponentId() + "," + mdcProduction.getId();
			ComponentDepartment compDep = new ComponentDepartment(childComponent.getComponentId(), mdcProduction.getId());
			allComponentPermissions.put(key, compDep);
			}

			List<String> componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
			List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
			List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds);
			if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) {
			for (ComponentDepartment existing : existingComponentPermissions) {
			String key = existing.getComponentId() + "," + existing.getDepartId();
			allComponentPermissions.remove(key);
			}
			}

			List<ComponentDepartment> newComponentPermissions = 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());
			PermissionStreamNew permStream = new PermissionStreamNew();
			permStream.setBusinessId(childComponent.getComponentId());
			permStream.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
			permStream.setDepartId(compDep.getDepartId());
			newPermissionStreams.add(permStream);
			}

			if (!newComponentPermissions.isEmpty()) {
			componentDepartmentService.saveBatch(newComponentPermissions);
			}
			if (!newPermissionStreams.isEmpty()) {
			permissionStreamNewService.saveBatch(newPermissionStreams);
			}
			}
			}

			private void handlePartsPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentId(componentInfo.getProductId(),componentInfo.getComponentId());
			if (partsInfoList == null \|\| partsInfoList.isEmpty()) {
			return;
			}
			for (PartsInfo partsInfo : partsInfoList) {
			partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
			handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
			}
			}

			private String getParentId(Object parentEntity) {
			if (parentEntity instanceof ProcessStream) {
			return ((ProcessStream) parentEntity).getProcessId();
			} else if (parentEntity instanceof WorkStep) {
			return ((WorkStep) parentEntity).getProcessId();
			}
			return null;
			}


			/*移除权限/

			private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			ProductInfo productInfo = super.getById(paramId);
			if (productInfo == null) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			}
			checkProductPerm(1, productInfo.getProductId());
			boolean result;
			if (userList!=null){
			result =this.assignRemoveUser(productInfo, userList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleProductRelatedRemovals(productInfo, userList);
			}
			}else {
			result = this.assignRemoveDepartment(productInfo, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleProductRelatedDepartmentRemovals(productInfo, mdcProductionList);
			}
			}
			return true;
			}

			private boolean handleComponentInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			ComponentInfo componentInfo = componentInfoService.getById(paramId);
			if (componentInfo == null) {
			ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
			}
			checkProductPerm(2, componentInfo.getComponentId());
			boolean result;
			if (userList!=null){
			result =componentInfoService.assignRemoveUser(componentInfo, userList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleComponentRelatedRemovals(componentInfo, userList,null);
			}
			}else {
			result = componentInfoService.assignRemoveDepart(componentInfo, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleComponentRelatedRemovals(componentInfo,null,mdcProductionList);
			}
			}
			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,
			IPermissionStreamNewService permissionStreamNewService,
			String queryField) {
			List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
			if (workStepList.isEmpty()) {
			return;
			}
			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<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(workStepIds, userIdList,"6");

			if (!workStepPermissions.isEmpty()) {
			workStepPermissionService.removeByCollection(workStepPermissions);
			}
			if (!permissionStreams.isEmpty()) {
			permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
			}
			}

			private void handleRelatedDepartmentRemovals(String parentId, Collection<MdcProduction> mdcProductionList,
			IWorkStepService workStepService,
			IWorkStepDepartmentService workStepDepartmentService,
			IPermissionStreamNewService permissionStreamNewService,
			String queryField) {
			List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
			if (workStepList.isEmpty()) {
			return;
			}
			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<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(workStepIds, departmentIdList,"6");

			if (!workStepDepartments.isEmpty()) {
			workStepDepartmentService.removeByCollection(workStepDepartments);
			}
			if (!permissionStreams.isEmpty()) {
			permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
			}
			}

			private void handleProcessSpecVersionRelatedRemovals(ComponentInfo componentInfo,ProcessSpecVersion processSpecVersion,Collection<SysUser> userList) {
			List<ProcessStream> processStreamList =new ArrayList<>();
			String productId="";
			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();
			}
			List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
			handleProcessRemovals(processIds, userList);
			handleWorkStepRemovals(productId, processIds, userList);
			}

			private void handleProcessRemovals(List<String> processIds, Collection<SysUser> userList) {
			if (processIds.isEmpty()) {
			return;
			}
			List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
			List<ProcessionPermission> processionPermissions = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userIdList);
			List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(processIds, userIdList,"5");

			if (!processionPermissions.isEmpty()) {
			iProcessStreamPermissionService.removeByCollection(processionPermissions);
			}
			if (!permissionStreams.isEmpty()) {
			permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
			}
			}

			private void handleProcessDepartmentRemovals(List<String> processIds, Collection<MdcProduction> mdcProductionList) {
			if (processIds.isEmpty()) {
			return;
			}
			List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
			List<ProcessionDepartment> processionDepartments = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIdList);
			List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(processIds, departmentIdList,"5");

			if (!processionDepartments.isEmpty()) {
			processionDepartmentService.removeByCollection(processionDepartments);
			}
			if (!permissionStreams.isEmpty()) {
			permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
			}
			}

			private void handleWorkStepRemovals(String productId, List<String> processIds, Collection<SysUser> userList) {
			List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
			if (workStepList!=null){
			workStepList.forEach(item->{
			handleRelatedRemovals(item.getProcessId(), userList, workStepService, iWorkStepPermissionService, permissionStreamNewService, "process_id");
			});
			}
			}

			private void handleWorkStepDepartmentRemovals(String productId, List<String> processIds, Collection<MdcProduction> mdcProductionList) {
			List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
			if (workStepList!=null){
			workStepList.forEach(item->{
			handleRelatedDepartmentRemovals(item.getProcessId(), mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService, "process_id");
			});
			}
			}

			private void handleProductRelatedRemovals(ProductInfo productInfo, Collection<SysUser> userList) {
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
			handleComponentRemovals(componentIds, userList);
			handlePartsRemovals(productInfo.getProductId(), componentIds, userList);
			componentInfoList.forEach(item->{
			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) {
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
			handleComponentDepartmentRemovals(componentIds, mdcProductionList);
			handlePartsDepartmentRemovals(productInfo.getProductId(), componentIds, mdcProductionList);
			componentInfoList.forEach(item->{
			handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
			});
			}

			private void handleComponentRemovals(List<String> componentIds, Collection<SysUser> userList) {
			if (componentIds.isEmpty()) {
			return;
			}
			List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
			List<ComponentPermission> componentPermissions = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userIdList);
			List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(componentIds, userIdList,"2");

			if (!componentPermissions.isEmpty()) {
			componentPermissionService.removeByCollection(componentPermissions);
			}
			if (!permissionStreams.isEmpty()) {
			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()) {
			return;
			}
			List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
			List<ComponentDepartment> componentDepartments = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIdList);
			List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(componentIds, departmentIdList,"2");

			if (!componentDepartments.isEmpty()) {
			componentDepartmentService.removeByCollection(componentDepartments);
			}
			if (!permissionStreams.isEmpty()) {
			permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
			}
			}

			private void handlePartsRemovals(String productId, List<String> componentIds,Collection<SysUser> userList) {
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
			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);
			if (partsInfoList!=null) {
			partsInfoList.forEach(item->{
			partsInfoService.assignRemoveDepart(item,mdcProductionList);
			handlePartRelatedDepartmentRemovals(item, mdcProductionList);
			});
			}
			}

			private void handleComponentRelatedRemovals(ComponentInfo componentInfo, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
			List<String> componentIds = new ArrayList<>();
			if (childrenList != null) {
			componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
			}
			componentIds.add(componentInfo.getComponentId());
			if (mdcProductionList!=null){
			handleComponentDepartmentRemovals(componentIds, mdcProductionList);
			handlePartsDepartmentRemovals(componentInfo.getProductId(), componentIds, mdcProductionList);
			if (childrenList != null) {
			childrenList.forEach(item->{
			handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
			});
			}
			}else {
			handleComponentRemovals(componentIds, userList);
			handlePartsRemovals(componentInfo.getProductId(), componentIds, userList);
			if (childrenList != null) {
			childrenList.forEach(item->{
			handleProcessSpecVersionRelatedRemovals(item,null, userList);
			});
			}
			}
			}

			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("psv_id", processSpecVersion.getId()));
			productId=processSpecVersion.getProductId();
			}
			List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
			handleProcessDepartmentRemovals(processIds, mdcProductionList);
			handleWorkStepDepartmentRemovals(productId, processIds, mdcProductionList);
			}

			}