From 23855599412c4d61b38d78f0f3abd3430a48b5b1 Mon Sep 17 00:00:00 2001
From: zhangherong <571457620@qq.com>
Date: 星期三, 25 六月 2025 11:51:38 +0800
Subject: [PATCH] Merge branch 'mdc_hyjs_master'
---
lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java | 2436 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 2,436 insertions(+), 0 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
new file mode 100644
index 0000000..6a6c10f
--- /dev/null
+++ b/lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/ProductInfoServiceImpl.java
@@ -0,0 +1,2436 @@
+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.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.system.entity.MdcProduction;
+import org.jeecg.modules.system.entity.SysUser;
+import org.jeecg.modules.system.service.IMdcProductionService;
+import org.jeecg.modules.system.service.ISysUserService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Service
+@Slf4j
+public class ProductInfoServiceImpl extends ServiceImpl<ProductInfoMapper,ProductInfo> implements IProductInfoService {
+ @Autowired
+ @Lazy
+ private IComponentInfoService componentInfoService;
+ @Autowired
+ @Lazy
+ private IPartsInfoService partsInfoService;
+ @Autowired
+ private IProcessSpecVersionService processSpecVersionService;
+ @Autowired
+ private IProductPermissionService productPermissionService;
+ @Autowired
+ private IProductDepartmentService productDepartmentService;
+ @Autowired
+ private IPermissionStreamNewService permissionStreamNewService;
+ @Autowired
+ private IComponentDepartmentService componentDepartmentService;
+ @Autowired
+ private IComponentPermissionService componentPermissionService;
+ @Autowired
+ private IPartsDepartmentService partsDepartmentService;
+ @Autowired
+ private IPartsPermissionService partsPermissionService;
+ @Autowired
+ private IProcessSpecVersionPermissionService processSpecVersionPermissionService;
+ @Autowired
+ private IProcessSpecVersionDepartmentService processSpecVersionDepartmentService;
+ @Autowired
+ private ISysUserService userService;
+ @Autowired
+ @Lazy
+ private IProcessStreamService processStreamService;
+ @Autowired
+ private IWorkStepService workStepService;
+ @Autowired
+ private IWorkStepDepartmentService workStepDepartmentService;
+ @Autowired
+ private IProcessionDepartmentService processionDepartmentService;
+ @Autowired
+ private IMdcProductionService mdcProductionService;
+ @Autowired
+ private IDocRelativeService iDocRelativeService;
+ @Autowired
+ private IProcessStreamPermissionService iProcessStreamPermissionService;
+ @Autowired
+ private IWorkStepPermissionService iWorkStepPermissionService;
+ @Autowired
+ private IProductMixService productMixService;
+ @Autowired
+ @Lazy
+ private IDocInfoService docInfoService;
+ @Autowired
+ private IDeviceTypeService deviceTypeService;
+ @Autowired
+ private IDeviceManagementService deviceManagementService;
+
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean addProductInfo(ProductInfo productInfo) {
+ if (productInfo == null)
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ if (!ValidateUtil.validateString(productInfo.getProductName()))
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_NAME_NONE);
+ if (!ValidateUtil.validateString(productInfo.getProductNo())) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_NO_NONE);
+ }
+ ProductInfo en = getByProductNo(productInfo.getProductNo());
+ if (en != null)
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_IS_EXIST);
+ LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+ String userId = user.getId();
+ if (!ValidateUtil.validateString(userId))
+ ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
+ productInfo.setProductStatus(1);
+ boolean b = super.save(productInfo);
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
+ }
+ b = productPermissionService.add(productInfo.getProductId(), userId,"1");
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
+ }
+ //娣诲姞缁撴瀯鏍�
+ 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);
+ stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
+ return permissionStreamNewService.addPermissionStreamNew(stream);
+ }
+
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean editProductInfo(String id, ProductInfo productInfo) {
+ if (!ValidateUtil.validateString(id) || productInfo == null)
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+ String userId = user.getId();
+ if (!ValidateUtil.validateString(userId))
+ ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
+ ProductInfo en = super.getById(id);
+ if (en == null)
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
+ 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);
+ if (permission == null) {
+ permission = new ProductPermission();
+ permission.setProductId(id);
+ permission.setUserId(userId);
+ b = productPermissionService.save(permission);
+ if (!b) {
+ return false;
+ }
+ }
+ PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(id, userId, DocAttributionTypeEnum.PRODUCT.getCode().toString());
+ if (stream == null) {
+ stream = new PermissionStreamNew();
+ stream.setBusinessId(productInfo.getProductId());
+ stream.setUserId(userId);
+ stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
+ return permissionStreamNewService.save(stream);
+ }
+ return b;
+ }
+
+ @Override
+ public List<CommonGenericTree> loadProductTree(String userId) {
+ //浜у搧
+ List<ProductInfo> productInfoList = getByUserPerms(userId);
+ if (productInfoList == null || productInfoList.isEmpty())
+ return Collections.emptyList();
+ //閮ㄤ欢
+ List<ComponentExt> componentInfoList = componentInfoService.getByUserPermsAs(userId);
+ if (componentInfoList == null)
+ componentInfoList = Collections.emptyList();
+ //闆朵欢
+ 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)
+ processStreams = Collections.emptyList();
+ //宸ユ
+ List<WorkStep> workStepList = workStepService.getByUserPerms(userId);
+ if (workStepList == null)
+ workStepList = Collections.emptyList();
+ return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos, processSpecVersions,processStreams, workStepList);
+ }
+
+ @Override
+ public List<ProductInfo> getByUserPerms(String userId) {
+ if (!ValidateUtil.validateString(userId))
+ return Collections.emptyList();
+ return super.getBaseMapper().getByUserPerms(userId);
+ }
+
+ @Override
+ public List<ProductInfo> getByUserPerms(String userId, String queryParam) {
+ if (!ValidateUtil.validateString(userId))
+ return Collections.emptyList();
+ //鍘婚櫎鏉冮檺 TODO
+ LambdaQueryWrapper<ProductInfo> queryWrapper = Wrappers.lambdaQuery();
+ if (ValidateUtil.validateString(queryParam)) {
+ queryWrapper.and(wrapper -> wrapper.like(ProductInfo::getProductNo, queryParam)
+ .or()
+ .like(ProductInfo::getProductName, queryParam));
+ }
+ return super.list(queryWrapper);
+ }
+
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean deleteProductInfo(String id) {
+ if (!ValidateUtil.validateString(id))
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ ProductInfo productInfo = super.getById(id);
+ if (productInfo == null)
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
+ //楠岃瘉浜у搧涓嬫槸鍚︽湁閮ㄤ欢
+ List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
+ if (componentInfoList != null && !componentInfoList.isEmpty()) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_COMPONENT_EXIST);
+ }
+ //楠岃瘉浜у搧涓嬫槸鍚︽湁闆朵欢
+ List<PartsInfo> partsInfoList = partsInfoService.getByProductId(productInfo.getProductId());
+ if (partsInfoList != null && !partsInfoList.isEmpty()) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_PARTS_EXIST);
+ }
+ List<ProcessStream> processStreams = processStreamService.findByProductId(id);
+ if (processStreams != null && !processStreams.isEmpty())
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_PROCESS_EXIST);
+ boolean b = productPermissionService.deleteByProductId(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);
+ }
+ if (!b)
+ ExceptionCast.cast(CommonCode.FAIL);
+ b = productDepartmentService.deleteByProductId(id);
+ if (!b)
+ ExceptionCast.cast(CommonCode.FAIL);
+ b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, DocAttributionTypeEnum.PRODUCT.getCode().toString(),"0");
+ if (!b)
+ ExceptionCast.cast(CommonCode.FAIL);
+ 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);
+ }
+
+ @Override
+ public boolean checkProductPerm(Integer nodeType, String paramId) {
+ if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+ String userId = user.getId();
+ if (!ValidateUtil.validateString(userId))
+ ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
+ if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
+ ProductInfo productInfo = super.getById(paramId);
+ if (productInfo == null)
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
+ PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(paramId, userId,"1");
+ return permission != null;
+ } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())) {
+ ComponentInfo componentInfo = componentInfoService.getById(paramId);
+ if (componentInfo == null)
+ ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
+ PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(componentInfo.getComponentId(), userId,"2");
+ return permission != null;
+ } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
+ PartsInfo partsInfo = partsInfoService.getById(paramId);
+ if (partsInfo == null)
+ ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
+ PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(partsInfo.getPartsId(), userId, "3");
+ return permission != null;
+ } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
+ ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
+ if (processSpecVersion == null)
+ ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
+ PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processSpecVersion.getId(),userId,"4");
+ return permission != null;
+ } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
+ ProcessStream processStream = processStreamService.getById(paramId);
+ if (processStream == null)
+ ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
+ PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processStream.getProcessId(), userId,"5");
+ return permission != null;
+ } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
+ WorkStep workStep = workStepService.getById(paramId);
+ if (workStep == null)
+ ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
+ PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(workStep.getId(), userId,"6");
+ return permission != null;
+ }
+ return false;
+ }
+
+ @Override
+ public List<UserDepartExt> getUserPermsList(Integer nodeType, String paramId) {
+ if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
+ return null;
+ if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
+ return productPermissionService.getUserPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())) {
+ return componentPermissionService.getUserPermsByComponentId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
+ return partsPermissionService.getUserPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
+ return processSpecVersionPermissionService.getUserPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
+ return iProcessStreamPermissionService.getUserPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
+ return iWorkStepPermissionService.getUserPermsByProductId(paramId);
+ } else {
+ return null;
+ }
+ }
+
+ @Override
+ public List<SysUser> getUserNonPermsList(Integer nodeType, String paramId) {
+ if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
+ return null;
+ if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
+ return productPermissionService.getUserNonPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){
+ return componentPermissionService.getUserNonPermsByComponentId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
+ return partsPermissionService.getUserNonPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
+ return processSpecVersionPermissionService.getUserNonPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
+ return iProcessStreamPermissionService.getUserNonPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
+ return iWorkStepPermissionService.getUserNonPermsByProductId(paramId);
+ } else {
+ return null;
+ }
+ }
+
+ @Override
+ public List<MdcProduction> getDepartPermsList(Integer nodeType, String paramId) {
+ if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
+ return null;
+ if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
+ return productDepartmentService.getDepartPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){
+ return componentDepartmentService.getDepartPermsByComponentId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
+ return partsDepartmentService.getDepartPermsByPartsId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
+ return processSpecVersionDepartmentService.getDepartPermsByPsvId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
+ return processionDepartmentService.getDepartPermsByProcessId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
+ return workStepDepartmentService.getDepartPermsByStepId(paramId);
+ }
+ else {
+ return null;
+ }
+ }
+
+ @Override
+ public List<MdcProduction> getDepartNonPermsList(Integer nodeType, String paramId) {
+ if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
+ return null;
+ if (nodeType.equals(DocAttributionTypeEnum.PRODUCT.getCode())) {
+ return productDepartmentService.getDepartNonPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.COMPONENT.getCode())){
+ return componentDepartmentService.getDepartNonPermsByComponentId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.PARTS.getCode())) {
+ return partsDepartmentService.getDepartNonPermsByProductId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.OPERATION.getCode())) {
+ return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.PROCESS.getCode())) {
+ return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
+ } else if (nodeType.equals(DocAttributionTypeEnum.WORKSITE.getCode())) {
+ return workStepDepartmentService.getDepartNonPermsByStepId(paramId);
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * @param nodeType 1 浜у搧 2 閮ㄤ欢 3 闆朵欢
+ * @param paramId 浜у搧鏍戣妭鐐筰d
+ * @param relativeFlag 1 鏄� 2 鍚�
+ * @param userIds 娣诲姞鐢ㄦ埛ids
+ * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛�
+ * @return
+ */
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean assignAddUserAll(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
+ // 鍙傛暟鏍￠獙
+ validateInputParameters(nodeType, paramId, relativeFlag, "1", userIds);
+ List<String> ids = new ArrayList<>(userIds.length);
+ Collections.addAll(ids, userIds);
+ Collection<SysUser> userList = userService.listByIds(ids);
+ validateSysUserList(userList, ids);
+ switch (nodeType) {
+ case 1:
+ return handleProductInfo(paramId, relativeFlag, null,userList);
+ case 2:
+ return handleComponentInfo(paramId, relativeFlag, null,userList);
+ case 3:
+ return handlePartsInfo(paramId, relativeFlag, null,userList);
+ case 4:
+ return handleProcessSpecVersion(paramId, relativeFlag, null,userList);
+ case 5:
+ return handleProcessStream(paramId, relativeFlag, null,userList);
+ case 6:
+ return handleWorkStep(paramId, null,userList);
+
+ default:
+ return false;
+ }
+ }
+
+ /**
+ * @param nodeType 1 浜у搧 2 閮ㄤ欢 3 闆朵欢 5 宸ュ簭 6 宸ユ
+ * @param paramId 浜у搧鏍戣妭鐐筰d
+ * @param relativeFlag 1 鏄� 2 鍚�
+ * @param departmentIds 娣诲姞閮ㄩ棬ids
+ * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛�
+ * @return
+ */
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean assignAddDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
+ validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds);
+ List<String> ids = new ArrayList<>(departmentIds.length);
+ Collections.addAll(ids, departmentIds);
+ List<String> deps=mdcProductionService.findAllProductionIds(ids);
+ Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(deps);
+ validateMdcProductionList(mdcProductionList, deps);
+ switch (nodeType) {
+ case 1:
+ return handleProductInfo(paramId, relativeFlag, mdcProductionList,null);
+ case 2:
+ return handleComponentInfo(paramId, relativeFlag, mdcProductionList,null);
+ case 3:
+ return handlePartsInfo(paramId, relativeFlag, mdcProductionList,null);
+ case 4:
+ return handleProcessSpecVersion(paramId, relativeFlag, mdcProductionList,null);
+ case 5:
+ return handleProcessStream(paramId, relativeFlag, mdcProductionList,null);
+ case 6:
+ return handleWorkStep(paramId, mdcProductionList,null);
+
+ default:
+ return false;
+ }
+ }
+
+ /**
+ * @param nodeType 1 浜у搧 2 閮ㄤ欢 3 闆朵欢
+ * @param paramId 浜у搧鏍戣妭鐐筰d
+ * @param relativeFlag 1 鏄� 2 鍚�
+ * @param userIds 绉婚櫎鐢ㄦ埛ids
+ * todo浼樺寲缁撴瀯锛岄噰鐢╩ix琛ㄨ繘琛岀埗瀛愰�掑綊鏌ヨ锛屽垎绫昏繘琛屾潈闄愬垎閰嶏紙鍗曡〃鏌ヨ锛�
+ * @return
+ */
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean assignRemoveUserAll(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
+ validateInputParameters(nodeType, paramId, relativeFlag, "1", userIds);
+ List<String> userIdsList = Arrays.asList(userIds);
+ Collection<SysUser> userList = userService.listByIds(userIdsList);
+ validateSysUserList(userList, userIdsList);
+ switch (nodeType) {
+ case 1:
+ return handleProductInfoRemoval(paramId, relativeFlag, userList,null);
+ case 2:
+ return handleComponentInfoRemoval(paramId, relativeFlag, userList,null);
+ case 3:
+ return handlePartsInfoRemoval(paramId, relativeFlag, userList,null);
+ case 4:
+ return handleProcessSpecVersionRemoval(paramId, relativeFlag, userList,null);
+ case 5:
+ return handleProcessStreamRemoval(paramId, relativeFlag, userList,null);
+ case 6:
+ return handleWorkStepRemoval(paramId, userList,null);
+ default:
+ return false;
+ }
+ }
+
+
+ /**
+ *
+ * @param nodeType 1 浜у搧 2 閮ㄤ欢 3 闆朵欢 5 宸ュ簭 6 宸ユ
+ * @param paramId 浜у搧鏍戣妭鐐筰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> 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 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;
+ }
+ }
+
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean assignAddUser(ProductInfo productInfo, Collection<SysUser> userList) {
+ if (productInfo == null || userList == null || userList.isEmpty())
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ List<ProductPermission> permissionList = new ArrayList<>();
+ List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
+ userList.forEach(item -> {
+ ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
+ if (en == null) {
+ en = new ProductPermission();
+ en.setUserId(item.getId());
+ en.setProductId(productInfo.getProductId());
+ permissionList.add(en);
+ }
+ PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(productInfo.getProductId(), item.getId(),"1");
+ if (stream == null) {
+ stream = new PermissionStreamNew();
+ stream.setUserId(item.getId());
+ stream.setBusinessId(productInfo.getProductId());
+ stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
+ permissionStreamList.add(stream);
+ }
+ });
+ if (!permissionList.isEmpty()) {
+ boolean b = productPermissionService.saveBatch(permissionList);
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ }
+ if (!permissionStreamList.isEmpty()) {
+ boolean b =permissionStreamNewService.saveBatch(permissionStreamList);
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ }
+ return true;
+ }
+
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean assignRemoveUser(ProductInfo productInfo, Collection<SysUser> userList) {
+ if (productInfo == null || userList == null || userList.isEmpty())
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ List<ProductPermission> permissionList = new ArrayList<>();
+ List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
+ userList.forEach(item -> {
+ ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
+ if (en != null) {
+ permissionList.add(en);
+ }
+ PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(productInfo.getProductId(), item.getId(),"1");
+ if (stream != null) {
+ permissionStreamList.add(stream);
+ }
+ });
+ //绉婚櫎鐢ㄦ埛鏉冮檺娓呯┖鏍￠獙
+ List<ProductPermission> existList = productPermissionService.getByProductId(productInfo.getProductId());
+ if (existList.size() <= permissionList.size())
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_NONE);
+ if (!permissionList.isEmpty()) {
+ boolean b = productPermissionService.removeByCollection(permissionList);
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ }
+ if (!permissionStreamList.isEmpty()) {
+ boolean b = permissionStreamNewService.deletePermissionStreamNewByList(permissionStreamList);
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ }
+ return true;
+ }
+
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean assignAddDepartment(ProductInfo productInfo, Collection<MdcProduction> departmentList) {
+ if (productInfo == null || departmentList == null || departmentList.isEmpty())
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ List<ProductDepartment> productDepartmentList = new ArrayList<>();
+ List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
+ departmentList.forEach(item -> {
+ ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
+ if (en == null) {
+ en = new ProductDepartment();
+ en.setDepartId(item.getId());
+ en.setProductId(productInfo.getProductId());
+ productDepartmentList.add(en);
+ }
+ PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1");
+ if (stream == null) {
+ stream = new PermissionStreamNew();
+ stream.setDepartId(item.getId());
+ stream.setBusinessId(productInfo.getProductId());
+ stream.setBusinessType(DocAttributionTypeEnum.PRODUCT.getCode().toString());
+ permissionStreamList.add(stream);
+ }
+ });
+ if (!productDepartmentList.isEmpty()) {
+ boolean b = productDepartmentService.saveBatch(productDepartmentList);
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ }
+ if (!permissionStreamList.isEmpty()) {
+ boolean b = permissionStreamNewService.saveBatch(permissionStreamList);
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ }
+ return true;
+ }
+
+ @Override
+ @Transactional(rollbackFor = {Exception.class})
+ public boolean assignRemoveDepartment(ProductInfo productInfo, Collection<MdcProduction> departmentList) {
+ if (productInfo == null || departmentList == null || departmentList.isEmpty())
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ List<ProductDepartment> productDepartmentList = new ArrayList<>();
+ List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
+ departmentList.forEach(item -> {
+ ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
+ if (en != null) {
+ productDepartmentList.add(en);
+ }
+ PermissionStreamNew stream = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndDepartId(productInfo.getProductId(), item.getId(),"1");
+ if (stream != null) {
+ permissionStreamList.add(stream);
+ }
+ });
+ if (!productDepartmentList.isEmpty()) {
+ boolean b = productDepartmentService.removeByCollection(productDepartmentList);
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ }
+ if (!permissionStreamList.isEmpty()) {
+ boolean b = permissionStreamNewService.deletePermissionStreamNewByList(permissionStreamList);
+ if (!b) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public List<String> getDepartIdsByParams(Integer nodeType, String paramId) {
+ List<String> departIds = new ArrayList<>();
+ //5-宸ュ簭
+ if (Objects.equals(nodeType, DocAttributionTypeEnum.PROCESS.getCode())) {
+ ProcessStream processStream = processStreamService.getById(paramId);
+ if (processStream == null)
+ return null;
+ 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 (Objects.equals(nodeType, DocAttributionTypeEnum.WORKSITE.getCode())) {
+ WorkStep workStep = workStepService.getById(paramId);
+ if (workStep == null)
+ return null;
+ List<PermissionStreamNew> permissionStreamList = permissionStreamNewService.loadProductMixByBusinessId(workStep.getId(),"6");
+ if (permissionStreamList == null || permissionStreamList.isEmpty())
+ return null;
+ permissionStreamList.forEach(item -> {
+ departIds.add(item.getDepartId());
+ });
+ } else {
+ return null;
+ }
+ //鍘婚噸
+ Set<String> set = new HashSet<>(departIds);
+ departIds.clear();
+ departIds.addAll(set);
+ return departIds;
+ }
+
+ @Override
+ public ProductInfo getByProductNo(String productNo) {
+ if (ValidateUtil.validateString(productNo)) {
+ List<ProductInfo> list = super.lambdaQuery().eq(ProductInfo::getProductNo, productNo).list();
+ if (list == null || list.isEmpty())
+ return null;
+ return list.get(0);
+ }
+ return null;
+ }
+
+ @Override
+ public List<CommonGenericTree> loadBaseTree(String userId) {
+ List<ProductInfo> productInfoList = getByUserPerms(userId);
+ if (productInfoList == null || productInfoList.isEmpty())
+ return Collections.emptyList();
+// List<ComponentExt> componentInfoList = componentInfoService.getByUserPermsAs(userId);
+// if(componentInfoList == null)
+// componentInfoList = Collections.emptyList();
+ return ProductTreeWrapper.loadTree(productInfoList);
+ }
+
+ @Override
+ public List<CommonGenericTree> loadTree(String userId, Integer nodeType, String paramId) {
+ if (Objects.equals(nodeType, DocAttributionTypeEnum.PRODUCT.getCode())) {
+ List<ComponentInfo> componentInfoList = componentInfoService.getByProductIdAndUserId(paramId, userId);
+ if (componentInfoList == null || componentInfoList.isEmpty())
+ return Collections.emptyList();
+ List<CommonGenericTree> list = new ArrayList<>();
+ CommonGenericTree<ComponentInfo> node;
+ for (ComponentInfo c : componentInfoList) {
+ node = new CommonGenericTree();
+ node.setId(c.getComponentId());
+// node.setLabel("[" + c.getComponentCode()+ "]" + c.getComponentName());
+ node.setLabel(c.getComponentName());
+ node.setParentId(c.getProductId());
+ node.setIconClass("");
+ node.setType(DocAttributionTypeEnum.COMPONENT.getCode());
+ node.setRField(c.getProductId());
+ node.setEntity(c);
+ list.add(node);
+ }
+ return list;
+ } else if (Objects.equals(nodeType, DocAttributionTypeEnum.COMPONENT.getCode())) {
+ List<ComponentInfo> componentInfoList = componentInfoService.getByParentIdAndUserId(paramId, userId);
+ List<CommonGenericTree> list = new ArrayList<>();
+ CommonGenericTree<ComponentInfo> componentNode;
+ if (componentInfoList != null && !componentInfoList.isEmpty()) {
+ for (ComponentInfo c : componentInfoList) {
+ componentNode = new CommonGenericTree();
+ componentNode.setId(c.getComponentId());
+// componentNode.setLabel("[" + c.getComponentCode()+ "]" + c.getComponentName());
+ componentNode.setLabel(c.getComponentName());
+ componentNode.setParentId(c.getParentId());
+ componentNode.setIconClass("");
+ componentNode.setType(DocAttributionTypeEnum.COMPONENT.getCode());
+ componentNode.setRField(c.getProductId());
+ componentNode.setEntity(c);
+ list.add(componentNode);
+ }
+ }
+ List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, paramId, null);
+ if (partsInfos == null || partsInfos.isEmpty())
+ return list;
+ CommonGenericTree<PartsInfo> partNode;
+ for (PartsInfo part : partsInfos) {
+ partNode = new CommonGenericTree();
+ partNode.setId(part.getPartsId());
+// partNode.setLabel("[" + part.getPartsCode()+ "]" + part.getPartsName());
+ partNode.setLabel(part.getPartsName());
+ partNode.setParentId(part.getComponentId());
+ partNode.setIconClass("");
+ partNode.setType(DocAttributionTypeEnum.PARTS.getCode());
+ partNode.setRField(part.getComponentId());
+ partNode.setEntity(part);
+ partNode.setLeaf(true);
+ list.add(partNode);
+ }
+ return list;
+ } else {
+ return Collections.emptyList();
+ }
+ }
+
+ @Override
+ public List<CommonGenericTree> searchProductTree(String userId, String queryParam) {
+ List<ProductInfo> productInfos = this.getByUserPerms(userId, queryParam);
+ List<ComponentInfo> componentInfos = componentInfoService.getByUserPerms(userId, queryParam);
+ List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, null, queryParam);
+ List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByUserPerms(userId, queryParam);
+ List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId, queryParam);
+ List<WorkStep> workSteps = workStepService.getByUserPerms(userId, queryParam);
+ List<ComponentInfo> componentInfoList = new ArrayList<>();
+ List<ProductInfo> productInfoList = new ArrayList<>();
+
+ Map<String, ProductInfo> productInfoMap = new HashMap<>();
+ Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
+
+ ProductInfo product;
+ ComponentInfo component;
+
+ if (productInfos != null && !productInfos.isEmpty()) {
+ for (ProductInfo p : productInfos) {
+ productInfoList.add(p);
+ productInfoMap.put(p.getProductId(), p);
+ }
+ }
+
+ if (componentInfos != null && !componentInfos.isEmpty()) {
+ for (ComponentInfo c : componentInfos) {
+ componentInfoList.add(c);
+ componentInfoMap.put(c.getComponentId(), c);
+ }
+ }
+
+ for (PartsInfo p : partsInfos) {
+ if (!productInfoMap.containsKey(p.getProductId())) {
+ product = super.getById(p.getProductId());
+ if (product != null) {
+ productInfoMap.put(product.getProductId(), product);
+ productInfoList.add(product);
+ }
+ }
+
+ if (!componentInfoMap.containsKey(p.getComponentId())) {
+ component = componentInfoService.getById(p.getComponentId());
+ if (component != null) {
+ componentInfoMap.put(component.getComponentId(), component);
+ componentInfoList.add(component);
+ }
+
+ }
+ }
+
+ for (ProcessStream processStream : processStreams) {
+ if (!productInfoMap.containsKey(processStream.getProductId())) {
+ product = super.getById(processStream.getProductId());
+ if (product != null) {
+ productInfoMap.put(product.getProductId(), product);
+ productInfoList.add(product);
+ }
+ }
+
+ if (!componentInfoMap.containsKey(processStream.getComponentId())) {
+ component = componentInfoService.getById(processStream.getComponentId());
+ if (component != null) {
+ componentInfoMap.put(component.getComponentId(), component);
+ componentInfoList.add(component);
+ }
+
+ }
+ }
+
+ for (WorkStep workStep : workSteps) {
+ if (!productInfoMap.containsKey(workStep.getProductId())) {
+ product = super.getById(workStep.getProductId());
+ if (product != null) {
+ productInfoMap.put(product.getProductId(), product);
+ productInfoList.add(product);
+ }
+ }
+
+ if (!componentInfoMap.containsKey(workStep.getComponentId())) {
+ component = componentInfoService.getById(workStep.getComponentId());
+ if (component != null) {
+ componentInfoMap.put(component.getComponentId(), component);
+ componentInfoList.add(component);
+ }
+
+ }
+ }
+
+ List<ComponentInfo> addList = new ArrayList<>();
+ log.info("componentInfoList闆嗗悎澶у皬={}", componentInfoList.size());
+ long start = System.currentTimeMillis();
+ log.info("寮�濮嬪惊鐜墽琛屾椂闂�={}", start);
+ String pid;
+ for (ComponentInfo c : componentInfoList) {
+ int rankLevel = c.getRankLevel();
+ component = c;
+ if (!productInfoMap.containsKey(c.getProductId())) {
+ product = super.getById(c.getProductId());
+ if (product != null) {
+ productInfoMap.put(product.getProductId(), product);
+ productInfoList.add(product);
+ }
+ }
+ while ((rankLevel - 1) > 0) {
+ pid = component.getParentId();
+ if (componentInfoMap.containsKey(pid)) {
+ component = componentInfoMap.get(pid);
+ rankLevel = component.getRankLevel();
+ continue;
+ }
+ component = componentInfoService.getById(pid);
+ if (component != null) {
+ log.info("addList娣诲姞浜嗘柊鐨勯儴浠秈d={}", component.getComponentId());
+ componentInfoMap.put(component.getComponentId(), component);
+ addList.add(component);
+ rankLevel = component.getRankLevel();
+ } else {
+ log.info("鏌ヨ涓嶅埌閮ㄤ欢id={}", pid);
+ break;
+ }
+
+ }
+ }
+ long end = System.currentTimeMillis();
+ log.info("寰幆鎵ц鎬昏�楁椂={}", (end - start));
+
+ if (!addList.isEmpty()) {
+ componentInfoList.addAll(addList);
+ }
+
+ //杞崲鏁版嵁
+ List<ComponentExt> componentExtList = ComponentExt.convertToExtList(componentInfoList);
+
+ return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos,processSpecVersions, processStreams, workSteps);
+ }
+
+ @Override
+ public boolean deleteProductTree(String id, Integer type) {
+ switch (type) {
+ //浜у搧
+ case 1:
+ return deleteProductInfo(id);
+ //閮ㄩ棬
+ case 2:
+ return componentInfoService.deleteComponentInfo(id);
+ //闆朵欢
+ case 3:
+ return partsInfoService.deletePartsInfo(id);
+ //宸ヨ壓瑙勭▼鐗堟湰
+ case 4:
+ return processSpecVersionService.deleteProcessSpecVersion(id);
+ //宸ュ簭
+ case 5:
+ return processStreamService.deleteProcessStream(id);
+ //宸ユ
+ case 6:
+ return workStepService.deleteWorkStep(id);
+ default:
+ }
+ return false;
+ }
+
+ @Override
+ public Result<?> getTreeById(String id, Integer type){
+ if (StrUtil.isNotEmpty(id)||type!=null){
+ switch (type){
+ case 1:
+ //浜у搧
+ QueryWrapper<ProductInfo> productInfoQueryWrapper = new QueryWrapper<>();
+ productInfoQueryWrapper.eq("product_id",id);
+ List<ProductInfo> productInfos = this.list(productInfoQueryWrapper);
+ return Result.OK(productInfos);
+ case 2:
+ //缁勪欢
+ QueryWrapper<ComponentInfo> componentInfoQueryWrapper = new QueryWrapper<>();
+ componentInfoQueryWrapper.eq("component_id",id);
+ List<ComponentInfo> componentInfos = componentInfoService.list(componentInfoQueryWrapper);
+ return Result.OK(componentInfos);
+ case 3:
+ //闆朵欢
+ QueryWrapper<PartsInfo> partsInfoQueryWrapper = new QueryWrapper<>();
+ partsInfoQueryWrapper.eq("parts_id",id);
+ List<PartsInfo> partsInfos = partsInfoService.list(partsInfoQueryWrapper);
+ return Result.OK(partsInfos);
+ case 4:
+ //宸ヨ壓瑙勫垝鐗堟湰
+ QueryWrapper<ProcessSpecVersion> processSpecVersionQueryWrapper = new QueryWrapper<>();
+ processSpecVersionQueryWrapper.eq("id",id);
+ List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.list(processSpecVersionQueryWrapper);
+ return Result.OK(processSpecVersions);
+ case 5:
+ //宸ュ簭
+ QueryWrapper<ProcessStream> processStreamQueryWrapper = new QueryWrapper<>();
+ processStreamQueryWrapper.eq("process_id",id);
+ List<ProcessStream> processStreams = processStreamService.list(processStreamQueryWrapper);
+ return Result.OK(processStreams);
+ case 6:
+ //宸ユ
+ QueryWrapper<WorkStep> workStepQueryWrapper = new QueryWrapper<>();
+ workStepQueryWrapper.eq("id",id);
+ List<WorkStep> workSteps = workStepService.list(workStepQueryWrapper);
+ return Result.OK(workSteps);
+ }
+ }
+ return Result.error("鍙傛暟閿欒");
+ }
+
+ /**
+ * 閫氳繃浠ｅ彿銆佸悕绉般�佹潗璐ㄧ瓑鏌ヨ瀵瑰簲鐢靛瓙鏍锋澘
+ * @param treeInfoRequest
+ * @return
+ */
+ @Override
+ public List<DocInfo> getByTreeOtherFileInfo(TreeInfoRequest treeInfoRequest){
+ switch (treeInfoRequest.getAttributionType()){
+ case 1:
+ LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>();
+ // 鏄庣‘鏉′欢锛氫粎褰揳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<>();
+ }
+
+ /**
+ * 閫氳繃浠ｅ彿銆佸悕绉般�佹潗璐ㄧ瓑鏌ヨ瀵瑰簲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;
+ }
+
+ /**
+ * 楠岃瘉杈撳叆鍙傛暟
+ */
+ private void validateInputParameters(Integer nodeType, String paramId, Integer relativeFlag, String type, String[] paramIds) {
+ if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
+ !ValidateUtil.validateInteger(relativeFlag)) {
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ }
+ if (paramIds == null || paramIds.length < 1) {
+ if (("1").equals(type)) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
+ } else {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_DEPART_PERM_NONE);
+ }
+ }
+ }
+
+ /**
+ * 楠岃瘉 SysUser 鍒楄〃
+ */
+ private void validateSysUserList(Collection<SysUser> sysUserList, List<String> userIds) {
+ if (sysUserList == null || sysUserList.isEmpty() || sysUserList.size() != userIds.size()) {
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ }
+ }
+
+ /**
+ * 楠岃瘉 MdcProduction 鍒楄〃
+ */
+ private void validateMdcProductionList(Collection<MdcProduction> mdcProductionList, List<String> departmentIds) {
+ if (mdcProductionList == null || mdcProductionList.isEmpty() || mdcProductionList.size() != departmentIds.size()) {
+ ExceptionCast.cast(CommonCode.INVALID_PARAM);
+ }
+ }
+
+ private void handleRelativePermissions(String productId, List<String> componentIds, String processId, String partsId,String psvId ,Collection<SysUser> userList) {
+ List<ComponentPermission> componentPermissionList = new ArrayList<>();
+ List<PartsPermission> partsPermissionList = new ArrayList<>();
+ List<ProcessSpecVersionPermission> processSpecVersionPermissionList = new ArrayList<>();
+ List<ProcessionPermission> processionPermissionList = new ArrayList<>();
+ List<WorkStepPermission> workStepPermissionList = new ArrayList<>();
+ List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
+ // 澶勭悊閮ㄤ欢鏉冮檺
+ if (componentIds != null && !componentIds.isEmpty()) {
+ handleComponentPermissions(componentIds, userList, componentPermissionList, permissionStreamList);
+ List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
+ if (partsInfoList != null && !partsInfoList.isEmpty()) {
+ List<String> partsIds = partsInfoList.stream()
+ .map(PartsInfo::getPartsId)
+ .collect(Collectors.toList());
+ handlePartsPermissions(partsIds, userList, partsPermissionList, permissionStreamList);
+ List<ProcessSpecVersion> processSpecVersionList = processSpecVersionService.getByPartsIds(partsIds);
+ if (processSpecVersionList!= null &&!processSpecVersionList.isEmpty()) {
+ List<String> psvIds = processSpecVersionList.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
+ handlePsvPermissions(psvIds, userList, processSpecVersionPermissionList, permissionStreamList);
+ }
+ List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productId, componentIds, partsIds);
+ processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
+ }
+ }
+
+ // 澶勭悊闆朵欢鏉冮檺
+ if (partsId != null) {
+ List<ProcessSpecVersion> processStreamList = processSpecVersionService.list(new QueryWrapper<ProcessSpecVersion>().eq("id", psvId));
+ if (processStreamList != null && !processStreamList.isEmpty()) {
+ List<String> psvIds = processStreamList.stream()
+ .map(ProcessSpecVersion::getId)
+ .collect(Collectors.toList());
+ handlePsvPermissions(psvIds,userList,processSpecVersionPermissionList,permissionStreamList);
+ }
+ }
+
+ // 澶勭悊宸ヨ壓瑙勭▼鐗堟湰鏉冮檺
+ if (psvId!= null) {
+ List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", psvId));
+ processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
+ }
+
+ // 澶勭悊宸ュ簭鏉冮檺
+ if (processId != null) {
+ List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", processId));
+ if (workStepList != null && !workStepList.isEmpty()) {
+ List<String> workStepIds = workStepList.stream()
+ .map(WorkStep::getId)
+ .collect(Collectors.toList());
+ handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList);
+ }
+ }
+
+ if (!componentPermissionList.isEmpty()) {
+ componentPermissionService.saveBatch(componentPermissionList);
+ }
+ if (!partsPermissionList.isEmpty()) {
+ partsPermissionService.saveBatch(partsPermissionList);
+ }
+ if (!processSpecVersionPermissionList.isEmpty()) {
+ processSpecVersionPermissionService.saveBatch(processSpecVersionPermissionList);
+ }
+ if (!processionPermissionList.isEmpty()) {
+ iProcessStreamPermissionService.saveBatch(processionPermissionList);
+ }
+ if (!workStepPermissionList.isEmpty()) {
+ iWorkStepPermissionService.saveBatch(workStepPermissionList);
+ }
+ if (!permissionStreamList.isEmpty()) {
+ permissionStreamNewService.saveBatch(permissionStreamList);
+ }
+ }
+
+ private void processStreamApi(String productId, Collection<SysUser> userList, List<ProcessionPermission> processionPermissionList,
+ List<WorkStepPermission> workStepPermissionList, List<PermissionStreamNew> permissionStreamList, List<ProcessStream> processStreamList) {
+ if (processStreamList != null && !processStreamList.isEmpty()) {
+ List<String> processIds = processStreamList.stream()
+ .map(ProcessStream::getProcessId)
+ .collect(Collectors.toList());
+ handleProcessPermissions(processIds, userList, processionPermissionList, permissionStreamList);
+ List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
+ if (workStepList != null && !workStepList.isEmpty()) {
+ List<String> workStepIds = workStepList.stream()
+ .map(WorkStep::getId)
+ .collect(Collectors.toList());
+ handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList);
+ }
+ }
+ }
+
+ private void handleComponentPermissions(List<String> componentIds, Collection<SysUser> userList,
+ List<ComponentPermission> componentPermissionList, List<PermissionStreamNew> permissionStreamList) {
+ Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
+ Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
+ String key;
+ for (ComponentInfo c : componentInfoService.listByIds(componentIds)) {
+ componentInfoMap.put(c.getComponentId(), c);
+ for (SysUser u : userList) {
+ key = c.getComponentId() + "," + u.getId();
+ componentPermissionMap.put(key, new ComponentPermission(c.getComponentId(), u.getId()));
+ }
+ }
+ List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
+ if (existList != null && !existList.isEmpty()) {
+ for (ComponentPermission permission : existList) {
+ key = permission.getComponentId() + "," + permission.getUserId();
+ componentPermissionMap.remove(key);
+ }
+ }
+ for (Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()) {
+ ComponentPermission cp = entry.getValue();
+ componentPermissionList.add(cp);
+ ComponentInfo cpInfo = componentInfoMap.get(cp.getComponentId());
+ PermissionStreamNew s = new PermissionStreamNew();
+ s.setBusinessId(cpInfo.getComponentId());
+ s.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
+ s.setUserId(cp.getUserId());
+ permissionStreamList.add(s);
+ }
+ }
+
+ private void handlePartsPermissions(List<String> partsIds, Collection<SysUser> userList,
+ List<PartsPermission> partsPermissionList, List<PermissionStreamNew> permissionStreamList) {
+ Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
+ Map<String, PartsInfo> partsInfoMap = new HashMap<>();
+ String key;
+ for (PartsInfo p : partsInfoService.listByIds(partsIds)) {
+ partsInfoMap.put(p.getPartsId(), p);
+ for (SysUser u : userList) {
+ key = p.getPartsId() + "," + u.getId();
+ partsPermissionHashMap.put(key, new PartsPermission(p.getPartsId(), u.getId()));
+ }
+ }
+ List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
+ if (existPartsList != null && !existPartsList.isEmpty()) {
+ for (PartsPermission permission : existPartsList) {
+ key = permission.getPartsId() + "," + permission.getUserId();
+ partsPermissionHashMap.remove(key);
+ }
+ }
+ for (Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()) {
+ PartsPermission pp = entry.getValue();
+ partsPermissionList.add(pp);
+ PartsInfo ptInfo = partsInfoMap.get(pp.getPartsId());
+ PermissionStreamNew s = new PermissionStreamNew();
+ s.setBusinessId(ptInfo.getPartsId());
+ s.setBusinessType(DocAttributionTypeEnum.PARTS.getCode().toString());
+ s.setUserId(pp.getUserId());
+ permissionStreamList.add(s);
+ }
+ }
+
+ private void handlePsvPermissions(List<String> psvIds, Collection<SysUser> userList,
+ List<ProcessSpecVersionPermission> processSpecVersionPermissionList, List<PermissionStreamNew> permissionStreamList) {
+ Map<String, ProcessSpecVersionPermission> processSpecVersionPermissionMap = new HashMap<>();
+ Map<String, ProcessSpecVersion> processStreamMap = new HashMap<>();
+ String key;
+ for (ProcessSpecVersion p : processSpecVersionService.listByIds(psvIds)) {
+ processStreamMap.put(p.getId(), p);
+ for (SysUser u : userList) {
+ key = p.getId() + "," + u.getId();
+ processSpecVersionPermissionMap.put(key, new ProcessSpecVersionPermission(p.getId(), u.getId()));
+ }
+ }
+ List<ProcessSpecVersionPermission> processSpecVersionPermissions = processSpecVersionPermissionService.getByPsvIdsAndUserIds(psvIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
+ if (processSpecVersionPermissions != null && !processSpecVersionPermissions.isEmpty()) {
+ for (ProcessSpecVersionPermission processionPermission : processSpecVersionPermissions) {
+ key = processionPermission.getPsvId() + "," + processionPermission.getUserId();
+ processSpecVersionPermissionMap.remove(key);
+ }
+ }
+ for (Map.Entry<String, ProcessSpecVersionPermission> entry : processSpecVersionPermissionMap.entrySet()) {
+ ProcessSpecVersionPermission pp = entry.getValue();
+ processSpecVersionPermissionList.add(pp);
+ ProcessSpecVersion processSpecVersion = processStreamMap.get(pp.getPsvId());
+ PermissionStreamNew s = new PermissionStreamNew();
+ s.setBusinessId(processSpecVersion.getId());
+ s.setBusinessType(DocAttributionTypeEnum.OPERATION.getCode().toString());
+ s.setUserId(pp.getUserId());
+ permissionStreamList.add(s);
+ }
+ }
+
+ private void handleProcessPermissions(List<String> processIds, Collection<SysUser> userList,
+ List<ProcessionPermission> processionPermissionList, List<PermissionStreamNew> permissionStreamList) {
+ Map<String, ProcessionPermission> processionPermissionHashMap = new HashMap<>();
+ Map<String, ProcessStream> processStreamMap = new HashMap<>();
+ String key;
+ for (ProcessStream p : processStreamService.listByIds(processIds)) {
+ processStreamMap.put(p.getProcessId(), p);
+ for (SysUser u : userList) {
+ key = p.getProcessId() + "," + u.getId();
+ processionPermissionHashMap.put(key, new ProcessionPermission(p.getProcessId(), u.getId()));
+ }
+ }
+ List<ProcessionPermission> processionDepartmentList = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
+ if (processionDepartmentList != null && !processionDepartmentList.isEmpty()) {
+ for (ProcessionPermission processionPermission : processionDepartmentList) {
+ key = processionPermission.getProcessId() + "," + processionPermission.getUserId();
+ processionPermissionHashMap.remove(key);
+ }
+ }
+ for (Map.Entry<String, ProcessionPermission> entry : processionPermissionHashMap.entrySet()) {
+ ProcessionPermission pp = entry.getValue();
+ processionPermissionList.add(pp);
+ ProcessStream processStream = processStreamMap.get(pp.getProcessId());
+ PermissionStreamNew s = new PermissionStreamNew();
+ s.setBusinessId(processStream.getProcessId());
+ s.setBusinessType(DocAttributionTypeEnum.PROCESS.getCode().toString());
+ s.setUserId(pp.getUserId());
+ permissionStreamList.add(s);
+ }
+ }
+
+ private void handleWorkStepPermissions(List<String> workStepIds, Collection<SysUser> userList,
+ List<WorkStepPermission> workStepPermissionList, List<PermissionStreamNew> permissionStreamList) {
+ Map<String, WorkStepPermission> workStepPermissionHashMap = new HashMap<>();
+ Map<String, WorkStep> workStepHashMap = new HashMap<>();
+ String key;
+ for (WorkStep w : workStepService.listByIds(workStepIds)) {
+ workStepHashMap.put(w.getId(), w);
+ for (SysUser u : userList) {
+ key = w.getId() + "," + u.getId();
+ workStepPermissionHashMap.put(key, new WorkStepPermission(w.getId(), u.getId()));
+ }
+ }
+ List<WorkStepPermission> workStepPermissions = iWorkStepPermissionService.getByStepIdsAndUserIds(workStepIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
+ if (workStepPermissions != null && !workStepPermissions.isEmpty()) {
+ for (WorkStepPermission workStepPermission : workStepPermissions) {
+ key = workStepPermission.getStepId() + "," + workStepPermission.getUserId();
+ workStepPermissionHashMap.remove(key);
+ }
+ }
+ for (Map.Entry<String, WorkStepPermission> entry : workStepPermissionHashMap.entrySet()) {
+ WorkStepPermission ws = entry.getValue();
+ workStepPermissionList.add(ws);
+ WorkStep workStep = workStepHashMap.get(ws.getStepId());
+ PermissionStreamNew s = new PermissionStreamNew();
+ s.setBusinessId(workStep.getId());
+ s.setBusinessType(DocAttributionTypeEnum.WORKSITE.getCode().toString());
+ s.setUserId(ws.getUserId());
+ permissionStreamList.add(s);
+ }
+ }
+
+ /**
+ * 娣诲姞鏉冮檺
+ */
+
+ private boolean handleWorkStep(String paramId, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
+ WorkStep workStep = workStepService.getById(paramId);
+ if (workStep == null) {
+ ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
+ }
+ boolean hasPerm = checkProductPerm(6, workStep.getId());
+ if (!hasPerm) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (userList!=null){
+ return workStepService.assignAddUser(workStep, userList);
+ }else {
+ return workStepService.assignAddDepart(workStep, mdcProductionList);
+ }
+ }
+
+ private boolean handleProcessStream(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
+ ProcessStream processStream = processStreamService.getById(paramId);
+ if (processStream == null) {
+ ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
+ }
+ boolean hasPerm = checkProductPerm(5, processStream.getProcessId());
+ if (!hasPerm) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ boolean result;
+ if (userList!=null){
+ boolean processResult = processStreamService.assignAddUser(processStream, userList);
+ if (!processResult) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelativePermissions(processStream.getProductId(), null, processStream.getProcessId(), null,null, userList);
+ }
+ }else {
+ result = processStreamService.assignAddDepart(processStream, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelatedPermissions(processStream, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
+ }
+ }
+ return true;
+ }
+
+ private boolean handleProcessSpecVersion(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
+ ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
+ if (processSpecVersion == null) {
+ ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
+ }
+ boolean hasPerm = checkProductPerm(4, processSpecVersion.getId());
+ if (!hasPerm) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ boolean result;
+ if (userList!=null){
+ result = processSpecVersionService.assignAddUser(processSpecVersion, userList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelativePermissions(processSpecVersion.getProductId(), null, null,null, processSpecVersion.getId(), userList);
+ }
+ }else {
+ result = processSpecVersionService.assignAddDepart(processSpecVersion, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelatedPermissionsForProcessSpecVersion(processSpecVersion, mdcProductionList);
+ }
+ }
+ return true;
+ }
+
+ private boolean handlePartsInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
+ PartsInfo partsInfo = partsInfoService.getById(paramId);
+ if (partsInfo == null) {
+ ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
+ }
+ boolean hasPerm = checkProductPerm(3, partsInfo.getPartsId());
+ if (!hasPerm) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ boolean result;
+ if (userList!=null){
+ result = partsInfoService.assignAddUser(partsInfo, userList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelativePermissions(partsInfo.getProductId(), null, null, partsInfo.getPartsId(),null, userList);
+ }
+ }else {
+ result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
+ }
+ }
+ return true;
+ }
+
+ private boolean handleProductInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
+ ProductInfo productInfo = super.getById(paramId);
+ if (productInfo == null) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
+ }
+ boolean hasPerm = checkProductPerm(1, productInfo.getProductId());
+ if (!hasPerm) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ boolean result;
+ if (userList!=null){
+ result = this.assignAddUser(productInfo, userList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
+ if (componentInfoList != null && !componentInfoList.isEmpty()) {
+ List<String> componentIds = componentInfoList.stream()
+ .map(ComponentInfo::getComponentId)
+ .collect(Collectors.toList());
+ handleRelativePermissions(productInfo.getProductId(), componentIds, null, null, null,userList);
+ }
+ }
+ }else {
+ result = this.assignAddDepartment(productInfo, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelatedPermissionsForProduct(productInfo, mdcProductionList);
+ }
+ }
+ return true;
+ }
+
+ private boolean handleComponentInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
+ ComponentInfo componentInfo = componentInfoService.getById(paramId);
+ if (componentInfo == null) {
+ ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
+ }
+ boolean hasPerm = checkProductPerm(2, componentInfo.getComponentId());
+ if (!hasPerm) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ boolean result;
+ if (userList!=null){
+ result = componentInfoService.assignAddUser(componentInfo, userList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
+ List<String> componentIds = new ArrayList<>();
+ if (childrenList != null && !childrenList.isEmpty()) {
+ componentIds = childrenList.stream()
+ .map(ComponentInfo::getComponentId)
+ .collect(Collectors.toList());
+ }
+ componentIds.add(componentInfo.getComponentId());
+
+
+ handleRelativePermissions(componentInfo.getProductId(), componentIds, null, null,null, userList);
+ }
+ }else {
+ result = componentInfoService.assignAddDepart(componentInfo, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelatedPermissionsForComponent(componentInfo, mdcProductionList);
+ }
+ }
+ return true;
+ }
+
+ private void handleRelatedPermissions(Object parentEntity, Collection<MdcProduction> mdcProductionList, IWorkStepService workStepService,
+ IWorkStepDepartmentService workStepDepartmentService, IPermissionStreamNewService permissionStreamNewService) {
+ String parentId = getParentId(parentEntity);
+ List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", parentId));
+ if (workStepList == null || workStepList.isEmpty()) {
+ return;
+ }
+ Map<String, WorkStepDepartment> allPermissions = new HashMap<>();
+ Map<String, WorkStep> workStepMap = new HashMap<>();
+ for (WorkStep workStep : workStepList) {
+ workStepMap.put(workStep.getId(), workStep);
+ for (MdcProduction mdcProduction : mdcProductionList) {
+ String key = workStep.getId() + "," + mdcProduction.getId();
+ WorkStepDepartment wsDep = new WorkStepDepartment(workStep.getId(), mdcProduction.getId());
+ allPermissions.put(key, wsDep);
+ }
+ }
+
+ List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
+ List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
+ List<WorkStepDepartment> existingPermissions = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIds);
+ if (existingPermissions != null && !existingPermissions.isEmpty()) {
+ for (WorkStepDepartment existing : existingPermissions) {
+ String key = existing.getStepId() + "," + existing.getDepartId();
+ allPermissions.remove(key);
+ }
+ }
+
+ List<WorkStepDepartment> newWorkStepDepartments = new ArrayList<>();
+ List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
+ for (Map.Entry<String, WorkStepDepartment> entry : allPermissions.entrySet()) {
+ WorkStepDepartment wsDep = entry.getValue();
+ newWorkStepDepartments.add(wsDep);
+ WorkStep workStep = workStepMap.get(wsDep.getStepId());
+ PermissionStreamNew permStream = new PermissionStreamNew();
+ permStream.setBusinessId(workStep.getId());
+ permStream.setBusinessType(DocAttributionTypeEnum.WORKSITE.getCode().toString());
+ permStream.setDepartId(wsDep.getDepartId());
+ newPermissionStreams.add(permStream);
+ }
+ if (!newWorkStepDepartments.isEmpty()) {
+ workStepDepartmentService.saveBatch(newWorkStepDepartments);
+ }
+ if (!newPermissionStreams.isEmpty()) {
+ permissionStreamNewService.saveBatch(newPermissionStreams);
+ }
+ }
+
+ private void handleRelatedPermissionsForParts(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
+ // 澶勭悊宸ヨ壓瑙勭▼鐗堟湰
+ List<ProcessSpecVersion> processSpecVersionList = processSpecVersionService.list(new QueryWrapper<ProcessSpecVersion>().eq("parts_id", partsInfo.getPartsId()));
+ processSpecVersionList.forEach(item->{
+ processSpecVersionService.assignAddDepart(item, mdcProductionList);
+ handleRelatedPermissionsForProcessSpecVersion(item, mdcProductionList);
+ });
+ }
+
+ private void handleRelatedPermissionsForProcessSpecVersion(ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
+ // 澶勭悊宸ュ簭鏉冮檺
+ handleProcessPermissions(processSpecVersion,null, mdcProductionList);
+ // 澶勭悊宸ユ鏉冮檺
+ handleWorkStepPermissions(processSpecVersion, mdcProductionList);
+
+ }
+
+ private void handleProcessPermissions(ProcessSpecVersion processSpecVersion,ComponentInfo componentInfo,Collection<MdcProduction> mdcProductionList) {
+ List<ProcessStream> processStreamList=new ArrayList<>();
+ if (componentInfo != null) {
+ processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
+ }else {
+ processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
+ }
+ if (processStreamList == null || processStreamList.isEmpty()) {
+ return;
+ }
+ processStreamList.forEach(item->{
+ handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
+ });
+ Map<String, ProcessionDepartment> allProcessPermissions = new HashMap<>();
+ Map<String, ProcessStream> processStreamMap = new HashMap<>();
+ for (ProcessStream processStream : processStreamList) {
+ processStreamMap.put(processStream.getProcessId(), processStream);
+ for (MdcProduction mdcProduction : mdcProductionList) {
+ String key = processStream.getProcessId() + "," + mdcProduction.getId();
+ ProcessionDepartment procDep = new ProcessionDepartment(processStream.getProcessId(), mdcProduction.getId());
+ allProcessPermissions.put(key, procDep);
+ }
+ }
+
+ List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
+ List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
+ List<ProcessionDepartment> existingProcessPermissions = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIds);
+ if (existingProcessPermissions != null && !existingProcessPermissions.isEmpty()) {
+ for (ProcessionDepartment existing : existingProcessPermissions) {
+ String key = existing.getProcessId() + "," + existing.getDepartId();
+ allProcessPermissions.remove(key);
+ }
+ }
+
+ List<ProcessionDepartment> newProcessPermissions = new ArrayList<>();
+ List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
+ for (Map.Entry<String, ProcessionDepartment> entry : allProcessPermissions.entrySet()) {
+ ProcessionDepartment procDep = entry.getValue();
+ newProcessPermissions.add(procDep);
+ ProcessStream processStream = processStreamMap.get(procDep.getProcessId());
+ PermissionStreamNew permStream = new PermissionStreamNew();
+ permStream.setBusinessId(processStream.getProcessId());
+ permStream.setBusinessType(DocAttributionTypeEnum.PROCESS.getCode().toString());
+ permStream.setDepartId(procDep.getDepartId());
+ newPermissionStreams.add(permStream);
+ }
+
+ if (!newProcessPermissions.isEmpty()) {
+ processionDepartmentService.saveBatch(newProcessPermissions);
+ }
+ if (!newPermissionStreams.isEmpty()) {
+ permissionStreamNewService.saveBatch(newPermissionStreams);
+ }
+ }
+
+ private void handleWorkStepPermissions(ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
+ List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
+ if (processStreamList == null || processStreamList.isEmpty()) {
+ return;
+ }
+ List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
+ List<WorkStep> workStepList = workStepService.getByProcessIds(processSpecVersion.getProductId(), processIds);
+ if (workStepList == null || workStepList.isEmpty()) {
+ return;
+ }
+ workStepList.forEach(item->{
+ handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
+ });
+ }
+
+ private void handleRelatedPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
+ // 澶勭悊缁勪欢鏉冮檺
+ handleComponentPermissionsForProduct(productInfo, mdcProductionList);
+ // 澶勭悊闆朵欢鏉冮檺
+ handlePartsPermissionsForProduct(productInfo, mdcProductionList);
+ List<ComponentInfo> componentInfoList=componentInfoService.list(new QueryWrapper<ComponentInfo>().eq("product_id", productInfo.getProductId()));
+ componentInfoList.forEach(item->{
+ handleProcessPermissions(null,item, mdcProductionList);
+ });
+ }
+
+ private void handleComponentPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
+ List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
+ if (componentInfoList == null || componentInfoList.isEmpty()) {
+ return;
+ }
+ Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>();
+ Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
+ for (ComponentInfo componentInfo : componentInfoList) {
+ componentInfoMap.put(componentInfo.getComponentId(), componentInfo);
+ for (MdcProduction mdcProduction : mdcProductionList) {
+ String key = componentInfo.getComponentId() + "," + mdcProduction.getId();
+ ComponentDepartment compDep = new ComponentDepartment(componentInfo.getComponentId(), mdcProduction.getId());
+ allComponentPermissions.put(key, compDep);
+ }
+ }
+
+ List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
+ List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
+ List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds);
+ if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) {
+ for (ComponentDepartment existing : existingComponentPermissions) {
+ String key = existing.getComponentId() + "," + existing.getDepartId();
+ allComponentPermissions.remove(key);
+ }
+ }
+
+ List<ComponentDepartment> newComponentPermissions = new ArrayList<>();
+ List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
+ for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
+ ComponentDepartment compDep = entry.getValue();
+ newComponentPermissions.add(compDep);
+ ComponentInfo componentInfo = componentInfoMap.get(compDep.getComponentId());
+ PermissionStreamNew permStream = new PermissionStreamNew();
+ permStream.setBusinessId(componentInfo.getComponentId());
+ permStream.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
+ permStream.setDepartId(compDep.getDepartId());
+ newPermissionStreams.add(permStream);
+ }
+
+ if (!newComponentPermissions.isEmpty()) {
+ componentDepartmentService.saveBatch(newComponentPermissions);
+ }
+ if (!newPermissionStreams.isEmpty()) {
+ permissionStreamNewService.saveBatch(newPermissionStreams);
+ }
+ }
+
+ private void handlePartsPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
+ List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
+ if (componentInfoList == null || componentInfoList.isEmpty()) {
+ return;
+ }
+ List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
+ List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
+ if (partsInfoList == null || partsInfoList.isEmpty()) {
+ return;
+ }
+ for (PartsInfo partsInfo : partsInfoList) {
+ boolean result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
+ }
+ }
+
+ private void handleRelatedPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
+ // 澶勭悊瀛愮粍浠舵潈闄�
+ handleChildComponentPermissions(componentInfo, mdcProductionList);
+ // 澶勭悊闆朵欢鏉冮檺
+ handlePartsPermissionsForComponent(componentInfo, mdcProductionList);
+ // 澶勭悊宸ュ簭鏉冮檺
+ handleProcessPermissions(null,componentInfo, mdcProductionList);
+ }
+
+ private void handleChildComponentPermissions(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
+ List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
+ if (childrenList == null || childrenList.isEmpty()) {
+ return;
+ }
+ Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>();
+ Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
+ for (ComponentInfo childComponent : childrenList) {
+ componentInfoMap.put(childComponent.getComponentId(), childComponent);
+ for (MdcProduction mdcProduction : mdcProductionList) {
+ String key = childComponent.getComponentId() + "," + mdcProduction.getId();
+ ComponentDepartment compDep = new ComponentDepartment(childComponent.getComponentId(), mdcProduction.getId());
+ allComponentPermissions.put(key, compDep);
+ }
+
+ List<String> componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
+ List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
+ List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds);
+ if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) {
+ for (ComponentDepartment existing : existingComponentPermissions) {
+ String key = existing.getComponentId() + "," + existing.getDepartId();
+ allComponentPermissions.remove(key);
+ }
+ }
+
+ List<ComponentDepartment> newComponentPermissions = new ArrayList<>();
+ List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
+ for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
+ ComponentDepartment compDep = entry.getValue();
+ newComponentPermissions.add(compDep);
+ childComponent = componentInfoMap.get(compDep.getComponentId());
+ PermissionStreamNew permStream = new PermissionStreamNew();
+ permStream.setBusinessId(childComponent.getComponentId());
+ permStream.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
+ permStream.setDepartId(compDep.getDepartId());
+ newPermissionStreams.add(permStream);
+ }
+
+ if (!newComponentPermissions.isEmpty()) {
+ componentDepartmentService.saveBatch(newComponentPermissions);
+ }
+ if (!newPermissionStreams.isEmpty()) {
+ permissionStreamNewService.saveBatch(newPermissionStreams);
+ }
+ }
+ }
+
+ private void handlePartsPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
+ List<PartsInfo> partsInfoList = partsInfoService.getByComponentId(componentInfo.getProductId(),componentInfo.getComponentId());
+ if (partsInfoList == null || partsInfoList.isEmpty()) {
+ return;
+ }
+ for (PartsInfo partsInfo : partsInfoList) {
+ partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
+ handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
+ }
+ }
+
+ private String getParentId(Object parentEntity) {
+ if (parentEntity instanceof ProcessStream) {
+ return ((ProcessStream) parentEntity).getProcessId();
+ } else if (parentEntity instanceof WorkStep) {
+ return ((WorkStep) parentEntity).getProcessId();
+ }
+ return null;
+ }
+
+
+ /**绉婚櫎鏉冮檺*/
+
+ private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+ ProductInfo productInfo = super.getById(paramId);
+ if (productInfo == null) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
+ }
+ checkProductPerm(1, productInfo.getProductId());
+ boolean result;
+ if (userList!=null){
+ result =this.assignRemoveUser(productInfo, userList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleProductRelatedRemovals(productInfo, userList);
+ }
+ }else {
+ result = this.assignRemoveDepartment(productInfo, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleProductRelatedDepartmentRemovals(productInfo, mdcProductionList);
+ }
+ }
+ return true;
+ }
+
+ private boolean handleComponentInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+ ComponentInfo componentInfo = componentInfoService.getById(paramId);
+ if (componentInfo == null) {
+ ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
+ }
+ checkProductPerm(2, componentInfo.getComponentId());
+ boolean result;
+ if (userList!=null){
+ result =componentInfoService.assignRemoveUser(componentInfo, userList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleComponentRelatedRemovals(componentInfo, userList,null);
+ }
+ }else {
+ result = componentInfoService.assignRemoveDepart(componentInfo, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleComponentRelatedRemovals(componentInfo,null,mdcProductionList);
+ }
+ }
+ return true;
+ }
+
+ private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+ PartsInfo partsInfo = partsInfoService.getById(paramId);
+ if (partsInfo == null) {
+ ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
+ }
+ checkProductPerm(3, partsInfo.getPartsId());
+ boolean result;
+ if (userList!=null){
+ result = partsInfoService.assignRemoveUser(partsInfo, userList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handlePartRelatedRemovals(partsInfo, userList);
+ }
+ }else {
+ result = partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handlePartRelatedDepartmentRemovals(partsInfo, mdcProductionList);
+ }
+ }
+ return true;
+ }
+
+ private boolean handleProcessSpecVersionRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+ ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
+ if (processSpecVersion == null) {
+ ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
+ }
+ checkProductPerm(4, processSpecVersion.getPartsId());
+ boolean result;
+ if (userList!=null){
+ result = processSpecVersionService.assignRemoveUser(processSpecVersion, userList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleProcessSpecVersionRelatedRemovals(null,processSpecVersion, userList);
+ }
+ }else {
+ result = processSpecVersionService.assignRemoveDepart(processSpecVersion, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleProcessSpecVersionRelatedDepartmentRemovals(null,processSpecVersion, mdcProductionList);
+ }
+ }
+ return true;
+ }
+
+ private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+ ProcessStream processStream = processStreamService.getById(paramId);
+ if (processStream == null) {
+ ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
+ }
+ checkProductPerm(5, processStream.getProcessId());
+ boolean result;
+ if (userList!=null){
+ result = processStreamService.assignRemoveUser(processStream, userList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelatedRemovals(processStream.getProcessId(), userList,
+ workStepService, iWorkStepPermissionService, permissionStreamNewService,
+ "process_id");
+ }
+ }else {
+ result = processStreamService.assignRemoveDepart(processStream, mdcProductionList);
+ if (!result) {
+ ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
+ }
+ if (relativeFlag == 1) {
+ handleRelatedDepartmentRemovals(processStream.getProcessId(), mdcProductionList,
+ workStepService, workStepDepartmentService, permissionStreamNewService,
+ "process_id");
+ }
+ }
+ return true;
+ }
+
+ private boolean handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+ WorkStep workStep = workStepService.getById(paramId);
+ if (workStep == null) {
+ ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
+ }
+ checkProductPerm(6, workStep.getId());
+ if (userList!=null){
+ return workStepService.assignRemoveUser(workStep, userList);
+ }else {
+ return workStepService.assignRemoveDepart(workStep, mdcProductionList);
+ }
+ }
+
+ private void handleRelatedRemovals(String parentId, Collection<SysUser> userList,
+ IWorkStepService workStepService,
+ IWorkStepPermissionService workStepPermissionService,
+ IPermissionStreamNewService permissionStreamNewService,
+ String queryField) {
+ List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
+ if (workStepList.isEmpty()) {
+ return;
+ }
+ List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
+ List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
+ List<WorkStepPermission> workStepPermissions = workStepPermissionService.getByStepIdsAndUserIds(workStepIds, userIdList);
+ List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(workStepIds, userIdList,"6");
+
+ if (!workStepPermissions.isEmpty()) {
+ workStepPermissionService.removeByCollection(workStepPermissions);
+ }
+ if (!permissionStreams.isEmpty()) {
+ permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+ }
+ }
+
+ private void handleRelatedDepartmentRemovals(String parentId, Collection<MdcProduction> mdcProductionList,
+ IWorkStepService workStepService,
+ IWorkStepDepartmentService workStepDepartmentService,
+ IPermissionStreamNewService permissionStreamNewService,
+ String queryField) {
+ List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
+ if (workStepList.isEmpty()) {
+ return;
+ }
+ List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
+ List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
+ List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIdList);
+ List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(workStepIds, departmentIdList,"6");
+
+ if (!workStepDepartments.isEmpty()) {
+ workStepDepartmentService.removeByCollection(workStepDepartments);
+ }
+ if (!permissionStreams.isEmpty()) {
+ permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+ }
+ }
+
+ private void handleProcessSpecVersionRelatedRemovals(ComponentInfo componentInfo,ProcessSpecVersion processSpecVersion,Collection<SysUser> userList) {
+ List<ProcessStream> processStreamList =new ArrayList<>();
+ String productId="";
+ if (processSpecVersion!=null){
+ processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
+ productId=processSpecVersion.getProductId();
+ }else {
+ processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()).isNull("parts_id"));
+ productId=componentInfo.getProductId();
+ }
+ List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
+ handleProcessRemovals(processIds, userList);
+ handleWorkStepRemovals(productId, processIds, userList);
+ }
+
+ private void handleProcessRemovals(List<String> processIds, Collection<SysUser> userList) {
+ if (processIds.isEmpty()) {
+ return;
+ }
+ List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
+ List<ProcessionPermission> processionPermissions = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userIdList);
+ List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(processIds, userIdList,"5");
+
+ if (!processionPermissions.isEmpty()) {
+ iProcessStreamPermissionService.removeByCollection(processionPermissions);
+ }
+ if (!permissionStreams.isEmpty()) {
+ permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+ }
+ }
+
+ private void handleProcessDepartmentRemovals(List<String> processIds, Collection<MdcProduction> mdcProductionList) {
+ if (processIds.isEmpty()) {
+ return;
+ }
+ List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
+ List<ProcessionDepartment> processionDepartments = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIdList);
+ List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(processIds, departmentIdList,"5");
+
+ if (!processionDepartments.isEmpty()) {
+ processionDepartmentService.removeByCollection(processionDepartments);
+ }
+ if (!permissionStreams.isEmpty()) {
+ permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+ }
+ }
+
+ private void handleWorkStepRemovals(String productId, List<String> processIds, Collection<SysUser> userList) {
+ List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
+ if (workStepList!=null){
+ workStepList.forEach(item->{
+ handleRelatedRemovals(item.getProcessId(), userList, workStepService, iWorkStepPermissionService, permissionStreamNewService, "process_id");
+ });
+ }
+ }
+
+ private void handleWorkStepDepartmentRemovals(String productId, List<String> processIds, Collection<MdcProduction> mdcProductionList) {
+ List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
+ if (workStepList!=null){
+ workStepList.forEach(item->{
+ handleRelatedDepartmentRemovals(item.getProcessId(), mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService, "process_id");
+ });
+ }
+ }
+
+ private void handleProductRelatedRemovals(ProductInfo productInfo, Collection<SysUser> userList) {
+ List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
+ List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
+ handleComponentRemovals(componentIds, userList);
+ handlePartsRemovals(productInfo.getProductId(), componentIds, userList);
+ componentInfoList.forEach(item->{
+ handleProcessSpecVersionRelatedRemovals(item,null, userList);
+ });
+ }
+
+ private void handlePartRelatedRemovals(PartsInfo partsInfo, Collection<SysUser> userList) {
+ List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByPartsId(partsInfo.getPartsId());
+ if (processSpecVersions!=null){
+ List<String> psvIds = processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
+ handleProcessSpecVersionRemovals(psvIds, userList);
+ processSpecVersions.forEach(item->{
+ handleProcessSpecVersionRelatedRemovals(null,item, userList);
+ });
+ }
+ }
+
+ private void handlePartRelatedDepartmentRemovals(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
+ List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByPartsId(partsInfo.getPartsId());
+ if (processSpecVersions!=null){
+ List<String> psvIds = processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
+ handleProcessSpecVersionDepartmentRemovals(psvIds, mdcProductionList);
+ processSpecVersions.forEach(item->{
+ handleProcessSpecVersionRelatedDepartmentRemovals(null,item, mdcProductionList);
+ });
+ }
+ }
+
+ private void handleProductRelatedDepartmentRemovals(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
+ List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
+ List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
+ handleComponentDepartmentRemovals(componentIds, mdcProductionList);
+ handlePartsDepartmentRemovals(productInfo.getProductId(), componentIds, mdcProductionList);
+ componentInfoList.forEach(item->{
+ handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
+ });
+ }
+
+ private void handleComponentRemovals(List<String> componentIds, Collection<SysUser> userList) {
+ if (componentIds.isEmpty()) {
+ return;
+ }
+ List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
+ List<ComponentPermission> componentPermissions = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userIdList);
+ List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(componentIds, userIdList,"2");
+
+ if (!componentPermissions.isEmpty()) {
+ componentPermissionService.removeByCollection(componentPermissions);
+ }
+ if (!permissionStreams.isEmpty()) {
+ permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+ }
+ }
+
+ private void handleProcessSpecVersionRemovals(List<String> psvIds, Collection<SysUser> userList) {
+ if (psvIds.isEmpty()) {
+ return;
+ }
+ List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
+ List<ProcessSpecVersionPermission> processSpecVersionPermissions = processSpecVersionPermissionService.getByPsvIdsAndUserIds(psvIds, userIdList);
+ List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(psvIds, userIdList,"4");
+ if (!processSpecVersionPermissions.isEmpty()) {
+ processSpecVersionPermissionService.removeByCollection(processSpecVersionPermissions);
+ }
+ if (!permissionStreams.isEmpty()) {
+ permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+ }
+ }
+
+ private void handleProcessSpecVersionDepartmentRemovals(List<String> psvIds, Collection<MdcProduction> mdcProductionList) {
+ if (psvIds.isEmpty()) {
+ return;
+ }
+ List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
+ List<ProcessSpecVersionDepartment> processSpecVersionDepartments =processSpecVersionDepartmentService.getByPsvIdsAndDepartIds(psvIds, departmentIdList);
+ List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(psvIds, departmentIdList,"4");
+ if (!processSpecVersionDepartments.isEmpty()) {
+ processSpecVersionDepartmentService.removeByCollection(processSpecVersionDepartments);
+ }
+ if (!permissionStreams.isEmpty()) {
+ permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+ }
+ }
+
+
+ private void handleComponentDepartmentRemovals(List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
+ if (componentIds.isEmpty()) {
+ return;
+ }
+ List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
+ List<ComponentDepartment> componentDepartments = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIdList);
+ List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(componentIds, departmentIdList,"2");
+
+ if (!componentDepartments.isEmpty()) {
+ componentDepartmentService.removeByCollection(componentDepartments);
+ }
+ if (!permissionStreams.isEmpty()) {
+ permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
+ }
+ }
+
+ private void handlePartsRemovals(String productId, List<String> componentIds,Collection<SysUser> userList) {
+ List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
+ if (partsInfoList!=null){
+ partsInfoList.forEach(item->{
+ partsInfoService.assignRemoveUser(item,userList);
+ //鍒犻櫎
+ handlePartRelatedRemovals(item, userList);
+ });
+ }
+ }
+ private void handlePartsDepartmentRemovals(String productId, List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
+ List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
+ if (partsInfoList!=null) {
+ partsInfoList.forEach(item->{
+ partsInfoService.assignRemoveDepart(item,mdcProductionList);
+ handlePartRelatedDepartmentRemovals(item, mdcProductionList);
+ });
+ }
+ }
+
+ private void handleComponentRelatedRemovals(ComponentInfo componentInfo, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
+ List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
+ List<String> componentIds = new ArrayList<>();
+ if (childrenList != null) {
+ componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
+ }
+ componentIds.add(componentInfo.getComponentId());
+ if (mdcProductionList!=null){
+ handleComponentDepartmentRemovals(componentIds, mdcProductionList);
+ handlePartsDepartmentRemovals(componentInfo.getProductId(), componentIds, mdcProductionList);
+ if (childrenList != null) {
+ childrenList.forEach(item->{
+ handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
+ });
+ }
+ }else {
+ handleComponentRemovals(componentIds, userList);
+ handlePartsRemovals(componentInfo.getProductId(), componentIds, userList);
+ if (childrenList != null) {
+ childrenList.forEach(item->{
+ handleProcessSpecVersionRelatedRemovals(item,null, userList);
+ });
+ }
+ }
+ }
+
+ private void handleProcessSpecVersionRelatedDepartmentRemovals(ComponentInfo componentInfo,ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
+ List<ProcessStream> processStreamList=new ArrayList<>();
+ String productId="";
+ if (componentInfo!=null){
+ processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
+ productId=componentInfo.getProductId();
+ }else {
+ processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
+ productId=processSpecVersion.getProductId();
+ }
+ List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
+ handleProcessDepartmentRemovals(processIds, mdcProductionList);
+ handleWorkStepDepartmentRemovals(productId, processIds, mdcProductionList);
+ }
+
+}
--
Gitblit v1.9.3