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 产品树节点id
|
* @param relativeFlag 1 是 2 否
|
* @param userIds 添加用户ids
|
* todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
|
* @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
|
* todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
|
* @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
|
* todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
|
* @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
|
* todo优化结构，采用mix表进行父子递归查询，分类进行权限分配（单表查询）
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean assignRemoveDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
|
validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds);
|
List<String> ids = new ArrayList<>(departmentIds.length);
|
Collections.addAll(ids, departmentIds);
|
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添加了新的部件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;
|
}
|
|
@Override
|
public Result<?> getTreeById(String id, Integer type){
|
if (StrUtil.isNotEmpty(id)||type!=null){
|
switch (type){
|
case 1:
|
//产品
|
QueryWrapper<ProductInfo> productInfoQueryWrapper = new QueryWrapper<>();
|
productInfoQueryWrapper.eq("product_id",id);
|
List<ProductInfo> productInfos = this.list(productInfoQueryWrapper);
|
return Result.OK(productInfos);
|
case 2:
|
//组件
|
QueryWrapper<ComponentInfo> componentInfoQueryWrapper = new QueryWrapper<>();
|
componentInfoQueryWrapper.eq("component_id",id);
|
List<ComponentInfo> componentInfos = componentInfoService.list(componentInfoQueryWrapper);
|
return Result.OK(componentInfos);
|
case 3:
|
//零件
|
QueryWrapper<PartsInfo> partsInfoQueryWrapper = new QueryWrapper<>();
|
partsInfoQueryWrapper.eq("parts_id",id);
|
List<PartsInfo> partsInfos = partsInfoService.list(partsInfoQueryWrapper);
|
return Result.OK(partsInfos);
|
case 4:
|
//工艺规划版本
|
QueryWrapper<ProcessSpecVersion> processSpecVersionQueryWrapper = new QueryWrapper<>();
|
processSpecVersionQueryWrapper.eq("id",id);
|
List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.list(processSpecVersionQueryWrapper);
|
return Result.OK(processSpecVersions);
|
case 5:
|
//工序
|
QueryWrapper<ProcessStream> processStreamQueryWrapper = new QueryWrapper<>();
|
processStreamQueryWrapper.eq("process_id",id);
|
List<ProcessStream> processStreams = processStreamService.list(processStreamQueryWrapper);
|
return Result.OK(processStreams);
|
case 6:
|
//工步
|
QueryWrapper<WorkStep> workStepQueryWrapper = new QueryWrapper<>();
|
workStepQueryWrapper.eq("id",id);
|
List<WorkStep> workSteps = workStepService.list(workStepQueryWrapper);
|
return Result.OK(workSteps);
|
}
|
}
|
return Result.error("参数错误");
|
}
|
|
/**
|
* 通过代号、名称、材质等查询对应电子样板
|
* @param treeInfoRequest
|
* @return
|
*/
|
@Override
|
public List<DocInfo> getByTreeOtherFileInfo(TreeInfoRequest treeInfoRequest){
|
switch (treeInfoRequest.getAttributionType()){
|
case 1:
|
LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>();
|
// 明确条件：仅当attributionType为1且attributionId非空时添加条件
|
if (treeInfoRequest.getAttributionType() == 1 && StrUtil.isNotBlank(treeInfoRequest.getAttributionId())) {
|
queryWrapper.eq(ProductInfo::getProductId, treeInfoRequest.getAttributionId());
|
}
|
queryWrapper.like(StrUtil.isNotBlank(treeInfoRequest.getTreeCode()), ProductInfo::getProductNo, treeInfoRequest.getTreeCode())
|
.like(StrUtil.isNotBlank(treeInfoRequest.getTreeName()), ProductInfo::getProductName, treeInfoRequest.getTreeName());
|
List<ProductInfo> productInfoList = super.list(queryWrapper);
|
List<DocInfo> docInfos = new ArrayList<>();
|
if (StrUtil.isNotBlank(treeInfoRequest.getStructureType())){
|
productInfoList=new ArrayList<>();
|
}
|
if (CollectionUtil.isNotEmpty(productInfoList)) {
|
String ids=productInfoList.stream().map(ProductInfo::getProductId).collect(Collectors.joining(","));
|
DocInfoQueryRequest docQuery = new DocInfoQueryRequest();
|
BeanUtil.copyProperties(treeInfoRequest, docQuery);
|
docQuery.setAttributionIds(ids);
|
docQuery.setDocClassCode("OTHER");
|
docQuery.setAttributionType(DocAttributionTypeEnum.PRODUCT.getCode());
|
docInfos = docInfoService.findListByDocQuery(docQuery);
|
}
|
// 创建新请求对象避免污染原参数
|
TreeInfoRequest componentRequest = new TreeInfoRequest();
|
BeanUtil.copyProperties(treeInfoRequest, componentRequest);
|
componentRequest.setProductIds(Collections.singletonList(treeInfoRequest.getAttributionId()));
|
// 合并查询结果
|
docInfos.addAll(componentInfoService.getByComponentInfo(componentRequest));
|
docInfos.addAll(partsInfoService.getByPartsInfo(componentRequest));
|
docInfos.addAll(processSpecVersionService.getByProcessSpecVersion(componentRequest));
|
docInfos.addAll(processStreamService.getByProcessStreamOtherFile(componentRequest));
|
docInfos.addAll(workStepService.getByWorkStepOtherFile(componentRequest));
|
return getByTreeOtherFileInfo(docInfos);
|
case 2:
|
return getByTreeOtherFileInfo(componentInfoService.getByComponentInfo(treeInfoRequest));
|
case 3:
|
return getByTreeOtherFileInfo(partsInfoService.getByPartsInfo(treeInfoRequest));
|
case 4:
|
return getByTreeOtherFileInfo(processSpecVersionService.getByProcessSpecVersion(treeInfoRequest));
|
case 5:
|
return getByTreeOtherFileInfo(processStreamService.getByProcessStreamOtherFile(treeInfoRequest));
|
case 6:
|
return getByTreeOtherFileInfo(workStepService.getByWorkStepOtherFile(treeInfoRequest));
|
}
|
return new ArrayList<>();
|
}
|
|
/**
|
* 通过代号、名称、材质等查询对应NC文件
|
* @param treeInfoRequest
|
* @return
|
*/
|
@Override
|
public List<DocInfo> getByTreeNcFileInfo(TreeInfoRequest treeInfoRequest){
|
//产品、部件、零件、工艺规程版本都没有对应的NC文件，直接查询子结构
|
switch (treeInfoRequest.getAttributionType()){
|
case 1:
|
LambdaQueryWrapper<ProductInfo> queryWrapper = new LambdaQueryWrapper<>();
|
// 明确条件：仅当attributionType为1且attributionId非空时添加条件
|
if (StrUtil.isNotBlank(treeInfoRequest.getAttributionId())) {
|
queryWrapper.eq(ProductInfo::getProductId, treeInfoRequest.getAttributionId());
|
}
|
// 简化条件判断
|
queryWrapper.like(StrUtil.isNotBlank(treeInfoRequest.getTreeCode()), ProductInfo::getProductNo, treeInfoRequest.getTreeCode())
|
.like(StrUtil.isNotBlank(treeInfoRequest.getTreeName()), ProductInfo::getProductName, treeInfoRequest.getTreeName());
|
List<ProductInfo> productInfoList = super.list(queryWrapper);
|
if (CollectionUtil.isNotEmpty(productInfoList)) {
|
treeInfoRequest.setProductIds(productInfoList.stream().map(ProductInfo::getProductId).collect(Collectors.toList()));
|
}
|
return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
|
case 2:
|
LambdaQueryWrapper<ComponentInfo> componentInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
// 明确条件：仅当attributionType为1且attributionId非空时添加条件
|
if (StrUtil.isNotBlank(treeInfoRequest.getAttributionId())) {
|
componentInfoLambdaQueryWrapper.eq(ComponentInfo::getComponentId, treeInfoRequest.getAttributionId());
|
}
|
componentInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeCode()),ComponentInfo::getComponentCode, treeInfoRequest.getTreeCode());
|
componentInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeName()),ComponentInfo::getComponentName, treeInfoRequest.getTreeName());
|
componentInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getStructureType()),ComponentInfo::getStructureType, treeInfoRequest.getStructureType());
|
componentInfoLambdaQueryWrapper.orderByDesc(ComponentInfo::getCreateTime);
|
List<ComponentInfo> componentInfoList = componentInfoService.list(componentInfoLambdaQueryWrapper);
|
if (CollectionUtil.isNotEmpty(componentInfoList)) {
|
treeInfoRequest.setComponentIds(componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList()));
|
}
|
return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
|
case 3:
|
LambdaQueryWrapper<PartsInfo> partsInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
if (treeInfoRequest.getProductIds() != null && !treeInfoRequest.getProductIds().isEmpty()) {
|
partsInfoLambdaQueryWrapper.in(PartsInfo::getProductId, treeInfoRequest.getProductIds());
|
}
|
if (treeInfoRequest.getComponentIds() != null && !treeInfoRequest.getComponentIds().isEmpty()) {
|
partsInfoLambdaQueryWrapper.in(PartsInfo::getComponentId, treeInfoRequest.getComponentIds());
|
}
|
if (Objects.equals(treeInfoRequest.getAttributionType(), DocAttributionTypeEnum.PARTS.getCode())){
|
partsInfoLambdaQueryWrapper.eq(StrUtil.isNotEmpty(treeInfoRequest.getAttributionId()),PartsInfo::getPartsId,treeInfoRequest.getAttributionId());
|
}
|
partsInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeCode()),PartsInfo::getPartsCode, treeInfoRequest.getTreeCode());
|
partsInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeName()),PartsInfo::getPartsName, treeInfoRequest.getTreeName());
|
partsInfoLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getStructureType()),PartsInfo::getStructureType, treeInfoRequest.getStructureType());
|
partsInfoLambdaQueryWrapper.orderByDesc(PartsInfo::getCreateTime);
|
List<PartsInfo> list = partsInfoService.list(partsInfoLambdaQueryWrapper);
|
if (CollectionUtil.isNotEmpty(list)) {
|
treeInfoRequest.setPartsIds(list.stream().map(PartsInfo::getPartsId).collect(Collectors.toList()));
|
}
|
return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
|
case 4:
|
LambdaQueryWrapper<ProcessSpecVersion> processSpecVersionLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
if (treeInfoRequest.getProductIds() != null && !treeInfoRequest.getProductIds().isEmpty()) {
|
processSpecVersionLambdaQueryWrapper.in(ProcessSpecVersion::getProductId, treeInfoRequest.getProductIds());
|
}
|
if (treeInfoRequest.getComponentIds() != null && !treeInfoRequest.getComponentIds().isEmpty()) {
|
processSpecVersionLambdaQueryWrapper.in(ProcessSpecVersion::getComponentId, treeInfoRequest.getComponentIds());
|
}
|
if (treeInfoRequest.getPartsIds() != null && !treeInfoRequest.getPartsIds().isEmpty()) {
|
processSpecVersionLambdaQueryWrapper.in(ProcessSpecVersion::getPartsId, treeInfoRequest.getPartsIds());
|
}
|
if (Objects.equals(treeInfoRequest.getAttributionType(), DocAttributionTypeEnum.OPERATION.getCode())){
|
processSpecVersionLambdaQueryWrapper.eq(StrUtil.isNotEmpty(treeInfoRequest.getAttributionId()),ProcessSpecVersion::getId,treeInfoRequest.getAttributionId());
|
}
|
processSpecVersionLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeName()),ProcessSpecVersion::getProcessSpecVersionName, treeInfoRequest.getTreeName());
|
processSpecVersionLambdaQueryWrapper.like(StrUtil.isNotEmpty(treeInfoRequest.getTreeCode()),ProcessSpecVersion::getProcessSpecVersionCode, treeInfoRequest.getTreeName());
|
processSpecVersionLambdaQueryWrapper.orderByDesc(ProcessSpecVersion::getCreateTime);
|
List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.list(processSpecVersionLambdaQueryWrapper);
|
if (CollectionUtil.isNotEmpty(processSpecVersions)) {
|
treeInfoRequest.setPsvIds(processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList()));
|
}
|
return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
|
case 5:
|
return getByTreeNcFileInfo(processStreamService.getByProcessStreamNCFile(treeInfoRequest));
|
case 6:
|
return getByTreeNcFileInfo(workStepService.getByWorkStepNCFile(treeInfoRequest));
|
}
|
return new ArrayList<>();
|
}
|
|
private List<DocInfo> getByTreeOtherFileInfo(List<DocInfo> docInfos){
|
//对所属id进行翻译
|
if (docInfos != null && !docInfos.isEmpty()) {
|
docInfos.forEach(docInfo -> {
|
switch (docInfo.getAttributionType()){
|
case 1:
|
ProductInfo productInfo=this.getById(docInfo.getAttributionId());
|
docInfo.setNodeName(productInfo.getProductName());
|
docInfo.setNodeCode(productInfo.getProductNo());
|
docInfo.setNodeId(productInfo.getProductId());
|
break;
|
case 2:
|
ComponentInfo componentInfo=componentInfoService.getById(docInfo.getAttributionId());
|
docInfo.setNodeName(componentInfo.getComponentName());
|
docInfo.setNodeCode(componentInfo.getComponentCode());
|
docInfo.setNodeId(componentInfo.getComponentId());
|
break;
|
case 3:
|
PartsInfo partsInfo=partsInfoService.getById(docInfo.getAttributionId());
|
docInfo.setNodeCode(partsInfo.getPartsCode());
|
docInfo.setNodeName(partsInfo.getPartsName());
|
docInfo.setNodeId(partsInfo.getPartsId());
|
break;
|
case 4:
|
ProcessSpecVersion processSpecVersion=processSpecVersionService.getById(docInfo.getAttributionId());
|
docInfo.setNodeName(processSpecVersion.getProcessSpecVersionName());
|
docInfo.setNodeCode(processSpecVersion.getProcessSpecVersionCode());
|
docInfo.setNodeId(processSpecVersion.getId());
|
break;
|
case 5:
|
ProcessStream processStream=processStreamService.getById(docInfo.getAttributionId());
|
docInfo.setNodeName(processStream.getProcessName());
|
docInfo.setNodeCode(processStream.getProcessCode());
|
docInfo.setNodeId(processStream.getProcessId());
|
break;
|
case 6:
|
WorkStep workStep=workStepService.getById(docInfo.getAttributionId());
|
docInfo.setNodeName(workStep.getStepName());
|
docInfo.setNodeCode(workStep.getStepName());
|
docInfo.setNodeId(workStep.getId());
|
break;
|
}
|
});
|
}
|
return docInfos;
|
}
|
|
private List<DocInfo> getByTreeNcFileInfo(List<DocInfo> docInfos){
|
//对所属id进行翻译
|
if (docInfos != null && !docInfos.isEmpty()) {
|
docInfos.forEach(docInfo -> {
|
//NC文件存在设备类下
|
DeviceType deviceType=deviceTypeService.getById(docInfo.getAttributionId());
|
DeviceManagement deviceManagement= deviceManagementService.getById(deviceType.getDeviceManagementId());
|
docInfo.setDeviceName(deviceManagement.getDeviceManagementName());
|
docInfo.setDeviceCode(deviceManagement.getDeviceManagementCode());
|
if (deviceType.getAttributionType().equals(DocAttributionTypeEnum.PROCESS.getCode())){
|
//工序下的设备类
|
ProcessStream processStream=processStreamService.getById(deviceType.getAttributionId());
|
docInfo.setNodeName(processStream.getProcessName());
|
docInfo.setNodeCode(processStream.getProcessCode());
|
docInfo.setNodeId(processStream.getProcessId());
|
}else {
|
//工步下的设备类
|
WorkStep workStep=workStepService.getById(deviceType.getAttributionId());
|
docInfo.setNodeName(workStep.getStepName());
|
docInfo.setNodeCode(workStep.getStepName());
|
docInfo.setNodeId(workStep.getId());
|
}
|
});
|
}
|
return docInfos;
|
}
|
|
/**
|
* 验证输入参数
|
*/
|
private void validateInputParameters(Integer nodeType, String paramId, Integer relativeFlag, String type, String[] paramIds) {
|
if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
|
!ValidateUtil.validateInteger(relativeFlag)) {
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
}
|
if (paramIds == null || paramIds.length < 1) {
|
if (("1").equals(type)) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
|
} else {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_DEPART_PERM_NONE);
|
}
|
}
|
}
|
|
/**
|
* 验证 SysUser 列表
|
*/
|
private void validateSysUserList(Collection<SysUser> sysUserList, List<String> userIds) {
|
if (sysUserList == null || sysUserList.isEmpty() || sysUserList.size() != userIds.size()) {
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
}
|
}
|
|
/**
|
* 验证 MdcProduction 列表
|
*/
|
private void validateMdcProductionList(Collection<MdcProduction> mdcProductionList, List<String> departmentIds) {
|
if (mdcProductionList == null || mdcProductionList.isEmpty() || mdcProductionList.size() != departmentIds.size()) {
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
}
|
}
|
|
/**
|
* 添加权限
|
*/
|
private boolean handleProductInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
return handlePermission(paramId, 1, relativeFlag, mdcProductionList, userList, true);
|
}
|
|
private boolean handleComponentInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
return handlePermission(paramId, 2, relativeFlag, mdcProductionList, userList, true);
|
}
|
|
private boolean handlePartsInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
return handlePermission(paramId, 3, relativeFlag, mdcProductionList, userList, true);
|
}
|
|
private boolean handleProcessSpecVersion(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
return handlePermission(paramId, 4, relativeFlag, mdcProductionList, userList, true);
|
}
|
|
private boolean handleProcessStream(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
return handlePermission(paramId, 5, relativeFlag, mdcProductionList, userList, true);
|
}
|
|
private boolean handleWorkStep(String paramId, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
|
return handlePermission(paramId, 6, null, mdcProductionList, userList, true);
|
}
|
|
|
/**
|
* 移除权限
|
*/
|
private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
return handlePermission(paramId, 1, relativeFlag, mdcProductionList, userList, false);
|
}
|
|
private boolean handleComponentInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
return handlePermission(paramId, 2, relativeFlag, mdcProductionList, userList, false);
|
}
|
|
private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
return handlePermission(paramId, 3, relativeFlag, mdcProductionList, userList, false);
|
}
|
|
private boolean handleProcessSpecVersionRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
return handlePermission(paramId, 4, relativeFlag, mdcProductionList, userList, false);
|
}
|
|
private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
return handlePermission(paramId, 5, relativeFlag, mdcProductionList, userList, false);
|
}
|
|
private boolean handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
|
return handlePermission(paramId, 6, null, mdcProductionList, userList, false);
|
}
|
|
/**
|
* 通用权限处理方法
|
*/
|
private boolean handlePermission(String paramId, int type, Integer relativeFlag,
|
Collection<MdcProduction> mdcProductionList,
|
Collection<SysUser> userList, boolean isAddOperation) {
|
|
// 获取实体和进行存在性检查
|
Object entity = getEntityById(type, paramId);
|
if (entity == null) {
|
throwExceptionForType(type);
|
}
|
|
// 权限检查
|
String entityId = getEntityId(entity, type);
|
if (!checkProductPerm(type, entityId)) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
|
// 获取子节点列表
|
List<ProductMix> productMixList = productMixService.getChildrenList(entityId);
|
boolean result;
|
|
// 执行用户/部门的权限操作
|
if (userList != null) {
|
result = executeUserPermissionOperation(entity, type, userList, isAddOperation);
|
handleChildrenPermission(productMixList, relativeFlag, userList, null, isAddOperation);
|
} else {
|
result = executeDepartmentPermissionOperation(entity, type, mdcProductionList, isAddOperation);
|
handleChildrenPermission(productMixList, relativeFlag, null, mdcProductionList, isAddOperation);
|
}
|
|
if (!result) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
|
return true;
|
}
|
|
/**
|
* 处理子节点权限
|
*/
|
private void handleChildrenPermission(List<ProductMix> productMixList, Integer relativeFlag,
|
Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList,
|
boolean isAddOperation) {
|
if (relativeFlag != 1) return;
|
|
productMixList.forEach(productMix -> {
|
int childType = productMix.getTreeType();
|
executeChildPermissionOperation(String.valueOf(productMix.getId()), childType, userList, mdcProductionList, isAddOperation);
|
});
|
}
|
|
/**
|
* 根据类型执行子节点权限操作
|
*/
|
private void executeChildPermissionOperation(String id, int type,
|
Collection<SysUser> userList,
|
Collection<MdcProduction> mdcProductionList,
|
boolean isAddOperation) {
|
switch (type) {
|
case 2: // 组件
|
ComponentInfo componentInfo = componentInfoService.getById(id);
|
if (userList != null) {
|
componentInfoService.assignPermission(componentInfo, userList, isAddOperation);
|
} else {
|
componentInfoService.assignDepartPermission(componentInfo, mdcProductionList, isAddOperation);
|
}
|
break;
|
case 3: // 零件
|
PartsInfo partsInfo = partsInfoService.getById(id);
|
if (userList != null) {
|
partsInfoService.assignPermission(partsInfo, userList, isAddOperation);
|
} else {
|
partsInfoService.assignDepartPermission(partsInfo, mdcProductionList, isAddOperation);
|
}
|
break;
|
case 4: // 工艺规范
|
ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(id);
|
if (userList != null) {
|
processSpecVersionService.assignPermission(processSpecVersion, userList, isAddOperation);
|
} else {
|
processSpecVersionService.assignDepartPermission(processSpecVersion, mdcProductionList, isAddOperation);
|
}
|
break;
|
case 5: // 工序
|
ProcessStream processStream = processStreamService.getById(id);
|
if (userList != null) {
|
processStreamService.assignPermission(processStream, userList, isAddOperation);
|
} else {
|
processStreamService.assignDepartPermission(processStream, mdcProductionList, isAddOperation);
|
}
|
break;
|
case 6: // 工步
|
WorkStep workStep = workStepService.getById(id);
|
if (userList != null) {
|
workStepService.assignPermission(workStep, userList, isAddOperation);
|
} else {
|
workStepService.assignDepartPermission(workStep, mdcProductionList, isAddOperation);
|
}
|
break;
|
}
|
}
|
|
/**
|
* 根据类型获取实体
|
*/
|
private Object getEntityById(int type, String paramId) {
|
switch (type) {
|
case 1: return super.getById(paramId); // 产品
|
case 2: return componentInfoService.getById(paramId); // 组件
|
case 3: return partsInfoService.getById(paramId); // 零件
|
case 4: return processSpecVersionService.getById(paramId); // 工艺规范
|
case 5: return processStreamService.getById(paramId); // 工序
|
case 6: return workStepService.getById(paramId); // 工步
|
default: return null;
|
}
|
}
|
|
/**
|
* 根据类型抛出异常
|
*/
|
private void throwExceptionForType(int type) {
|
switch (type) {
|
case 1: ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
|
case 2: ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
|
case 3: ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
case 4: ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
|
case 5: ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
|
case 6: ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
|
}
|
}
|
|
/**
|
* 获取实体ID
|
*/
|
private String getEntityId(Object entity, int type) {
|
switch (type) {
|
case 1: return ((ProductInfo) entity).getProductId();
|
case 2: return ((ComponentInfo) entity).getComponentId();
|
case 3: return ((PartsInfo) entity).getPartsId();
|
case 4: return ((ProcessSpecVersion) entity).getId();
|
case 5: return ((ProcessStream) entity).getProcessId();
|
case 6: return ((WorkStep) entity).getId();
|
default: return null;
|
}
|
}
|
|
/**
|
* 执行用户权限操作
|
*/
|
private boolean executeUserPermissionOperation(Object entity, int type,
|
Collection<SysUser> userList,
|
boolean isAddOperation) {
|
switch (type) {
|
case 1:
|
return isAddOperation ?
|
assignAddUser((ProductInfo) entity, userList) :
|
assignRemoveUser((ProductInfo) entity, userList);
|
case 2:
|
return isAddOperation ?
|
componentInfoService.assignAddUser((ComponentInfo) entity, userList) :
|
componentInfoService.assignRemoveUser((ComponentInfo) entity, userList);
|
case 3:
|
return isAddOperation ?
|
partsInfoService.assignAddUser((PartsInfo) entity, userList) :
|
partsInfoService.assignRemoveUser((PartsInfo) entity, userList);
|
case 4:
|
return isAddOperation ?
|
processSpecVersionService.assignAddUser((ProcessSpecVersion) entity, userList) :
|
processSpecVersionService.assignRemoveUser((ProcessSpecVersion) entity, userList);
|
case 5:
|
return isAddOperation ?
|
processStreamService.assignAddUser((ProcessStream) entity, userList) :
|
processStreamService.assignRemoveUser((ProcessStream) entity, userList);
|
case 6:
|
return isAddOperation ?
|
workStepService.assignAddUser((WorkStep) entity, userList) :
|
workStepService.assignRemoveUser((WorkStep) entity, userList);
|
default: return false;
|
}
|
}
|
|
/**
|
* 执行部门权限操作
|
*/
|
private boolean executeDepartmentPermissionOperation(Object entity, int type,
|
Collection<MdcProduction> mdcProductionList,
|
boolean isAddOperation) {
|
switch (type) {
|
case 1:
|
return isAddOperation ?
|
assignAddDepartment((ProductInfo) entity, mdcProductionList) :
|
assignRemoveDepartment((ProductInfo) entity, mdcProductionList);
|
case 2:
|
return isAddOperation ?
|
componentInfoService.assignAddDepart((ComponentInfo) entity, mdcProductionList) :
|
componentInfoService.assignRemoveDepart((ComponentInfo) entity, mdcProductionList);
|
case 3:
|
return isAddOperation ?
|
partsInfoService.assignAddDepart((PartsInfo) entity, mdcProductionList) :
|
partsInfoService.assignRemoveDepart((PartsInfo) entity, mdcProductionList);
|
case 4:
|
return isAddOperation ?
|
processSpecVersionService.assignAddDepart((ProcessSpecVersion) entity, mdcProductionList) :
|
processSpecVersionService.assignRemoveDepart((ProcessSpecVersion) entity, mdcProductionList);
|
case 5:
|
return isAddOperation ?
|
processStreamService.assignAddDepart((ProcessStream) entity, mdcProductionList) :
|
processStreamService.assignRemoveDepart((ProcessStream) entity, mdcProductionList);
|
case 6:
|
return isAddOperation ?
|
workStepService.assignAddDepart((WorkStep) entity, mdcProductionList) :
|
workStepService.assignRemoveDepart((WorkStep) entity, mdcProductionList);
|
default: return false;
|
}
|
}
|
}
|
