package org.jeecg.modules.dnc.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.shiro.SecurityUtils;
|
import org.jeecg.common.system.vo.LoginUser;
|
import org.jeecg.modules.dnc.dto.ComponentExt;
|
import org.jeecg.modules.dnc.entity.*;
|
import org.jeecg.modules.dnc.exception.ExceptionCast;
|
import org.jeecg.modules.dnc.mapper.ProductInfoMapper;
|
import org.jeecg.modules.dnc.response.*;
|
import org.jeecg.modules.dnc.service.*;
|
import org.jeecg.modules.dnc.service.support.ProductTreeWrapper;
|
import org.jeecg.modules.dnc.ucenter.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;
|
|
@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()),0,productInfo.getProductName(),productInfo.getProductNo(),"1");
|
productMixService.save(productMix);
|
//添加用户权限
|
PermissionStreamNew stream = new PermissionStreamNew();
|
stream.setBusinessId(productInfo.getProductId());
|
stream.setUserId(userId);
|
stream.setBusinessType("1");
|
return permissionStreamNewService.save(stream);
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean editProductInfo(String id, ProductInfo productInfo) {
|
if (!ValidateUtil.validateString(id) || productInfo == null)
|
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);
|
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, "1");
|
if (stream == null) {
|
stream = new PermissionStreamNew();
|
stream.setBusinessId(productInfo.getProductId());
|
stream.setUserId(userId);
|
stream.setBusinessType("1");
|
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", "1").eq("attribution_id", id));
|
if (!docRelativeList.isEmpty()) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_DOC_EXIST);
|
}
|
if (!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = productDepartmentService.deleteByProductId(id);
|
if (!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, "1","0");
|
if (!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = permissionStreamNewService.deletePermissionStreamNewByBusinessId(id, "1","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 == 1) {
|
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 == 2) {
|
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 == 3) {
|
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 == 4) {
|
ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
|
if (processSpecVersion == null)
|
ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
|
PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processSpecVersion.getId(),userId,"4");
|
return permission != null;
|
} else if (nodeType == 5) {
|
ProcessStream processStream = processStreamService.getById(paramId);
|
if (processStream == null)
|
ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
|
PermissionStreamNew permission = permissionStreamNewService.loadPermissionStreamNewByBusinessIdAndUserId(processStream.getProcessId(), userId,"5");
|
return permission != null;
|
} else if (nodeType == 6) {
|
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 == 1) {
|
return productPermissionService.getUserPermsByProductId(paramId);
|
} else if (nodeType == 2) {
|
return componentPermissionService.getUserPermsByComponentId(paramId);
|
} else if (nodeType == 3) {
|
return partsPermissionService.getUserPermsByProductId(paramId);
|
} else if (nodeType == 4) {
|
return processSpecVersionPermissionService.getUserPermsByProductId(paramId);
|
} else if (nodeType == 5) {
|
return iProcessStreamPermissionService.getUserPermsByProductId(paramId);
|
} else if (nodeType == 6) {
|
return iWorkStepPermissionService.getUserPermsByProductId(paramId);
|
} else {
|
return null;
|
}
|
}
|
|
@Override
|
public List<SysUser> getUserNonPermsList(Integer nodeType, String paramId) {
|
if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
|
return null;
|
if (nodeType == 1) {
|
return productPermissionService.getUserNonPermsByProductId(paramId);
|
} else if (nodeType == 2) {
|
return componentPermissionService.getUserNonPermsByComponentId(paramId);
|
} else if (nodeType == 3) {
|
return partsPermissionService.getUserNonPermsByProductId(paramId);
|
} else if (nodeType == 4) {
|
return processSpecVersionPermissionService.getUserNonPermsByProductId(paramId);
|
} else if (nodeType == 5) {
|
return iProcessStreamPermissionService.getUserNonPermsByProductId(paramId);
|
} else if (nodeType == 6) {
|
return iWorkStepPermissionService.getUserNonPermsByProductId(paramId);
|
} else {
|
return null;
|
}
|
}
|
|
@Override
|
public List<MdcProduction> getDepartPermsList(Integer nodeType, String paramId) {
|
if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
|
return null;
|
if (nodeType == 1) {
|
return productDepartmentService.getDepartPermsByProductId(paramId);
|
} else if (nodeType == 2) {
|
return componentDepartmentService.getDepartPermsByComponentId(paramId);
|
} else if (nodeType == 3) {
|
return partsDepartmentService.getDepartPermsByPartsId(paramId);
|
} else if (nodeType == 4) {
|
return processSpecVersionDepartmentService.getDepartPermsByPsvId(paramId);
|
}else if (nodeType == 5) {
|
return processionDepartmentService.getDepartPermsByProcessId(paramId);
|
} else if (nodeType == 6) {
|
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 == 1) {
|
return productDepartmentService.getDepartNonPermsByProductId(paramId);
|
} else if (nodeType == 2) {
|
return componentDepartmentService.getDepartNonPermsByComponentId(paramId);
|
} else if (nodeType == 3) {
|
return partsDepartmentService.getDepartNonPermsByProductId(paramId);
|
} else if (nodeType == 4) {
|
return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
|
} else if (nodeType == 5) {
|
return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
|
} else if (nodeType == 6) {
|
return workStepDepartmentService.getDepartNonPermsByStepId(paramId);
|
} else {
|
return null;
|
}
|
}
|
|
/**
|
* @param nodeType 1 产品 2 部件 3 零件
|
* @param paramId 产品树节点id
|
* @param relativeFlag 1 是 2 否
|
* @param userIds 添加用户ids
|
* @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 产品树节点id
|
* @param relativeFlag 1 是 2 否
|
* @param departmentIds 添加部门ids
|
* @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 产品树节点id
|
* @param relativeFlag 1 是 2 否
|
* @param userIds 移除用户ids
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean assignRemoveUserAll(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
|
validateInputParameters(nodeType, paramId, relativeFlag, "1", userIds);
|
List<String> userIdsList = Arrays.asList(userIds);
|
Collection<SysUser> userList = userService.listByIds(userIdsList);
|
validateSysUserList(userList, userIdsList);
|
switch (nodeType) {
|
case 1:
|
return handleProductInfoRemoval(paramId, relativeFlag, userList,null);
|
case 2:
|
return handleComponentInfoRemoval(paramId, relativeFlag, userList,null);
|
case 3:
|
return handlePartsInfoRemoval(paramId, relativeFlag, userList,null);
|
case 4:
|
return handleProcessSpecVersionRemoval(paramId, relativeFlag, userList,null);
|
case 5:
|
return handleProcessStreamRemoval(paramId, relativeFlag, userList,null);
|
case 6:
|
return handleWorkStepRemoval(paramId, userList,null);
|
default:
|
return false;
|
}
|
}
|
|
|
/**
|
*
|
* @param nodeType 1 产品 2 部件 3 零件 5 工序 6 工步
|
* @param paramId 产品树节点id
|
* @param relativeFlag 1 是 2 否
|
* @param departmentIds 移除部门ids
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean 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("1");
|
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("1");
|
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 (nodeType == 5) {
|
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 (nodeType == 6) {
|
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 (nodeType == 1) {
|
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(2);
|
node.setRField(c.getProductId());
|
node.setEntity(c);
|
list.add(node);
|
}
|
return list;
|
} else if (nodeType == 2) {
|
List<ComponentInfo> componentInfoList = componentInfoService.getByParentIdAndUserId(paramId, userId);
|
List<CommonGenericTree> list = new ArrayList<>();
|
CommonGenericTree<ComponentInfo> componentNode;
|
if (componentInfoList != null && !componentInfoList.isEmpty()) {
|
for (ComponentInfo c : componentInfoList) {
|
componentNode = new CommonGenericTree();
|
componentNode.setId(c.getComponentId());
|
// componentNode.setLabel("[" + c.getComponentCode()+ "]" + c.getComponentName());
|
componentNode.setLabel(c.getComponentName());
|
componentNode.setParentId(c.getParentId());
|
componentNode.setIconClass("");
|
componentNode.setType(2);
|
componentNode.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(3);
|
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添加了新的部件id={}", 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;
|
}
|
|
/**
|
* 验证输入参数
|
*/
|
private void validateInputParameters(Integer nodeType, String paramId, Integer relativeFlag, String type, String[] paramIds) {
|
if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
|
!ValidateUtil.validateInteger(relativeFlag)) {
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
}
|
if (paramIds == null || paramIds.length < 1) {
|
if (("1").equals(type)) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
|
} else {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_DEPART_PERM_NONE);
|
}
|
}
|
}
|
|
/**
|
* 验证 SysUser 列表
|
*/
|
private void validateSysUserList(Collection<SysUser> sysUserList, List<String> userIds) {
|
if (sysUserList == null || sysUserList.isEmpty() || sysUserList.size() != userIds.size()) {
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
}
|
}
|
|
/**
|
* 验证 MdcProduction 列表
|
*/
|
private void validateMdcProductionList(Collection<MdcProduction> mdcProductionList, List<String> departmentIds) {
|
if (mdcProductionList == null || mdcProductionList.isEmpty() || mdcProductionList.size() != departmentIds.size()) {
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
}
|
}
|
|
private void handleRelativePermissions(String productId, List<String> componentIds, String processId, String partsId,String psvId ,Collection<SysUser> userList) {
|
List<ComponentPermission> componentPermissionList = new ArrayList<>();
|
List<PartsPermission> partsPermissionList = new ArrayList<>();
|
List<ProcessSpecVersionPermission> processSpecVersionPermissionList = new ArrayList<>();
|
List<ProcessionPermission> processionPermissionList = new ArrayList<>();
|
List<WorkStepPermission> workStepPermissionList = new ArrayList<>();
|
List<PermissionStreamNew> permissionStreamList = new ArrayList<>();
|
// 处理部件权限
|
if (componentIds != null && !componentIds.isEmpty()) {
|
handleComponentPermissions(componentIds, userList, componentPermissionList, permissionStreamList);
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
|
if (partsInfoList != null && !partsInfoList.isEmpty()) {
|
List<String> partsIds = partsInfoList.stream()
|
.map(PartsInfo::getPartsId)
|
.collect(Collectors.toList());
|
handlePartsPermissions(partsIds, userList, partsPermissionList, permissionStreamList);
|
List<String> psvIds = processSpecVersionService.getByPartsIds(partsIds).stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
|
handlePsvPermissions(psvIds, userList, processSpecVersionPermissionList, permissionStreamList);
|
List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productId, componentIds, partsIds);
|
processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
|
}
|
}
|
|
// 处理零件权限
|
if (partsId != null) {
|
List<ProcessSpecVersion> processStreamList = processSpecVersionService.list(new QueryWrapper<ProcessSpecVersion>().eq("id", psvId));
|
if (processStreamList != null && !processStreamList.isEmpty()) {
|
List<String> psvIds = processStreamList.stream()
|
.map(ProcessSpecVersion::getId)
|
.collect(Collectors.toList());
|
handlePsvPermissions(psvIds,userList,processSpecVersionPermissionList,permissionStreamList);
|
}
|
}
|
|
// 处理工艺规程版本权限
|
if (psvId!= null) {
|
List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", psvId));
|
processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
|
}
|
|
// 处理工序权限
|
if (processId != null) {
|
List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", processId));
|
if (workStepList != null && !workStepList.isEmpty()) {
|
List<String> workStepIds = workStepList.stream()
|
.map(WorkStep::getId)
|
.collect(Collectors.toList());
|
handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList);
|
}
|
}
|
|
if (!componentPermissionList.isEmpty()) {
|
componentPermissionService.saveBatch(componentPermissionList);
|
}
|
if (!partsPermissionList.isEmpty()) {
|
partsPermissionService.saveBatch(partsPermissionList);
|
}
|
if (!processSpecVersionPermissionList.isEmpty()) {
|
processSpecVersionPermissionService.saveBatch(processSpecVersionPermissionList);
|
}
|
if (!processionPermissionList.isEmpty()) {
|
iProcessStreamPermissionService.saveBatch(processionPermissionList);
|
}
|
if (!workStepPermissionList.isEmpty()) {
|
iWorkStepPermissionService.saveBatch(workStepPermissionList);
|
}
|
if (!permissionStreamList.isEmpty()) {
|
permissionStreamNewService.saveBatch(permissionStreamList);
|
}
|
}
|
|
private void processStreamApi(String productId, Collection<SysUser> userList, List<ProcessionPermission> processionPermissionList,
|
List<WorkStepPermission> workStepPermissionList, List<PermissionStreamNew> permissionStreamList, List<ProcessStream> processStreamList) {
|
if (processStreamList != null && !processStreamList.isEmpty()) {
|
List<String> processIds = processStreamList.stream()
|
.map(ProcessStream::getProcessId)
|
.collect(Collectors.toList());
|
handleProcessPermissions(processIds, userList, processionPermissionList, permissionStreamList);
|
List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
|
if (workStepList != null && !workStepList.isEmpty()) {
|
List<String> workStepIds = workStepList.stream()
|
.map(WorkStep::getId)
|
.collect(Collectors.toList());
|
handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList);
|
}
|
}
|
}
|
|
private void handleComponentPermissions(List<String> componentIds, Collection<SysUser> userList,
|
List<ComponentPermission> componentPermissionList, List<PermissionStreamNew> permissionStreamList) {
|
Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
|
Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
|
String key;
|
for (ComponentInfo c : componentInfoService.listByIds(componentIds)) {
|
componentInfoMap.put(c.getComponentId(), c);
|
for (SysUser u : userList) {
|
key = c.getComponentId() + "," + u.getId();
|
componentPermissionMap.put(key, new ComponentPermission(c.getComponentId(), u.getId()));
|
}
|
}
|
List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
|
if (existList != null && !existList.isEmpty()) {
|
for (ComponentPermission permission : existList) {
|
key = permission.getComponentId() + "," + permission.getUserId();
|
componentPermissionMap.remove(key);
|
}
|
}
|
for (Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()) {
|
ComponentPermission cp = entry.getValue();
|
componentPermissionList.add(cp);
|
ComponentInfo cpInfo = componentInfoMap.get(cp.getComponentId());
|
PermissionStreamNew s = new PermissionStreamNew();
|
s.setBusinessId(cpInfo.getProductId());
|
s.setBusinessType("1");
|
s.setUserId(cp.getUserId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
private void handlePartsPermissions(List<String> partsIds, Collection<SysUser> userList,
|
List<PartsPermission> partsPermissionList, List<PermissionStreamNew> permissionStreamList) {
|
Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
|
Map<String, PartsInfo> partsInfoMap = new HashMap<>();
|
String key;
|
for (PartsInfo p : partsInfoService.listByIds(partsIds)) {
|
partsInfoMap.put(p.getPartsId(), p);
|
for (SysUser u : userList) {
|
key = p.getPartsId() + "," + u.getId();
|
partsPermissionHashMap.put(key, new PartsPermission(p.getPartsId(), u.getId()));
|
}
|
}
|
List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
|
if (existPartsList != null && !existPartsList.isEmpty()) {
|
for (PartsPermission permission : existPartsList) {
|
key = permission.getPartsId() + "," + permission.getUserId();
|
partsPermissionHashMap.remove(key);
|
}
|
}
|
for (Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()) {
|
PartsPermission pp = entry.getValue();
|
partsPermissionList.add(pp);
|
PartsInfo ptInfo = partsInfoMap.get(pp.getPartsId());
|
PermissionStreamNew s = new PermissionStreamNew();
|
s.setBusinessId(ptInfo.getPartsId());
|
s.setBusinessType("3");
|
s.setUserId(pp.getUserId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
private void handlePsvPermissions(List<String> psvIds, Collection<SysUser> userList,
|
List<ProcessSpecVersionPermission> processSpecVersionPermissionList, List<PermissionStreamNew> permissionStreamList) {
|
Map<String, ProcessSpecVersionPermission> processSpecVersionPermissionMap = new HashMap<>();
|
Map<String, ProcessSpecVersion> processStreamMap = new HashMap<>();
|
String key;
|
for (ProcessSpecVersion p : processSpecVersionService.listByIds(psvIds)) {
|
processStreamMap.put(p.getId(), p);
|
for (SysUser u : userList) {
|
key = p.getId() + "," + u.getId();
|
processSpecVersionPermissionMap.put(key, new ProcessSpecVersionPermission(p.getId(), u.getId()));
|
}
|
}
|
List<ProcessSpecVersionPermission> processSpecVersionPermissions = processSpecVersionPermissionService.getByPsvIdsAndUserIds(psvIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
|
if (processSpecVersionPermissions != null && !processSpecVersionPermissions.isEmpty()) {
|
for (ProcessSpecVersionPermission processionPermission : processSpecVersionPermissions) {
|
key = processionPermission.getPsvId() + "," + processionPermission.getUserId();
|
processSpecVersionPermissionMap.remove(key);
|
}
|
}
|
for (Map.Entry<String, ProcessSpecVersionPermission> entry : processSpecVersionPermissionMap.entrySet()) {
|
ProcessSpecVersionPermission pp = entry.getValue();
|
processSpecVersionPermissionList.add(pp);
|
ProcessSpecVersion processSpecVersion = processStreamMap.get(pp.getPsvId());
|
PermissionStreamNew s = new PermissionStreamNew();
|
s.setBusinessId(processSpecVersion.getId());
|
s.setBusinessType("4");
|
s.setUserId(pp.getUserId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
private void handleProcessPermissions(List<String> processIds, Collection<SysUser> userList,
|
List<ProcessionPermission> processionPermissionList, List<PermissionStreamNew> permissionStreamList) {
|
Map<String, ProcessionPermission> processionPermissionHashMap = new HashMap<>();
|
Map<String, ProcessStream> processStreamMap = new HashMap<>();
|
String key;
|
for (ProcessStream p : processStreamService.listByIds(processIds)) {
|
processStreamMap.put(p.getProcessId(), p);
|
for (SysUser u : userList) {
|
key = p.getProcessId() + "," + u.getId();
|
processionPermissionHashMap.put(key, new ProcessionPermission(p.getProcessId(), u.getId()));
|
}
|
}
|
List<ProcessionPermission> processionDepartmentList = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
|
if (processionDepartmentList != null && !processionDepartmentList.isEmpty()) {
|
for (ProcessionPermission processionPermission : processionDepartmentList) {
|
key = processionPermission.getProcessId() + "," + processionPermission.getUserId();
|
processionPermissionHashMap.remove(key);
|
}
|
}
|
for (Map.Entry<String, ProcessionPermission> entry : processionPermissionHashMap.entrySet()) {
|
ProcessionPermission pp = entry.getValue();
|
processionPermissionList.add(pp);
|
ProcessStream processStream = processStreamMap.get(pp.getProcessId());
|
PermissionStreamNew s = new PermissionStreamNew();
|
s.setBusinessId(processStream.getProcessId());
|
s.setBusinessType("5");
|
s.setUserId(pp.getUserId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
private void handleWorkStepPermissions(List<String> workStepIds, Collection<SysUser> userList,
|
List<WorkStepPermission> workStepPermissionList, List<PermissionStreamNew> permissionStreamList) {
|
Map<String, WorkStepPermission> workStepPermissionHashMap = new HashMap<>();
|
Map<String, WorkStep> workStepHashMap = new HashMap<>();
|
String key;
|
for (WorkStep w : workStepService.listByIds(workStepIds)) {
|
workStepHashMap.put(w.getId(), w);
|
for (SysUser u : userList) {
|
key = w.getId() + "," + u.getId();
|
workStepPermissionHashMap.put(key, new WorkStepPermission(w.getId(), u.getId()));
|
}
|
}
|
List<WorkStepPermission> workStepPermissions = iWorkStepPermissionService.getByStepIdsAndUserIds(workStepIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
|
if (workStepPermissions != null && !workStepPermissions.isEmpty()) {
|
for (WorkStepPermission workStepPermission : workStepPermissions) {
|
key = workStepPermission.getStepId() + "," + workStepPermission.getUserId();
|
workStepPermissionHashMap.remove(key);
|
}
|
}
|
for (Map.Entry<String, WorkStepPermission> entry : workStepPermissionHashMap.entrySet()) {
|
WorkStepPermission ws = entry.getValue();
|
workStepPermissionList.add(ws);
|
WorkStep workStep = workStepHashMap.get(ws.getStepId());
|
PermissionStreamNew s = new PermissionStreamNew();
|
s.setBusinessId(workStep.getId());
|
s.setBusinessType("6");
|
s.setUserId(ws.getUserId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
/**
|
* 添加权限
|
*/
|
|
private boolean handleWorkStep(String paramId, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
WorkStep workStep = workStepService.getById(paramId);
|
if (workStep == null) {
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
}
|
boolean hasPerm = checkProductPerm(6, workStep.getId());
|
if (!hasPerm) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (userList!=null){
|
return workStepService.assignAddUser(workStep, userList);
|
}else {
|
return workStepService.assignAddDepart(workStep, mdcProductionList);
|
}
|
}
|
|
private boolean handleProcessStream(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
ProcessStream processStream = processStreamService.getById(paramId);
|
if (processStream == null) {
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
}
|
boolean hasPerm = checkProductPerm(5, processStream.getProcessId());
|
if (!hasPerm) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
boolean result;
|
if (userList!=null){
|
boolean processResult = processStreamService.assignAddUser(processStream, userList);
|
if (!processResult) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelativePermissions(processStream.getProductId(), null, processStream.getProcessId(), null,null, userList);
|
}
|
}else {
|
result = processStreamService.assignAddDepart(processStream, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelatedPermissions(processStream, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
|
}
|
}
|
return true;
|
}
|
|
private boolean handleProcessSpecVersion(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
|
if (processSpecVersion == null) {
|
ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
|
}
|
boolean hasPerm = checkProductPerm(4, processSpecVersion.getId());
|
if (!hasPerm) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
boolean result;
|
if (userList!=null){
|
result = processSpecVersionService.assignAddUser(processSpecVersion, userList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelativePermissions(processSpecVersion.getProductId(), null, null,null, processSpecVersion.getId(), userList);
|
}
|
}else {
|
result = processSpecVersionService.assignAddDepart(processSpecVersion, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelatedPermissionsForProcessSpecVersion(processSpecVersion, mdcProductionList);
|
}
|
}
|
return true;
|
}
|
|
private boolean handlePartsInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
PartsInfo partsInfo = partsInfoService.getById(paramId);
|
if (partsInfo == null) {
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
}
|
boolean hasPerm = checkProductPerm(3, partsInfo.getPartsId());
|
if (!hasPerm) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
boolean result;
|
if (userList!=null){
|
result = partsInfoService.assignAddUser(partsInfo, userList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelativePermissions(partsInfo.getProductId(), null, null, partsInfo.getPartsId(),null, userList);
|
}
|
}else {
|
result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
|
}
|
}
|
return true;
|
}
|
|
private boolean handleProductInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
ProductInfo productInfo = super.getById(paramId);
|
if (productInfo == null) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
|
}
|
boolean hasPerm = checkProductPerm(1, productInfo.getProductId());
|
if (!hasPerm) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
boolean result;
|
if (userList!=null){
|
result = this.assignAddUser(productInfo, userList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
|
if (componentInfoList != null && !componentInfoList.isEmpty()) {
|
List<String> componentIds = componentInfoList.stream()
|
.map(ComponentInfo::getComponentId)
|
.collect(Collectors.toList());
|
handleRelativePermissions(productInfo.getProductId(), componentIds, null, null, null,userList);
|
}
|
}
|
}else {
|
result = this.assignAddDepartment(productInfo, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelatedPermissionsForProduct(productInfo, mdcProductionList);
|
}
|
}
|
return true;
|
}
|
|
private boolean handleComponentInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
ComponentInfo componentInfo = componentInfoService.getById(paramId);
|
if (componentInfo == null) {
|
ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
|
}
|
boolean hasPerm = checkProductPerm(2, componentInfo.getComponentId());
|
if (!hasPerm) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
boolean result;
|
if (userList!=null){
|
result = componentInfoService.assignAddUser(componentInfo, userList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
|
List<String> componentIds = new ArrayList<>();
|
if (childrenList != null && !childrenList.isEmpty()) {
|
componentIds = childrenList.stream()
|
.map(ComponentInfo::getComponentId)
|
.collect(Collectors.toList());
|
}
|
componentIds.add(componentInfo.getComponentId());
|
handleRelativePermissions(componentInfo.getProductId(), componentIds, null, null,null, userList);
|
}
|
}else {
|
result = componentInfoService.assignAddDepart(componentInfo, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelatedPermissionsForComponent(componentInfo, mdcProductionList);
|
}
|
}
|
return true;
|
}
|
|
private void handleRelatedPermissions(Object parentEntity, Collection<MdcProduction> mdcProductionList, IWorkStepService workStepService,
|
IWorkStepDepartmentService workStepDepartmentService, IPermissionStreamNewService permissionStreamNewService) {
|
String parentId = getParentId(parentEntity);
|
List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", parentId));
|
if (workStepList == null || workStepList.isEmpty()) {
|
return;
|
}
|
Map<String, WorkStepDepartment> allPermissions = new HashMap<>();
|
Map<String, WorkStep> workStepMap = new HashMap<>();
|
for (WorkStep workStep : workStepList) {
|
workStepMap.put(workStep.getId(), workStep);
|
for (MdcProduction mdcProduction : mdcProductionList) {
|
String key = workStep.getId() + "," + mdcProduction.getId();
|
WorkStepDepartment wsDep = new WorkStepDepartment(workStep.getId(), mdcProduction.getId());
|
allPermissions.put(key, wsDep);
|
}
|
}
|
|
List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
|
List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
|
List<WorkStepDepartment> existingPermissions = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIds);
|
if (existingPermissions != null && !existingPermissions.isEmpty()) {
|
for (WorkStepDepartment existing : existingPermissions) {
|
String key = existing.getStepId() + "," + existing.getDepartId();
|
allPermissions.remove(key);
|
}
|
}
|
|
List<WorkStepDepartment> newWorkStepDepartments = new ArrayList<>();
|
List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
|
for (Map.Entry<String, WorkStepDepartment> entry : allPermissions.entrySet()) {
|
WorkStepDepartment wsDep = entry.getValue();
|
newWorkStepDepartments.add(wsDep);
|
WorkStep workStep = workStepMap.get(wsDep.getStepId());
|
PermissionStreamNew permStream = new PermissionStreamNew();
|
permStream.setBusinessId(workStep.getId());
|
permStream.setBusinessType("6");
|
permStream.setDepartId(wsDep.getDepartId());
|
newPermissionStreams.add(permStream);
|
}
|
if (!newWorkStepDepartments.isEmpty()) {
|
workStepDepartmentService.saveBatch(newWorkStepDepartments);
|
}
|
if (!newPermissionStreams.isEmpty()) {
|
permissionStreamNewService.saveBatch(newPermissionStreams);
|
}
|
}
|
|
private void handleRelatedPermissionsForParts(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
|
// 处理工艺规程版本
|
List<ProcessSpecVersion> processSpecVersionList = processSpecVersionService.list(new QueryWrapper<ProcessSpecVersion>().eq("parts_id", partsInfo.getPartsId()));
|
processSpecVersionList.forEach(item->{
|
processSpecVersionService.assignAddDepart(item, mdcProductionList);
|
handleRelatedPermissionsForProcessSpecVersion(item, mdcProductionList);
|
});
|
}
|
|
private void handleRelatedPermissionsForProcessSpecVersion(ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
|
// 处理工序权限
|
handleProcessPermissions(processSpecVersion,null, mdcProductionList);
|
// 处理工步权限
|
handleWorkStepPermissions(processSpecVersion, mdcProductionList);
|
|
}
|
|
private void handleProcessPermissions(ProcessSpecVersion processSpecVersion,ComponentInfo componentInfo,Collection<MdcProduction> mdcProductionList) {
|
List<ProcessStream> processStreamList=new ArrayList<>();
|
if (componentInfo != null) {
|
processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
|
}else {
|
processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
|
}
|
if (processStreamList == null || processStreamList.isEmpty()) {
|
return;
|
}
|
processStreamList.forEach(item->{
|
handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
|
});
|
Map<String, ProcessionDepartment> allProcessPermissions = new HashMap<>();
|
Map<String, ProcessStream> processStreamMap = new HashMap<>();
|
for (ProcessStream processStream : processStreamList) {
|
processStreamMap.put(processStream.getProcessId(), processStream);
|
for (MdcProduction mdcProduction : mdcProductionList) {
|
String key = processStream.getProcessId() + "," + mdcProduction.getId();
|
ProcessionDepartment procDep = new ProcessionDepartment(processStream.getProcessId(), mdcProduction.getId());
|
allProcessPermissions.put(key, procDep);
|
}
|
}
|
|
List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
|
List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
|
List<ProcessionDepartment> existingProcessPermissions = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIds);
|
if (existingProcessPermissions != null && !existingProcessPermissions.isEmpty()) {
|
for (ProcessionDepartment existing : existingProcessPermissions) {
|
String key = existing.getProcessId() + "," + existing.getDepartId();
|
allProcessPermissions.remove(key);
|
}
|
}
|
|
List<ProcessionDepartment> newProcessPermissions = new ArrayList<>();
|
List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
|
for (Map.Entry<String, ProcessionDepartment> entry : allProcessPermissions.entrySet()) {
|
ProcessionDepartment procDep = entry.getValue();
|
newProcessPermissions.add(procDep);
|
ProcessStream processStream = processStreamMap.get(procDep.getProcessId());
|
PermissionStreamNew permStream = new PermissionStreamNew();
|
permStream.setBusinessId(processStream.getProcessId());
|
permStream.setBusinessType("5");
|
permStream.setDepartId(procDep.getDepartId());
|
newPermissionStreams.add(permStream);
|
}
|
|
if (!newProcessPermissions.isEmpty()) {
|
processionDepartmentService.saveBatch(newProcessPermissions);
|
}
|
if (!newPermissionStreams.isEmpty()) {
|
permissionStreamNewService.saveBatch(newPermissionStreams);
|
}
|
}
|
|
private void handleWorkStepPermissions(ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
|
List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
|
if (processStreamList == null || processStreamList.isEmpty()) {
|
return;
|
}
|
List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
|
List<WorkStep> workStepList = workStepService.getByProcessIds(processSpecVersion.getProductId(), processIds);
|
if (workStepList == null || workStepList.isEmpty()) {
|
return;
|
}
|
workStepList.forEach(item->{
|
handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
|
});
|
}
|
|
private void handleRelatedPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
|
// 处理组件权限
|
handleComponentPermissionsForProduct(productInfo, mdcProductionList);
|
// 处理零件权限
|
handlePartsPermissionsForProduct(productInfo, mdcProductionList);
|
List<ComponentInfo> componentInfoList=componentInfoService.list(new QueryWrapper<ComponentInfo>().eq("product_id", productInfo.getProductId()));
|
componentInfoList.forEach(item->{
|
handleProcessPermissions(null,item, mdcProductionList);
|
});
|
}
|
|
private void handleComponentPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
|
List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
|
if (componentInfoList == null || componentInfoList.isEmpty()) {
|
return;
|
}
|
Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>();
|
Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
|
for (ComponentInfo componentInfo : componentInfoList) {
|
componentInfoMap.put(componentInfo.getComponentId(), componentInfo);
|
for (MdcProduction mdcProduction : mdcProductionList) {
|
String key = componentInfo.getComponentId() + "," + mdcProduction.getId();
|
ComponentDepartment compDep = new ComponentDepartment(componentInfo.getComponentId(), mdcProduction.getId());
|
allComponentPermissions.put(key, compDep);
|
}
|
}
|
|
List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
|
List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
|
List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds);
|
if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) {
|
for (ComponentDepartment existing : existingComponentPermissions) {
|
String key = existing.getComponentId() + "," + existing.getDepartId();
|
allComponentPermissions.remove(key);
|
}
|
}
|
|
List<ComponentDepartment> newComponentPermissions = new ArrayList<>();
|
List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
|
for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
|
ComponentDepartment compDep = entry.getValue();
|
newComponentPermissions.add(compDep);
|
ComponentInfo componentInfo = componentInfoMap.get(compDep.getComponentId());
|
PermissionStreamNew permStream = new PermissionStreamNew();
|
permStream.setBusinessId(componentInfo.getComponentId());
|
permStream.setBusinessType("2");
|
permStream.setDepartId(compDep.getDepartId());
|
newPermissionStreams.add(permStream);
|
}
|
|
if (!newComponentPermissions.isEmpty()) {
|
componentDepartmentService.saveBatch(newComponentPermissions);
|
}
|
if (!newPermissionStreams.isEmpty()) {
|
permissionStreamNewService.saveBatch(newPermissionStreams);
|
}
|
}
|
|
private void handlePartsPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
|
List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
|
if (componentInfoList == null || componentInfoList.isEmpty()) {
|
return;
|
}
|
List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
|
if (partsInfoList == null || partsInfoList.isEmpty()) {
|
return;
|
}
|
for (PartsInfo partsInfo : partsInfoList) {
|
boolean result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
|
}
|
}
|
|
private void handleRelatedPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
|
// 处理子组件权限
|
handleChildComponentPermissions(componentInfo, mdcProductionList);
|
// 处理零件权限
|
handlePartsPermissionsForComponent(componentInfo, mdcProductionList);
|
// 处理工序权限
|
handleProcessPermissions(null,componentInfo, mdcProductionList);
|
}
|
|
private void handleChildComponentPermissions(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
|
List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
|
if (childrenList == null || childrenList.isEmpty()) {
|
return;
|
}
|
Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>();
|
Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
|
for (ComponentInfo childComponent : childrenList) {
|
componentInfoMap.put(childComponent.getComponentId(), childComponent);
|
for (MdcProduction mdcProduction : mdcProductionList) {
|
String key = childComponent.getComponentId() + "," + mdcProduction.getId();
|
ComponentDepartment compDep = new ComponentDepartment(childComponent.getComponentId(), mdcProduction.getId());
|
allComponentPermissions.put(key, compDep);
|
}
|
|
List<String> componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
|
List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
|
List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds);
|
if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) {
|
for (ComponentDepartment existing : existingComponentPermissions) {
|
String key = existing.getComponentId() + "," + existing.getDepartId();
|
allComponentPermissions.remove(key);
|
}
|
}
|
|
List<ComponentDepartment> newComponentPermissions = new ArrayList<>();
|
List<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
|
for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
|
ComponentDepartment compDep = entry.getValue();
|
newComponentPermissions.add(compDep);
|
childComponent = componentInfoMap.get(compDep.getComponentId());
|
PermissionStreamNew permStream = new PermissionStreamNew();
|
permStream.setBusinessId(childComponent.getComponentId());
|
permStream.setBusinessType("2");
|
permStream.setDepartId(compDep.getDepartId());
|
newPermissionStreams.add(permStream);
|
}
|
|
if (!newComponentPermissions.isEmpty()) {
|
componentDepartmentService.saveBatch(newComponentPermissions);
|
}
|
if (!newPermissionStreams.isEmpty()) {
|
permissionStreamNewService.saveBatch(newPermissionStreams);
|
}
|
}
|
}
|
|
private void handlePartsPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentId(componentInfo.getProductId(),componentInfo.getComponentId());
|
if (partsInfoList == null || partsInfoList.isEmpty()) {
|
return;
|
}
|
for (PartsInfo partsInfo : partsInfoList) {
|
partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
|
handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
|
}
|
}
|
|
private String getParentId(Object parentEntity) {
|
if (parentEntity instanceof ProcessStream) {
|
return ((ProcessStream) parentEntity).getProcessId();
|
} else if (parentEntity instanceof WorkStep) {
|
return ((WorkStep) parentEntity).getProcessId();
|
}
|
return null;
|
}
|
|
|
/**移除权限*/
|
|
private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
ProductInfo productInfo = super.getById(paramId);
|
if (productInfo == null) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
|
}
|
checkProductPerm(1, productInfo.getProductId());
|
boolean result;
|
if (userList!=null){
|
result =this.assignRemoveUser(productInfo, userList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleProductRelatedRemovals(productInfo, userList);
|
}
|
}else {
|
result = this.assignRemoveDepartment(productInfo, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleProductRelatedDepartmentRemovals(productInfo, mdcProductionList);
|
}
|
}
|
return true;
|
}
|
|
private boolean handleComponentInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
ComponentInfo componentInfo = componentInfoService.getById(paramId);
|
if (componentInfo == null) {
|
ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
|
}
|
checkProductPerm(2, componentInfo.getComponentId());
|
boolean result;
|
if (userList!=null){
|
result =componentInfoService.assignRemoveUser(componentInfo, userList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleComponentRelatedRemovals(componentInfo, userList,null);
|
}
|
}else {
|
result = componentInfoService.assignRemoveDepart(componentInfo, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleComponentRelatedRemovals(componentInfo,null,mdcProductionList);
|
}
|
}
|
return true;
|
}
|
|
private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
PartsInfo partsInfo = partsInfoService.getById(paramId);
|
if (partsInfo == null) {
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
}
|
checkProductPerm(3, partsInfo.getPartsId());
|
boolean result;
|
if (userList!=null){
|
result = partsInfoService.assignRemoveUser(partsInfo, userList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handlePartRelatedRemovals(partsInfo, userList);
|
}
|
}else {
|
result = partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handlePartRelatedDepartmentRemovals(partsInfo, mdcProductionList);
|
}
|
}
|
return true;
|
}
|
|
private boolean handleProcessSpecVersionRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
|
if (processSpecVersion == null) {
|
ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
|
}
|
checkProductPerm(4, processSpecVersion.getPartsId());
|
boolean result;
|
if (userList!=null){
|
result = processSpecVersionService.assignRemoveUser(processSpecVersion, userList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleProcessSpecVersionRelatedRemovals(null,processSpecVersion, userList);
|
}
|
}else {
|
result = processSpecVersionService.assignRemoveDepart(processSpecVersion, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleProcessSpecVersionRelatedDepartmentRemovals(null,processSpecVersion, mdcProductionList);
|
}
|
}
|
return true;
|
}
|
|
private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
ProcessStream processStream = processStreamService.getById(paramId);
|
if (processStream == null) {
|
ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
|
}
|
checkProductPerm(5, processStream.getProcessId());
|
boolean result;
|
if (userList!=null){
|
result = processStreamService.assignRemoveUser(processStream, userList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelatedRemovals(processStream.getProcessId(), userList,
|
workStepService, iWorkStepPermissionService, permissionStreamNewService,
|
"process_id");
|
}
|
}else {
|
result = processStreamService.assignRemoveDepart(processStream, mdcProductionList);
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if (relativeFlag == 1) {
|
handleRelatedDepartmentRemovals(processStream.getProcessId(), mdcProductionList,
|
workStepService, workStepDepartmentService, permissionStreamNewService,
|
"process_id");
|
}
|
}
|
return true;
|
}
|
|
private boolean handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
WorkStep workStep = workStepService.getById(paramId);
|
if (workStep == null) {
|
ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
|
}
|
checkProductPerm(6, workStep.getId());
|
if (userList!=null){
|
return workStepService.assignRemoveUser(workStep, userList);
|
}else {
|
return workStepService.assignRemoveDepart(workStep, mdcProductionList);
|
}
|
}
|
|
private void handleRelatedRemovals(String parentId, Collection<SysUser> userList,
|
IWorkStepService workStepService,
|
IWorkStepPermissionService workStepPermissionService,
|
IPermissionStreamNewService permissionStreamNewService,
|
String queryField) {
|
List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
|
if (workStepList.isEmpty()) {
|
return;
|
}
|
List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
|
List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
|
List<WorkStepPermission> workStepPermissions = workStepPermissionService.getByStepIdsAndUserIds(workStepIds, userIdList);
|
List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(workStepIds, userIdList,"6");
|
|
if (!workStepPermissions.isEmpty()) {
|
workStepPermissionService.removeByCollection(workStepPermissions);
|
}
|
if (!permissionStreams.isEmpty()) {
|
permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
|
}
|
}
|
|
private void handleRelatedDepartmentRemovals(String parentId, Collection<MdcProduction> mdcProductionList,
|
IWorkStepService workStepService,
|
IWorkStepDepartmentService workStepDepartmentService,
|
IPermissionStreamNewService permissionStreamNewService,
|
String queryField) {
|
List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
|
if (workStepList.isEmpty()) {
|
return;
|
}
|
List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
|
List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
|
List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIdList);
|
List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(workStepIds, departmentIdList,"6");
|
|
if (!workStepDepartments.isEmpty()) {
|
workStepDepartmentService.removeByCollection(workStepDepartments);
|
}
|
if (!permissionStreams.isEmpty()) {
|
permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
|
}
|
}
|
|
private void handleProcessSpecVersionRelatedRemovals(ComponentInfo componentInfo,ProcessSpecVersion processSpecVersion,Collection<SysUser> userList) {
|
List<ProcessStream> processStreamList =new ArrayList<>();
|
String productId="";
|
if (processSpecVersion!=null){
|
processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
|
productId=processSpecVersion.getProductId();
|
}else {
|
processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()).isNull("parts_id"));
|
productId=componentInfo.getProductId();
|
}
|
List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
|
handleProcessRemovals(processIds, userList);
|
handleWorkStepRemovals(productId, processIds, userList);
|
}
|
|
private void handleProcessRemovals(List<String> processIds, Collection<SysUser> userList) {
|
if (processIds.isEmpty()) {
|
return;
|
}
|
List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
|
List<ProcessionPermission> processionPermissions = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userIdList);
|
List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(processIds, userIdList,"5");
|
|
if (!processionPermissions.isEmpty()) {
|
iProcessStreamPermissionService.removeByCollection(processionPermissions);
|
}
|
if (!permissionStreams.isEmpty()) {
|
permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
|
}
|
}
|
|
private void handleProcessDepartmentRemovals(List<String> processIds, Collection<MdcProduction> mdcProductionList) {
|
if (processIds.isEmpty()) {
|
return;
|
}
|
List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
|
List<ProcessionDepartment> processionDepartments = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIdList);
|
List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(processIds, departmentIdList,"5");
|
|
if (!processionDepartments.isEmpty()) {
|
processionDepartmentService.removeByCollection(processionDepartments);
|
}
|
if (!permissionStreams.isEmpty()) {
|
permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
|
}
|
}
|
|
private void handleWorkStepRemovals(String productId, List<String> processIds, Collection<SysUser> userList) {
|
List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
|
if (workStepList!=null){
|
workStepList.forEach(item->{
|
handleRelatedRemovals(item.getProcessId(), userList, workStepService, iWorkStepPermissionService, permissionStreamNewService, "process_id");
|
});
|
}
|
}
|
|
private void handleWorkStepDepartmentRemovals(String productId, List<String> processIds, Collection<MdcProduction> mdcProductionList) {
|
List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
|
if (workStepList!=null){
|
workStepList.forEach(item->{
|
handleRelatedDepartmentRemovals(item.getProcessId(), mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService, "process_id");
|
});
|
}
|
}
|
|
private void handleProductRelatedRemovals(ProductInfo productInfo, Collection<SysUser> userList) {
|
List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
|
List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
|
handleComponentRemovals(componentIds, userList);
|
handlePartsRemovals(productInfo.getProductId(), componentIds, userList);
|
componentInfoList.forEach(item->{
|
handleProcessSpecVersionRelatedRemovals(item,null, userList);
|
});
|
}
|
|
private void handlePartRelatedRemovals(PartsInfo partsInfo, Collection<SysUser> userList) {
|
List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByPartsId(partsInfo.getPartsId());
|
if (processSpecVersions!=null){
|
List<String> psvIds = processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
|
handleProcessSpecVersionRemovals(psvIds, userList);
|
processSpecVersions.forEach(item->{
|
handleProcessSpecVersionRelatedRemovals(null,item, userList);
|
});
|
}
|
}
|
|
private void handlePartRelatedDepartmentRemovals(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
|
List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByPartsId(partsInfo.getPartsId());
|
if (processSpecVersions!=null){
|
List<String> psvIds = processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
|
handleProcessSpecVersionDepartmentRemovals(psvIds, mdcProductionList);
|
processSpecVersions.forEach(item->{
|
handleProcessSpecVersionRelatedDepartmentRemovals(null,item, mdcProductionList);
|
});
|
}
|
}
|
|
private void handleProductRelatedDepartmentRemovals(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
|
List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
|
List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
|
handleComponentDepartmentRemovals(componentIds, mdcProductionList);
|
handlePartsDepartmentRemovals(productInfo.getProductId(), componentIds, mdcProductionList);
|
componentInfoList.forEach(item->{
|
handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
|
});
|
}
|
|
private void handleComponentRemovals(List<String> componentIds, Collection<SysUser> userList) {
|
if (componentIds.isEmpty()) {
|
return;
|
}
|
List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
|
List<ComponentPermission> componentPermissions = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userIdList);
|
List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(componentIds, userIdList,"2");
|
|
if (!componentPermissions.isEmpty()) {
|
componentPermissionService.removeByCollection(componentPermissions);
|
}
|
if (!permissionStreams.isEmpty()) {
|
permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
|
}
|
}
|
|
private void handleProcessSpecVersionRemovals(List<String> psvIds, Collection<SysUser> userList) {
|
if (psvIds.isEmpty()) {
|
return;
|
}
|
List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
|
List<ProcessSpecVersionPermission> processSpecVersionPermissions = processSpecVersionPermissionService.getByPsvIdsAndUserIds(psvIds, userIdList);
|
List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(psvIds, userIdList,"4");
|
if (!processSpecVersionPermissions.isEmpty()) {
|
processSpecVersionPermissionService.removeByCollection(processSpecVersionPermissions);
|
}
|
if (!permissionStreams.isEmpty()) {
|
permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
|
}
|
}
|
|
private void handleProcessSpecVersionDepartmentRemovals(List<String> psvIds, Collection<MdcProduction> mdcProductionList) {
|
if (psvIds.isEmpty()) {
|
return;
|
}
|
List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
|
List<ProcessSpecVersionDepartment> processSpecVersionDepartments =processSpecVersionDepartmentService.getByPsvIdsAndDepartIds(psvIds, departmentIdList);
|
List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(psvIds, departmentIdList,"4");
|
if (!processSpecVersionDepartments.isEmpty()) {
|
processSpecVersionDepartmentService.removeByCollection(processSpecVersionDepartments);
|
}
|
if (!permissionStreams.isEmpty()) {
|
permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
|
}
|
}
|
|
|
private void handleComponentDepartmentRemovals(List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
|
if (componentIds.isEmpty()) {
|
return;
|
}
|
List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
|
List<ComponentDepartment> componentDepartments = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIdList);
|
List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(componentIds, departmentIdList,"2");
|
|
if (!componentDepartments.isEmpty()) {
|
componentDepartmentService.removeByCollection(componentDepartments);
|
}
|
if (!permissionStreams.isEmpty()) {
|
permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
|
}
|
}
|
|
private void handlePartsRemovals(String productId, List<String> componentIds,Collection<SysUser> userList) {
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
|
partsInfoList.forEach(item->{
|
partsInfoService.assignRemoveUser(item,userList);
|
//删除
|
handlePartRelatedRemovals(item, userList);
|
});
|
}
|
private void handlePartsDepartmentRemovals(String productId, List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
|
partsInfoList.forEach(item->{
|
partsInfoService.assignRemoveDepart(item,mdcProductionList);
|
handlePartRelatedDepartmentRemovals(item, mdcProductionList);
|
});
|
}
|
|
private void handleComponentRelatedRemovals(ComponentInfo componentInfo, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
|
List<String> componentIds = new ArrayList<>();
|
if (childrenList != null) {
|
componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
|
}
|
componentIds.add(componentInfo.getComponentId());
|
if (mdcProductionList!=null){
|
handleComponentDepartmentRemovals(componentIds, mdcProductionList);
|
handlePartsDepartmentRemovals(componentInfo.getProductId(), componentIds, mdcProductionList);
|
if (childrenList != null) {
|
childrenList.forEach(item->{
|
handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
|
});
|
}
|
}else {
|
handleComponentRemovals(componentIds, userList);
|
handlePartsRemovals(componentInfo.getProductId(), componentIds, userList);
|
if (childrenList != null) {
|
childrenList.forEach(item->{
|
handleProcessSpecVersionRelatedRemovals(item,null, userList);
|
});
|
}
|
}
|
}
|
|
private void handleProcessSpecVersionRelatedDepartmentRemovals(ComponentInfo componentInfo,ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
|
List<ProcessStream> processStreamList=new ArrayList<>();
|
String productId="";
|
if (componentInfo!=null){
|
processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
|
productId=componentInfo.getProductId();
|
}else {
|
processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
|
productId=processSpecVersion.getProductId();
|
}
|
List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
|
handleProcessDepartmentRemovals(processIds, mdcProductionList);
|
handleWorkStepDepartmentRemovals(productId, processIds, mdcProductionList);
|
}
|
|
}
|
