hy/mdc_hyjs_gk_new.git

			@@ -9,30 +9,25 @@
			import org.apache.shiro.SecurityUtils;
			import org.jeecg.common.system.vo.LoginUser;
			import org.jeecg.modules.dnc.dto.ComponentExt;

			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
			@@ -58,16 +53,12 @@
			@Autowired
			private IPartsPermissionService partsPermissionService;
			@Autowired
			private IDepartmentService departmentService;
			@Autowired
			private ISysUserService userService;
			@Autowired
			@Lazy
			private IProcessStreamService processStreamService;
			@Autowired
			private IWorkStepService workStepService;
			@Autowired
			private IDocInfoService docInfoService;
			@Autowired
			private INcLogInfoService iNcLogInfoService;
			@Autowired
			@@ -78,6 +69,10 @@
			private IMdcProductionService mdcProductionService;
			@Autowired
			private IDocRelativeService iDocRelativeService;
			@Autowired
			private IProcessStreamPermissionService iProcessStreamPermissionService;
			@Autowired
			private IWorkStepPermissionService iWorkStepPermissionService;

			@Override
			@Transactional(rollbackFor = {Exception.class})
			@@ -97,15 +92,6 @@
			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) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
			@@ -137,16 +123,6 @@
			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)
			return false;
			@@ -311,6 +287,10 @@
			return componentPermissionService.getUserPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			return partsPermissionService.getUserPermsByProductId(paramId);
			} else if (nodeType == 5) {
			return iProcessStreamPermissionService.getUserPermsByProductId(paramId);
			} else if (nodeType == 6) {
			return iWorkStepPermissionService.getUserPermsByProductId(paramId);
			}else {
			return null;
			}
			@@ -326,6 +306,10 @@
			return componentPermissionService.getUserNonPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			return partsPermissionService.getUserNonPermsByProductId(paramId);
			} else if (nodeType == 5) {
			return iProcessStreamPermissionService.getUserNonPermsByProductId(paramId);
			} else if (nodeType == 6) {
			return iWorkStepPermissionService.getUserNonPermsByProductId(paramId);
			}else {
			return null;
			}
			@@ -366,17 +350,12 @@
			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 relativeFlag 1 是 2 否
			@@ -385,413 +364,30 @@
			*/
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignAddUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
			public boolean assignAddUserAll(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);
			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) {

			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;
			}
			validateSysUserList(userList, ids);
			switch (nodeType) {
			case 6:
			return handleWorkStep(paramId, null,userList);
			case 5:
			return handleProcessStream(paramId, relativeFlag, null,userList);
			case 3:
			return handlePartsInfo(paramId, relativeFlag, null,userList);
			case 1:
			return handleProductInfo(paramId, relativeFlag, null,userList);
			case 2:
			return handleComponentInfo(paramId, relativeFlag, null,userList);
			default:
			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 否
			@@ -800,481 +396,61 @@
			*/
			@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;

			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;
			}
			validateMdcProductionList(mdcProductionList, ids);
			switch (nodeType) {
			case 6:
			return handleWorkStep(paramId, mdcProductionList,null);
			case 5:
			return handleProcessStream(paramId, relativeFlag, mdcProductionList,null);
			case 3:
			return handlePartsInfo(paramId, relativeFlag, mdcProductionList,null);
			case 1:
			return handleProductInfo(paramId, relativeFlag, mdcProductionList,null);
			case 2:
			return handleComponentInfo(paramId, relativeFlag, mdcProductionList,null);
			default:
			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 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 6:
			return handleWorkStepRemoval(paramId, userList,null);
			case 5:
			return handleProcessStreamRemoval(paramId, relativeFlag, userList,null);
			case 3:
			return handlePartsInfoRemoval(paramId, relativeFlag, userList,null);
			case 1:
			return handleProductInfoRemoval(paramId, relativeFlag, userList,null);
			case 2:
			return handleComponentInfoRemoval(paramId, relativeFlag, userList,null);
			default:
			return false;
			}
			}


			/**
			*
			* @param nodeType 1 产品 2 部件 3 零件 5 工序 6 工步
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			@@ -1283,236 +459,25 @@
			*/
			@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);
			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;
			}
			public boolean assignRemoveDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
			validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds);
			List<String> departmentIdList = Arrays.asList(departmentIds);
			Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(departmentIdList);
			validateMdcProductionList(mdcProductionList, departmentIdList);
			switch (nodeType) {
			case 6:
			return handleWorkStepRemoval(paramId,null,mdcProductionList);
			case 5:
			return handleProcessStreamRemoval(paramId, relativeFlag, null,mdcProductionList);
			case 3:
			return handlePartsInfoRemoval(paramId, relativeFlag,null, mdcProductionList);
			case 1:
			return handleProductInfoRemoval(paramId, relativeFlag,null, mdcProductionList);
			case 2:
			return handleComponentInfoRemoval(paramId, relativeFlag, null,mdcProductionList);
			default:
			return false;
			}
			}

			@Override
			@@ -1944,4 +909,1022 @@
			}
			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, Collection<SysUser> userList) {
			List<ComponentPermission> componentPermissionList = new ArrayList<>();
			List<PartsPermission> partsPermissionList = new ArrayList<>();
			List<ProcessionPermission> processionPermissionList = new ArrayList<>();
			List<WorkStepPermission> workStepPermissionList = new ArrayList<>();
			List<PermissionStream> 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<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productId, componentIds, partsIds);
			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 (partsId != null) {
			List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsId));
			processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
			}

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

			private void processStreamApi(String productId, Collection<SysUser> userList, List<ProcessionPermission> processionPermissionList, List<WorkStepPermission> workStepPermissionList, List<PermissionStream> 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<PermissionStream> 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());
			PermissionStream s = new PermissionStream();
			s.setProductId(cpInfo.getProductId());
			s.setComponentId(cpInfo.getComponentId());
			s.setUserId(cp.getUserId());
			permissionStreamList.add(s);
			}
			}

			private void handlePartsPermissions(List<String> partsIds, Collection<SysUser> userList,
			List<PartsPermission> partsPermissionList, List<PermissionStream> 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());
			PermissionStream s = new PermissionStream();
			s.setProductId(ptInfo.getProductId());
			s.setComponentId(ptInfo.getComponentId());
			s.setPartsId(ptInfo.getPartsId());
			s.setUserId(pp.getUserId());
			permissionStreamList.add(s);
			}
			}

			private void handleProcessPermissions(List<String> processIds, Collection<SysUser> userList,
			List<ProcessionPermission> processionPermissionList, List<PermissionStream> 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());
			PermissionStream s = new PermissionStream();
			s.setProductId(processStream.getProductId());
			s.setComponentId(processStream.getComponentId());
			s.setPartsId(processStream.getPartsId());
			s.setProcessId(processStream.getProcessId());
			s.setUserId(pp.getUserId());
			permissionStreamList.add(s);
			}
			}

			private void handleWorkStepPermissions(List<String> workStepIds, Collection<SysUser> userList,
			List<WorkStepPermission> workStepPermissionList, List<PermissionStream> 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());
			PermissionStream s = new PermissionStream();
			s.setProductId(workStep.getProductId());
			s.setComponentId(workStep.getComponentId());
			s.setPartsId(workStep.getPartsId());
			s.setProcessId(workStep.getProcessId());
			s.setStepId(workStep.getId());
			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, userList);
			}
			}else {
			result = processStreamService.assignAddDepart(processStream, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleRelatedPermissions(processStream, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService);
			}
			}
			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(), 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, 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, 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, IPermissionStreamService permissionStreamService) {
			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<PermissionStream> newPermissionStreams = new ArrayList<>();
			for (Map.Entry<String, WorkStepDepartment> entry : allPermissions.entrySet()) {
			WorkStepDepartment wsDep = entry.getValue();
			newWorkStepDepartments.add(wsDep);
			WorkStep workStep = workStepMap.get(wsDep.getStepId());
			PermissionStream permStream = new PermissionStream();
			permStream.setProductId(workStep.getProductId());
			permStream.setComponentId(workStep.getComponentId());
			permStream.setPartsId(workStep.getPartsId());
			permStream.setProcessId(workStep.getProcessId());
			permStream.setStepId(workStep.getId());
			permStream.setDepartId(wsDep.getDepartId());
			newPermissionStreams.add(permStream);
			}

			if (!newWorkStepDepartments.isEmpty()) {
			workStepDepartmentService.saveBatch(newWorkStepDepartments);
			}
			if (!newPermissionStreams.isEmpty()) {
			permissionStreamService.saveBatch(newPermissionStreams);
			}
			}

			private void handleRelatedPermissionsForParts(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
			// 处理工序权限
			handleProcessPermissions(partsInfo,null, mdcProductionList);
			// 处理工步权限
			handleWorkStepPermissions(partsInfo, mdcProductionList);
			}

			private void handleProcessPermissions(PartsInfo partsInfo,ComponentInfo componentInfo,Collection<MdcProduction> mdcProductionList) {
			List<ProcessStream> processStreamList=new ArrayList<>();
			if (componentInfo != null) {
			processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
			}else {
			processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
			}
			if (processStreamList == null \|\| processStreamList.isEmpty()) {
			return;
			}
			processStreamList.forEach(item->{
			handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService);
			});
			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<PermissionStream> newPermissionStreams = new ArrayList<>();
			for (Map.Entry<String, ProcessionDepartment> entry : allProcessPermissions.entrySet()) {
			ProcessionDepartment procDep = entry.getValue();
			newProcessPermissions.add(procDep);
			ProcessStream processStream = processStreamMap.get(procDep.getProcessId());
			PermissionStream permStream = new PermissionStream();
			permStream.setProductId(processStream.getProductId());
			permStream.setComponentId(processStream.getComponentId());
			permStream.setPartsId(processStream.getPartsId());
			permStream.setProcessId(processStream.getProcessId());
			permStream.setDepartId(procDep.getDepartId());
			newPermissionStreams.add(permStream);
			}

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

			private void handleWorkStepPermissions(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
			List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
			if (processStreamList == null \|\| processStreamList.isEmpty()) {
			return;
			}
			List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
			List<WorkStep> workStepList = workStepService.getByProcessIds(partsInfo.getProductId(), processIds);
			if (workStepList == null \|\| workStepList.isEmpty()) {
			return;
			}
			workStepList.forEach(item->{
			handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService);
			});
			}

			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<PermissionStream> newPermissionStreams = new ArrayList<>();
			for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
			ComponentDepartment compDep = entry.getValue();
			newComponentPermissions.add(compDep);
			ComponentInfo componentInfo = componentInfoMap.get(compDep.getComponentId());
			PermissionStream permStream = new PermissionStream();
			permStream.setProductId(componentInfo.getProductId());
			permStream.setComponentId(componentInfo.getComponentId());
			permStream.setDepartId(compDep.getDepartId());
			newPermissionStreams.add(permStream);
			}

			if (!newComponentPermissions.isEmpty()) {
			componentDepartmentService.saveBatch(newComponentPermissions);
			}
			if (!newPermissionStreams.isEmpty()) {
			permissionStreamService.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<PermissionStream> newPermissionStreams = new ArrayList<>();
			for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
			ComponentDepartment compDep = entry.getValue();
			newComponentPermissions.add(compDep);
			childComponent = componentInfoMap.get(compDep.getComponentId());
			PermissionStream permStream = new PermissionStream();
			permStream.setProductId(childComponent.getProductId());
			permStream.setComponentId(childComponent.getComponentId());
			permStream.setDepartId(compDep.getDepartId());
			newPermissionStreams.add(permStream);
			}

			if (!newComponentPermissions.isEmpty()) {
			componentDepartmentService.saveBatch(newComponentPermissions);
			}
			if (!newPermissionStreams.isEmpty()) {
			permissionStreamService.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) {
			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 handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			WorkStep workStep = workStepService.getById(paramId);
			if (workStep == null) {
			ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
			}
			checkProductPerm(6, workStep.getId());
			if (userList!=null){
			return workStepService.assignRemoveUser(workStep, userList);
			}else {
			return workStepService.assignRemoveDepart(workStep, mdcProductionList);
			}
			}

			private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			ProcessStream processStream = processStreamService.getById(paramId);
			if (processStream == null) {
			ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
			}
			checkProductPerm(5, processStream.getProcessId());
			boolean result;
			if (userList!=null){
			result = processStreamService.assignRemoveUser(processStream, userList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleRelatedRemovals(processStream.getProcessId(), userList,
			workStepService, iWorkStepPermissionService, permissionStreamService,
			"process_id");
			}
			}else {
			result = processStreamService.assignRemoveDepart(processStream, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handleRelatedDepartmentRemovals(processStream.getProcessId(), mdcProductionList,
			workStepService, workStepDepartmentService, permissionStreamService,
			"process_id");
			}
			}
			return true;
			}

			private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			PartsInfo partsInfo = partsInfoService.getById(paramId);
			if (partsInfo == null) {
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			}
			checkProductPerm(3, partsInfo.getPartsId());
			boolean result;
			if (userList!=null){
			result = partsInfoService.assignRemoveUser(partsInfo, userList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handlePartsRelatedRemovals(null,partsInfo, userList);
			}
			}else {
			result = partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList);
			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			if (relativeFlag == 1) {
			handlePartsRelatedDepartmentRemovals(null,partsInfo, mdcProductionList);
			}
			}
			return true;
			}

			private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			ProductInfo productInfo = super.getById(paramId);
			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 void handleRelatedRemovals(String parentId, Collection<SysUser> userList,
			IWorkStepService workStepService,
			IWorkStepPermissionService workStepPermissionService,
			IPermissionStreamService permissionStreamService,
			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<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, userIdList);

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

			private void handleRelatedDepartmentRemovals(String parentId, Collection<MdcProduction> mdcProductionList,
			IWorkStepService workStepService,
			IWorkStepDepartmentService workStepDepartmentService,
			IPermissionStreamService permissionStreamService,
			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<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, departmentIdList);

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

			private void handlePartsRelatedRemovals(ComponentInfo componentInfo,PartsInfo partsInfo,Collection<SysUser> userList) {
			List<ProcessStream> processStreamList =new ArrayList<>();
			String productId="";
			if (partsInfo!=null){
			processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
			productId=partsInfo.getProductId();
			}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<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndUserIds(processIds, userIdList);

			if (!processionPermissions.isEmpty()) {
			iProcessStreamPermissionService.removeByCollection(processionPermissions);
			}
			if (!permissionStreams.isEmpty()) {
			permissionStreamService.removeByCollection(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<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(processIds, departmentIdList);

			if (!processionDepartments.isEmpty()) {
			processionDepartmentService.removeByCollection(processionDepartments);
			}
			if (!permissionStreams.isEmpty()) {
			permissionStreamService.removeByCollection(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, permissionStreamService, "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, permissionStreamService, "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->{
			handlePartsRelatedRemovals(item,null, userList);
			});
			}

			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->{
			handlePartsRelatedDepartmentRemovals(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<PermissionStream> permissionStreams = permissionStreamService.getByComponentIdsAndUserIds(componentIds, userIdList);

			if (!componentPermissions.isEmpty()) {
			componentPermissionService.removeByCollection(componentPermissions);
			}
			if (!permissionStreams.isEmpty()) {
			permissionStreamService.removeByCollection(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<PermissionStream> permissionStreams = permissionStreamService.getByComponentIdsAndDepartIds(componentIds, departmentIdList);

			if (!componentDepartments.isEmpty()) {
			componentDepartmentService.removeByCollection(componentDepartments);
			}
			if (!permissionStreams.isEmpty()) {
			permissionStreamService.removeByCollection(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);
			handlePartsRelatedRemovals(null,item, userList);
			});
			}
			private void handlePartsDepartmentRemovals(String productId, List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
			List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
			partsInfoList.forEach(item->{
			partsInfoService.assignRemoveDepart(item,mdcProductionList);
			handlePartsRelatedDepartmentRemovals(null,item, mdcProductionList);
			});
			}

			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->{
			handlePartsRelatedDepartmentRemovals(item,null, mdcProductionList);
			});
			}
			}else {
			handleComponentRemovals(componentIds, userList);
			handlePartsRemovals(componentInfo.getProductId(), componentIds, userList);
			if (childrenList != null) {
			childrenList.forEach(item->{
			handlePartsRelatedRemovals(item,null, userList);
			});
			}
			}
			}

			private void handlePartsRelatedDepartmentRemovals(ComponentInfo componentInfo,PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
			List<ProcessStream> processStreamList=new ArrayList<>();
			String productId="";
			if (componentInfo!=null){
			processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
			productId=componentInfo.getProductId();
			}else {
			processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
			productId=partsInfo.getProductId();
			}
			List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
			handleProcessDepartmentRemovals(processIds, mdcProductionList);
			handleWorkStepDepartmentRemovals(productId, processIds, mdcProductionList);
			}

			}