package org.jeecg.modules.dnc.service.impl;
|
|
import cn.hutool.core.util.StrUtil;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import org.apache.shiro.SecurityUtils;
|
import org.jeecg.common.system.vo.LoginUser;
|
import org.jeecg.modules.dnc.dto.ComponentExt;
|
|
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.Department;
|
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
|
import org.jeecg.modules.dnc.utils.ValidateUtil;
|
|
import org.jeecg.modules.dnc.entity.*;
|
import org.jeecg.modules.system.entity.MdcProduction;
|
import org.jeecg.modules.system.entity.SysUser;
|
import org.jeecg.modules.system.service.IMdcProductionService;
|
import org.jeecg.modules.system.service.ISysUserService;
|
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
|
@Service
|
@Slf4j
|
public class ProductInfoServiceImpl extends ServiceImpl<ProductInfoMapper,ProductInfo> implements IProductInfoService {
|
@Autowired
|
@Lazy
|
private IComponentInfoService componentInfoService;
|
@Autowired
|
@Lazy
|
private IPartsInfoService partsInfoService;
|
@Autowired
|
private IProductPermissionService productPermissionService;
|
@Autowired
|
private IProductDepartmentService productDepartmentService;
|
@Autowired
|
private IPermissionStreamService permissionStreamService;
|
@Autowired
|
private IComponentDepartmentService componentDepartmentService;
|
@Autowired
|
private IComponentPermissionService componentPermissionService;
|
@Autowired
|
private IPartsDepartmentService partsDepartmentService;
|
@Autowired
|
private IPartsPermissionService partsPermissionService;
|
@Autowired
|
private IDepartmentService departmentService;
|
@Autowired
|
private ISysUserService userService;
|
@Autowired
|
@Lazy
|
private IProcessStreamService processStreamService;
|
@Autowired
|
private IWorkStepService workStepService;
|
@Autowired
|
private IDocInfoService docInfoService;
|
@Autowired
|
private INcLogInfoService iNcLogInfoService;
|
@Autowired
|
private IWorkStepDepartmentService workStepDepartmentService;
|
@Autowired
|
private IProcessionDepartmentService processionDepartmentService;
|
@Autowired
|
private IMdcProductionService mdcProductionService;
|
|
@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);
|
//添加日志
|
NcLogInfo ncLogInfo = new NcLogInfo();
|
//模块
|
ncLogInfo.setModuleInfo("产品结构树");
|
//类型
|
ncLogInfo.setOperateType(2);
|
//日志内容
|
ncLogInfo.setLogContent("产品名称："+productInfo.getProductName()+"，产品编号："+productInfo.getProductNo());
|
iNcLogInfoService.saveLogNcInfos(ncLogInfo);
|
boolean b = super.save(productInfo);
|
if(!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
|
}
|
ProductPermission permission = new ProductPermission();
|
permission.setProductId(productInfo.getProductId());
|
permission.setUserId(userId);
|
b = productPermissionService.save(permission);
|
if(!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
|
}
|
PermissionStream stream = new PermissionStream();
|
stream.setProductId(productInfo.getProductId());
|
stream.setUserId(userId);
|
return permissionStreamService.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);
|
//添加日志
|
NcLogInfo ncLogInfo = new NcLogInfo();
|
//模块
|
ncLogInfo.setModuleInfo("产品结构树");
|
//类型
|
ncLogInfo.setOperateType(3);
|
//日志内容
|
ncLogInfo.setLogContent("产品名称："+productInfo.getProductName());
|
ncLogInfo.setRemark(JSONObject.toJSONString(en));
|
iNcLogInfoService.saveLogNcInfos(ncLogInfo);
|
boolean b = super.updateById(productInfo);
|
if(!b)
|
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;
|
}
|
}
|
PermissionStream stream = permissionStreamService.getByProductIdAndUserId(id, userId);
|
if(stream == null) {
|
stream = new PermissionStream();
|
stream.setProductId(id);
|
stream.setUserId(userId);
|
return permissionStreamService.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<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,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);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = productDepartmentService.deleteByProductId(id);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = permissionStreamService.deleteUserPermsByProductId(id);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = permissionStreamService.deleteDepartPermsByProductId(id);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = docInfoService.deleteByProductId(id);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
//添加日志
|
NcLogInfo ncLogInfo = new NcLogInfo();
|
//模块
|
ncLogInfo.setModuleInfo("产品结构树");
|
//类型
|
ncLogInfo.setOperateType(4);
|
//日志内容
|
ncLogInfo.setLogContent("产品名称："+productInfo.getProductName());
|
iNcLogInfoService.saveLogNcInfos(ncLogInfo);
|
return super.removeById(id);
|
}
|
|
@Override
|
public boolean checkProductPerm(Integer nodeType, String paramId) {
|
if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
|
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);
|
PermissionStream permission = permissionStreamService.getByProductIdAndUserId(paramId, userId);
|
return permission != null;
|
}else if(nodeType == 2) {
|
ComponentInfo componentInfo = componentInfoService.getById(paramId);
|
if(componentInfo == null)
|
ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
|
PermissionStream permission = permissionStreamService.getByComponentIdAndUserId(componentInfo.getProductId(), paramId, userId);
|
return permission != null;
|
}else if(nodeType == 3) {
|
PartsInfo partsInfo = partsInfoService.getById(paramId);
|
if(partsInfo == null)
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
PermissionStream permission = permissionStreamService.getByPartsIdAndUserId(partsInfo.getProductId(), partsInfo.getComponentId(), paramId, userId);
|
return permission != null;
|
}else if (nodeType == 5) {
|
ProcessStream processStream=processStreamService.getById(paramId);
|
if(processStream == null)
|
ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
|
PermissionStream permission = permissionStreamService.getByProcessIdAndUserId(processStream.getProcessId(),processStream.getComponentId()
|
,processStream.getPartsId(),processStream.getProcessId(),userId);
|
return permission != null;
|
}else if (nodeType == 6){
|
WorkStep workStep=workStepService.getById(paramId);
|
if(workStep == null)
|
ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
|
PermissionStream permission = permissionStreamService.getByStepIdAndUserId(workStep.getProcessId(),workStep.getComponentId()
|
,workStep.getPartsId(),workStep.getProcessId(),workStep.getId(),userId);
|
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 {
|
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 {
|
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 == 5) {
|
return processionDepartmentService.getDepartPermsByProcessId(paramId);
|
}else if(nodeType == 6) {
|
return workStepDepartmentService.getDepartPermsByStepId(paramId);
|
}
|
//todo 封装树状结构
|
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 == 5) {
|
return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
|
}else if(nodeType == 6) {
|
return workStepDepartmentService.getDepartNonPermsByStepId(paramId);
|
}
|
//todo 封装树状结构
|
else {
|
return null;
|
}
|
}
|
|
/**
|
* 1、循环插入优化
|
* 2、查询优化
|
* 3、封装优化 TODO
|
* @param nodeType 1 产品 2 部件 3 零件
|
* @param paramId 产品树节点id
|
* @param relativeFlag 1 是 2 否
|
* @param userIds 添加用户ids
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean assignAddUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
|
//参数校验
|
if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
|
!ValidateUtil.validateInteger(relativeFlag))
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
if(userIds == null || userIds.length < 1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
|
List<String> ids = new ArrayList<>(userIds.length);
|
Collections.addAll(ids, userIds);
|
Collection<SysUser> userList = userService.listByIds(ids);
|
if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
//节点类型判定
|
if(nodeType == 3) {
|
//处理零件
|
PartsInfo partsInfo = partsInfoService.getById(paramId);
|
if(partsInfo == null)
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
boolean b = checkProductPerm(3, partsInfo.getPartsId());
|
if(!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
return partsInfoService.assignAddUser(partsInfo, userList);
|
}else if(nodeType == 1) {
|
//处理产品
|
ProductInfo productInfo = super.getById(paramId);
|
if(productInfo == null)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
|
boolean b1 = checkProductPerm(1, productInfo.getProductId());
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
b1 = this.assignAddUser(productInfo, userList);
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
if(relativeFlag == 1) {
|
|
List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
|
if(componentInfoList == null || componentInfoList.isEmpty()){
|
//没有可添加的零部件权限
|
return true;
|
}
|
|
//最终保存权限数据初始化
|
List<ComponentPermission> componentPermissionList = new ArrayList<>();
|
List<PartsPermission> partsPermissionList = new ArrayList<>();
|
List<PermissionStream> permissionStreamList = new ArrayList<>();
|
//处理子部件
|
List<String> componentIds = new ArrayList<>();
|
PermissionStream s;
|
|
Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
|
Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
|
|
//初始化全体数据
|
String key;
|
ComponentPermission cp;
|
ComponentInfo cpInfo;
|
for(ComponentInfo c : componentInfoList){
|
componentIds.add(c.getComponentId());
|
componentInfoMap.put(c.getComponentId(), c);
|
for(SysUser u : userList){
|
key = c.getComponentId() + "," + u.getId();
|
cp = new ComponentPermission(c.getComponentId(), u.getId());
|
componentPermissionMap.put(key, cp);
|
}
|
}
|
//查询已存在的权限数据
|
List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
|
if(existList != null && !existList.isEmpty()){
|
//踢出权限数据
|
for(ComponentPermission permission : existList){
|
key = permission.getComponentId() + "," + permission.getUserId();
|
if(componentPermissionMap.containsKey(key)){
|
componentPermissionMap.remove(key);
|
}
|
}
|
}
|
for(Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()){
|
cp = entry.getValue();
|
componentPermissionList.add(cp);
|
cpInfo = componentInfoMap.get(cp.getComponentId());
|
s = new PermissionStream();
|
s.setProductId(cpInfo.getProductId());
|
s.setComponentId(cpInfo.getComponentId());
|
s.setUserId(cp.getUserId());
|
permissionStreamList.add(s);
|
}
|
|
//处理子零件
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
|
if(partsInfoList != null && !partsInfoList.isEmpty()) {
|
Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
|
Map<String, PartsInfo> partsInfoMap = new HashMap<>();
|
List<String> partsIds = new ArrayList<>();
|
PartsPermission pp;
|
PartsInfo ptInfo;
|
for(PartsInfo p : partsInfoList){
|
partsIds.add(p.getPartsId());
|
partsInfoMap.put(p.getPartsId(), p);
|
for(SysUser u : userList){
|
key = p.getPartsId() + "," + u.getId();
|
pp = new PartsPermission(p.getPartsId(), u.getId());
|
partsPermissionHashMap.put(key, pp);
|
}
|
}
|
|
//查询已存在的权限数据
|
List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
|
if(existPartsList != null && !existPartsList.isEmpty()){
|
//踢出权限数据
|
for(PartsPermission permission : existPartsList){
|
key = permission.getPartsId() + "," + permission.getUserId();
|
if(partsPermissionHashMap.containsKey(key)){
|
partsPermissionHashMap.remove(key);
|
}
|
}
|
}
|
|
for(Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()){
|
pp = entry.getValue();
|
partsPermissionList.add(pp);
|
ptInfo = partsInfoMap.get(pp.getPartsId());
|
s = new PermissionStream();
|
s.setProductId(ptInfo.getProductId());
|
s.setComponentId(ptInfo.getComponentId());
|
s.setPartsId(ptInfo.getPartsId());
|
s.setUserId(pp.getUserId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
if(!componentPermissionList.isEmpty()){
|
componentPermissionService.saveBatch(componentPermissionList);
|
}
|
if(!partsPermissionList.isEmpty()){
|
partsPermissionService.saveBatch(partsPermissionList);
|
}
|
if(!permissionStreamList.isEmpty()){
|
permissionStreamService.saveBatch(permissionStreamList);
|
}
|
}
|
return true;
|
}else if(nodeType == 2) {
|
//处理部件
|
ComponentInfo componentInfo = componentInfoService.getById(paramId);
|
if(componentInfo == null)
|
ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
|
boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
|
if(!b1){
|
//没有当前部件的权限
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
b1 = componentInfoService.assignAddUser(componentInfo, userList);
|
if(!b1){
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
if(relativeFlag == 1) {
|
//最终保存权限数据初始化
|
List<ComponentPermission> componentPermissionList = new ArrayList<>();
|
List<PartsPermission> partsPermissionList = new ArrayList<>();
|
List<PermissionStream> permissionStreamList = new ArrayList<>();
|
|
List<String> componentIds = new ArrayList<>();
|
PermissionStream s;
|
String key;
|
//处理子部件
|
List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
|
if(childrenList != null && !childrenList.isEmpty()) {
|
Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
|
Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
|
|
//初始化全体数据
|
ComponentPermission cp;
|
ComponentInfo cpInfo;
|
for(ComponentInfo c : childrenList){
|
componentIds.add(c.getComponentId());
|
componentInfoMap.put(c.getComponentId(), c);
|
for(SysUser u : userList){
|
key = c.getComponentId() + "," + u.getId();
|
cp = new ComponentPermission(c.getComponentId(), u.getId());
|
componentPermissionMap.put(key, cp);
|
}
|
}
|
//查询已存在的权限数据
|
List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
|
if(existList != null && !existList.isEmpty()){
|
//踢出权限数据
|
for(ComponentPermission permission : existList){
|
key = permission.getComponentId() + "," + permission.getUserId();
|
if(componentPermissionMap.containsKey(key)){
|
componentPermissionMap.remove(key);
|
}
|
}
|
}
|
for(Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()){
|
cp = entry.getValue();
|
componentPermissionList.add(cp);
|
cpInfo = componentInfoMap.get(cp.getComponentId());
|
s = new PermissionStream();
|
s.setProductId(cpInfo.getProductId());
|
s.setComponentId(cpInfo.getComponentId());
|
s.setUserId(cp.getUserId());
|
permissionStreamList.add(s);
|
}
|
}
|
//处理零件
|
componentIds.add(componentInfo.getComponentId());
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIds);
|
if(partsInfoList != null && !partsInfoList.isEmpty()) {
|
Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
|
Map<String, PartsInfo> partsInfoMap = new HashMap<>();
|
List<String> partsIds = new ArrayList<>();
|
PartsPermission pp;
|
PartsInfo ptInfo;
|
for(PartsInfo p : partsInfoList){
|
partsIds.add(p.getPartsId());
|
partsInfoMap.put(p.getPartsId(), p);
|
for(SysUser u : userList){
|
key = p.getPartsId() + "," + u.getId();
|
pp = new PartsPermission(p.getPartsId(), u.getId());
|
partsPermissionHashMap.put(key, pp);
|
}
|
}
|
|
//查询已存在的权限数据
|
List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
|
if(existPartsList != null && !existPartsList.isEmpty()){
|
//踢出权限数据
|
for(PartsPermission permission : existPartsList){
|
key = permission.getPartsId() + "," + permission.getUserId();
|
if(partsPermissionHashMap.containsKey(key)){
|
partsPermissionHashMap.remove(key);
|
}
|
}
|
}
|
|
for(Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()){
|
pp = entry.getValue();
|
partsPermissionList.add(pp);
|
ptInfo = partsInfoMap.get(pp.getPartsId());
|
s = new PermissionStream();
|
s.setProductId(ptInfo.getProductId());
|
s.setComponentId(ptInfo.getComponentId());
|
s.setPartsId(ptInfo.getPartsId());
|
s.setUserId(pp.getUserId());
|
permissionStreamList.add(s);
|
}
|
}
|
if(!componentPermissionList.isEmpty()){
|
componentPermissionService.saveBatch(componentPermissionList);
|
}
|
if(!partsPermissionList.isEmpty()){
|
partsPermissionService.saveBatch(partsPermissionList);
|
}
|
if(!permissionStreamList.isEmpty()){
|
permissionStreamService.saveBatch(permissionStreamList);
|
}
|
}
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 待优化 TODO
|
* @param nodeType 1 产品 2 部件 3 零件
|
* @param paramId 产品树节点id
|
* @param relativeFlag 1 是 2 否
|
* @param userIds 移除用户ids
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean assignRemoveUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
|
if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
|
!ValidateUtil.validateInteger(relativeFlag))
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
if(userIds == null || userIds.length < 1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
|
List<String> ids = new ArrayList<>(userIds.length);
|
Collections.addAll(ids, userIds);
|
Collection<SysUser> userList = userService.listByIds(ids);
|
if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
if(nodeType == 3) {
|
//处理零件
|
PartsInfo partsInfo = partsInfoService.getById(paramId);
|
if(partsInfo == null)
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
boolean b = checkProductPerm(3, partsInfo.getPartsId());
|
if(!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
return partsInfoService.assignRemoveUser(partsInfo, userList);
|
}else if(nodeType == 1) {
|
//处理产品
|
ProductInfo productInfo = super.getById(paramId);
|
if(productInfo == null)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
|
boolean b1 = checkProductPerm(1, productInfo.getProductId());
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
b1 = this.assignRemoveUser(productInfo, userList);
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
if(relativeFlag == 1) {
|
//处理产品 下的部件
|
List<String> componentIds = new ArrayList<>();
|
//总计需要删除的数据信息
|
List<ComponentPermission> componentPermissionList = new ArrayList<>();
|
List<PartsPermission> partsPermissionList = new ArrayList<>();
|
List<PermissionStream> permissionStreamList = new ArrayList<>();
|
List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
|
if(componentInfoList != null && !componentInfoList.isEmpty()) {
|
for(ComponentInfo componentInfo : componentInfoList){
|
componentIds.add(componentInfo.getComponentId());
|
}
|
componentPermissionList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndUserIds(componentIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
//处理产品 下的零件
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
|
List<String> partsIds = new ArrayList<>();
|
if(partsInfoList != null && !partsInfoList.isEmpty()) {
|
for(PartsInfo partsInfo : partsInfoList){
|
partsIds.add(partsInfo.getPartsId());
|
}
|
partsPermissionList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndUserIds(partsIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
if(componentPermissionList != null && !componentPermissionList.isEmpty()){
|
componentPermissionService.removeByCollection(componentPermissionList);
|
}
|
if(partsPermissionList != null && !partsPermissionList.isEmpty()){
|
partsPermissionService.removeByCollection(partsPermissionList);
|
}
|
if(permissionStreamList != null && !permissionStreamList.isEmpty()){
|
permissionStreamService.removeByCollection(permissionStreamList);
|
}
|
}
|
return true;
|
}else if(nodeType == 2) {
|
ComponentInfo componentInfo = componentInfoService.getById(paramId);
|
if(componentInfo == null)
|
ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
|
boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
b1 = componentInfoService.assignRemoveUser(componentInfo, userList);
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
if(relativeFlag == 1) {
|
List<String> componentIdList = new ArrayList<>();
|
//最终需要删除的数据
|
List<ComponentPermission> componentPermissionList = new ArrayList<>();
|
List<PartsPermission> partsPermissionList = new ArrayList<>();
|
List<PermissionStream> permissionStreamList = new ArrayList<>();
|
List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
|
if(childrenList != null && !childrenList.isEmpty()) {
|
for(ComponentInfo component : childrenList){
|
componentIdList.add(component.getComponentId());
|
}
|
componentPermissionList = componentPermissionService.getByComponentIdsAndUserIds(componentIdList, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndUserIds(componentIdList, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
componentIdList.add(componentInfo.getComponentId());
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
|
List<String> partsIds = new ArrayList<>();
|
if(partsInfoList != null && !partsInfoList.isEmpty()) {
|
for(PartsInfo partsInfo : partsInfoList){
|
partsIds.add(partsInfo.getPartsId());
|
}
|
partsPermissionList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndUserIds(partsIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
if(componentPermissionList != null && !componentPermissionList.isEmpty()){
|
componentPermissionService.removeByCollection(componentPermissionList);
|
}
|
if(partsPermissionList != null && !partsPermissionList.isEmpty()){
|
partsPermissionService.removeByCollection(partsPermissionList);
|
}
|
if(permissionStreamList != null && !permissionStreamList.isEmpty()){
|
permissionStreamService.removeByCollection(permissionStreamList);
|
}
|
}
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 待优化 TODO
|
* @param nodeType 1 产品 2 部件 3 零件 5 工序 6 工步
|
* @param paramId 产品树节点id
|
* @param relativeFlag 1 是 2 否
|
* @param departmentIds 添加部门ids
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean assignAddDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
|
if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
|
!ValidateUtil.validateInteger(relativeFlag))
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
if(departmentIds == null || departmentIds.length < 1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
|
List<String> ids = new ArrayList<>(departmentIds.length);
|
Collections.addAll(ids, departmentIds);
|
Collection<MdcProduction> mdcProductionList=mdcProductionService.listByIds(ids);
|
if(mdcProductionList == null || mdcProductionList.isEmpty() || mdcProductionList.size() != departmentIds.length)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
if(nodeType == 6) {
|
//处理工步
|
WorkStep workStep=workStepService.getById(paramId);
|
if (workStep == null)
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
boolean b = checkProductPerm(6, workStep.getId());
|
if (!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
return workStepService.assignAddDepart(workStep, mdcProductionList);
|
}else if(nodeType == 5) {
|
//处理工序
|
ProcessStream processStream = processStreamService.getById(paramId);
|
if (processStream == null)
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
boolean b = checkProductPerm(5, processStream.getProcessId());
|
if (!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
return processStreamService.assignAddDepart(processStream, mdcProductionList);
|
}else if(nodeType == 3) {
|
//处理零件
|
PartsInfo partsInfo = partsInfoService.getById(paramId);
|
if(partsInfo == null)
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
boolean b = checkProductPerm(3, partsInfo.getPartsId());
|
if(!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
return partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
|
}else if(nodeType == 1) {
|
//处理产品
|
ProductInfo productInfo = super.getById(paramId);
|
if(productInfo == null)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
|
boolean b1 = checkProductPerm(1, productInfo.getProductId());
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
b1 = this.assignAddDepartment(productInfo, mdcProductionList);
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
if(relativeFlag == 1) {
|
//处理产品 下的部件
|
List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
|
//最终保存权限数据初始化
|
List<ComponentDepartment> componentPermissionList = new ArrayList<>();
|
List<PartsDepartment> partsPermissionList = new ArrayList<>();
|
List<ProcessionDepartment> processionPermissionList = new ArrayList<>();
|
List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
|
List<PermissionStream> permissionStreamList = new ArrayList<>();
|
//处理子部件
|
List<String> componentIds = new ArrayList<>();
|
List<String> partsIds= new ArrayList<>();
|
List<String> ProcessionIds= new ArrayList<>();
|
List<String> workStepIds= new ArrayList<>();
|
PermissionStream s;
|
|
Map<String, ComponentDepartment> componentPermissionMap = new HashMap<>();
|
Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
|
|
//初始化全体数据
|
String key;
|
ComponentDepartment cp;
|
ComponentInfo cpInfo;
|
for(ComponentInfo c : componentInfoList){
|
componentIds.add(c.getComponentId());
|
componentInfoMap.put(c.getComponentId(), c);
|
for(MdcProduction mdcProduction : mdcProductionList){
|
key = c.getComponentId() + "," + mdcProduction.getId();
|
cp = new ComponentDepartment(c.getComponentId(), mdcProduction.getId());
|
componentPermissionMap.put(key, cp);
|
}
|
}
|
//查询已存在的权限数据
|
List<ComponentDepartment> existList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, ids);
|
if(existList != null && !existList.isEmpty()){
|
//踢出权限数据
|
for(ComponentDepartment permission : existList){
|
key = permission.getComponentId() + "," + permission.getDepartId();
|
if(componentPermissionMap.containsKey(key)){
|
componentPermissionMap.remove(key);
|
}
|
}
|
}
|
for(Map.Entry<String, ComponentDepartment> entry : componentPermissionMap.entrySet()){
|
cp = entry.getValue();
|
componentPermissionList.add(cp);
|
cpInfo = componentInfoMap.get(cp.getComponentId());
|
s = new PermissionStream();
|
s.setProductId(cpInfo.getProductId());
|
s.setComponentId(cpInfo.getComponentId());
|
s.setDepartId(cp.getDepartId());
|
permissionStreamList.add(s);
|
}
|
|
//处理子零件
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
|
if(partsInfoList != null && !partsInfoList.isEmpty()) {
|
Map<String, PartsDepartment> partsPermissionHashMap = new HashMap<>();
|
Map<String, PartsInfo> partsInfoMap = new HashMap<>();
|
partsIds = new ArrayList<>();
|
PartsDepartment pp;
|
PartsInfo ptInfo;
|
for(PartsInfo p : partsInfoList){
|
partsIds.add(p.getPartsId());
|
partsInfoMap.put(p.getPartsId(), p);
|
for(MdcProduction mdcProduction : mdcProductionList){
|
key = p.getPartsId() + "," + mdcProduction.getId();
|
pp = new PartsDepartment(p.getPartsId(), mdcProduction.getId());
|
partsPermissionHashMap.put(key, pp);
|
}
|
}
|
|
//查询已存在的权限数据
|
List<PartsDepartment> existPartsList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
|
if(existPartsList != null && !existPartsList.isEmpty()){
|
//踢出权限数据
|
for(PartsDepartment permission : existPartsList){
|
key = permission.getPartsId() + "," + permission.getDepartId();
|
if(partsPermissionHashMap.containsKey(key)){
|
partsPermissionHashMap.remove(key);
|
}
|
}
|
}
|
|
for(Map.Entry<String, PartsDepartment> entry : partsPermissionHashMap.entrySet()){
|
pp = entry.getValue();
|
partsPermissionList.add(pp);
|
ptInfo = partsInfoMap.get(pp.getPartsId());
|
s = new PermissionStream();
|
s.setProductId(ptInfo.getProductId());
|
s.setComponentId(ptInfo.getComponentId());
|
s.setPartsId(ptInfo.getPartsId());
|
s.setDepartId(pp.getDepartId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
//查询工序已存在的权限数据
|
List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productInfo.getProductId(),componentIds,partsIds);
|
if(processStreamList != null && !processStreamList.isEmpty()) {
|
Map<String, ProcessionDepartment> processionDepartmentHashMap = new HashMap<>();
|
Map<String, ProcessStream> processStreamMap = new HashMap<>();
|
ProcessionIds = new ArrayList<>();
|
ProcessionDepartment pp;
|
ProcessStream processStream;
|
for(ProcessStream p : processStreamList){
|
ProcessionIds.add(p.getProcessId());
|
processStreamMap.put(p.getProcessId(), p);
|
for(MdcProduction mdcProduction : mdcProductionList){
|
key = p.getPartsId() + "," + mdcProduction.getId();
|
pp = new ProcessionDepartment(p.getProcessId(), mdcProduction.getId());
|
processionDepartmentHashMap.put(key, pp);
|
}
|
}
|
|
//查询已存在的权限数据
|
List<ProcessionDepartment> processionDepartmentList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
|
if(processionDepartmentList != null && !processionDepartmentList.isEmpty()){
|
//踢出权限数据
|
for(ProcessionDepartment processionDepartment : processionDepartmentList){
|
key = processionDepartment.getProcessId() + "," + processionDepartment.getDepartId();
|
if(processionDepartmentHashMap.containsKey(key)){
|
processionDepartmentHashMap.remove(key);
|
}
|
}
|
}
|
|
for(Map.Entry<String, ProcessionDepartment> entry : processionDepartmentHashMap.entrySet()){
|
pp = entry.getValue();
|
processionPermissionList.add(pp);
|
processStream = processStreamMap.get(pp.getProcessId());
|
s = new PermissionStream();
|
s.setProductId(processStream.getProductId());
|
s.setComponentId(processStream.getComponentId());
|
s.setPartsId(processStream.getPartsId());
|
s.setProcessId(processStream.getProcessId());
|
s.setDepartId(pp.getDepartId());
|
permissionStreamList.add(s);
|
}
|
}
|
//查询工步已存在的权限数据
|
List<WorkStep> workStepList = workStepService.getByProcessIds(productInfo.getProductId(),ProcessionIds);
|
if(workStepList != null && !workStepList.isEmpty()) {
|
Map<String, WorkStepDepartment> workStepDepartmentHashMap = new HashMap<>();
|
Map<String, WorkStep> workStepHashMap = new HashMap<>();
|
workStepIds = new ArrayList<>();
|
WorkStepDepartment ws;
|
WorkStep workStep;
|
for(WorkStep w : workStepList){
|
workStepIds.add(w.getId());
|
workStepHashMap.put(w.getId(), w);
|
for(MdcProduction mdcProduction : mdcProductionList){
|
key = w.getId() + "," + mdcProduction.getId();
|
ws = new WorkStepDepartment(w.getId(), mdcProduction.getId());
|
workStepDepartmentHashMap.put(key, ws);
|
}
|
}
|
|
//查询已存在的权限数据
|
List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
|
if(workStepDepartments != null && !workStepDepartments.isEmpty()){
|
//踢出权限数据
|
for(WorkStepDepartment workStepDepartment : workStepDepartments){
|
key = workStepDepartment.getStepId() + "," + workStepDepartment.getDepartId();
|
if(workStepDepartmentHashMap.containsKey(key)){
|
workStepDepartmentHashMap.remove(key);
|
}
|
}
|
}
|
|
for(Map.Entry<String, WorkStepDepartment> entry : workStepDepartmentHashMap.entrySet()){
|
ws = entry.getValue();
|
workStepDepartmentList.add(ws);
|
workStep = workStepHashMap.get(ws.getStepId());
|
s = new PermissionStream();
|
s.setProductId(workStep.getProductId());
|
s.setComponentId(workStep.getComponentId());
|
s.setPartsId(workStep.getPartsId());
|
s.setProcessId(workStep.getProcessId());
|
s.setStepId(workStep.getId());
|
s.setDepartId(ws.getDepartId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
if(!componentPermissionList.isEmpty()){
|
componentDepartmentService.saveBatch(componentPermissionList);
|
}
|
if(!partsPermissionList.isEmpty()){
|
partsDepartmentService.saveBatch(partsPermissionList);
|
}
|
if(!processionPermissionList.isEmpty()){
|
processionDepartmentService.saveBatch(processionPermissionList);
|
}
|
if (!workStepDepartmentList.isEmpty()) {
|
workStepDepartmentService.saveBatch(workStepDepartmentList);
|
}
|
if(!permissionStreamList.isEmpty()){
|
permissionStreamService.saveBatch(permissionStreamList);
|
}
|
}
|
return true;
|
}else if(nodeType == 2) {
|
ComponentInfo componentInfo = componentInfoService.getById(paramId);
|
if(componentInfo == null)
|
ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
|
boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
b1 = componentInfoService.assignAddDepart(componentInfo, mdcProductionList);
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
if(relativeFlag == 1) {
|
List<String> componentIdList = new ArrayList<>();
|
List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
|
|
//最终保存权限数据初始化
|
List<ComponentDepartment> componentPermissionList = new ArrayList<>();
|
List<PartsDepartment> partsPermissionList = new ArrayList<>();
|
List<ProcessionDepartment> processionPermissionList = new ArrayList<>();
|
List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
|
List<PermissionStream> permissionStreamList = new ArrayList<>();
|
//处理子部件
|
PermissionStream s;
|
List<String> componentIds = new ArrayList<>();
|
List<String> partsIds= new ArrayList<>();
|
List<String> ProcessionIds= new ArrayList<>();
|
List<String> workStepIds= new ArrayList<>();
|
Map<String, ComponentDepartment> componentPermissionMap = new HashMap<>();
|
Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
|
|
//初始化全体数据
|
String key;
|
ComponentDepartment cp;
|
ComponentInfo cpInfo;
|
for(ComponentInfo c : childrenList){
|
componentIdList.add(c.getComponentId());
|
componentInfoMap.put(c.getComponentId(), c);
|
for(MdcProduction mdcProduction : mdcProductionList){
|
key = c.getComponentId() + "," + mdcProduction.getId();
|
cp = new ComponentDepartment(c.getComponentId(), mdcProduction.getId());
|
componentPermissionMap.put(key, cp);
|
}
|
}
|
//查询已存在的权限数据
|
List<ComponentDepartment> existList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIdList, ids);
|
if(existList != null && !existList.isEmpty()){
|
//踢出权限数据
|
for(ComponentDepartment permission : existList){
|
key = permission.getComponentId() + "," + permission.getDepartId();
|
if(componentPermissionMap.containsKey(key)){
|
componentPermissionMap.remove(key);
|
}
|
}
|
}
|
for(Map.Entry<String, ComponentDepartment> entry : componentPermissionMap.entrySet()){
|
cp = entry.getValue();
|
componentPermissionList.add(cp);
|
cpInfo = componentInfoMap.get(cp.getComponentId());
|
s = new PermissionStream();
|
s.setProductId(cpInfo.getProductId());
|
s.setComponentId(cpInfo.getComponentId());
|
s.setDepartId(cp.getDepartId());
|
permissionStreamList.add(s);
|
}
|
|
//处理子零件
|
componentIdList.add(componentInfo.getComponentId());
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
|
if(partsInfoList != null && !partsInfoList.isEmpty()) {
|
Map<String, PartsDepartment> partsPermissionHashMap = new HashMap<>();
|
Map<String, PartsInfo> partsInfoMap = new HashMap<>();
|
partsIds = new ArrayList<>();
|
PartsDepartment pp;
|
PartsInfo ptInfo;
|
for(PartsInfo p : partsInfoList){
|
partsIds.add(p.getPartsId());
|
partsInfoMap.put(p.getPartsId(), p);
|
for(MdcProduction mdcProduction : mdcProductionList){
|
key = p.getPartsId() + "," + mdcProduction.getId();
|
pp = new PartsDepartment(p.getPartsId(), mdcProduction.getId());
|
partsPermissionHashMap.put(key, pp);
|
}
|
}
|
|
//查询已存在的权限数据
|
List<PartsDepartment> existPartsList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
|
if(existPartsList != null && !existPartsList.isEmpty()){
|
//踢出权限数据
|
for(PartsDepartment permission : existPartsList){
|
key = permission.getPartsId() + "," + permission.getDepartId();
|
if(partsPermissionHashMap.containsKey(key)){
|
partsPermissionHashMap.remove(key);
|
}
|
}
|
}
|
|
for(Map.Entry<String, PartsDepartment> entry : partsPermissionHashMap.entrySet()){
|
pp = entry.getValue();
|
partsPermissionList.add(pp);
|
ptInfo = partsInfoMap.get(pp.getPartsId());
|
s = new PermissionStream();
|
s.setProductId(ptInfo.getProductId());
|
s.setComponentId(ptInfo.getComponentId());
|
s.setPartsId(ptInfo.getPartsId());
|
s.setDepartId(pp.getDepartId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
//查询工序已存在的权限数据
|
List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(componentInfo.getProductId(),componentIds,partsIds);
|
if(processStreamList != null && !processStreamList.isEmpty()) {
|
Map<String, ProcessionDepartment> processionDepartmentHashMap = new HashMap<>();
|
Map<String, ProcessStream> processStreamMap = new HashMap<>();
|
ProcessionIds = new ArrayList<>();
|
ProcessionDepartment pp;
|
ProcessStream processStream;
|
for(ProcessStream p : processStreamList){
|
ProcessionIds.add(p.getProcessId());
|
processStreamMap.put(p.getProcessId(), p);
|
for(MdcProduction mdcProduction : mdcProductionList){
|
key = p.getPartsId() + "," + mdcProduction.getId();
|
pp = new ProcessionDepartment(p.getProcessId(), mdcProduction.getId());
|
processionDepartmentHashMap.put(key, pp);
|
}
|
}
|
|
//查询已存在的权限数据
|
List<ProcessionDepartment> processionDepartmentList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
|
if(processionDepartmentList != null && !processionDepartmentList.isEmpty()){
|
//踢出权限数据
|
for(ProcessionDepartment processionDepartment : processionDepartmentList){
|
key = processionDepartment.getProcessId() + "," + processionDepartment.getDepartId();
|
if(processionDepartmentHashMap.containsKey(key)){
|
processionDepartmentHashMap.remove(key);
|
}
|
}
|
}
|
|
for(Map.Entry<String, ProcessionDepartment> entry : processionDepartmentHashMap.entrySet()){
|
pp = entry.getValue();
|
processionPermissionList.add(pp);
|
processStream = processStreamMap.get(pp.getProcessId());
|
s = new PermissionStream();
|
s.setProductId(processStream.getProductId());
|
s.setComponentId(processStream.getComponentId());
|
s.setPartsId(processStream.getPartsId());
|
s.setProcessId(processStream.getProcessId());
|
s.setDepartId(pp.getDepartId());
|
permissionStreamList.add(s);
|
}
|
}
|
//查询工步已存在的权限数据
|
List<WorkStep> workStepList = workStepService.getByProcessIds(componentInfo.getProductId(),ProcessionIds);
|
if(workStepList != null && !workStepList.isEmpty()) {
|
Map<String, WorkStepDepartment> workStepDepartmentHashMap = new HashMap<>();
|
Map<String, WorkStep> workStepHashMap = new HashMap<>();
|
workStepIds = new ArrayList<>();
|
WorkStepDepartment ws;
|
WorkStep workStep;
|
for(WorkStep w : workStepList){
|
workStepIds.add(w.getId());
|
workStepHashMap.put(w.getId(), w);
|
for(MdcProduction mdcProduction : mdcProductionList){
|
key = w.getId() + "," + mdcProduction.getId();
|
ws = new WorkStepDepartment(w.getId(), mdcProduction.getId());
|
workStepDepartmentHashMap.put(key, ws);
|
}
|
}
|
|
//查询已存在的权限数据
|
List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
|
if(workStepDepartments != null && !workStepDepartments.isEmpty()){
|
//踢出权限数据
|
for(WorkStepDepartment workStepDepartment : workStepDepartments){
|
key = workStepDepartment.getStepId() + "," + workStepDepartment.getDepartId();
|
if(workStepDepartmentHashMap.containsKey(key)){
|
workStepDepartmentHashMap.remove(key);
|
}
|
}
|
}
|
|
for(Map.Entry<String, WorkStepDepartment> entry : workStepDepartmentHashMap.entrySet()){
|
ws = entry.getValue();
|
workStepDepartmentList.add(ws);
|
workStep = workStepHashMap.get(ws.getStepId());
|
s = new PermissionStream();
|
s.setProductId(workStep.getProductId());
|
s.setComponentId(workStep.getComponentId());
|
s.setPartsId(workStep.getPartsId());
|
s.setProcessId(workStep.getProcessId());
|
s.setStepId(workStep.getId());
|
s.setDepartId(ws.getDepartId());
|
permissionStreamList.add(s);
|
}
|
}
|
|
if(!componentPermissionList.isEmpty()){
|
componentDepartmentService.saveBatch(componentPermissionList);
|
}
|
if(!partsPermissionList.isEmpty()){
|
partsDepartmentService.saveBatch(partsPermissionList);
|
}
|
if(!processionPermissionList.isEmpty()){
|
processionDepartmentService.saveBatch(processionPermissionList);
|
}
|
if (!workStepDepartmentList.isEmpty()) {
|
workStepDepartmentService.saveBatch(workStepDepartmentList);
|
}
|
if(!permissionStreamList.isEmpty()){
|
permissionStreamService.saveBatch(permissionStreamList);
|
}
|
}
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 待优化 TODO
|
* @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 assignRemoveDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
|
if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
|
!ValidateUtil.validateInteger(relativeFlag))
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
if(departmentIds == null || departmentIds.length < 1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
|
List<String> ids = new ArrayList<>(departmentIds.length);
|
Collections.addAll(ids, departmentIds);
|
Collection<MdcProduction> mdcProductionList=mdcProductionService.listByIds(ids);
|
if(mdcProductionList == null || mdcProductionList.isEmpty() || mdcProductionList.size() != departmentIds.length)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
if(nodeType == 6) {
|
//处理工步
|
WorkStep workStep=workStepService.getById(paramId);
|
if (workStep == null)
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
boolean b = checkProductPerm(6, workStep.getId());
|
if (!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
return workStepService.assignRemoveDepart(workStep, mdcProductionList);
|
}else if(nodeType == 5) {
|
//处理工序
|
ProcessStream processStream = processStreamService.getById(paramId);
|
if (processStream == null)
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
boolean b = checkProductPerm(5, processStream.getProcessId());
|
if (!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
return processStreamService.assignRemoveDepart(processStream, mdcProductionList);
|
}else if(nodeType == 3) {
|
//处理零件
|
PartsInfo partsInfo = partsInfoService.getById(paramId);
|
if(partsInfo == null)
|
ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
|
boolean b = checkProductPerm(3, partsInfo.getPartsId());
|
if(!b) {
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
}
|
return partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList);
|
}else if(nodeType == 1) {
|
//处理产品
|
ProductInfo productInfo = super.getById(paramId);
|
if(productInfo == null)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
|
boolean b1 = checkProductPerm(1, productInfo.getProductId());
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
b1 = this.assignRemoveDepartment(productInfo, mdcProductionList);
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
if(relativeFlag == 1) {
|
//处理产品 下的部件
|
List<String> componentIds = new ArrayList<>();
|
//总计需要删除的数据信息
|
List<ComponentDepartment> componentPermissionList = new ArrayList<>();
|
List<PartsDepartment> partsPermissionList = new ArrayList<>();
|
List<ProcessionDepartment> processionPermissionList = new ArrayList<>();
|
List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
|
List<PermissionStream> permissionStreamList = new ArrayList<>();
|
List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
|
List<String> partsIds= new ArrayList<>();
|
List<String> ProcessionIds= new ArrayList<>();
|
List<String> workStepIds= new ArrayList<>();
|
if(componentInfoList != null && !componentInfoList.isEmpty()) {
|
for(ComponentInfo componentInfo : componentInfoList){
|
componentIds.add(componentInfo.getComponentId());
|
}
|
componentPermissionList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndDepartIds(componentIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
//处理产品 下的零件
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
|
partsIds = new ArrayList<>();
|
if(partsInfoList != null && !partsInfoList.isEmpty()) {
|
for(PartsInfo partsInfo : partsInfoList){
|
partsIds.add(partsInfo.getPartsId());
|
}
|
partsPermissionList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(partsIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
//处理工序
|
List<ProcessStream> processStreamList=processStreamService.getByComponentIdList(productInfo.getProductId(), componentIds,partsIds);
|
ProcessionIds = new ArrayList<>();
|
if(processStreamList != null && !processStreamList.isEmpty()) {
|
for(ProcessStream processStream : processStreamList){
|
ProcessionIds.add(processStream.getProcessId());
|
}
|
processionPermissionList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
//处理工步
|
List<WorkStep> workStepList=workStepService.getByProcessIds(productInfo.getProductId(), ProcessionIds);
|
workStepIds = new ArrayList<>();
|
if(workStepList != null && !workStepList.isEmpty()) {
|
for(WorkStep workStep : workStepList){
|
workStepIds.add(workStep.getId());
|
}
|
workStepDepartmentList = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
if(componentPermissionList != null && !componentPermissionList.isEmpty()){
|
componentDepartmentService.removeByCollection(componentPermissionList);
|
}
|
if(partsPermissionList != null && !partsPermissionList.isEmpty()){
|
partsDepartmentService.removeByCollection(partsPermissionList);
|
}
|
if(processionPermissionList != null && !processionPermissionList.isEmpty()){
|
processionDepartmentService.removeByCollection(processionPermissionList);
|
}
|
if(workStepDepartmentList != null && !workStepDepartmentList.isEmpty()){
|
workStepDepartmentService.removeByCollection(workStepDepartmentList);
|
}
|
if(permissionStreamList != null && !permissionStreamList.isEmpty()){
|
permissionStreamService.removeByCollection(permissionStreamList);
|
}
|
}
|
return true;
|
}else if(nodeType == 2) {
|
ComponentInfo componentInfo = componentInfoService.getById(paramId);
|
if(componentInfo == null)
|
ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
|
boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
b1 = componentInfoService.assignRemoveDepart(componentInfo, mdcProductionList);
|
if(!b1)
|
ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
|
if(relativeFlag == 1) {
|
List<String> componentIdList = new ArrayList<>();
|
//总计需要删除的数据信息
|
List<ComponentDepartment> componentPermissionList = new ArrayList<>();
|
List<PartsDepartment> partsPermissionList = new ArrayList<>();
|
List<ProcessionDepartment> processionPermissionList = new ArrayList<>();
|
List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
|
List<PermissionStream> permissionStreamList = new ArrayList<>();
|
List<String> partsIds= new ArrayList<>();
|
List<String> ProcessionIds= new ArrayList<>();
|
List<String> workStepIds= new ArrayList<>();
|
List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
|
if(childrenList != null && !childrenList.isEmpty()) {
|
for(ComponentInfo cpn : childrenList){
|
componentIdList.add(cpn.getComponentId());
|
}
|
componentPermissionList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIdList, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndDepartIds(componentIdList, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
//处理产品 下的零件
|
componentIdList.add(componentInfo.getComponentId());
|
List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
|
partsIds = new ArrayList<>();
|
if(partsInfoList != null && !partsInfoList.isEmpty()) {
|
for(PartsInfo partsInfo : partsInfoList){
|
partsIds.add(partsInfo.getPartsId());
|
}
|
partsPermissionList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(partsIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
//处理工序
|
List<ProcessStream> processStreamList=processStreamService.getByComponentIdList(componentInfo.getProductId(), componentIdList,partsIds);
|
ProcessionIds = new ArrayList<>();
|
if(processStreamList != null && !processStreamList.isEmpty()) {
|
for(ProcessStream processStream : processStreamList){
|
ProcessionIds.add(processStream.getProcessId());
|
}
|
processionPermissionList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
//处理工步
|
List<WorkStep> workStepList=workStepService.getByProcessIds(componentInfo.getProductId(), ProcessionIds);
|
workStepIds = new ArrayList<>();
|
if(workStepList != null && !workStepList.isEmpty()) {
|
for(WorkStep workStep : workStepList){
|
workStepIds.add(workStep.getId());
|
}
|
workStepDepartmentList = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
|
List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, ids);
|
if(existPermissionList != null && !existPermissionList.isEmpty()){
|
permissionStreamList.addAll(existPermissionList);
|
}
|
}
|
|
if(componentPermissionList != null && !componentPermissionList.isEmpty()){
|
componentDepartmentService.removeByCollection(componentPermissionList);
|
}
|
if(partsPermissionList != null && !partsPermissionList.isEmpty()){
|
partsDepartmentService.removeByCollection(partsPermissionList);
|
}
|
if(processionPermissionList != null && !processionPermissionList.isEmpty()){
|
processionDepartmentService.removeByCollection(processionPermissionList);
|
}
|
if(workStepDepartmentList != null && !workStepDepartmentList.isEmpty()){
|
workStepDepartmentService.removeByCollection(workStepDepartmentList);
|
}
|
if(permissionStreamList != null && !permissionStreamList.isEmpty()){
|
permissionStreamService.removeByCollection(permissionStreamList);
|
}
|
}
|
return true;
|
}
|
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<PermissionStream> 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);
|
}
|
PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
|
if(stream == null) {
|
stream = new PermissionStream();
|
stream.setUserId(item.getId());
|
stream.setProductId(productInfo.getProductId());
|
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 = permissionStreamService.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<PermissionStream> permissionStreamList = new ArrayList<>();
|
userList.forEach(item -> {
|
ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
|
if(en != null) {
|
permissionList.add(en);
|
}
|
PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
|
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 = permissionStreamService.removeByCollection(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<PermissionStream> 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);
|
}
|
PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
|
if(stream == null) {
|
stream = new PermissionStream();
|
stream.setDepartId(item.getId());
|
stream.setProductId(productInfo.getProductId());
|
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 = permissionStreamService.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<PermissionStream> permissionStreamList = new ArrayList<>();
|
departmentList.forEach(item -> {
|
ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
|
if(en != null) {
|
productDepartmentList.add(en);
|
}
|
PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
|
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 = permissionStreamService.removeByCollection(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<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
|
.eq(StrUtil.isNotEmpty(processStream.getProductId()),"product_id", processStream.getProductId())
|
.eq(StrUtil.isNotEmpty(processStream.getComponentId()),"component_id",processStream.getComponentId())
|
.eq(StrUtil.isNotEmpty(processStream.getPartsId()),"parts_id", processStream.getPartsId())
|
.eq(StrUtil.isNotEmpty(processStream.getProcessId()),"process_id",processStream.getProcessId()));
|
if(permissionStreamList == null || permissionStreamList.isEmpty())
|
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<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
|
.eq(StrUtil.isNotEmpty(workStep.getProductId()),"product_id", workStep.getProductId())
|
.eq(StrUtil.isNotEmpty(workStep.getComponentId()),"component_id",workStep.getComponentId())
|
.eq(StrUtil.isNotEmpty(workStep.getPartsId()),"parts_id", workStep.getPartsId())
|
.eq(StrUtil.isNotEmpty(workStep.getProcessId()),"process_id",workStep.getProcessId())
|
.eq(StrUtil.isNotEmpty(workStep.getId()),"step_id", workStep.getId()));
|
if(permissionStreamList == null || permissionStreamList.isEmpty())
|
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<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,processStreams,workSteps);
|
}
|
}
|
