hy/mdc_hyjs_gk_new.git

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

			import cn.hutool.core.bean.BeanUtil;
			import cn.hutool.core.collection.CollectionUtil;
			import cn.hutool.core.util.StrUtil;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.baomidou.mybatisplus.core.toolkit.Wrappers;
			import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
			import lombok.extern.slf4j.Slf4j;
			import org.apache.shiro.SecurityUtils;
			import org.jeecg.common.api.vo.Result;
			import org.jeecg.common.system.vo.LoginUser;
			import org.jeecg.modules.dnc.constant.DocAttributionTypeEnum;
			import org.jeecg.modules.dnc.dto.ComponentExt;

			import org.jeecg.modules.dnc.entity.*;
			import org.jeecg.modules.dnc.exception.ExceptionCast;
			import org.jeecg.modules.dnc.mapper.ProductInfoMapper;

			import org.jeecg.modules.dnc.request.DocInfoQueryRequest;
			import org.jeecg.modules.dnc.request.TreeInfoRequest;
			import org.jeecg.modules.dnc.response.*;
			import org.jeecg.modules.dnc.service.*;
			import org.jeecg.modules.dnc.service.support.ProductTreeWrapper;
			import org.jeecg.modules.dnc.ucenter.Department;
			import org.jeecg.modules.dnc.ucenter.UserDepartExt;
			import org.jeecg.modules.dnc.utils.ValidateUtil;

			import org.jeecg.modules.dnc.entity.*;
			import org.jeecg.modules.system.entity.MdcProduction;
			import org.jeecg.modules.system.entity.SysUser;
			import org.jeecg.modules.system.service.IMdcProductionService;
			import org.jeecg.modules.system.service.ISysUserService;

			import org.jeecg.modules.dnc.response.ComponentInfoCode;
			import org.jeecg.modules.dnc.response.PartsInfoCode;
			import org.jeecg.modules.dnc.response.ProductInfoCode;
			import org.jeecg.modules.dnc.response.UcenterCode;
			import org.jeecg.modules.dnc.response.CommonCode;
			import org.jeecg.modules.dnc.response.CommonGenericTree;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.context.annotation.Lazy;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;

			import java.util.*;
			import java.util.stream.Collectors;

			@Service
			@Slf4j
			@@ -47,11 +45,13 @@
			@Lazy
			private IPartsInfoService partsInfoService;
			@Autowired
			private IProcessSpecVersionService processSpecVersionService;
			@Autowired
			private IProductPermissionService productPermissionService;
			@Autowired
			private IProductDepartmentService productDepartmentService;
			@Autowired
			private IPermissionStreamService permissionStreamService;
			private IPermissionStreamNewService permissionStreamNewService;
			@Autowired
			private IComponentDepartmentService componentDepartmentService;
			@Autowired
			@@ -61,7 +61,9 @@
			@Autowired
			private IPartsPermissionService partsPermissionService;
			@Autowired
			private IDepartmentService departmentService;
			private IProcessSpecVersionPermissionService processSpecVersionPermissionService;
			@Autowired
			private IProcessSpecVersionDepartmentService processSpecVersionDepartmentService;
			@Autowired
			private ISysUserService userService;
			@Autowired
			@@ -70,97 +72,120 @@
			@Autowired
			private IWorkStepService workStepService;
			@Autowired
			private IWorkStepDepartmentService workStepDepartmentService;
			@Autowired
			private IProcessionDepartmentService processionDepartmentService;
			@Autowired
			private IMdcProductionService mdcProductionService;
			@Autowired
			private IDocRelativeService iDocRelativeService;
			@Autowired
			private IProcessStreamPermissionService iProcessStreamPermissionService;
			@Autowired
			private IWorkStepPermissionService iWorkStepPermissionService;
			@Autowired
			private IProductMixService productMixService;
			@Autowired
			@Lazy
			private IDocInfoService docInfoService;
			@Autowired
			private INcLogInfoService iNcLogInfoService;
			private IDeviceTypeService deviceTypeService;
			@Autowired
			private IDeviceManagementService deviceManagementService;

			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean addProductInfo(ProductInfo productInfo) {
			if(productInfo == null)
			if (productInfo == null)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(!ValidateUtil.validateString(productInfo.getProductName()))
			if (!ValidateUtil.validateString(productInfo.getProductName()))
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NAME_NONE);
			if(!ValidateUtil.validateString(productInfo.getProductNo())) {
			if (!ValidateUtil.validateString(productInfo.getProductNo())) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NO_NONE);
			}
			ProductInfo en = getByProductNo(productInfo.getProductNo());
			if(en != null)
			if (en != null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_IS_EXIST);
			LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
			String userId = user.getId();
			if(!ValidateUtil.validateString(userId))
			if (!ValidateUtil.validateString(userId))
			ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
			productInfo.setProductStatus(1);
			//添加日志
			NcLogInfo ncLogInfo = new NcLogInfo();
			//模块
			ncLogInfo.setModuleInfo("产品结构树");
			//类型
			ncLogInfo.setOperateType(2);
			//日志内容
			ncLogInfo.setLogContent("产品名称："+productInfo.getProductName()+"，产品编号："+productInfo.getProductNo());
			iNcLogInfoService.saveLogNcInfos(ncLogInfo);
			boolean b = super.save(productInfo);
			if(!b) {
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
			}
			ProductPermission permission = new ProductPermission();
			permission.setProductId(productInfo.getProductId());
			permission.setUserId(userId);
			b = productPermissionService.save(permission);
			if(!b) {
			b = productPermissionService.add(productInfo.getProductId(), userId,"1");
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
			}
			PermissionStream stream = new PermissionStream();
			stream.setProductId(productInfo.getProductId());
			//添加结构树
			ProductMix productMix = new ProductMix(Long.parseLong(productInfo.getProductId()),0L,
			productInfo.getProductName(),productInfo.getProductNo(),1,new Date());
			productMixService.save(productMix);
			//添加用户部门
			if(StrUtil.isNotBlank(user.getProductionIds())){
			String[] split = user.getProductionIds().split(",");
			String[] departIds = split;
			for (String departId : departIds) {
			ProductDepartment productDepartment = new ProductDepartment();
			productDepartment.setProductId(productInfo.getProductId());
			productDepartment.setDepartId(departId);
			productDepartmentService.save(productDepartment);
			PermissionStreamNew stream = new PermissionStreamNew();
			stream.setBusinessId(productInfo.getProductId());
			stream.setDepartId(departId);
			stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
			permissionStreamNewService.save(stream);
			}
			}
			//添加用户权限
			PermissionStreamNew stream = new PermissionStreamNew();
			stream.setBusinessId(productInfo.getProductId());
			stream.setUserId(userId);
			return permissionStreamService.save(stream);
			stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
			return permissionStreamNewService.addPermissionStreamNew(stream);
			}

			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean editProductInfo(String id ,ProductInfo productInfo) {
			if(!ValidateUtil.validateString(id) \|\| productInfo == null)
			public boolean editProductInfo(String id, ProductInfo productInfo) {
			if (!ValidateUtil.validateString(id) \|\| productInfo == null)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
			String userId = user.getId();
			if(!ValidateUtil.validateString(userId))
			if (!ValidateUtil.validateString(userId))
			ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
			ProductInfo en = super.getById(id);
			if(en == null)
			if (en == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			productInfo.setProductId(id);
			productInfo.setProductStatus(null);
			//添加日志
			NcLogInfo ncLogInfo = new NcLogInfo();
			//模块
			ncLogInfo.setModuleInfo("产品结构树");
			//类型
			ncLogInfo.setOperateType(3);
			//日志内容
			ncLogInfo.setLogContent("产品名称："+productInfo.getProductName());
			ncLogInfo.setRemark(JSONObject.toJSONString(en));
			iNcLogInfoService.saveLogNcInfos(ncLogInfo);
			boolean b = super.updateById(productInfo);
			if(!b)
			//同步修改结构树
			ProductMix productMix = productMixService.getById(Long.parseLong(id));
			productMix.setTreeName(productInfo.getProductName());
			productMix.setTreeCode(productInfo.getProductNo());
			productMixService.updateById(productMix);
			if (!b)
			return false;
			ProductPermission permission = productPermissionService.getByProductIdAndUserId(id, userId);
			if(permission == null) {
			if (permission == null) {
			permission = new ProductPermission();
			permission.setProductId(id);
			permission.setUserId(userId);
			b = productPermissionService.save(permission);
			if(!b) {
			if (!b) {
			return false;
			}
			}
			PermissionStream stream = permissionStreamService.getByProductIdAndUserId(id, userId);
			if(stream == null) {
			stream = new PermissionStream();
			stream.setProductId(id);
			PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(id, userId, DocAttributionTypeEnum.PRODUCT.getCode().toString());
			if (stream == null) {
			stream = new PermissionStreamNew();
			stream.setBusinessId(productInfo.getProductId());
			stream.setUserId(userId);
			return permissionStreamService.save(stream);
			stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
			return permissionStreamNewService.save(stream);
			}
			return b;
			}
			@@ -169,41 +194,45 @@
			public List<CommonGenericTree> loadProductTree(String userId) {
			//产品
			List<ProductInfo> productInfoList = getByUserPerms(userId);
			if(productInfoList == null \|\| productInfoList.isEmpty())
			if (productInfoList == null \|\| productInfoList.isEmpty())
			return Collections.emptyList();
			//部件
			List<ComponentExt> componentInfoList = componentInfoService.getByUserPermsAs(userId);
			if(componentInfoList == null)
			if (componentInfoList == null)
			componentInfoList = Collections.emptyList();
			//零件
			List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId);
			if(partsInfos == null)
			if (partsInfos == null)
			partsInfos = Collections.emptyList();
			//工艺规程版本
			List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByUserPerms(userId);
			if (processSpecVersions == null)
			processSpecVersions = Collections.emptyList();
			//工序
			List<ProcessStream> processStreams=processStreamService.getByuserPerms(userId);
			if(processStreams==null)
			List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId);
			if (processStreams == null)
			processStreams = Collections.emptyList();
			//工步
			List<WorkStep> workStepList=workStepService.getByUserPerms(userId);
			if(workStepList==null)
			List<WorkStep> workStepList = workStepService.getByUserPerms(userId);
			if (workStepList == null)
			workStepList = Collections.emptyList();
			return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos,processStreams,workStepList);
			return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos, processSpecVersions,processStreams, workStepList);
			}

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

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

			@Override
			public boolean checkProductPerm(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			if (!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
			String userId = user.getId();
			if(!ValidateUtil.validateString(userId))
			if (!ValidateUtil.validateString(userId))
			ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
			if(nodeType == 1) {
			if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
			ProductInfo productInfo = super.getById(paramId);
			if(productInfo == null)
			if (productInfo == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			PermissionStream permission = permissionStreamService.getByProductIdAndUserId(paramId, userId);
			if(permission == null)
			return false;
			return true;
			}else if(nodeType == 2) {
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(paramId, userId,"1");
			return permission != null;
			} else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())) {
			ComponentInfo componentInfo = componentInfoService.getById(paramId);
			if(componentInfo == null)
			if (componentInfo == null)
			ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
			PermissionStream permission = permissionStreamService.getByComponentIdAndUserId(componentInfo.getProductId(), paramId, userId);
			if(permission == null)
			return false;
			return true;
			}else if(nodeType == 3) {
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(componentInfo.getComponentId(), userId,"2");
			return permission != null;
			} else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
			PartsInfo partsInfo = partsInfoService.getById(paramId);
			if(partsInfo == null)
			if (partsInfo == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			PermissionStream permission = permissionStreamService.getByPartsIdAndUserId(partsInfo.getProductId(), partsInfo.getComponentId(), paramId, userId);
			if(permission == null)
			return false;
			return true;
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(partsInfo.getPartsId(), userId, "3");
			return permission != null;
			} else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
			ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
			if (processSpecVersion == null)
			ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processSpecVersion.getId(),userId,"4");
			return permission != null;
			} else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
			ProcessStream processStream = processStreamService.getById(paramId);
			if (processStream == null)
			ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processStream.getProcessId(), userId,"5");
			return permission != null;
			} else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
			WorkStep workStep = workStepService.getById(paramId);
			if (workStep == null)
			ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
			PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(workStep.getId(), userId,"6");
			return permission != null;
			}
			return false;
			}

			@Override
			public List<UserDepartExt> getUserPermsList(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			if (!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			return null;
			if(nodeType == 1) {
			if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
			return productPermissionService.getUserPermsByProductId(paramId);
			}else if(nodeType == 2) {
			} else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())) {
			return componentPermissionService.getUserPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			} else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
			return partsPermissionService.getUserPermsByProductId(paramId);
			}else {
			} else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
			return processSpecVersionPermissionService.getUserPermsByProductId(paramId);
			} else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
			return iProcessStreamPermissionService.getUserPermsByProductId(paramId);
			} else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
			return iWorkStepPermissionService.getUserPermsByProductId(paramId);
			} else {
			return null;
			}
			}

			@Override
			public List<SysUser> getUserNonPermsList(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			if (!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			return null;
			if(nodeType == 1) {
			if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
			return productPermissionService.getUserNonPermsByProductId(paramId);
			}else if(nodeType == 2) {
			} else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){
			return componentPermissionService.getUserNonPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			} else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
			return partsPermissionService.getUserNonPermsByProductId(paramId);
			}else {
			} else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
			return processSpecVersionPermissionService.getUserNonPermsByProductId(paramId);
			} else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
			return iProcessStreamPermissionService.getUserNonPermsByProductId(paramId);
			} else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
			return iWorkStepPermissionService.getUserNonPermsByProductId(paramId);
			} else {
			return null;
			}
			}

			@Override
			public List<Department> getDepartPermsList(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			public List<MdcProduction> getDepartPermsList(Integer nodeType, String paramId) {
			if (!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			return null;
			if(nodeType == 1) {
			if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
			return productDepartmentService.getDepartPermsByProductId(paramId);
			}else if(nodeType == 2) {
			} else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){
			return componentDepartmentService.getDepartPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			} else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
			return partsDepartmentService.getDepartPermsByPartsId(paramId);
			}else {
			} else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
			return processSpecVersionDepartmentService.getDepartPermsByPsvId(paramId);
			} else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
			return processionDepartmentService.getDepartPermsByProcessId(paramId);
			} else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
			return workStepDepartmentService.getDepartPermsByStepId(paramId);
			}
			else {
			return null;
			}
			}

			@Override
			public List<Department> getDepartNonPermsList(Integer nodeType, String paramId) {
			if(!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			public List<MdcProduction> getDepartNonPermsList(Integer nodeType, String paramId) {
			if (!ValidateUtil.validateInteger(nodeType) \|\| !ValidateUtil.validateString(paramId))
			return null;
			if(nodeType == 1) {
			if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
			return productDepartmentService.getDepartNonPermsByProductId(paramId);
			}else if(nodeType == 2) {
			} else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){
			return componentDepartmentService.getDepartNonPermsByComponentId(paramId);
			}else if(nodeType == 3) {
			} else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
			return partsDepartmentService.getDepartNonPermsByProductId(paramId);
			}else {
			} else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
			return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
			} else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
			return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
			} else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
			return workStepDepartmentService.getDepartNonPermsByStepId(paramId);
			} else {
			return null;
			}
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


			/**
			*
			* @param nodeType 1 产品 2 部件 3 零件 5 工序 6 工步
			* @param paramId 产品树节点id
			* @param relativeFlag 1 是 2 否
			* @param departmentIds 移除部门ids
			* todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
			* @return
			*/
			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignRemoveDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
			validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds);
			List<String> ids = new ArrayList<>(departmentIds.length);
			Collections.addAll(ids, departmentIds);
			Collection<Department> departList = departmentService.listByIds(ids);
			if(departList == null \|\| departList.isEmpty() \|\| departList.size() != departmentIds.length)
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			if(nodeType == 3) {
			//处理零件
			PartsInfo partsInfo = partsInfoService.getById(paramId);
			if(partsInfo == null)
			ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			boolean b = checkProductPerm(3, partsInfo.getPartsId());
			if(!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			return partsInfoService.assignRemoveDepart(partsInfo, departList);
			}else if(nodeType == 1) {
			//处理产品
			ProductInfo productInfo = super.getById(paramId);
			if(productInfo == null)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			boolean b1 = checkProductPerm(1, productInfo.getProductId());
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			b1 = this.assignRemoveDepartment(productInfo, departList);
			if(!b1)
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			if(relativeFlag == 1) {
			//处理产品下的部件
			List<String> componentIds = new ArrayList<>();
			//总计需要删除的数据信息
			List<ComponentDepartment> componentPermissionList = new ArrayList<>();
			List<PartsDepartment> partsPermissionList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
			if(componentInfoList != null && !componentInfoList.isEmpty()) {
			for(ComponentInfo componentInfo : componentInfoList){
			componentIds.add(componentInfo.getComponentId());
			}
			componentPermissionList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, ids);
			List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndDepartIds(componentIds, ids);
			if(existPermissionList != null && !existPermissionList.isEmpty()){
			permissionStreamList.addAll(existPermissionList);
			}
			}

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

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

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

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

			if(componentPermissionList != null && !componentPermissionList.isEmpty()){
			componentDepartmentService.removeByCollection(componentPermissionList);
			}
			if(partsPermissionList != null && !partsPermissionList.isEmpty()){
			partsDepartmentService.removeByCollection(partsPermissionList);
			}
			if(permissionStreamList != null && !permissionStreamList.isEmpty()){
			permissionStreamService.removeByCollection(permissionStreamList);
			}
			}
			return true;
			List<String> deps=mdcProductionService.findAllProductionIds(ids);
			Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(deps);
			validateMdcProductionList(mdcProductionList, deps);
			switch (nodeType) {
			case 1:
			return handleProductInfoRemoval(paramId, relativeFlag,null, mdcProductionList);
			case 2:
			return handleComponentInfoRemoval(paramId, relativeFlag, null,mdcProductionList);
			case 3:
			return handlePartsInfoRemoval(paramId, relativeFlag,null, mdcProductionList);
			case 4:
			return handleProcessSpecVersionRemoval(paramId, relativeFlag, null,mdcProductionList);
			case 5:
			return handleProcessStreamRemoval(paramId, relativeFlag, null,mdcProductionList);
			case 6:
			return handleWorkStepRemoval(paramId,null,mdcProductionList);
			default:
			return false;
			}
			return false;
			}

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

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

			@Override
			@Transactional(rollbackFor = {Exception.class})
			public boolean assignRemoveDepartment(ProductInfo productInfo, Collection<Department> departmentList) {
			if(productInfo == null \|\| departmentList == null \|\| departmentList.isEmpty())
			public boolean assignRemoveDepartment(ProductInfo productInfo, Collection<MdcProduction> departmentList) {
			if (productInfo == null \|\| departmentList == null \|\| departmentList.isEmpty())
			ExceptionCast.cast(CommonCode.INVALID_PARAM);
			List<ProductDepartment> productDepartmentList = new ArrayList<>();
			List<PermissionStream> permissionStreamList = new ArrayList<>();
			List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
			departmentList.forEach(item -> {
			ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getDepartId());
			if(en != null) {
			ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
			if (en != null) {
			productDepartmentList.add(en);
			}
			PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getDepartId());
			if(stream != null) {
			PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1");
			if (stream != null) {
			permissionStreamList.add(stream);
			}
			});
			if(!productDepartmentList.isEmpty()) {
			if (!productDepartmentList.isEmpty()) {
			boolean b = productDepartmentService.removeByCollection(productDepartmentList);
			if(!b) {
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			if(!permissionStreamList.isEmpty()) {
			boolean b = permissionStreamService.removeByCollection(permissionStreamList);
			if(!b) {
			if (!permissionStreamList.isEmpty()) {
			boolean b = permissionStreamNewService.deletePermissionStreamNewByList(permissionStreamList);
			if (!b) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}
			}
			@@ -1328,37 +709,28 @@
			public List<String> getDepartIdsByParams(Integer nodeType, String paramId) {
			List<String> departIds = new ArrayList<>();
			//5-工序
			if(nodeType == 5) {
			ProcessStream processStream= processStreamService.getById(paramId);
			if(processStream == null)
			if (Objects.equals(nodeType, DocAttributionTypeEnum.PROCESS.getCode())) {
			ProcessStream processStream = processStreamService.getById(paramId);
			if (processStream == null)
			return null;
			List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
			.eq(StrUtil.isNotEmpty(processStream.getProductId()),"product_id", processStream.getProductId())
			.eq(StrUtil.isNotEmpty(processStream.getComponentId()),"component_id",processStream.getComponentId())
			.eq(StrUtil.isNotEmpty(processStream.getPartsId()),"parts_id", processStream.getPartsId())
			.eq(StrUtil.isNotEmpty(processStream.getProcessId()),"process_id",processStream.getProcessId()));
			if(permissionStreamList == null \|\| permissionStreamList.isEmpty())
			List<PermissionStreamNew> permissionStreamList = permissionStreamNewService.loadProductMixByBusinessId(processStream.getProcessId(),"5");
			if (permissionStreamList == null \|\| permissionStreamList.isEmpty())
			return null;
			permissionStreamList.forEach(item -> {
			departIds.add(item.getDepartId());
			});
			//6-工步
			}else if(nodeType == 6) {
			} else if (Objects.equals(nodeType, DocAttributionTypeEnum.WORKSITE.getCode())) {
			WorkStep workStep = workStepService.getById(paramId);
			if(workStep == null)
			if (workStep == null)
			return null;
			List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
			.eq(StrUtil.isNotEmpty(workStep.getProductId()),"product_id", workStep.getProductId())
			.eq(StrUtil.isNotEmpty(workStep.getComponentId()),"component_id",workStep.getComponentId())
			.eq(StrUtil.isNotEmpty(workStep.getPartsId()),"parts_id", workStep.getPartsId())
			.eq(StrUtil.isNotEmpty(workStep.getProcessId()),"process_id",workStep.getProcessId())
			.eq(StrUtil.isNotEmpty(workStep.getId()),"step_id", workStep.getId()));
			if(permissionStreamList == null \|\| permissionStreamList.isEmpty())
			List<PermissionStreamNew> permissionStreamList = permissionStreamNewService.loadProductMixByBusinessId(workStep.getId(),"6");
			if (permissionStreamList == null \|\| permissionStreamList.isEmpty())
			return null;
			permissionStreamList.forEach(item -> {
			departIds.add(item.getDepartId());
			});
			}else {
			} else {
			return null;
			}
			//去重
			@@ -1370,9 +742,9 @@

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

			@Override
			public List<CommonGenericTree> loadTree(String userId, Integer nodeType, String paramId) {
			if(nodeType == 1) {
			if (Objects.equals(nodeType, DocAttributionTypeEnum.PRODUCT.getCode())) {
			List<ComponentInfo> componentInfoList = componentInfoService.getByProductIdAndUserId(paramId, userId);
			if(componentInfoList == null \|\| componentInfoList.isEmpty())
			if (componentInfoList == null \|\| componentInfoList.isEmpty())
			return Collections.emptyList();
			List<CommonGenericTree> list = new ArrayList<>();
			CommonGenericTree<ComponentInfo> node;
			for(ComponentInfo c : componentInfoList) {
			for (ComponentInfo c : componentInfoList) {
			node = new CommonGenericTree();
			node.setId(c.getComponentId());
			// node.setLabel("[" + c.getComponentCode()+ "]" + c.getComponentName());
			node.setLabel(c.getComponentName());
			node.setParentId(c.getProductId());
			node.setIconClass("");
			node.setType(2);
			node.setType(DocAttributionTypeEnum.COMPONENT.getCode());
			node.setRField(c.getProductId());
			node.setEntity(c);
			list.add(node);
			}
			return list;
			}else if(nodeType == 2) {
			} else if (Objects.equals(nodeType, DocAttributionTypeEnum.COMPONENT.getCode())) {
			List<ComponentInfo> componentInfoList = componentInfoService.getByParentIdAndUserId(paramId, userId);
			List<CommonGenericTree> list = new ArrayList<>();
			CommonGenericTree<ComponentInfo> componentNode;
			if(componentInfoList != null && !componentInfoList.isEmpty()) {
			for(ComponentInfo c : componentInfoList) {
			if (componentInfoList != null && !componentInfoList.isEmpty()) {
			for (ComponentInfo c : componentInfoList) {
			componentNode = new CommonGenericTree();
			componentNode.setId(c.getComponentId());
			// componentNode.setLabel("[" + c.getComponentCode()+ "]" + c.getComponentName());
			componentNode.setLabel(c.getComponentName());
			componentNode.setParentId(c.getParentId());
			componentNode.setIconClass("");
			componentNode.setType(2);
			componentNode.setType(DocAttributionTypeEnum.COMPONENT.getCode());
			componentNode.setRField(c.getProductId());
			componentNode.setEntity(c);
			list.add(componentNode);
			}
			}
			List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, paramId, null);
			if(partsInfos == null \|\| partsInfos.isEmpty())
			if (partsInfos == null \|\| partsInfos.isEmpty())
			return list;
			CommonGenericTree<PartsInfo> partNode;
			for(PartsInfo part : partsInfos) {
			for (PartsInfo part : partsInfos) {
			partNode = new CommonGenericTree();
			partNode.setId(part.getPartsId());
			// partNode.setLabel("[" + part.getPartsCode()+ "]" + part.getPartsName());
			partNode.setLabel(part.getPartsName());
			partNode.setParentId(part.getComponentId());
			partNode.setIconClass("");
			partNode.setType(3);
			partNode.setType(DocAttributionTypeEnum.PARTS.getCode());
			partNode.setRField(part.getComponentId());
			partNode.setEntity(part);
			partNode.setLeaf(true);
			list.add(partNode);
			}
			return list;
			}else {
			} else {
			return Collections.emptyList();
			}
			}
			@@ -1457,8 +829,9 @@
			List<ProductInfo> productInfos = this.getByUserPerms(userId, queryParam);
			List<ComponentInfo> componentInfos = componentInfoService.getByUserPerms(userId, queryParam);
			List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, null, queryParam);
			List<ProcessStream> processStreams=processStreamService.getByuserPerms(userId, queryParam);
			List<WorkStep> workSteps=workStepService.getByUserPerms(userId, queryParam);
			List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByUserPerms(userId, queryParam);
			List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId, queryParam);
			List<WorkStep> workSteps = workStepService.getByUserPerms(userId, queryParam);
			List<ComponentInfo> componentInfoList = new ArrayList<>();
			List<ProductInfo> productInfoList = new ArrayList<>();

			@@ -1468,32 +841,32 @@
			ProductInfo product;
			ComponentInfo component;

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

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

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

			if(!componentInfoMap.containsKey(p.getComponentId())) {
			if (!componentInfoMap.containsKey(p.getComponentId())) {
			component = componentInfoService.getById(p.getComponentId());
			if(component != null) {
			if (component != null) {
			componentInfoMap.put(component.getComponentId(), component);
			componentInfoList.add(component);
			}
			@@ -1503,16 +876,16 @@

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

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

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

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

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

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

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

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

			@Override
			public Result<?> getTreeById(String id, Integer type){
			if (StrUtil.isNotEmpty(id)\|\|type!=null){
			switch (type){
			case 1:
			//产品
			QueryWrapper<ProductInfo> productInfoQueryWrapper = new QueryWrapper<>();
			productInfoQueryWrapper.eq("product_id",id);
			List<ProductInfo> productInfos = this.list(productInfoQueryWrapper);
			return Result.OK(productInfos);
			case 2:
			//组件
			QueryWrapper<ComponentInfo> componentInfoQueryWrapper = new QueryWrapper<>();
			componentInfoQueryWrapper.eq("component_id",id);
			List<ComponentInfo> componentInfos = componentInfoService.list(componentInfoQueryWrapper);
			return Result.OK(componentInfos);
			case 3:
			//零件
			QueryWrapper<PartsInfo> partsInfoQueryWrapper = new QueryWrapper<>();
			partsInfoQueryWrapper.eq("parts_id",id);
			List<PartsInfo> partsInfos = partsInfoService.list(partsInfoQueryWrapper);
			return Result.OK(partsInfos);
			case 4:
			//工艺规划版本
			QueryWrapper<ProcessSpecVersion> processSpecVersionQueryWrapper = new QueryWrapper<>();
			processSpecVersionQueryWrapper.eq("id",id);
			List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.list(processSpecVersionQueryWrapper);
			return Result.OK(processSpecVersions);
			case 5:
			//工序
			QueryWrapper<ProcessStream> processStreamQueryWrapper = new QueryWrapper<>();
			processStreamQueryWrapper.eq("process_id",id);
			List<ProcessStream> processStreams = processStreamService.list(processStreamQueryWrapper);
			return Result.OK(processStreams);
			case 6:
			//工步
			QueryWrapper<WorkStep> workStepQueryWrapper = new QueryWrapper<>();
			workStepQueryWrapper.eq("id",id);
			List<WorkStep> workSteps = workStepService.list(workStepQueryWrapper);
			return Result.OK(workSteps);
			}
			}
			return Result.error("参数错误");
			}

			/**
			* 通过代号、名称、材质等查询对应电子样板
			* @param treeInfoRequest
			* @return
			*/
			@Override
			public List<DocInfo> getByTreeOtherFileInfo(TreeInfoRequest treeInfoRequest){
			switch (treeInfoRequest.getAttributionType()){
			case 1:
			LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>();
			// 明确条件：仅当attributionType为1且attributionId非空时添加条件
			if (treeInfoRequest.getAttributionType() == 1 && StrUtil.isNotBlank(treeInfoRequest.getAttributionId())) {
			queryWrapper.eq(ProductInfo::getProductId, treeInfoRequest.getAttributionId());
			}
			queryWrapper.like(StrUtil.isNotBlank(treeInfoRequest.getTreeCode()), ProductInfo::getProductNo, treeInfoRequest.getTreeCode())
			.like(StrUtil.isNotBlank(treeInfoRequest.getTreeName()), ProductInfo::getProductName, treeInfoRequest.getTreeName());
			List<ProductInfo> productInfoList = super.list(queryWrapper);
			List<DocInfo> docInfos = new ArrayList<>();
			if (StrUtil.isNotBlank(treeInfoRequest.getStructureType())){
			productInfoList=new ArrayList<>();
			}
			if (CollectionUtil.isNotEmpty(productInfoList)) {
			String ids=productInfoList.stream().map(ProductInfo::getProductId).collect(Collectors.joining(","));
			DocInfoQueryRequest docQuery = new DocInfoQueryRequest();
			BeanUtil.copyProperties(treeInfoRequest, docQuery);
			docQuery.setAttributionIds(ids);
			docQuery.setDocClassCode("OTHER");
			docQuery.setAttributionType(DocAttributionTypeEnum.PRODUCT.getCode());
			docInfos = docInfoService.findListByDocQuery(docQuery);
			}
			// 创建新请求对象避免污染原参数
			TreeInfoRequest componentRequest = new TreeInfoRequest();
			BeanUtil.copyProperties(treeInfoRequest, componentRequest);
			componentRequest.setProductIds(Collections.singletonList(treeInfoRequest.getAttributionId()));
			// 合并查询结果
			docInfos.addAll(componentInfoService.getByComponentInfo(componentRequest));
			docInfos.addAll(partsInfoService.getByPartsInfo(componentRequest));
			docInfos.addAll(processSpecVersionService.getByProcessSpecVersion(componentRequest));
			docInfos.addAll(processStreamService.getByProcessStreamOtherFile(componentRequest));
			docInfos.addAll(workStepService.getByWorkStepOtherFile(componentRequest));
			return getByTreeOtherFileInfo(docInfos);
			case 2:
			return getByTreeOtherFileInfo(componentInfoService.getByComponentInfo(treeInfoRequest));
			case 3:
			return getByTreeOtherFileInfo(partsInfoService.getByPartsInfo(treeInfoRequest));
			case 4:
			return getByTreeOtherFileInfo(processSpecVersionService.getByProcessSpecVersion(treeInfoRequest));
			case 5:
			return getByTreeOtherFileInfo(processStreamService.getByProcessStreamOtherFile(treeInfoRequest));
			case 6:
			return getByTreeOtherFileInfo(workStepService.getByWorkStepOtherFile(treeInfoRequest));
			}
			return new ArrayList<>();
			}

			/**
			* 通过代号、名称、材质等查询对应NC文件
			* @param treeInfoRequest
			* @return
			*/
			@Override
			public List<DocInfo> getByTreeNcFileInfo(TreeInfoRequest treeInfoRequest){
			//产品、部件、零件、工艺规程版本都没有对应的NC文件，直接查询子结构
			switch (treeInfoRequest.getAttributionType()){
			case 1:
			LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>();
			// 明确条件：仅当attributionType为1且attributionId非空时添加条件
			if (StrUtil.isNotBlank(treeInfoRequest.getAttributionId())) {
			queryWrapper.eq(ProductInfo::getProductId, treeInfoRequest.getAttributionId());
			}
			// 简化条件判断
			queryWrapper.like(StrUtil.isNotBlank(treeInfoRequest.getTreeCode()), ProductInfo::getProductNo, treeInfoRequest.getTreeCode())
			.like(StrUtil.isNotBlank(treeInfoRequest.getTreeName()), ProductInfo::getProductName, treeInfoRequest.getTreeName());
			List<ProductInfo> productInfoList = super.list(queryWrapper);
			if (CollectionUtil.isNotEmpty(productInfoList)) {
			treeInfoRequest.setProductIds(productInfoList.stream().map(ProductInfo::getProductId).collect(Collectors.toList()));
			}
			return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
			case 2:
			LambdaQueryWrapper<ComponentInfo> componentInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
			// 明确条件：仅当attributionType为1且attributionId非空时添加条件
			if (StrUtil.isNotBlank(treeInfoRequest.getAttributionId())) {
			componentInfoLambdaQueryWrapper.eq(ComponentInfo::getComponentId, treeInfoRequest.getAttributionId());
			}
			componentInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeCode()),ComponentInfo::getComponentCode, treeInfoRequest.getTreeCode());
			componentInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeName()),ComponentInfo::getComponentName, treeInfoRequest.getTreeName());
			componentInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getStructureType()),ComponentInfo::getStructureType, treeInfoRequest.getStructureType());
			componentInfoLambdaQueryWrapper.orderByDesc(ComponentInfo::getCreateTime);
			List<ComponentInfo> componentInfoList = componentInfoService.list(componentInfoLambdaQueryWrapper);
			if (CollectionUtil.isNotEmpty(componentInfoList)) {
			treeInfoRequest.setComponentIds(componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList()));
			}
			return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
			case 3:
			LambdaQueryWrapper<PartsInfo> partsInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
			if (treeInfoRequest.getProductIds() != null && !treeInfoRequest.getProductIds().isEmpty()) {
			partsInfoLambdaQueryWrapper.in(PartsInfo::getProductId, treeInfoRequest.getProductIds());
			}
			if (treeInfoRequest.getComponentIds() != null && !treeInfoRequest.getComponentIds().isEmpty()) {
			partsInfoLambdaQueryWrapper.in(PartsInfo::getComponentId, treeInfoRequest.getComponentIds());
			}
			if (Objects.equals(treeInfoRequest.getAttributionType(), DocAttributionTypeEnum.PARTS.getCode())){
			partsInfoLambdaQueryWrapper.eq(StrUtil.isNotEmpty(treeInfoRequest.getAttributionId()),PartsInfo::getPartsId,treeInfoRequest.getAttributionId());
			}
			partsInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeCode()),PartsInfo::getPartsCode, treeInfoRequest.getTreeCode());
			partsInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeName()),PartsInfo::getPartsName, treeInfoRequest.getTreeName());
			partsInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getStructureType()),PartsInfo::getStructureType, treeInfoRequest.getStructureType());
			partsInfoLambdaQueryWrapper.orderByDesc(PartsInfo::getCreateTime);
			List<PartsInfo> list = partsInfoService.list(partsInfoLambdaQueryWrapper);
			if (CollectionUtil.isNotEmpty(list)) {
			treeInfoRequest.setPartsIds(list.stream().map(PartsInfo::getPartsId).collect(Collectors.toList()));
			}
			return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
			case 4:
			LambdaQueryWrapper<ProcessSpecVersion> processSpecVersionLambdaQueryWrapper = new LambdaQueryWrapper<>();
			if (treeInfoRequest.getProductIds() != null && !treeInfoRequest.getProductIds().isEmpty()) {
			processSpecVersionLambdaQueryWrapper.in(ProcessSpecVersion::getProductId, treeInfoRequest.getProductIds());
			}
			if (treeInfoRequest.getComponentIds() != null && !treeInfoRequest.getComponentIds().isEmpty()) {
			processSpecVersionLambdaQueryWrapper.in(ProcessSpecVersion::getComponentId, treeInfoRequest.getComponentIds());
			}
			if (treeInfoRequest.getPartsIds() != null && !treeInfoRequest.getPartsIds().isEmpty()) {
			processSpecVersionLambdaQueryWrapper.in(ProcessSpecVersion::getPartsId, treeInfoRequest.getPartsIds());
			}
			if (Objects.equals(treeInfoRequest.getAttributionType(), DocAttributionTypeEnum.OPERATION.getCode())){
			processSpecVersionLambdaQueryWrapper.eq(StrUtil.isNotEmpty(treeInfoRequest.getAttributionId()),ProcessSpecVersion::getId,treeInfoRequest.getAttributionId());
			}
			processSpecVersionLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeName()),ProcessSpecVersion::getProcessSpecVersionName, treeInfoRequest.getTreeName());
			processSpecVersionLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeCode()),ProcessSpecVersion::getProcessSpecVersionCode, treeInfoRequest.getTreeName());
			processSpecVersionLambdaQueryWrapper.orderByDesc(ProcessSpecVersion::getCreateTime);
			List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.list(processSpecVersionLambdaQueryWrapper);
			if (CollectionUtil.isNotEmpty(processSpecVersions)) {
			treeInfoRequest.setPsvIds(processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList()));
			}
			return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
			case 5:
			return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
			case 6:
			return getByTreeNcFileInfo(workStepService.getByWorkStepNCFile(treeInfoRequest));
			}
			return new ArrayList<>();
			}

			private List<DocInfo> getByTreeOtherFileInfo(List<DocInfo> docInfos){
			//对所属id进行翻译
			if (docInfos != null && !docInfos.isEmpty()) {
			docInfos.forEach(docInfo -> {
			switch (docInfo.getAttributionType()){
			case 1:
			ProductInfo productInfo=this.getById(docInfo.getAttributionId());
			docInfo.setNodeName(productInfo.getProductName());
			docInfo.setNodeCode(productInfo.getProductNo());
			docInfo.setNodeId(productInfo.getProductId());
			break;
			case 2:
			ComponentInfo componentInfo=componentInfoService.getById(docInfo.getAttributionId());
			docInfo.setNodeName(componentInfo.getComponentName());
			docInfo.setNodeCode(componentInfo.getComponentCode());
			docInfo.setNodeId(componentInfo.getComponentId());
			break;
			case 3:
			PartsInfo partsInfo=partsInfoService.getById(docInfo.getAttributionId());
			docInfo.setNodeCode(partsInfo.getPartsCode());
			docInfo.setNodeName(partsInfo.getPartsName());
			docInfo.setNodeId(partsInfo.getPartsId());
			break;
			case 4:
			ProcessSpecVersion processSpecVersion=processSpecVersionService.getById(docInfo.getAttributionId());
			docInfo.setNodeName(processSpecVersion.getProcessSpecVersionName());
			docInfo.setNodeCode(processSpecVersion.getProcessSpecVersionCode());
			docInfo.setNodeId(processSpecVersion.getId());
			break;
			case 5:
			ProcessStream processStream=processStreamService.getById(docInfo.getAttributionId());
			docInfo.setNodeName(processStream.getProcessName());
			docInfo.setNodeCode(processStream.getProcessCode());
			docInfo.setNodeId(processStream.getProcessId());
			break;
			case 6:
			WorkStep workStep=workStepService.getById(docInfo.getAttributionId());
			docInfo.setNodeName(workStep.getStepName());
			docInfo.setNodeCode(workStep.getStepName());
			docInfo.setNodeId(workStep.getId());
			break;
			}
			});
			}
			return docInfos;
			}

			private List<DocInfo> getByTreeNcFileInfo(List<DocInfo> docInfos){
			//对所属id进行翻译
			if (docInfos != null && !docInfos.isEmpty()) {
			docInfos.forEach(docInfo -> {
			//NC文件存在设备类下
			DeviceType deviceType=deviceTypeService.getById(docInfo.getAttributionId());
			DeviceManagement deviceManagement= deviceManagementService.getById(deviceType.getDeviceManagementId());
			docInfo.setDeviceName(deviceManagement.getDeviceManagementName());
			docInfo.setDeviceCode(deviceManagement.getDeviceManagementCode());
			if (deviceType.getAttributionType().equals(DocAttributionTypeEnum.PROCESS.getCode())){
			//工序下的设备类
			ProcessStream processStream=processStreamService.getById(deviceType.getAttributionId());
			docInfo.setNodeName(processStream.getProcessName());
			docInfo.setNodeCode(processStream.getProcessCode());
			docInfo.setNodeId(processStream.getProcessId());
			}else {
			//工步下的设备类
			WorkStep workStep=workStepService.getById(deviceType.getAttributionId());
			docInfo.setNodeName(workStep.getStepName());
			docInfo.setNodeCode(workStep.getStepName());
			docInfo.setNodeId(workStep.getId());
			}
			});
			}
			return docInfos;
			}

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

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

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

			/**
			* 添加权限
			*/
			private boolean handleProductInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			return handlePermission(paramId, 1, relativeFlag, mdcProductionList, userList, true);
			}

			private boolean handleComponentInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			return handlePermission(paramId, 2, relativeFlag, mdcProductionList, userList, true);
			}

			private boolean handlePartsInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			return handlePermission(paramId, 3, relativeFlag, mdcProductionList, userList, true);
			}

			private boolean handleProcessSpecVersion(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			return handlePermission(paramId, 4, relativeFlag, mdcProductionList, userList, true);
			}

			private boolean handleProcessStream(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			return handlePermission(paramId, 5, relativeFlag, mdcProductionList, userList, true);
			}

			private boolean handleWorkStep(String paramId, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
			return handlePermission(paramId, 6, null, mdcProductionList, userList, true);
			}


			/**
			* 移除权限
			*/
			private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			return handlePermission(paramId, 1, relativeFlag, mdcProductionList, userList, false);
			}

			private boolean handleComponentInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			return handlePermission(paramId, 2, relativeFlag, mdcProductionList, userList, false);
			}

			private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			return handlePermission(paramId, 3, relativeFlag, mdcProductionList, userList, false);
			}

			private boolean handleProcessSpecVersionRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			return handlePermission(paramId, 4, relativeFlag, mdcProductionList, userList, false);
			}

			private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			return handlePermission(paramId, 5, relativeFlag, mdcProductionList, userList, false);
			}

			private boolean handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
			return handlePermission(paramId, 6, null, mdcProductionList, userList, false);
			}

			/**
			* 通用权限处理方法
			*/
			private boolean handlePermission(String paramId, int type, Integer relativeFlag,
			Collection<MdcProduction> mdcProductionList,
			Collection<SysUser> userList, boolean isAddOperation) {

			// 获取实体和进行存在性检查
			Object entity = getEntityById(type, paramId);
			if (entity == null) {
			throwExceptionForType(type);
			}

			// 权限检查
			String entityId = getEntityId(entity, type);
			if (!checkProductPerm(type, entityId)) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}

			// 获取子节点列表
			List<ProductMix> productMixList = productMixService.getChildrenList(entityId);
			boolean result;

			// 执行用户/部门的权限操作
			if (userList != null) {
			result = executeUserPermissionOperation(entity, type, userList, isAddOperation);
			handleChildrenPermission(productMixList, relativeFlag, userList, null, isAddOperation);
			} else {
			result = executeDepartmentPermissionOperation(entity, type, mdcProductionList, isAddOperation);
			handleChildrenPermission(productMixList, relativeFlag, null, mdcProductionList, isAddOperation);
			}

			if (!result) {
			ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
			}

			return true;
			}

			/**
			* 处理子节点权限
			*/
			private void handleChildrenPermission(List<ProductMix> productMixList, Integer relativeFlag,
			Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList,
			boolean isAddOperation) {
			if (relativeFlag != 1) return;

			productMixList.forEach(productMix -> {
			int childType = productMix.getTreeType();
			executeChildPermissionOperation(String.valueOf(productMix.getId()), childType, userList, mdcProductionList, isAddOperation);
			});
			}

			/**
			* 根据类型执行子节点权限操作
			*/
			private void executeChildPermissionOperation(String id, int type,
			Collection<SysUser> userList,
			Collection<MdcProduction> mdcProductionList,
			boolean isAddOperation) {
			switch (type) {
			case 2: // 组件
			ComponentInfo componentInfo = componentInfoService.getById(id);
			if (userList != null) {
			componentInfoService.assignPermission(componentInfo, userList, isAddOperation);
			} else {
			componentInfoService.assignDepartPermission(componentInfo, mdcProductionList, isAddOperation);
			}
			break;
			case 3: // 零件
			PartsInfo partsInfo = partsInfoService.getById(id);
			if (userList != null) {
			partsInfoService.assignPermission(partsInfo, userList, isAddOperation);
			} else {
			partsInfoService.assignDepartPermission(partsInfo, mdcProductionList, isAddOperation);
			}
			break;
			case 4: // 工艺规范
			ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(id);
			if (userList != null) {
			processSpecVersionService.assignPermission(processSpecVersion, userList, isAddOperation);
			} else {
			processSpecVersionService.assignDepartPermission(processSpecVersion, mdcProductionList, isAddOperation);
			}
			break;
			case 5: // 工序
			ProcessStream processStream = processStreamService.getById(id);
			if (userList != null) {
			processStreamService.assignPermission(processStream, userList, isAddOperation);
			} else {
			processStreamService.assignDepartPermission(processStream, mdcProductionList, isAddOperation);
			}
			break;
			case 6: // 工步
			WorkStep workStep = workStepService.getById(id);
			if (userList != null) {
			workStepService.assignPermission(workStep, userList, isAddOperation);
			} else {
			workStepService.assignDepartPermission(workStep, mdcProductionList, isAddOperation);
			}
			break;
			}
			}

			/**
			* 根据类型获取实体
			*/
			private Object getEntityById(int type, String paramId) {
			switch (type) {
			case 1: return super.getById(paramId); // 产品
			case 2: return componentInfoService.getById(paramId); // 组件
			case 3: return partsInfoService.getById(paramId); // 零件
			case 4: return processSpecVersionService.getById(paramId); // 工艺规范
			case 5: return processStreamService.getById(paramId); // 工序
			case 6: return workStepService.getById(paramId); // 工步
			default: return null;
			}
			}

			/**
			* 根据类型抛出异常
			*/
			private void throwExceptionForType(int type) {
			switch (type) {
			case 1: ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
			case 2: ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
			case 3: ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
			case 4: ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
			case 5: ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
			case 6: ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
			}
			}

			/**
			* 获取实体ID
			*/
			private String getEntityId(Object entity, int type) {
			switch (type) {
			case 1: return ((ProductInfo) entity).getProductId();
			case 2: return ((ComponentInfo) entity).getComponentId();
			case 3: return ((PartsInfo) entity).getPartsId();
			case 4: return ((ProcessSpecVersion) entity).getId();
			case 5: return ((ProcessStream) entity).getProcessId();
			case 6: return ((WorkStep) entity).getId();
			default: return null;
			}
			}

			/**
			* 执行用户权限操作
			*/
			private boolean executeUserPermissionOperation(Object entity, int type,
			Collection<SysUser> userList,
			boolean isAddOperation) {
			switch (type) {
			case 1:
			return isAddOperation ?
			assignAddUser((ProductInfo) entity, userList) :
			assignRemoveUser((ProductInfo) entity, userList);
			case 2:
			return isAddOperation ?
			componentInfoService.assignAddUser((ComponentInfo) entity, userList) :
			componentInfoService.assignRemoveUser((ComponentInfo) entity, userList);
			case 3:
			return isAddOperation ?
			partsInfoService.assignAddUser((PartsInfo) entity, userList) :
			partsInfoService.assignRemoveUser((PartsInfo) entity, userList);
			case 4:
			return isAddOperation ?
			processSpecVersionService.assignAddUser((ProcessSpecVersion) entity, userList) :
			processSpecVersionService.assignRemoveUser((ProcessSpecVersion) entity, userList);
			case 5:
			return isAddOperation ?
			processStreamService.assignAddUser((ProcessStream) entity, userList) :
			processStreamService.assignRemoveUser((ProcessStream) entity, userList);
			case 6:
			return isAddOperation ?
			workStepService.assignAddUser((WorkStep) entity, userList) :
			workStepService.assignRemoveUser((WorkStep) entity, userList);
			default: return false;
			}
			}

			/**
			* 执行部门权限操作
			*/
			private boolean executeDepartmentPermissionOperation(Object entity, int type,
			Collection<MdcProduction> mdcProductionList,
			boolean isAddOperation) {
			switch (type) {
			case 1:
			return isAddOperation ?
			assignAddDepartment((ProductInfo) entity, mdcProductionList) :
			assignRemoveDepartment((ProductInfo) entity, mdcProductionList);
			case 2:
			return isAddOperation ?
			componentInfoService.assignAddDepart((ComponentInfo) entity, mdcProductionList) :
			componentInfoService.assignRemoveDepart((ComponentInfo) entity, mdcProductionList);
			case 3:
			return isAddOperation ?
			partsInfoService.assignAddDepart((PartsInfo) entity, mdcProductionList) :
			partsInfoService.assignRemoveDepart((PartsInfo) entity, mdcProductionList);
			case 4:
			return isAddOperation ?
			processSpecVersionService.assignAddDepart((ProcessSpecVersion) entity, mdcProductionList) :
			processSpecVersionService.assignRemoveDepart((ProcessSpecVersion) entity, mdcProductionList);
			case 5:
			return isAddOperation ?
			processStreamService.assignAddDepart((ProcessStream) entity, mdcProductionList) :
			processStreamService.assignRemoveDepart((ProcessStream) entity, mdcProductionList);
			case 6:
			return isAddOperation ?
			workStepService.assignAddDepart((WorkStep) entity, mdcProductionList) :
			workStepService.assignRemoveDepart((WorkStep) entity, mdcProductionList);
			default: return false;
			}
			}
			}