hy/mdc_hyjs_gk_new.git

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

			import cn.hutool.core.util.StrUtil;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.baomidou.mybatisplus.core.toolkit.Wrappers;
			import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
			import lombok.extern.slf4j.Slf4j;
			import org.apache.shiro.SecurityUtils;
			import org.jeecg.common.system.vo.LoginUser;
			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.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 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
			@@ -44,11 +38,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
			@@ -58,7 +54,9 @@
			@Autowired
			private IPartsPermissionService partsPermissionService;
			@Autowired
			private IDepartmentService departmentService;
			private IProcessSpecVersionPermissionService processSpecVersionPermissionService;
			@Autowired
			private IProcessSpecVersionDepartmentService processSpecVersionDepartmentService;
			@Autowired
			private ISysUserService userService;
			@Autowired
			@@ -67,103 +65,91 @@
			@Autowired
			private IWorkStepService workStepService;
			@Autowired
			private IDocInfoService docInfoService;
			@Autowired
			private INcLogInfoService iNcLogInfoService;
			@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;

			@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()),0,productInfo.getProductName(),productInfo.getProductNo(),"1");
			productMixService.save(productMix);
			//添加用户权限
			PermissionStreamNew stream = new PermissionStreamNew();
			stream.setBusinessId(productInfo.getProductId());
			stream.setUserId(userId);
			return permissionStreamService.save(stream);
			stream.setBusinessType("1");
			return permissionStreamNewService.save(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)
			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, "1");
			if (stream == null) {
			stream = new PermissionStreamNew();
			stream.setBusinessId(productInfo.getProductId());
			stream.setUserId(userId);
			return permissionStreamService.save(stream);
			stream.setBusinessType("1");
			return permissionStreamNewService.save(stream);
			}
			return b;
			}
			@@ -172,41 +158,45 @@
			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();
			//工艺规程版本
			List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByUserPerms(userId);
			if (processSpecVersions == null)
			processSpecVersions = Collections.emptyList();
			//工序
			List<ProcessStream> processStreams=processStreamService.getByuserPerms(userId);
			if(processStreams==null)
			List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId);
			if (processStreams == null)
			processStreams = Collections.emptyList();
			//工步
			List<WorkStep> workStepList=workStepService.getByUserPerms(userId);
			if(workStepList==null)
			List<WorkStep> workStepList = workStepService.getByUserPerms(userId);
			if (workStepList == null)
			workStepList = Collections.emptyList();
			return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos,processStreams,workStepList);
			return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos, processSpecVersions,processStreams, workStepList);
			}

			@Override
			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));
			@@ -217,90 +207,90 @@
			@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", "1").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, "1","0");
			if (!b)
			ExceptionCast.cast(CommonCode.FAIL);
			b = permissionStreamService.deleteDepartPermsByProductId(id);
			if(!b)
			b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, "1","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 == 1) {
			ProductInfo productInfo = super.getById(paramId);
			if(productInfo == null)
			if (productInfo == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			PermissionStream permission = permissionStreamService.getByProductIdAndUserId(paramId, userId);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(paramId, userId,"1");
			return permission != null;
			}else if(nodeType == 2) {
			} else if (nodeType == 2) {
			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);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(componentInfo.getComponentId(), userId,"2");
			return permission != null;
			}else if(nodeType == 3) {
			} else if (nodeType == 3) {
			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);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(partsInfo.getPartsId(), userId, "3");
			return permission != null;
			}else if (nodeType == 5) {
			ProcessStream processStream=processStreamService.getById(paramId);
			if(processStream == null)
			} else if (nodeType == 4) {
			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 == 5) {
			ProcessStream processStream = processStreamService.getById(paramId);
			if (processStream == null)
			ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
			PermissionStream permission = permissionStreamService.getByProcessIdAndUserId(processStream.getProductId(),processStream.getComponentId()
			,processStream.getPartsId(),processStream.getProcessId(),userId);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processStream.getProcessId(), userId,"5");
			return permission != null;
			}else if (nodeType == 6){
			WorkStep workStep=workStepService.getById(paramId);
			if(workStep == null)
			} else if (nodeType == 6) {
			WorkStep workStep = workStepService.getById(paramId);
			if (workStep == null)
			ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
			PermissionStream permission = permissionStreamService.getByStepIdAndUserId(workStep.getProductId(),workStep.getComponentId()
			,workStep.getPartsId(),workStep.getProcessId(),workStep.getId(),userId);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(workStep.getId(), userId,"6");
			return permission != null;
			}
			return false;
			@@ -308,50 +298,63 @@

			@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 == 1) {
			return productPermissionService.getUserPermsByProductId(paramId);
			}else if(nodeType == 2) {
			} else if (nodeType == 2) {
			return componentPermissionService.getUserPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			} else if (nodeType == 3) {
			return partsPermissionService.getUserPermsByProductId(paramId);
			}else {
			} else if (nodeType == 4) {
			return processSpecVersionPermissionService.getUserPermsByProductId(paramId);
			} else if (nodeType == 5) {
			return iProcessStreamPermissionService.getUserPermsByProductId(paramId);
			} else if (nodeType == 6) {
			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 == 1) {
			return productPermissionService.getUserNonPermsByProductId(paramId);
			}else if(nodeType == 2) {
			} else if (nodeType == 2) {
			return componentPermissionService.getUserNonPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			} else if (nodeType == 3) {
			return partsPermissionService.getUserNonPermsByProductId(paramId);
			}else {
			} else if (nodeType == 4) {
			return processSpecVersionPermissionService.getUserNonPermsByProductId(paramId);
			} else if (nodeType == 5) {
			return iProcessStreamPermissionService.getUserNonPermsByProductId(paramId);
			} else if (nodeType == 6) {
			return iWorkStepPermissionService.getUserNonPermsByProductId(paramId);
			} else {
			return null;
			}
			}

			@Override
			public List<MdcProduction> getDepartPermsList(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 == 1) {
			return productDepartmentService.getDepartPermsByProductId(paramId);
			}else if(nodeType == 2) {
			} else if (nodeType == 2) {
			return componentDepartmentService.getDepartPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			} else if (nodeType == 3) {
			return partsDepartmentService.getDepartPermsByPartsId(paramId);
			}else if(nodeType == 5) {
			} else if (nodeType == 4) {
			return processSpecVersionDepartmentService.getDepartPermsByPsvId(paramId);
			}else if (nodeType == 5) {
			return processionDepartmentService.getDepartPermsByProcessId(paramId);
			}else if(nodeType == 6) {
			} else if (nodeType == 6) {
			return workStepDepartmentService.getDepartPermsByStepId(paramId);
			}
			//todo 封装树状结构
			else {
			return null;
			}
			@@ -359,1199 +362,196 @@

			@Override
			public List<MdcProduction> getDepartNonPermsList(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 == 1) {
			return productDepartmentService.getDepartNonPermsByProductId(paramId);
			}else if(nodeType == 2) {
			} else if (nodeType == 2) {
			return componentDepartmentService.getDepartNonPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			} else if (nodeType == 3) {
			return partsDepartmentService.getDepartNonPermsByProductId(paramId);
			}else if(nodeType == 5) {
			} else if (nodeType == 4) {
			return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
			}else if(nodeType == 6) {
			} else if (nodeType == 5) {
			return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
			} else if (nodeType == 6) {
			return workStepDepartmentService.getDepartNonPermsByStepId(paramId);
			}
			//todo 封装树状结构
			else {
			} 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
			* @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 零件 5 工序 6 工步
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			* @param nodeType 1 产品 2 部件 3 零件 5 工序 6 工步
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			* @param departmentIds 添加部门ids
			* @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<MdcProduction> mdcProductionList=mdcProductionService.listByIds(ids);
			if(mdcProductionList == null \|\| mdcProductionList.isEmpty() \|\| mdcProductionList.size() != departmentIds.length)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(nodeType == 6) {
			//处理工步
			WorkStep workStep=workStepService.getById(paramId);
			if (workStep == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			boolean b = checkProductPerm(6, workStep.getId());
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			return workStepService.assignAddDepart(workStep, mdcProductionList);
			}else if(nodeType == 5) {
			//处理工序
			ProcessStream processStream = processStreamService.getById(paramId);
			if (processStream == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			boolean b = checkProductPerm(5, processStream.getProcessId());
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			return processStreamService.assignAddDepart(processStream, mdcProductionList);
			}else 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, mdcProductionList);
			}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, mdcProductionList);
			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<ProcessionDepartment> processionPermissionList = new ArrayList<>();
			List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			//处理子部件
			List<String> componentIds = new ArrayList<>();
			List<String> partsIds= new ArrayList<>();
			List<String> ProcessionIds= new ArrayList<>();
			List<String> workStepIds= 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(MdcProduction mdcProduction : mdcProductionList){
			key = c.getComponentId() + "," + mdcProduction.getId();
			cp = new ComponentDepartment(c.getComponentId(), mdcProduction.getId());
			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<>();
			partsIds = new ArrayList<>();
			PartsDepartment pp;
			PartsInfo ptInfo;
			for(PartsInfo p : partsInfoList){
			partsIds.add(p.getPartsId());
			partsInfoMap.put(p.getPartsId(), p);
			for(MdcProduction mdcProduction : mdcProductionList){
			key = p.getPartsId() + "," + mdcProduction.getId();
			pp = new PartsDepartment(p.getPartsId(), mdcProduction.getId());
			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);
			}
			}

			//查询工序已存在的权限数据
			List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productInfo.getProductId(),componentIds,partsIds);
			if(processStreamList != null && !processStreamList.isEmpty()) {
			Map<String, ProcessionDepartment> processionDepartmentHashMap = new HashMap<>();
			Map<String, ProcessStream> processStreamMap = new HashMap<>();
			ProcessionIds = new ArrayList<>();
			ProcessionDepartment pp;
			ProcessStream processStream;
			for(ProcessStream p : processStreamList){
			ProcessionIds.add(p.getProcessId());
			processStreamMap.put(p.getProcessId(), p);
			for(MdcProduction mdcProduction : mdcProductionList){
			key = p.getPartsId() + "," + mdcProduction.getId();
			pp = new ProcessionDepartment(p.getProcessId(), mdcProduction.getId());
			processionDepartmentHashMap.put(key, pp);
			}
			}

			//查询已存在的权限数据
			List<ProcessionDepartment> processionDepartmentList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
			if(processionDepartmentList != null && !processionDepartmentList.isEmpty()){
			//踢出权限数据
			for(ProcessionDepartment processionDepartment : processionDepartmentList){
			key = processionDepartment.getProcessId() + "," + processionDepartment.getDepartId();
			if(processionDepartmentHashMap.containsKey(key)){
			processionDepartmentHashMap.remove(key);
			}
			}
			}

			for(Map.Entry<String, ProcessionDepartment> entry : processionDepartmentHashMap.entrySet()){
			pp = entry.getValue();
			processionPermissionList.add(pp);
			processStream = processStreamMap.get(pp.getProcessId());
			s = new PermissionStream();
			s.setProductId(processStream.getProductId());
			s.setComponentId(processStream.getComponentId());
			s.setPartsId(processStream.getPartsId());
			s.setProcessId(processStream.getProcessId());
			s.setDepartId(pp.getDepartId());
			permissionStreamList.add(s);
			}
			}
			//查询工步已存在的权限数据
			List<WorkStep> workStepList = workStepService.getByProcessIds(productInfo.getProductId(),ProcessionIds);
			if(workStepList != null && !workStepList.isEmpty()) {
			Map<String, WorkStepDepartment> workStepDepartmentHashMap = new HashMap<>();
			Map<String, WorkStep> workStepHashMap = new HashMap<>();
			workStepIds = new ArrayList<>();
			WorkStepDepartment ws;
			WorkStep workStep;
			for(WorkStep w : workStepList){
			workStepIds.add(w.getId());
			workStepHashMap.put(w.getId(), w);
			for(MdcProduction mdcProduction : mdcProductionList){
			key = w.getId() + "," + mdcProduction.getId();
			ws = new WorkStepDepartment(w.getId(), mdcProduction.getId());
			workStepDepartmentHashMap.put(key, ws);
			}
			}

			//查询已存在的权限数据
			List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
			if(workStepDepartments != null && !workStepDepartments.isEmpty()){
			//踢出权限数据
			for(WorkStepDepartment workStepDepartment : workStepDepartments){
			key = workStepDepartment.getStepId() + "," + workStepDepartment.getDepartId();
			if(workStepDepartmentHashMap.containsKey(key)){
			workStepDepartmentHashMap.remove(key);
			}
			}
			}

			for(Map.Entry<String, WorkStepDepartment> entry : workStepDepartmentHashMap.entrySet()){
			ws = entry.getValue();
			workStepDepartmentList.add(ws);
			workStep = workStepHashMap.get(ws.getStepId());
			s = new PermissionStream();
			s.setProductId(workStep.getProductId());
			s.setComponentId(workStep.getComponentId());
			s.setPartsId(workStep.getPartsId());
			s.setProcessId(workStep.getProcessId());
			s.setStepId(workStep.getId());
			s.setDepartId(ws.getDepartId());
			permissionStreamList.add(s);
			}
			}

			if(!componentPermissionList.isEmpty()){
			componentDepartmentService.saveBatch(componentPermissionList);
			}
			if(!partsPermissionList.isEmpty()){
			partsDepartmentService.saveBatch(partsPermissionList);
			}
			if(!processionPermissionList.isEmpty()){
			processionDepartmentService.saveBatch(processionPermissionList);
			}
			if (!workStepDepartmentList.isEmpty()) {
			workStepDepartmentService.saveBatch(workStepDepartmentList);
			}
			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, mdcProductionList);
			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<ProcessionDepartment> processionPermissionList = new ArrayList<>();
			List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			//处理子部件
			PermissionStream s;
			List<String> componentIds = new ArrayList<>();
			List<String> partsIds= new ArrayList<>();
			List<String> ProcessionIds= new ArrayList<>();
			List<String> workStepIds= new ArrayList<>();
			Map<String, ComponentDepartment> componentPermissionMap = new HashMap<>();
			Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

			//初始化全体数据
			String key;
			ComponentDepartment cp;
			ComponentInfo cpInfo;
			if(childrenList != null && !childrenList.isEmpty()) {
			for (ComponentInfo c : childrenList) {
			componentIdList.add(c.getComponentId());
			componentInfoMap.put(c.getComponentId(), c);
			for (MdcProduction mdcProduction : mdcProductionList) {
			key = c.getComponentId() + "," + mdcProduction.getId();
			cp = new ComponentDepartment(c.getComponentId(), mdcProduction.getId());
			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<>();
			partsIds = new ArrayList<>();
			PartsDepartment pp;
			PartsInfo ptInfo;
			for(PartsInfo p : partsInfoList){
			partsIds.add(p.getPartsId());
			partsInfoMap.put(p.getPartsId(), p);
			for(MdcProduction mdcProduction : mdcProductionList){
			key = p.getPartsId() + "," + mdcProduction.getId();
			pp = new PartsDepartment(p.getPartsId(), mdcProduction.getId());
			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);
			}
			}

			//查询工序已存在的权限数据
			List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(componentInfo.getProductId(),componentIds,partsIds);
			if(processStreamList != null && !processStreamList.isEmpty()) {
			Map<String, ProcessionDepartment> processionDepartmentHashMap = new HashMap<>();
			Map<String, ProcessStream> processStreamMap = new HashMap<>();
			ProcessionIds = new ArrayList<>();
			ProcessionDepartment pp;
			ProcessStream processStream;
			for(ProcessStream p : processStreamList){
			ProcessionIds.add(p.getProcessId());
			processStreamMap.put(p.getProcessId(), p);
			for(MdcProduction mdcProduction : mdcProductionList){
			key = p.getPartsId() + "," + mdcProduction.getId();
			pp = new ProcessionDepartment(p.getProcessId(), mdcProduction.getId());
			processionDepartmentHashMap.put(key, pp);
			}
			}

			//查询已存在的权限数据
			List<ProcessionDepartment> processionDepartmentList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
			if(processionDepartmentList != null && !processionDepartmentList.isEmpty()){
			//踢出权限数据
			for(ProcessionDepartment processionDepartment : processionDepartmentList){
			key = processionDepartment.getProcessId() + "," + processionDepartment.getDepartId();
			if(processionDepartmentHashMap.containsKey(key)){
			processionDepartmentHashMap.remove(key);
			}
			}
			}

			for(Map.Entry<String, ProcessionDepartment> entry : processionDepartmentHashMap.entrySet()){
			pp = entry.getValue();
			processionPermissionList.add(pp);
			processStream = processStreamMap.get(pp.getProcessId());
			s = new PermissionStream();
			s.setProductId(processStream.getProductId());
			s.setComponentId(processStream.getComponentId());
			s.setPartsId(processStream.getPartsId());
			s.setProcessId(processStream.getProcessId());
			s.setDepartId(pp.getDepartId());
			permissionStreamList.add(s);
			}
			}
			//查询工步已存在的权限数据
			List<WorkStep> workStepList = workStepService.getByProcessIds(componentInfo.getProductId(),ProcessionIds);
			if(workStepList != null && !workStepList.isEmpty()) {
			Map<String, WorkStepDepartment> workStepDepartmentHashMap = new HashMap<>();
			Map<String, WorkStep> workStepHashMap = new HashMap<>();
			workStepIds = new ArrayList<>();
			WorkStepDepartment ws;
			WorkStep workStep;
			for(WorkStep w : workStepList){
			workStepIds.add(w.getId());
			workStepHashMap.put(w.getId(), w);
			for(MdcProduction mdcProduction : mdcProductionList){
			key = w.getId() + "," + mdcProduction.getId();
			ws = new WorkStepDepartment(w.getId(), mdcProduction.getId());
			workStepDepartmentHashMap.put(key, ws);
			}
			}

			//查询已存在的权限数据
			List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
			if(workStepDepartments != null && !workStepDepartments.isEmpty()){
			//踢出权限数据
			for(WorkStepDepartment workStepDepartment : workStepDepartments){
			key = workStepDepartment.getStepId() + "," + workStepDepartment.getDepartId();
			if(workStepDepartmentHashMap.containsKey(key)){
			workStepDepartmentHashMap.remove(key);
			}
			}
			}

			for(Map.Entry<String, WorkStepDepartment> entry : workStepDepartmentHashMap.entrySet()){
			ws = entry.getValue();
			workStepDepartmentList.add(ws);
			workStep = workStepHashMap.get(ws.getStepId());
			s = new PermissionStream();
			s.setProductId(workStep.getProductId());
			s.setComponentId(workStep.getComponentId());
			s.setPartsId(workStep.getPartsId());
			s.setProcessId(workStep.getProcessId());
			s.setStepId(workStep.getId());
			s.setDepartId(ws.getDepartId());
			permissionStreamList.add(s);
			}
			}

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

			/**
			* 待优化 TODO
			* @param nodeType 1 产品 2 部件 3 零件 5 工序 6 工步
			* @param paramId 产品树节点id
			* @param nodeType 1 产品 2 部件 3 零件
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			* @param userIds 移除用户ids
			* @return
			*/
			@Override
			@Transactional(rollbackFor = {Exception.class})
			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
			* @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 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<MdcProduction> mdcProductionList=mdcProductionService.listByIds(ids);
			if(mdcProductionList == null \|\| mdcProductionList.isEmpty() \|\| mdcProductionList.size() != departmentIds.length)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(nodeType == 6) {
			//处理工步
			WorkStep workStep=workStepService.getById(paramId);
			if (workStep == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			boolean b = checkProductPerm(6, workStep.getId());
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			return workStepService.assignRemoveDepart(workStep, mdcProductionList);
			}else if(nodeType == 5) {
			//处理工序
			ProcessStream processStream = processStreamService.getById(paramId);
			if (processStream == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			boolean b = checkProductPerm(5, processStream.getProcessId());
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			return processStreamService.assignRemoveDepart(processStream, mdcProductionList);
			}else 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, mdcProductionList);
			}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, mdcProductionList);
			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<ProcessionDepartment> processionPermissionList = new ArrayList<>();
			List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			List<String> partsIds= new ArrayList<>();
			List<String> ProcessionIds= new ArrayList<>();
			List<String> workStepIds= new ArrayList<>();
			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);
			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);
			}
			}

			//处理工序
			List<ProcessStream> processStreamList=processStreamService.getByComponentIdList(productInfo.getProductId(), componentIds,partsIds);
			ProcessionIds = new ArrayList<>();
			if(processStreamList != null && !processStreamList.isEmpty()) {
			for(ProcessStream processStream : processStreamList){
			ProcessionIds.add(processStream.getProcessId());
			}
			processionPermissionList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

			//处理工步
			List<WorkStep> workStepList=workStepService.getByProcessIds(productInfo.getProductId(), ProcessionIds);
			workStepIds = new ArrayList<>();
			if(workStepList != null && !workStepList.isEmpty()) {
			for(WorkStep workStep : workStepList){
			workStepIds.add(workStep.getId());
			}
			workStepDepartmentList = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, 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(processionPermissionList != null && !processionPermissionList.isEmpty()){
			processionDepartmentService.removeByCollection(processionPermissionList);
			}
			if(workStepDepartmentList != null && !workStepDepartmentList.isEmpty()){
			workStepDepartmentService.removeByCollection(workStepDepartmentList);
			}
			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, mdcProductionList);
			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<ProcessionDepartment> processionPermissionList = new ArrayList<>();
			List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			List<String> partsIds= new ArrayList<>();
			List<String> ProcessionIds= new ArrayList<>();
			List<String> workStepIds= 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);
			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);
			}
			}

			//处理工序
			List<ProcessStream> processStreamList=processStreamService.getByComponentIdList(componentInfo.getProductId(), componentIdList,partsIds);
			ProcessionIds = new ArrayList<>();
			if(processStreamList != null && !processStreamList.isEmpty()) {
			for(ProcessStream processStream : processStreamList){
			ProcessionIds.add(processStream.getProcessId());
			}
			processionPermissionList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

			//处理工步
			List<WorkStep> workStepList=workStepService.getByProcessIds(componentInfo.getProductId(), ProcessionIds);
			workStepIds = new ArrayList<>();
			if(workStepList != null && !workStepList.isEmpty()) {
			for(WorkStep workStep : workStepList){
			workStepIds.add(workStep.getId());
			}
			workStepDepartmentList = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, 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(processionPermissionList != null && !processionPermissionList.isEmpty()){
			processionDepartmentService.removeByCollection(processionPermissionList);
			}
			if(workStepDepartmentList != null && !workStepDepartmentList.isEmpty()){
			workStepDepartmentService.removeByCollection(workStepDepartmentList);
			}
			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("1");
			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);
			}
			}
			@@ -1561,33 +561,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);
			}
			}
			@@ -1597,35 +597,36 @@
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignAddDepartment(ProductInfo productInfo, Collection<MdcProduction> departmentList) {
			if(productInfo == null \|\| departmentList == null \|\| departmentList.isEmpty())
			if (productInfo == null \|\| departmentList == null \|\| departmentList.isEmpty())
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			List<ProductDepartment> productDepartmentList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
			departmentList.forEach(item -> {
			ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
			if(en == null) {
			if (en == null) {
			en = new ProductDepartment();
			en.setDepartId(item.getId());
			en.setProductId(productInfo.getProductId());
			productDepartmentList.add(en);
			}
			PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
			if(stream == null) {
			stream = new PermissionStream();
			PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1");
			if (stream == null) {
			stream = new PermissionStreamNew();
			stream.setDepartId(item.getId());
			stream.setProductId(productInfo.getProductId());
			stream.setBusinessId(productInfo.getProductId());
			stream.setBusinessType("1");
			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);
			}
			}
			@@ -1635,29 +636,29 @@
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignRemoveDepartment(ProductInfo productInfo, Collection<MdcProduction> departmentList) {
			if(productInfo == null \|\| departmentList == null \|\| departmentList.isEmpty())
			if (productInfo == null \|\| departmentList == null \|\| departmentList.isEmpty())
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			List<ProductDepartment> productDepartmentList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
			departmentList.forEach(item -> {
			ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
			if(en != null) {
			if (en != null) {
			productDepartmentList.add(en);
			}
			PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
			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);
			}
			}
			@@ -1668,37 +669,28 @@
			public List<String> getDepartIdsByParams(Integer nodeType, String paramId) {
			List<String> departIds = new ArrayList<>();
			//5-工序
			if(nodeType == 5) {
			ProcessStream processStream= processStreamService.getById(paramId);
			if(processStream == null)
			if (nodeType == 5) {
			ProcessStream processStream = processStreamService.getById(paramId);
			if (processStream == null)
			return null;
			List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
			.eq(StrUtil.isNotEmpty(processStream.getProductId()),"product_id", processStream.getProductId())
			.eq(StrUtil.isNotEmpty(processStream.getComponentId()),"component_id",processStream.getComponentId())
			.eq(StrUtil.isNotEmpty(processStream.getPartsId()),"parts_id", processStream.getPartsId())
			.eq(StrUtil.isNotEmpty(processStream.getProcessId()),"process_id",processStream.getProcessId()));
			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());
			});
			//6-工步
			}else if(nodeType == 6) {
			} else if (nodeType == 6) {
			WorkStep workStep = workStepService.getById(paramId);
			if(workStep == null)
			if (workStep == null)
			return null;
			List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
			.eq(StrUtil.isNotEmpty(workStep.getProductId()),"product_id", workStep.getProductId())
			.eq(StrUtil.isNotEmpty(workStep.getComponentId()),"component_id",workStep.getComponentId())
			.eq(StrUtil.isNotEmpty(workStep.getPartsId()),"parts_id", workStep.getPartsId())
			.eq(StrUtil.isNotEmpty(workStep.getProcessId()),"process_id",workStep.getProcessId())
			.eq(StrUtil.isNotEmpty(workStep.getId()),"step_id", workStep.getId()));
			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;
			}
			//去重
			@@ -1710,9 +702,9 @@

			@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);
			}
			@@ -1722,7 +714,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)
			@@ -1732,13 +724,13 @@

			@Override
			public List<CommonGenericTree> loadTree(String userId, Integer nodeType, String paramId) {
			if(nodeType == 1) {
			if (nodeType == 1) {
			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());
			@@ -1751,12 +743,12 @@
			list.add(node);
			}
			return list;
			}else if(nodeType == 2) {
			} else if (nodeType == 2) {
			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());
			@@ -1770,10 +762,10 @@
			}
			}
			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());
			@@ -1787,7 +779,7 @@
			list.add(partNode);
			}
			return list;
			}else {
			} else {
			return Collections.emptyList();
			}
			}
			@@ -1797,8 +789,9 @@
			List<ProductInfo> productInfos = this.getByUserPerms(userId, queryParam);
			List<ComponentInfo> componentInfos = componentInfoService.getByUserPerms(userId, queryParam);
			List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, null, queryParam);
			List<ProcessStream> processStreams=processStreamService.getByuserPerms(userId, queryParam);
			List<WorkStep> workSteps=workStepService.getByUserPerms(userId, 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<>();

			@@ -1808,32 +801,32 @@
			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);
			}
			@@ -1843,16 +836,16 @@

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

			if(!componentInfoMap.containsKey(processStream.getComponentId())) {
			if (!componentInfoMap.containsKey(processStream.getComponentId())) {
			component = componentInfoService.getById(processStream.getComponentId());
			if(component != null) {
			if (component != null) {
			componentInfoMap.put(component.getComponentId(), component);
			componentInfoList.add(component);
			}
			@@ -1860,18 +853,18 @@
			}
			}

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

			if(!componentInfoMap.containsKey(workStep.getComponentId())) {
			if (!componentInfoMap.containsKey(workStep.getComponentId())) {
			component = componentInfoService.getById(workStep.getComponentId());
			if(component != null) {
			if (component != null) {
			componentInfoMap.put(component.getComponentId(), component);
			componentInfoList.add(component);
			}
			@@ -1884,30 +877,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;
			}
			@@ -1917,13 +910,1216 @@
			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,processStreams,workSteps);
			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;
			}

			/**
			* 验证输入参数
			*/
			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<String> psvIds = processSpecVersionService.getByPartsIds(partsIds).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.getProductId());
			s.setBusinessType("1");
			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("3");
			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("4");
			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("5");
			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("6");
			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("6");
			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("5");
			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("2");
			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("2");
			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);
			partsInfoList.forEach(item->{
			partsInfoService.assignRemoveUser(item,userList);
			//删除
			handlePartRelatedRemovals(item, userList);
			});
			}
			private void handlePartsDepartmentRemovals(String productId, List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
			partsInfoList.forEach(item->{
			partsInfoService.assignRemoveDepart(item,mdcProductionList);
			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);
			}

			}