From 6d44fa56ae000ecc3b34c681e16d721789c1f49e Mon Sep 17 00:00:00 2001 From: lyh <925863403@qq.com> Date: 星期三, 25 六月 2025 11:56:22 +0800 Subject: [PATCH] 优化分配权限代码 --- lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java | 1761 +++++++++++++++++++++++----------------------------------- 1 files changed, 697 insertions(+), 1,064 deletions(-) diff --git a/lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java b/lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java index 0e8b19d..930f19e 100644 --- a/lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java +++ b/lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java @@ -1,31 +1,37 @@ package org.jeecg.modules.dnc.service.impl; +import cn.hutool.core.bean.BeanUtil; +import cn.hutool.core.collection.CollectionUtil; import cn.hutool.core.util.StrUtil; -import com.alibaba.fastjson.JSONObject; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.toolkit.Wrappers; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import lombok.extern.slf4j.Slf4j; import org.apache.shiro.SecurityUtils; +import org.jeecg.common.api.vo.Result; import org.jeecg.common.system.vo.LoginUser; +import org.jeecg.modules.dnc.constant.DocAttributionTypeEnum; import org.jeecg.modules.dnc.dto.ComponentExt; +import org.jeecg.modules.dnc.entity.*; import org.jeecg.modules.dnc.exception.ExceptionCast; import org.jeecg.modules.dnc.mapper.ProductInfoMapper; +import org.jeecg.modules.dnc.request.DocInfoQueryRequest; +import org.jeecg.modules.dnc.request.TreeInfoRequest; import org.jeecg.modules.dnc.response.*; import org.jeecg.modules.dnc.service.*; import org.jeecg.modules.dnc.service.support.ProductTreeWrapper; import org.jeecg.modules.dnc.ucenter.UserDepartExt; import org.jeecg.modules.dnc.utils.ValidateUtil; -import org.jeecg.modules.dnc.entity.*; import org.jeecg.modules.system.entity.MdcProduction; import org.jeecg.modules.system.entity.SysUser; import org.jeecg.modules.system.service.IMdcProductionService; import org.jeecg.modules.system.service.ISysUserService; -import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; + import java.util.*; import java.util.stream.Collectors; @@ -39,11 +45,13 @@ @Lazy private IPartsInfoService partsInfoService; @Autowired + private IProcessSpecVersionService processSpecVersionService; + @Autowired private IProductPermissionService productPermissionService; @Autowired private IProductDepartmentService productDepartmentService; @Autowired - private IPermissionStreamService permissionStreamService; + private IPermissionStreamNewService permissionStreamNewService; @Autowired private IComponentDepartmentService componentDepartmentService; @Autowired @@ -52,6 +60,10 @@ private IPartsDepartmentService partsDepartmentService; @Autowired private IPartsPermissionService partsPermissionService; + @Autowired + private IProcessSpecVersionPermissionService processSpecVersionPermissionService; + @Autowired + private IProcessSpecVersionDepartmentService processSpecVersionDepartmentService; @Autowired private ISysUserService userService; @Autowired @@ -71,6 +83,15 @@ private IProcessStreamPermissionService iProcessStreamPermissionService; @Autowired private IWorkStepPermissionService iWorkStepPermissionService; + @Autowired + private IProductMixService productMixService; + @Autowired + @Lazy + private IDocInfoService docInfoService; + @Autowired + private IDeviceTypeService deviceTypeService; + @Autowired + private IDeviceManagementService deviceManagementService; @Override @Transactional(rollbackFor = {Exception.class}) @@ -98,10 +119,32 @@ 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 @@ -119,6 +162,11 @@ productInfo.setProductId(id); productInfo.setProductStatus(null); boolean b = super.updateById(productInfo); + //鍚屾淇敼缁撴瀯鏍� + 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); @@ -131,12 +179,13 @@ return false; } } - PermissionStream stream = permissionStreamService.getByProductIdAndUserId(id, userId); + PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(id, userId, DocAttributionTypeEnum.PRODUCT.getCode().toString()); if (stream == null) { - stream = new PermissionStream(); - stream.setProductId(id); + stream = new PermissionStreamNew(); + stream.setBusinessId(productInfo.getProductId()); stream.setUserId(userId); - return permissionStreamService.save(stream); + stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString()); + return permissionStreamNewService.save(stream); } return b; } @@ -155,6 +204,10 @@ List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId); if (partsInfos == null) partsInfos = Collections.emptyList(); + //宸ヨ壓瑙勭▼鐗堟湰 + List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByUserPerms(userId); + if (processSpecVersions == null) + processSpecVersions = Collections.emptyList(); //宸ュ簭 List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId); if (processStreams == null) @@ -163,7 +216,7 @@ List<WorkStep> workStepList = workStepService.getByUserPerms(userId); if (workStepList == null) workStepList = Collections.emptyList(); - return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos, processStreams, workStepList); + return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos, processSpecVersions,processStreams, workStepList); } @Override @@ -210,7 +263,7 @@ ExceptionCast.cast(ProductInfoCode.PRODUCT_PROCESS_EXIST); boolean b = productPermissionService.deleteByProductId(id); //楠岃瘉鏄惁瀛樺湪鏂囨。 - List<DocRelative> docRelativeList = iDocRelativeService.list(new QueryWrapper<DocRelative>().eq("attribution_type", "1").eq("attribution_id", id)); + List<DocRelative> docRelativeList = iDocRelativeService.list(new QueryWrapper<DocRelative>().eq("attribution_type", DocAttributionTypeEnum.PRODUCT.getCode() ).eq("attribution_id", id)); if (!docRelativeList.isEmpty()) { ExceptionCast.cast(ProductInfoCode.PRODUCT_DOC_EXIST); } @@ -219,10 +272,13 @@ b = productDepartmentService.deleteByProductId(id); if (!b) ExceptionCast.cast(CommonCode.FAIL); - b = permissionStreamService.deleteUserPermsByProductId(id); + b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, DocAttributionTypeEnum.PRODUCT.getCode().toString(),"0"); if (!b) ExceptionCast.cast(CommonCode.FAIL); - b = permissionStreamService.deleteDepartPermsByProductId(id); + b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, DocAttributionTypeEnum.PRODUCT.getCode().toString(),"1"); + if (!b) + ExceptionCast.cast(CommonCode.FAIL); + b = productMixService.removeById(id); if (!b) ExceptionCast.cast(CommonCode.FAIL); return super.removeById(id); @@ -236,37 +292,41 @@ String userId = user.getId(); if (!ValidateUtil.validateString(userId)) ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST); - if (nodeType == 1) { + if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) { ProductInfo productInfo = super.getById(paramId); if (productInfo == null) ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST); - PermissionStream permission = permissionStreamService.getByProductIdAndUserId(paramId, userId); + PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(paramId, userId,"1"); return permission != null; - } else if (nodeType == 2) { + } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())) { ComponentInfo componentInfo = componentInfoService.getById(paramId); if (componentInfo == null) ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST); - PermissionStream permission = permissionStreamService.getByComponentIdAndUserId(componentInfo.getProductId(), paramId, userId); + PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(componentInfo.getComponentId(), userId,"2"); return permission != null; - } else if (nodeType == 3) { + } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) { PartsInfo partsInfo = partsInfoService.getById(paramId); if (partsInfo == null) ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST); - PermissionStream permission = permissionStreamService.getByPartsIdAndUserId(partsInfo.getProductId(), partsInfo.getComponentId(), paramId, userId); + PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(partsInfo.getPartsId(), userId, "3"); return permission != null; - } else if (nodeType == 5) { + } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) { + ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId); + if (processSpecVersion == null) + ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST); + PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processSpecVersion.getId(),userId,"4"); + return permission != null; + } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) { ProcessStream processStream = processStreamService.getById(paramId); if (processStream == null) ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST); - PermissionStream permission = permissionStreamService.getByProcessIdAndUserId(processStream.getProductId(), processStream.getComponentId() - , processStream.getPartsId(), processStream.getProcessId(), userId); + PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processStream.getProcessId(), userId,"5"); return permission != null; - } else if (nodeType == 6) { + } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) { WorkStep workStep = workStepService.getById(paramId); if (workStep == null) ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST); - PermissionStream permission = permissionStreamService.getByStepIdAndUserId(workStep.getProductId(), workStep.getComponentId() - , workStep.getPartsId(), workStep.getProcessId(), workStep.getId(), userId); + PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(workStep.getId(), userId,"6"); return permission != null; } return false; @@ -276,15 +336,17 @@ public List<UserDepartExt> getUserPermsList(Integer nodeType, String paramId) { if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId)) return null; - if (nodeType == 1) { + if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) { return productPermissionService.getUserPermsByProductId(paramId); - } else if (nodeType == 2) { + } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())) { return componentPermissionService.getUserPermsByComponentId(paramId); - } else if (nodeType == 3) { + } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) { return partsPermissionService.getUserPermsByProductId(paramId); - } else if (nodeType == 5) { + } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) { + return processSpecVersionPermissionService.getUserPermsByProductId(paramId); + } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) { return iProcessStreamPermissionService.getUserPermsByProductId(paramId); - } else if (nodeType == 6) { + } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) { return iWorkStepPermissionService.getUserPermsByProductId(paramId); } else { return null; @@ -295,15 +357,17 @@ public List<SysUser> getUserNonPermsList(Integer nodeType, String paramId) { if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId)) return null; - if (nodeType == 1) { + if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) { return productPermissionService.getUserNonPermsByProductId(paramId); - } else if (nodeType == 2) { + } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){ return componentPermissionService.getUserNonPermsByComponentId(paramId); - } else if (nodeType == 3) { + } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) { return partsPermissionService.getUserNonPermsByProductId(paramId); - } else if (nodeType == 5) { + } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) { + return processSpecVersionPermissionService.getUserNonPermsByProductId(paramId); + } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) { return iProcessStreamPermissionService.getUserNonPermsByProductId(paramId); - } else if (nodeType == 6) { + } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) { return iWorkStepPermissionService.getUserNonPermsByProductId(paramId); } else { return null; @@ -314,18 +378,19 @@ public List<MdcProduction> getDepartPermsList(Integer nodeType, String paramId) { if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId)) return null; - if (nodeType == 1) { + if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) { return productDepartmentService.getDepartPermsByProductId(paramId); - } else if (nodeType == 2) { + } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){ return componentDepartmentService.getDepartPermsByComponentId(paramId); - } else if (nodeType == 3) { + } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) { return partsDepartmentService.getDepartPermsByPartsId(paramId); - } else if (nodeType == 5) { + } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) { + return processSpecVersionDepartmentService.getDepartPermsByPsvId(paramId); + } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) { return processionDepartmentService.getDepartPermsByProcessId(paramId); - } else if (nodeType == 6) { + } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) { return workStepDepartmentService.getDepartPermsByStepId(paramId); } - //todo 灏佽鏍戠姸缁撴瀯 else { return null; } @@ -335,15 +400,17 @@ public List<MdcProduction> getDepartNonPermsList(Integer nodeType, String paramId) { if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId)) return null; - if (nodeType == 1) { + if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) { return productDepartmentService.getDepartNonPermsByProductId(paramId); - } else if (nodeType == 2) { + } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){ return componentDepartmentService.getDepartNonPermsByComponentId(paramId); - } else if (nodeType == 3) { + } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) { return partsDepartmentService.getDepartNonPermsByProductId(paramId); - } else if (nodeType == 5) { + } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) { return processionDepartmentService.getDepartNonPermsByProcessId(paramId); - } else if (nodeType == 6) { + } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) { + return processionDepartmentService.getDepartNonPermsByProcessId(paramId); + } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) { return workStepDepartmentService.getDepartNonPermsByStepId(paramId); } else { return null; @@ -355,6 +422,7 @@ * @param paramId 浜у搧鏍戣妭鐐筰d * @param relativeFlag 1 鏄� 2 鍚� * @param userIds 娣诲姞鐢ㄦ埛ids + * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛� * @return */ @Override @@ -367,16 +435,19 @@ Collection<SysUser> userList = userService.listByIds(ids); validateSysUserList(userList, ids); switch (nodeType) { - case 6: - return handleWorkStep(paramId, null,userList); - case 5: - return handleProcessStream(paramId, relativeFlag, null,userList); - case 3: - return handlePartsInfo(paramId, relativeFlag, null,userList); case 1: return handleProductInfo(paramId, relativeFlag, null,userList); case 2: return handleComponentInfo(paramId, relativeFlag, null,userList); + case 3: + return handlePartsInfo(paramId, relativeFlag, null,userList); + case 4: + return handleProcessSpecVersion(paramId, relativeFlag, null,userList); + case 5: + return handleProcessStream(paramId, relativeFlag, null,userList); + case 6: + return handleWorkStep(paramId, null,userList); + default: return false; } @@ -387,6 +458,7 @@ * @param paramId 浜у搧鏍戣妭鐐筰d * @param relativeFlag 1 鏄� 2 鍚� * @param departmentIds 娣诲姞閮ㄩ棬ids + * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛� * @return */ @Override @@ -395,19 +467,23 @@ validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds); List<String> ids = new ArrayList<>(departmentIds.length); Collections.addAll(ids, departmentIds); - Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(ids); - validateMdcProductionList(mdcProductionList, ids); + List<String> deps=mdcProductionService.findAllProductionIds(ids); + Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(deps); + validateMdcProductionList(mdcProductionList, deps); switch (nodeType) { - case 6: - return handleWorkStep(paramId, mdcProductionList,null); - case 5: - return handleProcessStream(paramId, relativeFlag, mdcProductionList,null); - case 3: - return handlePartsInfo(paramId, relativeFlag, mdcProductionList,null); case 1: return handleProductInfo(paramId, relativeFlag, mdcProductionList,null); case 2: return handleComponentInfo(paramId, relativeFlag, mdcProductionList,null); + case 3: + return handlePartsInfo(paramId, relativeFlag, mdcProductionList,null); + case 4: + return handleProcessSpecVersion(paramId, relativeFlag, mdcProductionList,null); + case 5: + return handleProcessStream(paramId, relativeFlag, mdcProductionList,null); + case 6: + return handleWorkStep(paramId, mdcProductionList,null); + default: return false; } @@ -418,6 +494,7 @@ * @param paramId 浜у搧鏍戣妭鐐筰d * @param relativeFlag 1 鏄� 2 鍚� * @param userIds 绉婚櫎鐢ㄦ埛ids + * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛� * @return */ @Override @@ -428,16 +505,18 @@ Collection<SysUser> userList = userService.listByIds(userIdsList); validateSysUserList(userList, userIdsList); switch (nodeType) { - case 6: - return handleWorkStepRemoval(paramId, userList,null); - case 5: - return handleProcessStreamRemoval(paramId, relativeFlag, userList,null); - case 3: - return handlePartsInfoRemoval(paramId, relativeFlag, userList,null); case 1: return handleProductInfoRemoval(paramId, relativeFlag, userList,null); case 2: return handleComponentInfoRemoval(paramId, relativeFlag, userList,null); + case 3: + return handlePartsInfoRemoval(paramId, relativeFlag, userList,null); + case 4: + return handleProcessSpecVersionRemoval(paramId, relativeFlag, userList,null); + case 5: + return handleProcessStreamRemoval(paramId, relativeFlag, userList,null); + case 6: + return handleWorkStepRemoval(paramId, userList,null); default: return false; } @@ -450,26 +529,31 @@ * @param paramId 浜у搧鏍戣妭鐐筰d * @param relativeFlag 1 鏄� 2 鍚� * @param departmentIds 绉婚櫎閮ㄩ棬ids + * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛� * @return */ @Override @Transactional(rollbackFor = {Exception.class}) public boolean assignRemoveDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) { validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds); - List<String> departmentIdList = Arrays.asList(departmentIds); - Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(departmentIdList); - validateMdcProductionList(mdcProductionList, departmentIdList); + List<String> ids = new ArrayList<>(departmentIds.length); + Collections.addAll(ids, departmentIds); + List<String> deps=mdcProductionService.findAllProductionIds(ids); + Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(deps); + validateMdcProductionList(mdcProductionList, deps); switch (nodeType) { - case 6: - return handleWorkStepRemoval(paramId,null,mdcProductionList); - case 5: - return handleProcessStreamRemoval(paramId, relativeFlag, null,mdcProductionList); - case 3: - return handlePartsInfoRemoval(paramId, relativeFlag,null, mdcProductionList); case 1: return handleProductInfoRemoval(paramId, relativeFlag,null, mdcProductionList); case 2: return handleComponentInfoRemoval(paramId, relativeFlag, null,mdcProductionList); + case 3: + return handlePartsInfoRemoval(paramId, relativeFlag,null, mdcProductionList); + case 4: + return handleProcessSpecVersionRemoval(paramId, relativeFlag, null,mdcProductionList); + case 5: + return handleProcessStreamRemoval(paramId, relativeFlag, null,mdcProductionList); + case 6: + return handleWorkStepRemoval(paramId,null,mdcProductionList); default: return false; } @@ -481,7 +565,7 @@ if (productInfo == null || userList == null || userList.isEmpty()) ExceptionCast.cast(CommonCode.INVALID_PARAM); List<ProductPermission> permissionList = new ArrayList<>(); - List<PermissionStream> permissionStreamList = new ArrayList<>(); + List<PermissionStreamNew> permissionStreamList = new ArrayList<>(); userList.forEach(item -> { ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId()); if (en == null) { @@ -490,11 +574,12 @@ en.setProductId(productInfo.getProductId()); permissionList.add(en); } - PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId()); + PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(productInfo.getProductId(), item.getId(),"1"); if (stream == null) { - stream = new PermissionStream(); + stream = new PermissionStreamNew(); stream.setUserId(item.getId()); - stream.setProductId(productInfo.getProductId()); + stream.setBusinessId(productInfo.getProductId()); + stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString()); permissionStreamList.add(stream); } }); @@ -505,7 +590,7 @@ } } if (!permissionStreamList.isEmpty()) { - boolean b = permissionStreamService.saveBatch(permissionStreamList); + boolean b =permissionStreamNewService.saveBatch(permissionStreamList); if (!b) { ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); } @@ -519,13 +604,13 @@ if (productInfo == null || userList == null || userList.isEmpty()) ExceptionCast.cast(CommonCode.INVALID_PARAM); List<ProductPermission> permissionList = new ArrayList<>(); - List<PermissionStream> permissionStreamList = new ArrayList<>(); + List<PermissionStreamNew> permissionStreamList = new ArrayList<>(); userList.forEach(item -> { ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId()); if (en != null) { permissionList.add(en); } - PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId()); + PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(productInfo.getProductId(), item.getId(),"1"); if (stream != null) { permissionStreamList.add(stream); } @@ -541,7 +626,7 @@ } } if (!permissionStreamList.isEmpty()) { - boolean b = permissionStreamService.removeByCollection(permissionStreamList); + boolean b = permissionStreamNewService.deletePermissionStreamNewByList(permissionStreamList); if (!b) { ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); } @@ -555,7 +640,7 @@ if (productInfo == null || departmentList == null || departmentList.isEmpty()) ExceptionCast.cast(CommonCode.INVALID_PARAM); List<ProductDepartment> productDepartmentList = new ArrayList<>(); - List<PermissionStream> permissionStreamList = new ArrayList<>(); + List<PermissionStreamNew> permissionStreamList = new ArrayList<>(); departmentList.forEach(item -> { ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId()); if (en == null) { @@ -564,11 +649,12 @@ en.setProductId(productInfo.getProductId()); productDepartmentList.add(en); } - PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId()); + PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1"); if (stream == null) { - stream = new PermissionStream(); + stream = new PermissionStreamNew(); stream.setDepartId(item.getId()); - stream.setProductId(productInfo.getProductId()); + stream.setBusinessId(productInfo.getProductId()); + stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString()); permissionStreamList.add(stream); } }); @@ -579,7 +665,7 @@ } } if (!permissionStreamList.isEmpty()) { - boolean b = permissionStreamService.saveBatch(permissionStreamList); + boolean b = permissionStreamNewService.saveBatch(permissionStreamList); if (!b) { ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); } @@ -593,13 +679,13 @@ if (productInfo == null || departmentList == null || departmentList.isEmpty()) ExceptionCast.cast(CommonCode.INVALID_PARAM); List<ProductDepartment> productDepartmentList = new ArrayList<>(); - List<PermissionStream> permissionStreamList = new ArrayList<>(); + List<PermissionStreamNew> permissionStreamList = new ArrayList<>(); departmentList.forEach(item -> { ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId()); if (en != null) { productDepartmentList.add(en); } - PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId()); + PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1"); if (stream != null) { permissionStreamList.add(stream); } @@ -611,7 +697,7 @@ } } if (!permissionStreamList.isEmpty()) { - boolean b = permissionStreamService.removeByCollection(permissionStreamList); + boolean b = permissionStreamNewService.deletePermissionStreamNewByList(permissionStreamList); if (!b) { ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); } @@ -623,31 +709,22 @@ public List<String> getDepartIdsByParams(Integer nodeType, String paramId) { List<String> departIds = new ArrayList<>(); //5-宸ュ簭 - if (nodeType == 5) { + if (Objects.equals(nodeType, DocAttributionTypeEnum.PROCESS.getCode())) { ProcessStream processStream = processStreamService.getById(paramId); if (processStream == null) return null; - List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>() - .eq(StrUtil.isNotEmpty(processStream.getProductId()), "product_id", processStream.getProductId()) - .eq(StrUtil.isNotEmpty(processStream.getComponentId()), "component_id", processStream.getComponentId()) - .eq(StrUtil.isNotEmpty(processStream.getPartsId()), "parts_id", processStream.getPartsId()) - .eq(StrUtil.isNotEmpty(processStream.getProcessId()), "process_id", processStream.getProcessId())); + List<PermissionStreamNew> permissionStreamList = permissionStreamNewService.loadProductMixByBusinessId(processStream.getProcessId(),"5"); if (permissionStreamList == null || permissionStreamList.isEmpty()) return null; permissionStreamList.forEach(item -> { departIds.add(item.getDepartId()); }); //6-宸ユ - } else if (nodeType == 6) { + } else if (Objects.equals(nodeType, DocAttributionTypeEnum.WORKSITE.getCode())) { WorkStep workStep = workStepService.getById(paramId); if (workStep == null) return null; - List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>() - .eq(StrUtil.isNotEmpty(workStep.getProductId()), "product_id", workStep.getProductId()) - .eq(StrUtil.isNotEmpty(workStep.getComponentId()), "component_id", workStep.getComponentId()) - .eq(StrUtil.isNotEmpty(workStep.getPartsId()), "parts_id", workStep.getPartsId()) - .eq(StrUtil.isNotEmpty(workStep.getProcessId()), "process_id", workStep.getProcessId()) - .eq(StrUtil.isNotEmpty(workStep.getId()), "step_id", workStep.getId())); + List<PermissionStreamNew> permissionStreamList = permissionStreamNewService.loadProductMixByBusinessId(workStep.getId(),"6"); if (permissionStreamList == null || permissionStreamList.isEmpty()) return null; permissionStreamList.forEach(item -> { @@ -687,7 +764,7 @@ @Override public List<CommonGenericTree> loadTree(String userId, Integer nodeType, String paramId) { - if (nodeType == 1) { + if (Objects.equals(nodeType, DocAttributionTypeEnum.PRODUCT.getCode())) { List<ComponentInfo> componentInfoList = componentInfoService.getByProductIdAndUserId(paramId, userId); if (componentInfoList == null || componentInfoList.isEmpty()) return Collections.emptyList(); @@ -700,13 +777,13 @@ node.setLabel(c.getComponentName()); node.setParentId(c.getProductId()); node.setIconClass(""); - node.setType(2); + node.setType(DocAttributionTypeEnum.COMPONENT.getCode()); node.setRField(c.getProductId()); node.setEntity(c); list.add(node); } return list; - } else if (nodeType == 2) { + } else if (Objects.equals(nodeType, DocAttributionTypeEnum.COMPONENT.getCode())) { List<ComponentInfo> componentInfoList = componentInfoService.getByParentIdAndUserId(paramId, userId); List<CommonGenericTree> list = new ArrayList<>(); CommonGenericTree<ComponentInfo> componentNode; @@ -718,7 +795,7 @@ componentNode.setLabel(c.getComponentName()); componentNode.setParentId(c.getParentId()); componentNode.setIconClass(""); - componentNode.setType(2); + componentNode.setType(DocAttributionTypeEnum.COMPONENT.getCode()); componentNode.setRField(c.getProductId()); componentNode.setEntity(c); list.add(componentNode); @@ -735,7 +812,7 @@ partNode.setLabel(part.getPartsName()); partNode.setParentId(part.getComponentId()); partNode.setIconClass(""); - partNode.setType(3); + partNode.setType(DocAttributionTypeEnum.PARTS.getCode()); partNode.setRField(part.getComponentId()); partNode.setEntity(part); partNode.setLeaf(true); @@ -752,6 +829,7 @@ List<ProductInfo> productInfos = this.getByUserPerms(userId, queryParam); List<ComponentInfo> componentInfos = componentInfoService.getByUserPerms(userId, queryParam); List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, null, queryParam); + List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByUserPerms(userId, queryParam); List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId, queryParam); List<WorkStep> workSteps = workStepService.getByUserPerms(userId, queryParam); List<ComponentInfo> componentInfoList = new ArrayList<>(); @@ -879,7 +957,7 @@ //杞崲鏁版嵁 List<ComponentExt> componentExtList = ComponentExt.convertToExtList(componentInfoList); - return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos, processStreams, workSteps); + return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos,processSpecVersions, processStreams, workSteps); } @Override @@ -894,6 +972,9 @@ //闆朵欢 case 3: return partsInfoService.deletePartsInfo(id); + //宸ヨ壓瑙勭▼鐗堟湰 + case 4: + return processSpecVersionService.deleteProcessSpecVersion(id); //宸ュ簭 case 5: return processStreamService.deleteProcessStream(id); @@ -903,6 +984,268 @@ default: } return false; + } + + @Override + public Result<?> getTreeById(String id, Integer type){ + if (StrUtil.isNotEmpty(id)||type!=null){ + switch (type){ + case 1: + //浜у搧 + QueryWrapper<ProductInfo> productInfoQueryWrapper = new QueryWrapper<>(); + productInfoQueryWrapper.eq("product_id",id); + List<ProductInfo> productInfos = this.list(productInfoQueryWrapper); + return Result.OK(productInfos); + case 2: + //缁勪欢 + QueryWrapper<ComponentInfo> componentInfoQueryWrapper = new QueryWrapper<>(); + componentInfoQueryWrapper.eq("component_id",id); + List<ComponentInfo> componentInfos = componentInfoService.list(componentInfoQueryWrapper); + return Result.OK(componentInfos); + case 3: + //闆朵欢 + QueryWrapper<PartsInfo> partsInfoQueryWrapper = new QueryWrapper<>(); + partsInfoQueryWrapper.eq("parts_id",id); + List<PartsInfo> partsInfos = partsInfoService.list(partsInfoQueryWrapper); + return Result.OK(partsInfos); + case 4: + //宸ヨ壓瑙勫垝鐗堟湰 + QueryWrapper<ProcessSpecVersion> processSpecVersionQueryWrapper = new QueryWrapper<>(); + processSpecVersionQueryWrapper.eq("id",id); + List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.list(processSpecVersionQueryWrapper); + return Result.OK(processSpecVersions); + case 5: + //宸ュ簭 + QueryWrapper<ProcessStream> processStreamQueryWrapper = new QueryWrapper<>(); + processStreamQueryWrapper.eq("process_id",id); + List<ProcessStream> processStreams = processStreamService.list(processStreamQueryWrapper); + return Result.OK(processStreams); + case 6: + //宸ユ + QueryWrapper<WorkStep> workStepQueryWrapper = new QueryWrapper<>(); + workStepQueryWrapper.eq("id",id); + List<WorkStep> workSteps = workStepService.list(workStepQueryWrapper); + return Result.OK(workSteps); + } + } + return Result.error("鍙傛暟閿欒"); + } + + /** + * 閫氳繃浠e彿銆佸悕绉般�佹潗璐ㄧ瓑鏌ヨ瀵瑰簲鐢靛瓙鏍锋澘 + * @param treeInfoRequest + * @return + */ + @Override + public List<DocInfo> getByTreeOtherFileInfo(TreeInfoRequest treeInfoRequest){ + switch (treeInfoRequest.getAttributionType()){ + case 1: + LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>(); + // 鏄庣‘鏉′欢锛氫粎褰揳ttributionType涓�1涓攁ttributionId闈炵┖鏃舵坊鍔犳潯浠� + 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<>(); + } + + /** + * 閫氳繃浠e彿銆佸悕绉般�佹潗璐ㄧ瓑鏌ヨ瀵瑰簲NC鏂囦欢 + * @param treeInfoRequest + * @return + */ + @Override + public List<DocInfo> getByTreeNcFileInfo(TreeInfoRequest treeInfoRequest){ + //浜у搧銆侀儴浠躲�侀浂浠躲�佸伐鑹鸿绋嬬増鏈兘娌℃湁瀵瑰簲鐨凬C鏂囦欢锛岀洿鎺ユ煡璇㈠瓙缁撴瀯 + switch (treeInfoRequest.getAttributionType()){ + case 1: + LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>(); + // 鏄庣‘鏉′欢锛氫粎褰揳ttributionType涓�1涓攁ttributionId闈炵┖鏃舵坊鍔犳潯浠� + 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<>(); + // 鏄庣‘鏉′欢锛氫粎褰揳ttributionType涓�1涓攁ttributionId闈炵┖鏃舵坊鍔犳潯浠� + 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){ + //瀵规墍灞瀒d杩涜缈昏瘧 + 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){ + //瀵规墍灞瀒d杩涜缈昏瘧 + 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; } /** @@ -940,986 +1283,276 @@ } } - private void handleRelativePermissions(String productId, List<String> componentIds, String processId, String partsId, Collection<SysUser> userList) { - List<ComponentPermission> componentPermissionList = new ArrayList<>(); - List<PartsPermission> partsPermissionList = new ArrayList<>(); - List<ProcessionPermission> processionPermissionList = new ArrayList<>(); - List<WorkStepPermission> workStepPermissionList = new ArrayList<>(); - List<PermissionStream> permissionStreamList = new ArrayList<>(); - - // 澶勭悊閮ㄤ欢鏉冮檺 - if (componentIds != null && !componentIds.isEmpty()) { - handleComponentPermissions(componentIds, userList, componentPermissionList, permissionStreamList); - List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds); - if (partsInfoList != null && !partsInfoList.isEmpty()) { - List<String> partsIds = partsInfoList.stream() - .map(PartsInfo::getPartsId) - .collect(Collectors.toList()); - handlePartsPermissions(partsIds, userList, partsPermissionList, permissionStreamList); - List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productId, componentIds, partsIds); - processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList); - } - } - - // 澶勭悊宸ュ簭鏉冮檺 - if (processId != null) { - List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", processId)); - if (workStepList != null && !workStepList.isEmpty()) { - List<String> workStepIds = workStepList.stream() - .map(WorkStep::getId) - .collect(Collectors.toList()); - handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList); - } - } - - // 澶勭悊闆朵欢鏉冮檺 - if (partsId != null) { - List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsId)); - processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList); - } - - if (!componentPermissionList.isEmpty()) { - componentPermissionService.saveBatch(componentPermissionList); - } - if (!partsPermissionList.isEmpty()) { - partsPermissionService.saveBatch(partsPermissionList); - } - if (!processionPermissionList.isEmpty()) { - iProcessStreamPermissionService.saveBatch(processionPermissionList); - } - if (!workStepPermissionList.isEmpty()) { - iWorkStepPermissionService.saveBatch(workStepPermissionList); - } - if (!permissionStreamList.isEmpty()) { - permissionStreamService.saveBatch(permissionStreamList); - } + /** + * 娣诲姞鏉冮檺 + */ + private boolean handleProductInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { + return handlePermission(paramId, 1, relativeFlag, mdcProductionList, userList, true); } - private void processStreamApi(String productId, Collection<SysUser> userList, List<ProcessionPermission> processionPermissionList, List<WorkStepPermission> workStepPermissionList, List<PermissionStream> permissionStreamList, List<ProcessStream> processStreamList) { - if (processStreamList != null && !processStreamList.isEmpty()) { - List<String> processIds = processStreamList.stream() - .map(ProcessStream::getProcessId) - .collect(Collectors.toList()); - handleProcessPermissions(processIds, userList, processionPermissionList, permissionStreamList); - List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds); - if (workStepList != null && !workStepList.isEmpty()) { - List<String> workStepIds = workStepList.stream() - .map(WorkStep::getId) - .collect(Collectors.toList()); - handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList); - } - } + private boolean handleComponentInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { + return handlePermission(paramId, 2, relativeFlag, mdcProductionList, userList, true); } - private void handleComponentPermissions(List<String> componentIds, Collection<SysUser> userList, - List<ComponentPermission> componentPermissionList, List<PermissionStream> permissionStreamList) { - Map<String, ComponentPermission> componentPermissionMap = new HashMap<>(); - Map<String, ComponentInfo> componentInfoMap = new HashMap<>(); - String key; - for (ComponentInfo c : componentInfoService.listByIds(componentIds)) { - componentInfoMap.put(c.getComponentId(), c); - for (SysUser u : userList) { - key = c.getComponentId() + "," + u.getId(); - componentPermissionMap.put(key, new ComponentPermission(c.getComponentId(), u.getId())); - } - } - List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userList.stream().map(SysUser::getId).collect(Collectors.toList())); - if (existList != null && !existList.isEmpty()) { - for (ComponentPermission permission : existList) { - key = permission.getComponentId() + "," + permission.getUserId(); - componentPermissionMap.remove(key); - } - } - for (Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()) { - ComponentPermission cp = entry.getValue(); - componentPermissionList.add(cp); - ComponentInfo cpInfo = componentInfoMap.get(cp.getComponentId()); - PermissionStream s = new PermissionStream(); - s.setProductId(cpInfo.getProductId()); - s.setComponentId(cpInfo.getComponentId()); - s.setUserId(cp.getUserId()); - permissionStreamList.add(s); - } + private boolean handlePartsInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { + return handlePermission(paramId, 3, relativeFlag, mdcProductionList, userList, true); } - private void handlePartsPermissions(List<String> partsIds, Collection<SysUser> userList, - List<PartsPermission> partsPermissionList, List<PermissionStream> permissionStreamList) { - Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>(); - Map<String, PartsInfo> partsInfoMap = new HashMap<>(); - String key; - for (PartsInfo p : partsInfoService.listByIds(partsIds)) { - partsInfoMap.put(p.getPartsId(), p); - for (SysUser u : userList) { - key = p.getPartsId() + "," + u.getId(); - partsPermissionHashMap.put(key, new PartsPermission(p.getPartsId(), u.getId())); - } - } - List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, userList.stream().map(SysUser::getId).collect(Collectors.toList())); - if (existPartsList != null && !existPartsList.isEmpty()) { - for (PartsPermission permission : existPartsList) { - key = permission.getPartsId() + "," + permission.getUserId(); - partsPermissionHashMap.remove(key); - } - } - for (Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()) { - PartsPermission pp = entry.getValue(); - partsPermissionList.add(pp); - PartsInfo ptInfo = partsInfoMap.get(pp.getPartsId()); - PermissionStream s = new PermissionStream(); - s.setProductId(ptInfo.getProductId()); - s.setComponentId(ptInfo.getComponentId()); - s.setPartsId(ptInfo.getPartsId()); - s.setUserId(pp.getUserId()); - permissionStreamList.add(s); - } + private boolean handleProcessSpecVersion(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { + return handlePermission(paramId, 4, relativeFlag, mdcProductionList, userList, true); } - private void handleProcessPermissions(List<String> processIds, Collection<SysUser> userList, - List<ProcessionPermission> processionPermissionList, List<PermissionStream> permissionStreamList) { - Map<String, ProcessionPermission> processionPermissionHashMap = new HashMap<>(); - Map<String, ProcessStream> processStreamMap = new HashMap<>(); - String key; - for (ProcessStream p : processStreamService.listByIds(processIds)) { - processStreamMap.put(p.getProcessId(), p); - for (SysUser u : userList) { - key = p.getProcessId() + "," + u.getId(); - processionPermissionHashMap.put(key, new ProcessionPermission(p.getProcessId(), u.getId())); - } - } - List<ProcessionPermission> processionDepartmentList = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userList.stream().map(SysUser::getId).collect(Collectors.toList())); - if (processionDepartmentList != null && !processionDepartmentList.isEmpty()) { - for (ProcessionPermission processionPermission : processionDepartmentList) { - key = processionPermission.getProcessId() + "," + processionPermission.getUserId(); - processionPermissionHashMap.remove(key); - } - } - for (Map.Entry<String, ProcessionPermission> entry : processionPermissionHashMap.entrySet()) { - ProcessionPermission pp = entry.getValue(); - processionPermissionList.add(pp); - ProcessStream processStream = processStreamMap.get(pp.getProcessId()); - PermissionStream s = new PermissionStream(); - s.setProductId(processStream.getProductId()); - s.setComponentId(processStream.getComponentId()); - s.setPartsId(processStream.getPartsId()); - s.setProcessId(processStream.getProcessId()); - s.setUserId(pp.getUserId()); - permissionStreamList.add(s); - } + private boolean handleProcessStream(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { + return handlePermission(paramId, 5, relativeFlag, mdcProductionList, userList, true); } - private void handleWorkStepPermissions(List<String> workStepIds, Collection<SysUser> userList, - List<WorkStepPermission> workStepPermissionList, List<PermissionStream> permissionStreamList) { - Map<String, WorkStepPermission> workStepPermissionHashMap = new HashMap<>(); - Map<String, WorkStep> workStepHashMap = new HashMap<>(); - String key; - for (WorkStep w : workStepService.listByIds(workStepIds)) { - workStepHashMap.put(w.getId(), w); - for (SysUser u : userList) { - key = w.getId() + "," + u.getId(); - workStepPermissionHashMap.put(key, new WorkStepPermission(w.getId(), u.getId())); - } + 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); } - List<WorkStepPermission> workStepPermissions = iWorkStepPermissionService.getByStepIdsAndUserIds(workStepIds, userList.stream().map(SysUser::getId).collect(Collectors.toList())); - if (workStepPermissions != null && !workStepPermissions.isEmpty()) { - for (WorkStepPermission workStepPermission : workStepPermissions) { - key = workStepPermission.getStepId() + "," + workStepPermission.getUserId(); - workStepPermissionHashMap.remove(key); - } + + // 鏉冮檺妫�鏌� + String entityId = getEntityId(entity, type); + if (!checkProductPerm(type, entityId)) { + ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); } - for (Map.Entry<String, WorkStepPermission> entry : workStepPermissionHashMap.entrySet()) { - WorkStepPermission ws = entry.getValue(); - workStepPermissionList.add(ws); - WorkStep workStep = workStepHashMap.get(ws.getStepId()); - PermissionStream s = new PermissionStream(); - s.setProductId(workStep.getProductId()); - s.setComponentId(workStep.getComponentId()); - s.setPartsId(workStep.getPartsId()); - s.setProcessId(workStep.getProcessId()); - s.setStepId(workStep.getId()); - s.setUserId(ws.getUserId()); - permissionStreamList.add(s); + + // 鑾峰彇瀛愯妭鐐瑰垪琛� + 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 boolean handleWorkStep(String paramId, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { - WorkStep workStep = workStepService.getById(paramId); - if (workStep == null) { - ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST); - } - boolean hasPerm = checkProductPerm(6, workStep.getId()); - if (!hasPerm) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (userList!=null){ - return workStepService.assignAddUser(workStep, userList); - }else { - return workStepService.assignAddDepart(workStep, mdcProductionList); + * 鏍规嵁绫诲瀷鑾峰彇瀹炰綋 + */ + private 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 boolean handleProcessStream(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { - ProcessStream processStream = processStreamService.getById(paramId); - if (processStream == null) { - ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST); - } - boolean hasPerm = checkProductPerm(5, processStream.getProcessId()); - if (!hasPerm) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - boolean result; - if (userList!=null){ - boolean processResult = processStreamService.assignAddUser(processStream, userList); - if (!processResult) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleRelativePermissions(processStream.getProductId(), null, processStream.getProcessId(), null, userList); - } - }else { - result = processStreamService.assignAddDepart(processStream, mdcProductionList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleRelatedPermissions(processStream, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService); - } - } - return true; - } - - private boolean handlePartsInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { - PartsInfo partsInfo = partsInfoService.getById(paramId); - if (partsInfo == null) { - ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST); - } - boolean hasPerm = checkProductPerm(3, partsInfo.getPartsId()); - if (!hasPerm) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - boolean result; - if (userList!=null){ - result = partsInfoService.assignAddUser(partsInfo, userList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleRelativePermissions(partsInfo.getProductId(), null, null, partsInfo.getPartsId(), userList); - } - }else { - result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleRelatedPermissionsForParts(partsInfo, mdcProductionList); - } - } - return true; - } - - private boolean handleProductInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { - ProductInfo productInfo = super.getById(paramId); - if (productInfo == null) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST); - } - boolean hasPerm = checkProductPerm(1, productInfo.getProductId()); - if (!hasPerm) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - boolean result; - if (userList!=null){ - result = this.assignAddUser(productInfo, userList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId()); - if (componentInfoList != null && !componentInfoList.isEmpty()) { - List<String> componentIds = componentInfoList.stream() - .map(ComponentInfo::getComponentId) - .collect(Collectors.toList()); - handleRelativePermissions(productInfo.getProductId(), componentIds, null, null, userList); - } - } - }else { - result = this.assignAddDepartment(productInfo, mdcProductionList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleRelatedPermissionsForProduct(productInfo, mdcProductionList); - } - } - return true; - } - - private boolean handleComponentInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) { - ComponentInfo componentInfo = componentInfoService.getById(paramId); - if (componentInfo == null) { - ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST); - } - boolean hasPerm = checkProductPerm(2, componentInfo.getComponentId()); - if (!hasPerm) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - boolean result; - if (userList!=null){ - result = componentInfoService.assignAddUser(componentInfo, userList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId()); - List<String> componentIds = new ArrayList<>(); - if (childrenList != null && !childrenList.isEmpty()) { - componentIds = childrenList.stream() - .map(ComponentInfo::getComponentId) - .collect(Collectors.toList()); - } - componentIds.add(componentInfo.getComponentId()); - handleRelativePermissions(componentInfo.getProductId(), componentIds, null, null, userList); - } - }else { - result = componentInfoService.assignAddDepart(componentInfo, mdcProductionList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleRelatedPermissionsForComponent(componentInfo, mdcProductionList); - } - } - return true; - } - - private void handleRelatedPermissions(Object parentEntity, Collection<MdcProduction> mdcProductionList, IWorkStepService workStepService, IWorkStepDepartmentService workStepDepartmentService, IPermissionStreamService permissionStreamService) { - String parentId = getParentId(parentEntity); - List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", parentId)); - if (workStepList == null || workStepList.isEmpty()) { - return; - } - Map<String, WorkStepDepartment> allPermissions = new HashMap<>(); - Map<String, WorkStep> workStepMap = new HashMap<>(); - for (WorkStep workStep : workStepList) { - workStepMap.put(workStep.getId(), workStep); - for (MdcProduction mdcProduction : mdcProductionList) { - String key = workStep.getId() + "," + mdcProduction.getId(); - WorkStepDepartment wsDep = new WorkStepDepartment(workStep.getId(), mdcProduction.getId()); - allPermissions.put(key, wsDep); - } - } - - List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList()); - List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList()); - List<WorkStepDepartment> existingPermissions = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIds); - if (existingPermissions != null && !existingPermissions.isEmpty()) { - for (WorkStepDepartment existing : existingPermissions) { - String key = existing.getStepId() + "," + existing.getDepartId(); - allPermissions.remove(key); - } - } - - List<WorkStepDepartment> newWorkStepDepartments = new ArrayList<>(); - List<PermissionStream> newPermissionStreams = new ArrayList<>(); - for (Map.Entry<String, WorkStepDepartment> entry : allPermissions.entrySet()) { - WorkStepDepartment wsDep = entry.getValue(); - newWorkStepDepartments.add(wsDep); - WorkStep workStep = workStepMap.get(wsDep.getStepId()); - PermissionStream permStream = new PermissionStream(); - permStream.setProductId(workStep.getProductId()); - permStream.setComponentId(workStep.getComponentId()); - permStream.setPartsId(workStep.getPartsId()); - permStream.setProcessId(workStep.getProcessId()); - permStream.setStepId(workStep.getId()); - permStream.setDepartId(wsDep.getDepartId()); - newPermissionStreams.add(permStream); - } - - if (!newWorkStepDepartments.isEmpty()) { - workStepDepartmentService.saveBatch(newWorkStepDepartments); - } - if (!newPermissionStreams.isEmpty()) { - permissionStreamService.saveBatch(newPermissionStreams); + /** + * 鏍规嵁绫诲瀷鎶涘嚭寮傚父 + */ + private void 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); } } - private void handleRelatedPermissionsForParts(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) { - // 澶勭悊宸ュ簭鏉冮檺 - handleProcessPermissions(partsInfo,null, mdcProductionList); - // 澶勭悊宸ユ鏉冮檺 - handleWorkStepPermissions(partsInfo, mdcProductionList); - } - - private void handleProcessPermissions(PartsInfo partsInfo,ComponentInfo componentInfo,Collection<MdcProduction> mdcProductionList) { - List<ProcessStream> processStreamList=new ArrayList<>(); - if (componentInfo != null) { - processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId())); - }else { - processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId())); - } - if (processStreamList == null || processStreamList.isEmpty()) { - return; - } - processStreamList.forEach(item->{ - handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService); - }); - Map<String, ProcessionDepartment> allProcessPermissions = new HashMap<>(); - Map<String, ProcessStream> processStreamMap = new HashMap<>(); - for (ProcessStream processStream : processStreamList) { - processStreamMap.put(processStream.getProcessId(), processStream); - for (MdcProduction mdcProduction : mdcProductionList) { - String key = processStream.getProcessId() + "," + mdcProduction.getId(); - ProcessionDepartment procDep = new ProcessionDepartment(processStream.getProcessId(), mdcProduction.getId()); - allProcessPermissions.put(key, procDep); - } - } - - List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList()); - List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList()); - List<ProcessionDepartment> existingProcessPermissions = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIds); - if (existingProcessPermissions != null && !existingProcessPermissions.isEmpty()) { - for (ProcessionDepartment existing : existingProcessPermissions) { - String key = existing.getProcessId() + "," + existing.getDepartId(); - allProcessPermissions.remove(key); - } - } - - List<ProcessionDepartment> newProcessPermissions = new ArrayList<>(); - List<PermissionStream> newPermissionStreams = new ArrayList<>(); - for (Map.Entry<String, ProcessionDepartment> entry : allProcessPermissions.entrySet()) { - ProcessionDepartment procDep = entry.getValue(); - newProcessPermissions.add(procDep); - ProcessStream processStream = processStreamMap.get(procDep.getProcessId()); - PermissionStream permStream = new PermissionStream(); - permStream.setProductId(processStream.getProductId()); - permStream.setComponentId(processStream.getComponentId()); - permStream.setPartsId(processStream.getPartsId()); - permStream.setProcessId(processStream.getProcessId()); - permStream.setDepartId(procDep.getDepartId()); - newPermissionStreams.add(permStream); - } - - if (!newProcessPermissions.isEmpty()) { - processionDepartmentService.saveBatch(newProcessPermissions); - } - if (!newPermissionStreams.isEmpty()) { - permissionStreamService.saveBatch(newPermissionStreams); + /** + * 鑾峰彇瀹炰綋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 void handleWorkStepPermissions(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) { - List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId())); - if (processStreamList == null || processStreamList.isEmpty()) { - return; - } - List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList()); - List<WorkStep> workStepList = workStepService.getByProcessIds(partsInfo.getProductId(), processIds); - if (workStepList == null || workStepList.isEmpty()) { - return; - } - workStepList.forEach(item->{ - handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService); - }); - } - - private void handleRelatedPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) { - // 澶勭悊缁勪欢鏉冮檺 - handleComponentPermissionsForProduct(productInfo, mdcProductionList); - // 澶勭悊闆朵欢鏉冮檺 - handlePartsPermissionsForProduct(productInfo, mdcProductionList); - List<ComponentInfo> componentInfoList=componentInfoService.list(new QueryWrapper<ComponentInfo>().eq("product_id", productInfo.getProductId())); - componentInfoList.forEach(item->{ - handleProcessPermissions(null,item, mdcProductionList); - }); - } - - private void handleComponentPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) { - List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId()); - if (componentInfoList == null || componentInfoList.isEmpty()) { - return; - } - Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>(); - Map<String, ComponentInfo> componentInfoMap = new HashMap<>(); - for (ComponentInfo componentInfo : componentInfoList) { - componentInfoMap.put(componentInfo.getComponentId(), componentInfo); - for (MdcProduction mdcProduction : mdcProductionList) { - String key = componentInfo.getComponentId() + "," + mdcProduction.getId(); - ComponentDepartment compDep = new ComponentDepartment(componentInfo.getComponentId(), mdcProduction.getId()); - allComponentPermissions.put(key, compDep); - } - } - - List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList()); - List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList()); - List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds); - if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) { - for (ComponentDepartment existing : existingComponentPermissions) { - String key = existing.getComponentId() + "," + existing.getDepartId(); - allComponentPermissions.remove(key); - } - } - - List<ComponentDepartment> newComponentPermissions = new ArrayList<>(); - List<PermissionStream> newPermissionStreams = new ArrayList<>(); - for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) { - ComponentDepartment compDep = entry.getValue(); - newComponentPermissions.add(compDep); - ComponentInfo componentInfo = componentInfoMap.get(compDep.getComponentId()); - PermissionStream permStream = new PermissionStream(); - permStream.setProductId(componentInfo.getProductId()); - permStream.setComponentId(componentInfo.getComponentId()); - permStream.setDepartId(compDep.getDepartId()); - newPermissionStreams.add(permStream); - } - - if (!newComponentPermissions.isEmpty()) { - componentDepartmentService.saveBatch(newComponentPermissions); - } - if (!newPermissionStreams.isEmpty()) { - permissionStreamService.saveBatch(newPermissionStreams); + /** + * 鎵ц鐢ㄦ埛鏉冮檺鎿嶄綔 + */ + private 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 void handlePartsPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) { - List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId()); - if (componentInfoList == null || componentInfoList.isEmpty()) { - return; - } - List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList()); - List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds); - if (partsInfoList == null || partsInfoList.isEmpty()) { - return; - } - for (PartsInfo partsInfo : partsInfoList) { - boolean result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - handleRelatedPermissionsForParts(partsInfo, mdcProductionList); + /** + * 鎵ц閮ㄩ棬鏉冮檺鎿嶄綔 + */ + private 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; } } - - private void handleRelatedPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) { - // 澶勭悊瀛愮粍浠舵潈闄� - handleChildComponentPermissions(componentInfo, mdcProductionList); - // 澶勭悊闆朵欢鏉冮檺 - handlePartsPermissionsForComponent(componentInfo, mdcProductionList); - // 澶勭悊宸ュ簭鏉冮檺 - handleProcessPermissions(null,componentInfo, mdcProductionList); - } - - private void handleChildComponentPermissions(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) { - List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId()); - if (childrenList == null || childrenList.isEmpty()) { - return; - } - Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>(); - Map<String, ComponentInfo> componentInfoMap = new HashMap<>(); - for (ComponentInfo childComponent : childrenList) { - componentInfoMap.put(childComponent.getComponentId(), childComponent); - for (MdcProduction mdcProduction : mdcProductionList) { - String key = childComponent.getComponentId() + "," + mdcProduction.getId(); - ComponentDepartment compDep = new ComponentDepartment(childComponent.getComponentId(), mdcProduction.getId()); - allComponentPermissions.put(key, compDep); - } - - List<String> componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList()); - List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList()); - List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds); - if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) { - for (ComponentDepartment existing : existingComponentPermissions) { - String key = existing.getComponentId() + "," + existing.getDepartId(); - allComponentPermissions.remove(key); - } - } - - List<ComponentDepartment> newComponentPermissions = new ArrayList<>(); - List<PermissionStream> newPermissionStreams = new ArrayList<>(); - for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) { - ComponentDepartment compDep = entry.getValue(); - newComponentPermissions.add(compDep); - childComponent = componentInfoMap.get(compDep.getComponentId()); - PermissionStream permStream = new PermissionStream(); - permStream.setProductId(childComponent.getProductId()); - permStream.setComponentId(childComponent.getComponentId()); - permStream.setDepartId(compDep.getDepartId()); - newPermissionStreams.add(permStream); - } - - if (!newComponentPermissions.isEmpty()) { - componentDepartmentService.saveBatch(newComponentPermissions); - } - if (!newPermissionStreams.isEmpty()) { - permissionStreamService.saveBatch(newPermissionStreams); - } - } - } - - private void handlePartsPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) { - List<PartsInfo> partsInfoList = partsInfoService.getByComponentId(componentInfo.getProductId(),componentInfo.getComponentId()); - if (partsInfoList == null || partsInfoList.isEmpty()) { - return; - } - for (PartsInfo partsInfo : partsInfoList) { - handleRelatedPermissionsForParts(partsInfo, mdcProductionList); - } - } - - private String getParentId(Object parentEntity) { - if (parentEntity instanceof ProcessStream) { - return ((ProcessStream) parentEntity).getProcessId(); - } else if (parentEntity instanceof WorkStep) { - return ((WorkStep) parentEntity).getProcessId(); - } - return null; - } - - - /**绉婚櫎鏉冮檺*/ - - private boolean handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) { - WorkStep workStep = workStepService.getById(paramId); - if (workStep == null) { - ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST); - } - checkProductPerm(6, workStep.getId()); - if (userList!=null){ - return workStepService.assignRemoveUser(workStep, userList); - }else { - return workStepService.assignRemoveDepart(workStep, mdcProductionList); - } - } - - private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) { - ProcessStream processStream = processStreamService.getById(paramId); - if (processStream == null) { - ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST); - } - checkProductPerm(5, processStream.getProcessId()); - boolean result; - if (userList!=null){ - result = processStreamService.assignRemoveUser(processStream, userList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleRelatedRemovals(processStream.getProcessId(), userList, - workStepService, iWorkStepPermissionService, permissionStreamService, - "process_id"); - } - }else { - result = processStreamService.assignRemoveDepart(processStream, mdcProductionList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleRelatedDepartmentRemovals(processStream.getProcessId(), mdcProductionList, - workStepService, workStepDepartmentService, permissionStreamService, - "process_id"); - } - } - return true; - } - - private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) { - PartsInfo partsInfo = partsInfoService.getById(paramId); - if (partsInfo == null) { - ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST); - } - checkProductPerm(3, partsInfo.getPartsId()); - boolean result; - if (userList!=null){ - result = partsInfoService.assignRemoveUser(partsInfo, userList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handlePartsRelatedRemovals(null,partsInfo, userList); - } - }else { - result = partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handlePartsRelatedDepartmentRemovals(null,partsInfo, mdcProductionList); - } - } - return true; - } - - private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) { - ProductInfo productInfo = super.getById(paramId); - if (productInfo == null) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST); - } - checkProductPerm(1, productInfo.getProductId()); - boolean result; - if (userList!=null){ - result =this.assignRemoveUser(productInfo, userList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleProductRelatedRemovals(productInfo, userList); - } - }else { - result = this.assignRemoveDepartment(productInfo, mdcProductionList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleProductRelatedDepartmentRemovals(productInfo, mdcProductionList); - } - } - return true; - } - - private boolean handleComponentInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) { - ComponentInfo componentInfo = componentInfoService.getById(paramId); - if (componentInfo == null) { - ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST); - } - checkProductPerm(2, componentInfo.getComponentId()); - boolean result; - if (userList!=null){ - result =componentInfoService.assignRemoveUser(componentInfo, userList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleComponentRelatedRemovals(componentInfo, userList,null); - } - }else { - result = componentInfoService.assignRemoveDepart(componentInfo, mdcProductionList); - if (!result) { - ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR); - } - if (relativeFlag == 1) { - handleComponentRelatedRemovals(componentInfo,null,mdcProductionList); - } - } - return true; - } - - private void handleRelatedRemovals(String parentId, Collection<SysUser> userList, - IWorkStepService workStepService, - IWorkStepPermissionService workStepPermissionService, - IPermissionStreamService permissionStreamService, - String queryField) { - List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId)); - if (workStepList.isEmpty()) { - return; - } - List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList()); - List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList()); - List<WorkStepPermission> workStepPermissions = workStepPermissionService.getByStepIdsAndUserIds(workStepIds, userIdList); - List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, userIdList); - - if (!workStepPermissions.isEmpty()) { - workStepPermissionService.removeByCollection(workStepPermissions); - } - if (!permissionStreams.isEmpty()) { - permissionStreamService.removeByCollection(permissionStreams); - } - } - - private void handleRelatedDepartmentRemovals(String parentId, Collection<MdcProduction> mdcProductionList, - IWorkStepService workStepService, - IWorkStepDepartmentService workStepDepartmentService, - IPermissionStreamService permissionStreamService, - String queryField) { - List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId)); - if (workStepList.isEmpty()) { - return; - } - List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList()); - List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList()); - List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIdList); - List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, departmentIdList); - - if (!workStepDepartments.isEmpty()) { - workStepDepartmentService.removeByCollection(workStepDepartments); - } - if (!permissionStreams.isEmpty()) { - permissionStreamService.removeByCollection(permissionStreams); - } - } - - private void handlePartsRelatedRemovals(ComponentInfo componentInfo,PartsInfo partsInfo,Collection<SysUser> userList) { - List<ProcessStream> processStreamList =new ArrayList<>(); - String productId=""; - if (partsInfo!=null){ - processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId())); - productId=partsInfo.getProductId(); - }else { - processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()).isNull("parts_id")); - productId=componentInfo.getProductId(); - } - List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList()); - handleProcessRemovals(processIds, userList); - handleWorkStepRemovals(productId, processIds, userList); - } - - private void handleProcessRemovals(List<String> processIds, Collection<SysUser> userList) { - if (processIds.isEmpty()) { - return; - } - List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList()); - List<ProcessionPermission> processionPermissions = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userIdList); - List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndUserIds(processIds, userIdList); - - if (!processionPermissions.isEmpty()) { - iProcessStreamPermissionService.removeByCollection(processionPermissions); - } - if (!permissionStreams.isEmpty()) { - permissionStreamService.removeByCollection(permissionStreams); - } - } - - private void handleProcessDepartmentRemovals(List<String> processIds, Collection<MdcProduction> mdcProductionList) { - if (processIds.isEmpty()) { - return; - } - List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList()); - List<ProcessionDepartment> processionDepartments = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIdList); - List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(processIds, departmentIdList); - - if (!processionDepartments.isEmpty()) { - processionDepartmentService.removeByCollection(processionDepartments); - } - if (!permissionStreams.isEmpty()) { - permissionStreamService.removeByCollection(permissionStreams); - } - } - - private void handleWorkStepRemovals(String productId, List<String> processIds, Collection<SysUser> userList) { - List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds); - if (workStepList!=null){ - workStepList.forEach(item->{ - handleRelatedRemovals(item.getProcessId(), userList, workStepService, iWorkStepPermissionService, permissionStreamService, "process_id"); - }); - } - } - - private void handleWorkStepDepartmentRemovals(String productId, List<String> processIds, Collection<MdcProduction> mdcProductionList) { - List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds); - if (workStepList!=null){ - workStepList.forEach(item->{ - handleRelatedDepartmentRemovals(item.getProcessId(), mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService, "process_id"); - }); - } - } - - private void handleProductRelatedRemovals(ProductInfo productInfo, Collection<SysUser> userList) { - List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId()); - List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList()); - handleComponentRemovals(componentIds, userList); - handlePartsRemovals(productInfo.getProductId(), componentIds, userList); - componentInfoList.forEach(item->{ - handlePartsRelatedRemovals(item,null, userList); - }); - } - - private void handleProductRelatedDepartmentRemovals(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) { - List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId()); - List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList()); - handleComponentDepartmentRemovals(componentIds, mdcProductionList); - handlePartsDepartmentRemovals(productInfo.getProductId(), componentIds, mdcProductionList); - componentInfoList.forEach(item->{ - handlePartsRelatedDepartmentRemovals(item,null, mdcProductionList); - }); - } - - private void handleComponentRemovals(List<String> componentIds, Collection<SysUser> userList) { - if (componentIds.isEmpty()) { - return; - } - List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList()); - List<ComponentPermission> componentPermissions = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userIdList); - List<PermissionStream> permissionStreams = permissionStreamService.getByComponentIdsAndUserIds(componentIds, userIdList); - - if (!componentPermissions.isEmpty()) { - componentPermissionService.removeByCollection(componentPermissions); - } - if (!permissionStreams.isEmpty()) { - permissionStreamService.removeByCollection(permissionStreams); - } - } - - private void handleComponentDepartmentRemovals(List<String> componentIds, Collection<MdcProduction> mdcProductionList) { - if (componentIds.isEmpty()) { - return; - } - List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList()); - List<ComponentDepartment> componentDepartments = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIdList); - List<PermissionStream> permissionStreams = permissionStreamService.getByComponentIdsAndDepartIds(componentIds, departmentIdList); - - if (!componentDepartments.isEmpty()) { - componentDepartmentService.removeByCollection(componentDepartments); - } - if (!permissionStreams.isEmpty()) { - permissionStreamService.removeByCollection(permissionStreams); - } - } - - private void handlePartsRemovals(String productId, List<String> componentIds, Collection<SysUser> userList) { - List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds); - partsInfoList.forEach(item->{ - partsInfoService.assignRemoveUser(item,userList); - handlePartsRelatedRemovals(null,item, userList); - }); - } - private void handlePartsDepartmentRemovals(String productId, List<String> componentIds, Collection<MdcProduction> mdcProductionList) { - List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds); - partsInfoList.forEach(item->{ - partsInfoService.assignRemoveDepart(item,mdcProductionList); - handlePartsRelatedDepartmentRemovals(null,item, mdcProductionList); - }); - } - - private void handleComponentRelatedRemovals(ComponentInfo componentInfo, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) { - List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId()); - List<String> componentIds = new ArrayList<>(); - if (childrenList != null) { - componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList()); - } - componentIds.add(componentInfo.getComponentId()); - if (mdcProductionList!=null){ - handleComponentDepartmentRemovals(componentIds, mdcProductionList); - handlePartsDepartmentRemovals(componentInfo.getProductId(), componentIds, mdcProductionList); - if (childrenList != null) { - childrenList.forEach(item->{ - handlePartsRelatedDepartmentRemovals(item,null, mdcProductionList); - }); - } - }else { - handleComponentRemovals(componentIds, userList); - handlePartsRemovals(componentInfo.getProductId(), componentIds, userList); - if (childrenList != null) { - childrenList.forEach(item->{ - handlePartsRelatedRemovals(item,null, userList); - }); - } - } - } - - private void handlePartsRelatedDepartmentRemovals(ComponentInfo componentInfo,PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) { - List<ProcessStream> processStreamList=new ArrayList<>(); - String productId=""; - if (componentInfo!=null){ - processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId())); - productId=componentInfo.getProductId(); - }else { - processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId())); - productId=partsInfo.getProductId(); - } - List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList()); - handleProcessDepartmentRemovals(processIds, mdcProductionList); - handleWorkStepDepartmentRemovals(productId, processIds, mdcProductionList); - } - } -- Gitblit v1.9.3