package com.vci.web.service.impl;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.vci.common.exception.VciException;
|
import com.vci.corba.common.PLException;
|
import com.vci.corba.common.data.UserEntityInfo;
|
import com.vci.corba.framework.data.*;
|
import com.vci.corba.omd.data.BusinessObject;
|
import com.vci.corba.portal.data.PLUILayout;
|
import com.vci.dto.RoleInfoDTO;
|
import com.vci.dto.RoleRightParamDTO;
|
import com.vci.model.SmFunctionForPlatform1;
|
import com.vci.model.SmRoleForPlatform1;
|
import com.vci.omd.utils.ObjectTool;
|
import com.vci.pagemodel.MenuVO;
|
import com.vci.pagemodel.RoleRightVO;
|
import com.vci.pagemodel.SmFunctionVO;
|
import com.vci.pagemodel.UIContentVO;
|
import com.vci.starter.web.constant.QueryOptionConstant;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.pagemodel.*;
|
import com.vci.starter.web.util.VciBaseUtil;
|
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
|
import com.vci.web.enumpck.ResourceControlTypeEnum;
|
import com.vci.web.properties.JsonConfigReader;
|
import com.vci.web.service.ISmFunctionQueryService;
|
import com.vci.web.service.UIEngineServiceI;
|
import com.vci.web.service.UIManagerServiceI;
|
import com.vci.web.service.WebBoServiceI;
|
import com.vci.starter.web.util.Lcm.Func;
|
import com.vci.web.util.PlatformClientUtil;
|
import com.vci.web.util.RightControlUtil;
|
import com.vci.web.util.WebUtil;
|
import org.apache.commons.lang3.StringUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 老平台的权限服务
|
* @author weidy
|
* @date 2020/3/1
|
*/
|
@Service
|
public class SmFunctionQueryServicePlatformImpl implements ISmFunctionQueryService {
|
|
/**
|
* 日志
|
*/
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
|
/**
|
* 菜单的根节点主键，这个是平台定义的
|
*/
|
private final String ROOT_MENU_ID = "business";
|
|
/**
|
* 管理功能模块菜单根节点
|
*/
|
private final String SYSTEMMANAGMENTNODE = "system";
|
|
/**
|
* 操作类型管理菜单根节点
|
*/
|
private final String OPERATENODE = "operateNode";
|
|
/**
|
* 使用用户查询
|
*/
|
public static final String QUERY_BY_USER = "select r.PLFUNCOID from plroleright r left join pluserrole u on r.PLROLEOID = u.PLROLEUID ";
|
|
/**
|
* 业务数据服务
|
*/
|
@Autowired
|
private WebBoServiceI boService;
|
|
/**
|
* 加载自身
|
*/
|
@Autowired(required = false)
|
@Lazy
|
private ISmFunctionQueryService self;
|
|
@Autowired
|
private UIEngineServiceI uiEngineServiceI;
|
|
@Autowired
|
private UIManagerServiceI uiManagerServiceI;
|
|
@Autowired
|
private RightControlUtil rightControlUtil;
|
|
@Autowired
|
private PlatformClientUtil platformClientUtil;
|
|
/**
|
* 查询所有的功能
|
*
|
* @return 功能的显示对象
|
*/
|
@Override
|
public List<SmFunctionVO> selectAllFunction() {
|
VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(null, SmFunctionForPlatform1.class);
|
List<SmFunctionForPlatform1> functions = boService.selectByQueryWrapper(queryWrapper, SmFunctionForPlatform1.class);
|
return functionForPlatform1ToFunctionDOs(functions);
|
}
|
|
/**
|
* 查询所有的功能映射
|
*
|
* @return 功能的显示对象
|
*/
|
@Override
|
public Map<String, SmFunctionVO> selectAllFunctionMap() {
|
return Optional.ofNullable(self.selectAllFunction()).orElseGet(()->new ArrayList<>()).stream().collect(Collectors.toMap(s->s.getOid(),t->t));
|
}
|
|
/**
|
* 根据用户查询关联的权限
|
*
|
* @param userOid 用户的主键
|
* @param queryMap 查询条件，如果要用用户的属性查询，可以使用pkUser.xxx
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 权限的显示对象，未转化为上下级关系
|
*/
|
@Override
|
public List<SmFunctionVO> listFunctionByUserOid(String userOid, Map<String, String> queryMap, ResourceControlTypeEnum resourceControlTypeEnum) {
|
if(StringUtils.isBlank(userOid)){
|
return new ArrayList<>();
|
}
|
VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(queryMap,SmFunctionForPlatform1.class);
|
queryWrapper.in("ploid",QUERY_BY_USER + " where u.pluseruid = '" + userOid.trim() + "'");
|
List<SmFunctionForPlatform1> functions = boService.selectByQueryWrapper(queryWrapper, SmFunctionForPlatform1.class);
|
if(CollectionUtils.isEmpty(functions)){
|
return new ArrayList<>();
|
}
|
//TODO 密级的控制
|
//超级管理员，一般不让登录，登录后可以看业务的功能，也可以看管理功能
|
//三员的，只看管理的
|
//普通的只看业务的
|
|
if(resourceControlTypeEnum == null){
|
resourceControlTypeEnum = ResourceControlTypeEnum.BS;
|
}
|
String controlType = resourceControlTypeEnum.getValue();
|
List<SmFunctionVO> functionVOS = functionForPlatform1ToFunctionDOs(functions);
|
return functionVOS.stream().filter(s->controlType.equalsIgnoreCase(s.getResourceControlType())).collect(Collectors.toList());
|
}
|
|
/**
|
* 根据用户返回所有菜单下的按钮（树形结构）
|
*
|
* @param treeQueryObject
|
* @return
|
*/
|
@Override
|
public List<MenuVO> buttons(TreeQueryObject treeQueryObject) {
|
//1、先根据session判断当前用户类型
|
SessionInfo sessionInfo = WebUtil.getCurrentUserSessionInfoNotException();
|
boolean adminOrDeveloperOrRoot = rightControlUtil.isAdminOrDeveloperOrRoot(sessionInfo.getUserId());
|
String parentId;
|
//2、根据不同用户返回不同的节点下的菜单和按钮
|
if (adminOrDeveloperOrRoot) {
|
//系统菜单
|
parentId = SYSTEMMANAGMENTNODE;
|
} else if (rightControlUtil.isThreeAdminCurUser()) {
|
//三员返回管理功能模块相关的菜单
|
parentId = SYSTEMMANAGMENTNODE;
|
} else {
|
// 普通用户只返回业务功能模块相关的菜单，
|
// 但可能存在普通用户分配系统功能的菜单和按钮权限，不过需要
|
// 再业务功能模块下创建对应的管理功能模块的菜单并进行授权。
|
parentId = ROOT_MENU_ID;
|
}
|
RoleRightInfo[] userRoleRights = rightControlUtil.getRoleRightByUserName(sessionInfo.getUserId());
|
//3、根据角色查询出对应的父节点下的所有的菜单，然后再获取菜单下的所有按钮
|
//List<FunctionInfo> menuList = rightControlUtil.getMenusByPIdAndPermission(parentId, sessionInfo.getUserId(),userRoleRights);
|
Map<String, List<FunctionInfo>> map = rightControlUtil.getAllChildrenFunctionsByUserName(
|
parentId, sessionInfo.getUserId(), userRoleRights);
|
List<MenuVO> functionVOList = new ArrayList<>();
|
//4、先获取parentid对应的菜单，再获取每一层子节点，同时过滤掉按钮未启用的功能模块
|
for (FunctionInfo menu : map.get(parentId)) {
|
if(!menu.isValid){
|
continue;
|
}
|
MenuVO functionVO = new MenuVO();
|
functionVO.setId(menu.id);
|
functionVO.setSource(menu.image);
|
functionVO.setPath(menu.resourceB);
|
functionVO.setParentId(menu.parentId);
|
functionVO.setCode(menu.aliasName);
|
functionVO.setAlias(menu.aliasName);
|
functionVO.setName(menu.name);
|
functionVO.setFunctionType(menu.functionType);
|
functionVO.setIsValid(menu.isValid);
|
functionVO.getMeta().put("keepAlive",false);
|
functionVO.setSort((int) menu.seq);
|
try {
|
functionVO.setChildren(findChildFunctionVO(menu.id, map));
|
} catch (PLException e) {
|
e.printStackTrace();
|
String errorMsg = "菜单查询时出现错误，原因：" + VciBaseUtil.getExceptionMessage(e);
|
logger.error(errorMsg);
|
throw new VciBaseException(errorMsg);
|
}
|
if(functionVO.getChildren().size() > 0){
|
functionVO.setHasChildren(true);
|
}else {
|
functionVO.setHasChildren(false);
|
}
|
functionVOList.add(functionVO);
|
}
|
//6、过滤出实际的菜单节点
|
List<MenuVO> menuVOList = new ArrayList<>();
|
recursionFunction(functionVOList,menuVOList);
|
// 5、处理每一个菜单下需要返回的按钮
|
menuVOList.stream().forEach(menuVO -> {
|
try {
|
//6、获取当前菜单下的按钮
|
Map<String, Long> authMap = Arrays.stream(userRoleRights).collect(Collectors.toMap(e -> e.funcId, e -> e.rightValue,
|
(existing, replacement) -> existing));
|
menuVO.setChildren(getButtonsByAuth(menuVO.getId(),adminOrDeveloperOrRoot,authMap));
|
} catch (PLException e) {
|
e.printStackTrace();
|
String errorMsg = "按钮查询时出现错误，原因：" + VciBaseUtil.getExceptionMessage(e);
|
logger.error(errorMsg);
|
throw new VciBaseException(errorMsg);
|
}
|
});
|
return menuVOList;
|
}
|
|
/**
|
* 过滤出菜单只返回菜单节点
|
* @param sourceList
|
* @param targetList
|
*/
|
private static void recursionFunction(List<MenuVO> sourceList, List<MenuVO> targetList) {
|
for (MenuVO menu : sourceList) {
|
// 检查functionType是否为0
|
if (menu.getFunctionType() == 0) {
|
targetList.add(menu);
|
}
|
// 递归处理children
|
recursionFunction(menu.getChildren(), targetList);
|
}
|
}
|
|
/**
|
* 根据菜单主键和角色权限获取其下的按钮
|
* @param parentOid
|
* @return
|
* @throws PLException
|
*/
|
private List<MenuVO> getButtonsByAuth(String parentOid,boolean adminOrDeveloperOrRoot,Map<String, Long> authMap) throws PLException {
|
List<MenuVO> buttonList = new ArrayList<>();
|
if(Func.isBlank(parentOid)){
|
return buttonList;
|
}
|
FuncOperationInfo[] funcOperates = platformClientUtil.getFrameworkService().getFuncOperationByModule(parentOid, "", true);
|
List<FuncOperationInfo> funcOperationList = new ArrayList<>();
|
if(!adminOrDeveloperOrRoot){
|
for (int i = 0; i < funcOperates.length; i++) {
|
if(authMap.containsKey(funcOperates[i].funcId)){
|
long rightValue = authMap.get(funcOperates[i].funcId);
|
long nodeValue = funcOperates[i].number;
|
long preValue = (rightValue >> nodeValue) & 1;
|
//进行位与操作，如果相等则表示具有当前操作的权限
|
if (preValue == 1) {
|
funcOperationList.add(funcOperates[i]);
|
}
|
}
|
}
|
}else{
|
funcOperationList = Arrays.asList(funcOperates);
|
}
|
if(Func.isNotEmpty(funcOperationList)){
|
for(FuncOperationInfo info: funcOperationList){
|
MenuVO menuVO = new MenuVO();
|
menuVO.setChildType(0);
|
menuVO.setId(info.id);
|
menuVO.setFuncId(info.funcId);
|
menuVO.setCode(info.operIndentify);
|
menuVO.setOperId(info.operId);
|
menuVO.setName(info.operName);
|
menuVO.setAlias(info.operAlias);
|
menuVO.setRemark(info.operDesc);
|
menuVO.setSort((int) info.number);
|
menuVO.setIsValid(info.isValid);
|
menuVO.setHasChildren(false);
|
menuVO.setCategory(1);
|
menuVO.setFunctionType(2);
|
buttonList.add(menuVO);
|
}
|
}
|
return buttonList;
|
}
|
|
/**
|
* 原平台功能转换为新平台的功能
|
* @param functionForPlatform1List 原平台功能对象列表
|
* @return 新平台功能对象
|
*/
|
private List<SmFunctionVO> functionForPlatform1ToFunctionDOs(List<SmFunctionForPlatform1> functionForPlatform1List){
|
List<SmFunctionVO> functionVOList = new ArrayList<SmFunctionVO>();
|
if(!CollectionUtils.isEmpty(functionForPlatform1List)){
|
for(int i = 0 ; i < functionForPlatform1List.size(); i ++ ) {
|
functionVOList.add(functionForPlatform1ToFunctionVO(functionForPlatform1List.get(i)));
|
}
|
}
|
return functionVOList;
|
}
|
|
/**
|
* 原平台功能转换为新平台的功能
|
*
|
* @param functionForPlatform1 原平台功能对象
|
* @return 新平台功能对象
|
*/
|
private SmFunctionVO functionForPlatform1ToFunctionVO(SmFunctionForPlatform1 functionForPlatform1){
|
SmFunctionVO functionVO = new SmFunctionVO();
|
functionVO.setOid(functionForPlatform1.getPloid());
|
//functionVO.setId(String.valueOf(functionForPlatform1.getPlmoduleno()));
|
functionVO.setName(functionForPlatform1.getPlname());
|
functionVO.setLogName(functionForPlatform1.getPlaliasname());
|
if(StringUtils.isNotBlank(functionForPlatform1.getPlresourceb())){
|
functionVO.setResourceControlType(ResourceControlTypeEnum.BS.getValue());
|
functionVO.setUrl(functionForPlatform1.getPlresourceb());
|
}else if(StringUtils.isNotBlank(functionForPlatform1.getPlresourcedotnet())) {
|
functionVO.setResourceControlType(ResourceControlTypeEnum.DOTNET.getValue());
|
functionVO.setUrl(functionForPlatform1.getPlresourcedotnet());
|
}else if(StringUtils.isNotBlank(functionForPlatform1.getPlresourcemobil())) {
|
functionVO.setResourceControlType(ResourceControlTypeEnum.MOBILE.getValue());
|
functionVO.setUrl(functionForPlatform1.getPlresourcemobil());
|
}else {
|
functionVO.setResourceControlType(ResourceControlTypeEnum.CS.getValue());
|
functionVO.setUrl(functionForPlatform1.getPlresourcec());
|
}
|
functionVO.setResourceControlTypeText(ResourceControlTypeEnum.getTextByValue(functionVO.getResourceControlType()));
|
functionVO.setDisplayFlag((functionForPlatform1.getPlisvalid() !=null&& 1 == functionForPlatform1.getPlisvalid())? true:false);
|
functionVO.setControlRightFlag(true);
|
functionVO.setParentFunctionId(functionForPlatform1.getPlparentid());
|
functionVO.setOrderNum(functionForPlatform1.getPlmodulesequence());
|
if(StringUtils.isNotBlank(functionForPlatform1.getPlimage())) {
|
functionVO.setIconCss(functionForPlatform1.getPlimage());
|
}
|
//以前的老图标没办法转换了，但是支持layui的图标
|
if(StringUtils.isNotBlank(functionForPlatform1.getPldesc())){
|
//需要在平台中设置菜单的图标路径，在描述字段中添加
|
//{iconSrc:xxxx,desc:yyyy}
|
try{
|
JSONObject jo = JSONObject.parseObject(functionForPlatform1.getPldesc());
|
if(jo!=null&&jo.containsKey("iconSrc")){
|
functionVO.setIconCss(jo.getString("iconSrc"));
|
}
|
if(jo!=null&&jo.containsKey("desc")){
|
functionVO.setDescription(jo.getString("desc"));
|
}
|
}catch(Exception e){
|
functionVO.setDescription(functionForPlatform1.getPldesc());
|
}
|
}
|
|
functionVO.setBtmName("function");
|
//老的数据里创建人，最后修改人等都没有
|
return functionVO;
|
}
|
|
/**
|
* 获取当前角色的菜单
|
*
|
* @param treeQueryObject 属性查询对象
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 菜单，包含上下级
|
*/
|
@Override
|
public List<MenuVO> treeCurrentUserMenu(TreeQueryObject treeQueryObject, ResourceControlTypeEnum resourceControlTypeEnum) throws PLException {
|
SessionInfo sessionInfo = WebUtil.getCurrentUserSessionInfoNotException();
|
String parentId;
|
boolean adminOrDeveloperOrRoot = rightControlUtil.isAdminOrDeveloperOrRoot(sessionInfo.getUserId());
|
if (adminOrDeveloperOrRoot) {
|
//系统菜单
|
parentId = SYSTEMMANAGMENTNODE;
|
} else if (rightControlUtil.isThreeAdminCurUser()) {
|
//三员返回管理功能模块相关的菜单
|
parentId = SYSTEMMANAGMENTNODE;
|
} else {
|
//普通用户只返回业务功能模块相关的菜单
|
parentId = ROOT_MENU_ID;
|
}
|
RoleRightInfo[] userRoleRights = rightControlUtil.getRoleRightByUserName(sessionInfo.getUserId());
|
Map<String, List<FunctionInfo>> map = rightControlUtil.getAllChildrenFunctionsByUserName(
|
parentId, sessionInfo.getUserId(), userRoleRights);
|
|
List<MenuVO> functionVOList = new ArrayList<>();
|
if(Func.isEmpty(map.get(parentId))) {
|
return functionVOList;
|
}
|
for (FunctionInfo menu : map.get(parentId)) {
|
if(!menu.isValid){
|
continue;
|
}
|
MenuVO functionVO = new MenuVO();
|
functionVO.setId(menu.id);
|
functionVO.setSource(menu.image);
|
//if(StringUtils.isBlank(menu.resourceB)){
|
// continue;
|
//}
|
functionVO.setPath(menu.resourceB);
|
functionVO.setParentId(menu.parentId);
|
//functionVO.setCode(menu.aliasName);
|
functionVO.setAlias(menu.aliasName);
|
functionVO.setName(menu.name);
|
functionVO.getMeta().put("keepAlive",true);
|
functionVO.setSort((int) menu.seq);
|
try {
|
functionVO.setChildren(findChildFunctionVO(menu.id, map));
|
} catch (PLException e) {
|
e.printStackTrace();
|
String errorMsg = "菜单查询时出现错误，原因：" + VciBaseUtil.getExceptionMessage(e);
|
logger.error(errorMsg);
|
throw new VciBaseException(errorMsg);
|
}
|
if(functionVO.getChildren().size() > 0){
|
functionVO.setHasChildren(true);
|
}else {
|
functionVO.setHasChildren(false);
|
}
|
functionVOList.add(functionVO);
|
}
|
//如果是开发或者测试用户，需要获取系统模块配置菜单
|
if(adminOrDeveloperOrRoot){
|
//获取首页系统模块配置菜单
|
MenuVO menuVO = JsonConfigReader.getSysModuleConf().getSysModuleNode();
|
if(Func.isNotEmpty(menuVO)){
|
functionVOList.add(menuVO);
|
}
|
}
|
return functionVOList.stream().sorted(Comparator.comparing(s -> s.getSort())).collect(Collectors.toList());
|
}
|
|
/**
|
* 通过模块ID获取子级列表
|
* @param parentId
|
* @param modeType 模块类型
|
* @param isAll 是否包括无效的模块，true则包括
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public List<MenuVO> getSysModelTreeMenuByPID(String parentId,String modeType,boolean isAll) throws VciBaseException{
|
List<MenuVO> menuVOList = new ArrayList<>();
|
if(Func.isBlank(parentId)){
|
return menuVOList;
|
}
|
boolean isFunctionObject = Func.isNotBlank(modeType) && modeType.equalsIgnoreCase("FunctionObject");
|
if(parentId.equals("system") || parentId.equals("business") || isFunctionObject){
|
int childType = this.checkChildObject(parentId);
|
if(isFunctionObject){
|
try {
|
/**判断该模块下子对象是模块还是操作，0表示无子节点，1表示是模块，2表示是操作**/
|
if(childType == 2){
|
try{
|
FuncOperationInfo[] infos = platformClientUtil.getFrameworkService().getFuncOperationByModule(parentId, "", false);
|
if(Func.isNotEmpty(infos)){
|
childType = this.checkChildObject(infos[0].id); //都是同一层所以取第一个即可查询是什么类型
|
for(int i = 0;i < infos.length ;i++){
|
FuncOperationInfo info = infos[i];
|
MenuVO menuVO = new MenuVO();
|
menuVO.setChildType(childType);
|
menuVO.setId(info.id);
|
menuVO.setFuncId(info.funcId);
|
menuVO.setCode(info.operIndentify);
|
menuVO.setOperId(info.operId);
|
menuVO.setName(info.operName);
|
menuVO.setAlias(info.operAlias);
|
menuVO.setRemark(info.operDesc);
|
menuVO.setSort((int) info.number);
|
menuVO.setModeType("FunctionObject");
|
menuVO.setIsValid(info.isValid);
|
menuVO.setHasChildren(false);
|
menuVO.setCategory(1);
|
menuVO.setFunctionType(3);
|
menuVOList.add(menuVO);
|
}
|
}
|
}catch (PLException e) {
|
e.printStackTrace();
|
throw new VciBaseException(String.valueOf(e.code), e.messages);
|
}
|
}else if(childType == 1){
|
try{
|
FunctionInfo[] funcInfos = platformClientUtil.getFrameworkService().getModuleListByParentId(parentId, isAll);
|
if(Func.isNotEmpty(funcInfos.length)){
|
childType = this.checkChildObject(funcInfos[0].id); //都是同一层所以取第一个即可查询是什么类型
|
for(int i = 0;i < funcInfos.length; i++){
|
FunctionInfo funcInfo = funcInfos[i];
|
MenuVO menuVO = this.functionInfoToMenuVO(funcInfo);
|
menuVO.setChildType(childType);
|
menuVO.setModeType("FunctionObject");
|
menuVO.setCategory(0);
|
menuVOList.add(menuVO);
|
}
|
}
|
}catch (PLException e) {
|
e.printStackTrace();
|
throw new VciBaseException(String.valueOf(e.code),e.messages);
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new VciBaseException("模块查询时出现错误，原因："+VciBaseUtil.getExceptionMessage(e));
|
}
|
}else{
|
try{
|
MenuVO parentNode = null;
|
//将返回的节点外层套上当前父节点
|
if("system".equals(parentId)){
|
parentNode = JsonConfigReader.getSysModuleConf().getSystemManagmentNode();
|
}else if("business".equals(parentId)){
|
parentNode = JsonConfigReader.getSysModuleConf().getModelManagmentNode();
|
}
|
//如果查询的是第一层节点就需要直接返回systemManagmentNode或modelManagmentNode节点
|
if(Func.isNotBlank(modeType) && modeType.equals("firstNode")){
|
menuVOList.add(parentNode);
|
return menuVOList;
|
}
|
//查询的三级节点
|
FunctionInfo[] funcInfos = platformClientUtil.getFrameworkService().getModuleListByParentId(parentId, isAll);
|
for(int i = 0;i < funcInfos.length; i++){
|
FunctionInfo funcInfo = funcInfos[i];
|
MenuVO menuVO = this.functionInfoToMenuVO(funcInfo);
|
menuVO.setModeType("FunctionObject");
|
childType = this.checkChildObject(funcInfos[i].id);
|
menuVO.setChildType(childType);
|
menuVO.setCategory(0);
|
menuVOList.add(menuVO);
|
}
|
return menuVOList;
|
}catch (PLException e) {
|
e.printStackTrace();
|
throw new VciBaseException(String.valueOf(e.code),e.messages);
|
}
|
}
|
}else if(parentId.equals("operateNode")){
|
//加载所有操作
|
try{
|
//将返回的节点外层套上当前父节点
|
MenuVO parentNode = JsonConfigReader.getSysModuleConf().getOperateNode();
|
//如果查询的是第一层节点就需要直接返回sysOptionNode节点
|
if(Func.isNotBlank(modeType) && modeType.equals("firstNode")){
|
menuVOList.add(parentNode);
|
return menuVOList;
|
}
|
OperateInfo[] operateInfos = platformClientUtil.getFrameworkService().getOperateTreeList(parentId);
|
for(int i = 0; i < operateInfos.length;i++ ){
|
OperateInfo operateInfo = operateInfos[i];
|
MenuVO menuVO = new MenuVO();
|
menuVO.setId(operateInfo.id);
|
menuVO.setName(operateInfo.name);
|
menuVO.setCode(operateInfo.identify);
|
menuVO.setAlias(operateInfo.alias);
|
menuVO.setCategory(1);
|
menuVO.setFunctionType(2);
|
menuVO.setChildType(0);
|
menuVO.setRemark(operateInfo.desc);
|
menuVO.getMeta().put("keepAlive",true);
|
menuVO.setSort((int) operateInfo.seq);
|
menuVO.setModeType("operateObject");
|
menuVO.setHasChildren(false);
|
menuVOList.add(menuVO);
|
}
|
}catch (PLException e) {
|
e.printStackTrace();
|
throw new VciBaseException(String.valueOf(e.code),new String[]{VciBaseUtil.getExceptionMessage(e)});
|
}
|
}
|
return menuVOList.stream().sorted(Comparator.comparing(s -> s.getSort())).collect(Collectors.toList());
|
}
|
|
/**
|
* functionInfo转VO对象
|
* @param funcInfo
|
* @return
|
*/
|
private MenuVO functionInfoToMenuVO(FunctionInfo funcInfo) {
|
MenuVO menuVO = new MenuVO();
|
menuVO.setId(funcInfo.id);
|
menuVO.setIsValid(funcInfo.isValid);
|
menuVO.setSource(funcInfo.image);
|
menuVO.setFunctionType(funcInfo.functionType);
|
menuVO.setPathC(funcInfo.resourceC);
|
menuVO.setResourceDotNet(funcInfo.resourceDotNet);
|
menuVO.setResourceMobile(funcInfo.resourceMobile);
|
menuVO.setPath(funcInfo.resourceB);
|
menuVO.setParentId(funcInfo.parentId);
|
//menuVO.setCode(funcInfo.aliasName);
|
menuVO.setAlias(funcInfo.aliasName);
|
menuVO.setName(funcInfo.name);
|
menuVO.getMeta().put("keepAlive",true);
|
menuVO.setSort((int) funcInfo.seq);
|
if(this.checkChildObject(menuVO.getId()) == 0){
|
menuVO.setHasChildren(false);
|
}else{
|
menuVO.setHasChildren(true);
|
}
|
return menuVO;
|
}
|
|
/**
|
* 通过模块ID检查该模块子级对象是模块还是操作
|
* @param moduleId
|
* @return 0表示没有模块也没有操作，1表示有模块，2表示有操作
|
* @throws VciException
|
*/
|
@Override
|
public int checkChildObject(String moduleId) throws VciBaseException {
|
long res = 0;
|
try{
|
res = platformClientUtil.getFrameworkService().checkChildObject(moduleId);
|
}catch (PLException e) {
|
e.printStackTrace();
|
throw new VciBaseException(String.valueOf(e.code),e.messages);
|
}
|
return (int)res;
|
}
|
|
public List<MenuVO> findChildFunctionVO(String parentOid,Map<String, List<FunctionInfo>> map) throws PLException {
|
List<FunctionInfo> menus = map.get(parentOid);
|
List<MenuVO> functionVOList = new ArrayList<>();
|
if(menus == null){
|
return functionVOList;
|
}
|
for (FunctionInfo menu : menus) {
|
if(!menu.isValid){
|
continue;
|
}
|
MenuVO functionVO = new MenuVO();
|
functionVO.setId(menu.id);
|
functionVO.setSource(menu.image);
|
functionVO.setFunctionType(menu.functionType);
|
functionVO.setIsValid(menu.isValid);
|
functionVO.setPath(menu.resourceB);
|
//functionVO.setCode(menu.aliasName);
|
functionVO.setAlias(menu.aliasName);
|
functionVO.setParentId(menu.parentId);
|
functionVO.setName(menu.name);
|
functionVO.getMeta().put("keepAlive",true);
|
functionVO.setSort((int) menu.seq);
|
functionVO.setChildren(findChildFunctionVO(menu.id,map));
|
if(functionVO.getChildren().size() > 0){
|
functionVO.setHasChildren(true);
|
}else {
|
functionVO.setHasChildren(false);
|
}
|
functionVOList.add(functionVO);
|
}
|
return functionVOList.stream().sorted(Comparator.comparing(s -> s.getSort())).collect(Collectors.toList());
|
}
|
|
public void findChildAuthFunctionVO(MenuVO functionVO, boolean isAll) throws PLException {
|
//0表示没有模块也没有操作，1表示有模块，2表示有操作
|
long type = platformClientUtil.getFrameworkService().checkChildObject(functionVO.getId());
|
if(type == 1){
|
FunctionInfo[] funcObjs = platformClientUtil.getFrameworkService().getModuleListByParentId(functionVO.getId(), isAll);
|
for (FunctionInfo funcObj : funcObjs) {
|
MenuVO menuVO = new MenuVO();
|
menuVO.setId(funcObj.id);
|
menuVO.setSource(funcObj.image);
|
menuVO.setPath(funcObj.resourceB);
|
menuVO.setCode(funcObj.aliasName);
|
menuVO.setAlias(funcObj.aliasName);
|
menuVO.setParentId(funcObj.parentId);
|
menuVO.setChildType((int) type);
|
menuVO.setName(funcObj.name);
|
menuVO.getMeta().put("keepAlive",true);
|
menuVO.setSort((int) funcObj.seq);
|
findChildAuthFunctionVO(menuVO, isAll);
|
functionVO.getChildren().add(menuVO);
|
functionVO.setHasChildren(true);
|
}
|
}else if(type == 2){
|
FuncOperationInfo[] infos = platformClientUtil.getFrameworkService().getFuncOperationByModule(functionVO.getId(), "", true);
|
for (FuncOperationInfo info : infos) {
|
MenuVO menuVO = new MenuVO();
|
menuVO.setChildType((int) type);
|
menuVO.setId(info.id);
|
menuVO.setFuncId(info.funcId);
|
menuVO.setCode(info.operIndentify);
|
menuVO.setOperId(info.operId);
|
menuVO.setName(info.operName);
|
menuVO.setAlias(info.operAlias);
|
menuVO.setRemark(info.operDesc);
|
menuVO.setSort((int) info.number);
|
menuVO.setModeType("FunctionObject");
|
menuVO.setIsValid(info.isValid);
|
menuVO.setHasChildren(false);
|
functionVO.getChildren().add(menuVO);
|
functionVO.setHasChildren(true);
|
}
|
}else{
|
functionVO.setHasChildren(false);
|
}
|
}
|
|
@Override
|
public UIContentVO getUIContentByBtmTypeAndId(TreeQueryObject treeQueryObject, ResourceControlTypeEnum resourceControlTypeEnum) throws PLException {
|
SessionInfo sessionInfo = WebUtil.getCurrentUserSessionInfoNotException();
|
/* if(resourceControlTypeEnum == null){
|
resourceControlTypeEnum = ResourceControlTypeEnum.BS;
|
}*/
|
Map<String, RoleRightVO> roleRightMap = uiManagerServiceI.getRoleRightMap(null);
|
for (PLUILayout allPLUILayout : platformClientUtil.getUIService().getAllPLUILayouts()) {
|
if(treeQueryObject.getConditionMap().getOrDefault("type","").equals(allPLUILayout.plRelatedType)
|
&& treeQueryObject.getConditionMap().getOrDefault("context","").equals(allPLUILayout.plCode)){
|
return uiEngineServiceI.UIContentDO2VO(allPLUILayout,true,roleRightMap);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 获取授权的模块
|
* @param roleId 角色主键
|
* @return 所具有权限的主键
|
* @throws PLException
|
*/
|
@Override
|
public List<String> getSysModelAuth(String roleId) throws PLException {
|
|
RoleRightInfo[] roleRightList = platformClientUtil.getFrameworkService().getRoleRightList(roleId, WebUtil.getCurrentUserId());
|
Map<String, Long> authMap = Arrays.stream(roleRightList).collect(Collectors.toMap(e -> e.funcId, e -> e.rightValue,
|
(existing, replacement) -> existing));
|
String parentId;
|
SessionInfo sessionInfo = WebUtil.getCurrentUserSessionInfoNotException();
|
boolean adminOrDeveloperOrRoot = rightControlUtil.isAdminOrDeveloperOrRoot(sessionInfo.getUserId());
|
if (adminOrDeveloperOrRoot) {
|
//系统菜单
|
parentId = SYSTEMMANAGMENTNODE;
|
} else {
|
//普通用户只返回业务功能模块相关的菜单
|
parentId = ROOT_MENU_ID;
|
}
|
FunctionInfo[] moduleListByParentId = getModuleListByParentId(parentId, false);
|
List<String> authList = new ArrayList<>();
|
for (FunctionInfo functionInfo : moduleListByParentId) {
|
if(authMap.containsKey(functionInfo.id)){
|
// authList.add(functionInfo.id);
|
getChildAuthNode(functionInfo, authMap, authList);
|
}
|
}
|
return authList;
|
}
|
|
public BaseResult saveRoleRight(List<RoleRightParamDTO> roleRightDTOS, String roleId) throws PLException {
|
/**
|
* 存储需要保存的权限
|
*/
|
Map<String,RoleRightInfo> rightMap = new HashMap<String,RoleRightInfo>();
|
|
Map<String, List<RoleRightParamDTO>> parentMap = roleRightDTOS.stream().collect(Collectors.groupingBy(e -> e.parentId));
|
|
for (RoleRightParamDTO dto : roleRightDTOS) {
|
RoleRightInfo obj = null;
|
//判断类型
|
if(dto.getType() == 1 && !dto.getParentId().equals(ROOT_MENU_ID)
|
&& !dto.getParentId().equals(SYSTEMMANAGMENTNODE)
|
&& !dto.getParentId().equals(OPERATENODE)){
|
if(!rightMap.containsKey(dto.getParentId())){
|
obj = new RoleRightInfo();
|
obj.funcId = dto.getParentId();
|
obj.rightType = (short)1;
|
obj.rightValue = 1;//没有操作的模块权限值存储为0
|
obj.roleId = roleId;
|
obj.createUser = WebUtil.getCurrentUserId();
|
obj.createTime = new Date().getTime();
|
obj.modifyUser = WebUtil.getCurrentUserId();
|
obj.modifyTime = new Date().getTime();
|
obj.licensor = "";
|
}else{
|
obj = rightMap.get(dto.getParentId());
|
if (obj == null) {
|
obj = new RoleRightInfo();
|
obj.funcId = dto.getParentId();
|
obj.rightType = (short)1;
|
obj.rightValue = 1;//没有操作的模块权限值存储为0
|
obj.roleId = roleId;
|
obj.createUser = WebUtil.getCurrentUserId();
|
obj.createTime = new Date().getTime();
|
obj.modifyUser = WebUtil.getCurrentUserId();
|
obj.modifyTime = new Date().getTime();
|
obj.licensor = "";
|
}else {
|
obj.rightValue = 1;
|
}
|
}
|
rightMap.put(dto.getParentId(), obj);
|
}else if (dto.getType() == 2){
|
// RoleRightInfo roleRightObj = new RoleRightInfo();
|
if(!rightMap.containsKey(dto.getParentId())) {
|
obj = new RoleRightInfo();
|
obj.funcId = dto.getParentId();
|
obj.rightType = (short)1;
|
obj.rightValue = countRightValue(parentMap.get(dto.getParentId()));//没有操作的模块权限值存储为0
|
obj.roleId = roleId;
|
obj.createUser = WebUtil.getCurrentUserId();
|
obj.createTime = new Date().getTime();
|
obj.modifyUser = WebUtil.getCurrentUserId();
|
obj.modifyTime = new Date().getTime();
|
obj.licensor = "";
|
rightMap.put(dto.getParentId(), obj);
|
}
|
|
}
|
}
|
/**上面处理完成后，循环遍历取出MAP里的对象进行保存**/
|
RoleRightInfo[] roleRightObjs = new RoleRightInfo[rightMap.size()];
|
Set<String> objSet = rightMap.keySet();
|
Iterator<String> it = objSet.iterator();
|
int i = 0;
|
while(it.hasNext()){
|
roleRightObjs[i++] = rightMap.get(it.next());
|
}
|
UserEntityInfo userEntityInfo = new UserEntityInfo();
|
userEntityInfo.setModules("com.vci.client.framework.rightdistribution.roleRight.RoleRightPanel");
|
userEntityInfo.setUserName(WebUtil.getCurrentUserId());
|
boolean res = platformClientUtil.getFrameworkService()
|
.saveRoleRight(roleRightObjs,roleId,WebUtil.getCurrentUserId(), userEntityInfo);
|
if(!res){
|
throw new PLException("500", new String[]{"功能模块授权失败！"});
|
}
|
return BaseResult.success();
|
}
|
|
/**
|
* 获取所授权的模块权限
|
* @param roleName 搜索的角色
|
* @return 角色列表
|
*/
|
@Override
|
public List<RoleInfoDTO> getRoleList(String roleName) throws PLException {
|
RoleInfo[] roleInfos = platformClientUtil.getFrameworkService().fetchRoleInfoByUserType(WebUtil.getCurrentUserId());
|
List<RoleInfoDTO> dtos = new ArrayList<>();
|
for (RoleInfo roleInfo : roleInfos) {
|
if(StringUtils.isBlank(roleName) || roleInfo.name.indexOf(roleName) != -1) {
|
RoleInfoDTO dto = new RoleInfoDTO();
|
dto.setName(roleInfo.name);
|
dto.setDescription(roleInfo.description);
|
dto.setId(roleInfo.id);
|
dto.setGrantor(roleInfo.grantor);
|
dto.setType(roleInfo.type);
|
dto.setCreateTime(roleInfo.createTime);
|
dto.setCreateUser(roleInfo.createUser);
|
dto.setUpdateTime(roleInfo.updateTime);
|
dto.setUpdateUser(roleInfo.updateUser);
|
dtos.add(dto);
|
}
|
}
|
return dtos;
|
}
|
|
private long countRightValue(List<RoleRightParamDTO> dtos){
|
long value = 0;
|
for (RoleRightParamDTO dto : dtos) {
|
value += (long)Math.pow(2, dto.getNumber());//累计加上各个操作的权限值
|
}
|
return value;
|
}
|
|
/**
|
*
|
* @param funcObj 模块对象
|
* @param authMap 该角色下所有的权限数据
|
* @param authList 该角色下所具有的权限
|
* @throws PLException
|
*/
|
private void getChildAuthNode(FunctionInfo funcObj, Map<String, Long> authMap, List<String> authList) throws PLException {
|
/**0表示该模块下什么都没有，1表示有模块，2表示有操作**/
|
long funcType = platformClientUtil.getFrameworkService().checkChildObject(funcObj.id);
|
if(funcType == 1){
|
FunctionInfo[] funcInfos = platformClientUtil.getFrameworkService().getModuleListByParentId(funcObj.id, false);
|
for(int i=0;i<funcInfos.length;i++){
|
if(authMap.containsKey(funcInfos[i].id)){
|
// authList.add(funcInfos[i].id);
|
getChildAuthNode(funcInfos[i], authMap, authList);
|
}
|
}
|
}else if(funcType == 2){
|
FuncOperationInfo[] funcOperates = platformClientUtil.getFrameworkService().getFuncOperationByModule(funcObj.id, "", true);
|
for (int j = 0; j < funcOperates.length; j++) {
|
if(authMap.containsKey(funcOperates[j].funcId)){
|
long rightValue = authMap.get(funcOperates[j].funcId);
|
long nodeValue = funcOperates[j].number;
|
long preValue = (rightValue >> nodeValue) & 1;
|
//进行位与操作，如果相等则表示具有当前操作的权限
|
if (preValue == 1) {
|
authList.add(funcOperates[j].id);
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* 获取所有的功能菜单
|
*
|
* @param treeQueryObject 树查询对象
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 树节点，出现错误会在异常处理器中统一返回Json
|
*/
|
@Override
|
public List<Tree> treeAllMenu(TreeQueryObject treeQueryObject, ResourceControlTypeEnum resourceControlTypeEnum) {
|
List<SmFunctionVO> functionVOList = self.selectAllFunction().stream().filter(s -> s.isDisplayFlag() && resourceControlTypeEnum.getValue().equalsIgnoreCase(s.getResourceControlType())).collect(Collectors.toList());
|
if(!treeQueryObject.isQueryAllLevel() && StringUtils.isNotBlank(treeQueryObject.getParentOid())){
|
functionVOList = functionVOList.stream().filter(s->treeQueryObject.getParentOid().equalsIgnoreCase(s.getParentFunctionId())).collect(Collectors.toList());
|
}
|
return dos2Trees(functionVOList.stream().sorted(Comparator.comparing(s -> s.getOrderNum())).collect(Collectors.toList()),treeQueryObject == null?null:treeQueryObject.getParentOid());
|
}
|
|
/**
|
* 批量将数据对象转换为树节点
|
* @param functionVOList 数据对象列表
|
* @param rootId 根节点的主键，最顶层使用null或者""
|
* @return 树节点列表，不存在数据时返回空列表
|
*/
|
public List<Tree> dos2Trees(List<SmFunctionVO> functionVOList,String rootId){
|
if(!CollectionUtils.isEmpty(functionVOList)) {
|
List<Tree> rootList = new ArrayList<>();
|
List<Tree> childList = new ArrayList<>();
|
functionVOList.stream().forEach(s -> {
|
Tree tree = DO2Tree(s);
|
if (tree.getParentId() == null || tree.getParentId().equals(rootId) || ROOT_MENU_ID.equalsIgnoreCase(tree.getParentId())) {
|
rootList.add(tree);
|
} else {
|
childList.add(tree);
|
}
|
});
|
return Tree.getChildList(rootList, childList);
|
}else{
|
return new ArrayList<>();
|
}
|
}
|
|
/**
|
* 数据对象转换为树节点
|
* @param functionVO 数据显示对象
|
* @return 树节点对象
|
*/
|
public Tree DO2Tree(SmFunctionVO functionVO){
|
Tree tree = new Tree();
|
tree.setOid(functionVO.getOid());
|
tree.setText(functionVO.getName());
|
tree.setIndex(functionVO.getOrderNum() + "");
|
tree.setParentId(functionVO.getParentFunctionId());
|
tree.setIconCls(functionVO.getIconCss());
|
tree.setHref(functionVO.getUrl());
|
try {
|
tree.setAttributes(WebUtil.objectToMapString(functionVO));
|
} catch (Throwable e) {
|
logger.error("拷贝信息",e);
|
}
|
return tree;
|
}
|
|
/**
|
* 通过上级节点获取下级的所有的菜单节点
|
*
|
* @param treeQueryObject 树查询对象
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 树节点，出现错误会在异常处理器中统一返回Json
|
*/
|
@Override
|
public List<Tree> treeFunctionByParent(TreeQueryObject treeQueryObject, ResourceControlTypeEnum resourceControlTypeEnum) {
|
List<SmFunctionVO> functionVOList = self.selectAllFunction().stream().filter(s -> s.isDisplayFlag() && resourceControlTypeEnum.getValue().equalsIgnoreCase(s.getResourceControlType())).collect(Collectors.toList());
|
if(!treeQueryObject.isQueryAllLevel() && StringUtils.isNotBlank(treeQueryObject.getParentOid())){
|
functionVOList = functionVOList.stream().filter(s->treeQueryObject.getParentOid().equalsIgnoreCase(s.getParentFunctionId())).collect(Collectors.toList());
|
}
|
return dos2Trees(functionVOList,treeQueryObject == null?null:treeQueryObject.getParentOid());
|
}
|
|
/**
|
* 通过上级节点获取当前角色有权限的下级的所有的菜单节点
|
*
|
* @param treeQueryObject 树查询对象
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 树节点，出现错误会在异常处理器中统一返回Json
|
*/
|
@Override
|
public List<Tree> treeCurrentFunctionByParent(TreeQueryObject treeQueryObject, ResourceControlTypeEnum resourceControlTypeEnum) {
|
SessionInfo sessionInfo = WebUtil.getCurrentUserSessionInfo();
|
List<SmFunctionVO> functionVOList =self.selectAllFunction().stream().filter(s -> s.isDisplayFlag()
|
&& resourceControlTypeEnum.getValue().equalsIgnoreCase(s.getResourceControlType())
|
&& !CollectionUtils.isEmpty(sessionInfo.getFunctionOids())
|
&& sessionInfo.getFunctionOids().contains(s.getOid())
|
).collect(Collectors.toList());
|
if(!treeQueryObject.isQueryAllLevel() && StringUtils.isNotBlank(treeQueryObject.getParentOid())){
|
functionVOList = functionVOList.stream().filter(s->treeQueryObject.getParentOid().equalsIgnoreCase(s.getParentFunctionId())).collect(Collectors.toList());
|
}
|
return dos2Trees(functionVOList,treeQueryObject == null?null:treeQueryObject.getParentOid());
|
}
|
|
/**
|
* 获取系统功能列表
|
*
|
* @param queryMap 查询条件
|
* @param pageHelper 排序和分页对象
|
* @return DataGrid 系统功能列表
|
*/
|
@Override
|
public DataGrid<SmFunctionVO> dataGrid(Map<String, String> queryMap, PageHelper pageHelper) {
|
VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(queryMap,SmFunctionForPlatform1.class,pageHelper);
|
List<SmFunctionForPlatform1> functionForPlatform1s = boService.selectByQueryWrapper(queryWrapperForDO, SmFunctionForPlatform1.class);
|
List<SmFunctionVO> functionVOS = functionForPlatform1ToFunctionDOs(functionForPlatform1s);
|
DataGrid dataGrid = new DataGrid();
|
dataGrid.setData(functionVOS);
|
if(!CollectionUtils.isEmpty(functionVOS)){
|
dataGrid.setTotal(boService.countByQueryWrapper(queryWrapperForDO,SmFunctionForPlatform1.class));
|
}
|
return dataGrid;
|
}
|
|
/**
|
* 根据角色主键获取关联的权限
|
*
|
* @param roleOid 角色主键
|
* @param queryMap 查询条件，如果需要使用角色的属性来查询可以使用pkUser.xxxx
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 权限的显示对象
|
*/
|
@Override
|
public List<SmFunctionVO> listFunctionByRoleOid(String roleOid, Map<String, String> queryMap, ResourceControlTypeEnum resourceControlTypeEnum) {
|
String controlType = resourceControlTypeEnum == null? ResourceControlTypeEnum.BS.getValue(): resourceControlTypeEnum.getValue();
|
return Optional.ofNullable(listFunctionByRoleOid(roleOid,queryMap,false)).orElseGet(()->new ArrayList<>()).stream().filter(s->controlType.equalsIgnoreCase(s.getResourceControlType())).collect(Collectors.toList());
|
}
|
|
/**
|
* 获取未关联某个角色的权限
|
*
|
* @param roleOid 角色主键
|
* @param queryMap 查询条件，如果需要使用角色的属性来查询可以使用pkUser.xxxx
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 权限的显示对象
|
*/
|
@Override
|
public List<SmFunctionVO> listFunctionUnInRoleOid(String roleOid, Map<String, String> queryMap, ResourceControlTypeEnum resourceControlTypeEnum) {
|
String controlType = resourceControlTypeEnum == null? ResourceControlTypeEnum.BS.getValue(): resourceControlTypeEnum.getValue();
|
return Optional.ofNullable(listFunctionByRoleOid(roleOid,queryMap,true)).orElseGet(()->new ArrayList<>()).stream().filter(s->controlType.equalsIgnoreCase(s.getResourceControlType())).collect(Collectors.toList());
|
}
|
|
/**
|
* 使用角色主键查询权限
|
* @param roleOid 用户主键
|
* @param queryMap 查询条件
|
* @param notIn 是否为不包含
|
* @return 角色的显示对象
|
*/
|
private List<SmFunctionVO> listFunctionByRoleOid(String roleOid, Map<String,String> queryMap, boolean notIn){
|
if(StringUtils.isBlank(roleOid)){
|
return new ArrayList<>();
|
}
|
if(queryMap == null){
|
queryMap = new HashMap<>();
|
}
|
List<SmFunctionForPlatform1> functions = new ArrayList<>();
|
if(roleOid.contains(",")){
|
Map<String, String> finalQueryMap = queryMap;
|
WebUtil.switchCollectionForOracleIn(WebUtil.str2List(roleOid)).stream().forEach(roleOids->{
|
Map<String,String> conditionMap = new HashMap<>();
|
finalQueryMap.forEach((key,value)->{
|
conditionMap.put(key,value);
|
});
|
conditionMap.put("ploid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plfuncoid from plroleright where plroleoid in (" + WebUtil.toInSql(roleOids.toArray(new String[0])) + ")");
|
VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(conditionMap, SmRoleForPlatform1.class);
|
List<SmFunctionForPlatform1> functionForPlatform1s = boService.selectByQueryWrapper(queryWrapper, SmFunctionForPlatform1.class);
|
if(!CollectionUtils.isEmpty(functionForPlatform1s)){
|
functions.addAll(functionForPlatform1s);
|
}
|
});
|
}else {
|
queryMap.put("ploid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plfuncoid from plroleright where plroleoid ='" + roleOid.trim() + "'");
|
}
|
VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(queryMap,SmRoleForPlatform1.class);
|
List<SmFunctionForPlatform1> roleForPlatform1s = boService.selectByQueryWrapper(queryWrapper, SmFunctionForPlatform1.class);
|
if(!CollectionUtils.isEmpty(roleForPlatform1s)){
|
functions.addAll(roleForPlatform1s);
|
}
|
return functionForPlatform1ToFunctionDOs(functions);
|
}
|
|
/**
|
* 获取未关联某个角色的权限
|
*
|
* @param roleOid 角色主键
|
* @param queryMap 查询条件，如果需要使用角色的属性来查询可以使用pkUser.xxxx
|
* @param pageHelper 分页和排序对象，老平台不支持使用权限编号来排序
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 权限的显示对象
|
*/
|
@Override
|
public DataGrid<SmFunctionVO> gridFunctionUninRoleOid(String roleOid, Map<String, String> queryMap, PageHelper pageHelper, ResourceControlTypeEnum resourceControlTypeEnum) {
|
return gridFunctionByRoleOid(roleOid,queryMap,pageHelper,resourceControlTypeEnum,true);
|
}
|
|
/**
|
* 批量根据角色的主键来获取权限
|
*
|
* @param roleOidCollection 角色主键集合
|
* @param queryMap 查询条件，如果需要使用角色的属性来查询可以使用pkRole.xxxx
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 权限的显示对象，key是角色主键,value是这个角色关联的权限
|
*/
|
@Override
|
public Map<String, List<SmFunctionVO>> batchListFunctionByRoleOids(Collection<String> roleOidCollection, Map<String, String> queryMap, ResourceControlTypeEnum resourceControlTypeEnum) {
|
if(CollectionUtils.isEmpty(roleOidCollection)){
|
return new HashMap<>();
|
}
|
List<SmFunctionVO> functionVOList = new ArrayList<>();
|
Map<String,List<String>> roleFunctionOidMap = new HashMap<>();
|
String roleContoll = resourceControlTypeEnum == null?ResourceControlTypeEnum.BS.getValue():resourceControlTypeEnum.getValue();
|
WebUtil.switchCollectionForOracleIn(roleOidCollection).stream().forEach(roleOids->{
|
List<SmFunctionVO> functionVOS = Optional.ofNullable(listFunctionByRoleOid(roleOids.stream().collect(Collectors.joining(",")), queryMap, false)).orElseGet(()->new ArrayList<>()).stream().filter(s->roleContoll.equalsIgnoreCase(s.getResourceControlType())).collect(Collectors.toList());
|
if(!CollectionUtils.isEmpty(functionVOS)){
|
functionVOList.addAll(functionVOS);
|
String sql = "select plfuncoid,plroleoid from plroleright where plroleoid in (" + WebUtil.toInSql(roleOids.toArray(new String[0])) + ")";
|
List<BusinessObject> cbos = boService.queryBySql(sql, null);
|
if(!CollectionUtils.isEmpty(cbos)){
|
cbos.stream().forEach(cbo->{
|
String roleOid = ObjectTool.getBOAttributeValue(cbo,"plroleoid");
|
List<String> functionOids = roleFunctionOidMap.getOrDefault(roleOid,new ArrayList<>());
|
functionOids.add(ObjectTool.getBOAttributeValue(cbo,"plfuncoid"));
|
roleFunctionOidMap.put(roleOid,functionOids);
|
});
|
}
|
}
|
});
|
if(!CollectionUtils.isEmpty(functionVOList)){
|
Map<String, SmFunctionVO> functionVOMap = functionVOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
|
Map<String, List<SmFunctionVO>> roleFunctionVOMap = new HashMap<>();
|
roleFunctionOidMap.forEach((roleOid,functionOids)->{
|
List<SmFunctionVO> functionVOS = new ArrayList<>();
|
functionOids.forEach(functionOid->{
|
if(functionVOMap.containsKey(functionOid)){
|
functionVOS.add(functionVOMap.get(functionOid));
|
}
|
});
|
roleFunctionVOMap.put(roleOid,functionVOS);
|
});
|
return roleFunctionVOMap;
|
}
|
return new HashMap<>();
|
}
|
|
/**
|
* 使用角色查询权限表
|
* @param roleOid 角色的主键
|
* @param queryMap 查询条件
|
* @param pageHelper 分页对象
|
* @param notIn 不包含
|
* @return 列表数据
|
*/
|
private DataGrid<SmFunctionVO> gridFunctionByRoleOid(String roleOid,Map<String,String> queryMap,PageHelper pageHelper,ResourceControlTypeEnum resourceControlTypeEnum,boolean notIn){
|
if(queryMap == null){
|
queryMap = new HashMap<>();
|
}
|
if(StringUtils.isBlank(roleOid)){
|
return new DataGrid<>();
|
}
|
if(roleOid.contains(",")){
|
String[] roleOids = roleOid.trim().split(",");
|
if(roleOids.length>1000){
|
//这个方法不支持超过1000个的用户查询
|
throw new VciBaseException("这个方法不支持超过1000个角色的主键来查询");
|
}
|
queryMap.put("ploid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plfuncoid from plroleright where plroleoid in (" + WebUtil.toInSql(roleOid) + ")");
|
}else {
|
queryMap.put("ploid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plfuncoid from plroleright where plroleoid ='" + roleOid.trim() + "'");
|
}
|
if(resourceControlTypeEnum == null){
|
resourceControlTypeEnum = ResourceControlTypeEnum.BS;
|
}
|
switch (resourceControlTypeEnum){
|
case BS:
|
queryMap.put("plresourceb",QueryOptionConstant.ISNOTNULL);
|
break;
|
case DOTNET:
|
queryMap.put("plresourcedotnet",QueryOptionConstant.ISNOTNULL);
|
break;
|
case MOBILE:
|
queryMap.put("plresourcemobil",QueryOptionConstant.ISNOTNULL);
|
break;
|
default:
|
queryMap.put("plsuffixc",QueryOptionConstant.ISNOTNULL);
|
}
|
return dataGrid(queryMap,pageHelper);
|
}
|
|
/**
|
* 批量根据角色的主键获取关联的权限
|
*
|
* @param roleOidCollection 角色的主键集合
|
* @param queryMap 查询条件，如果需要使用角色的属性来查询可以使用pkRole.xxxx
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 权限的显示对象, 会去除重复的项
|
*/
|
@Override
|
public List<SmFunctionVO> listFunctionByRoleOids(Collection<String> roleOidCollection, Map<String, String> queryMap, ResourceControlTypeEnum resourceControlTypeEnum) {
|
if(CollectionUtils.isEmpty(roleOidCollection)){
|
return new ArrayList<>();
|
}
|
return listFunctionByRoleOid(roleOidCollection.stream().collect(Collectors.joining(",")),queryMap,false);
|
}
|
|
/**
|
* 批量根据角色的主键获取关联的权限
|
*
|
* @param roleOidCollection 角色的主键集合
|
* @param queryMap 查询条件，如果需要使用角色的属性来查询可以使用pkRole.xxxx
|
* @param pageHelper 分页对象
|
* @param resourceControlTypeEnum 角色控制区域，也是功能控制的区域
|
* @return 权限的显示对象, 会去除重复的项
|
*/
|
@Override
|
public DataGrid<SmFunctionVO> gridFunctionByRoleOids(Collection<String> roleOidCollection, Map<String, String> queryMap, PageHelper pageHelper, ResourceControlTypeEnum resourceControlTypeEnum) {
|
if(CollectionUtils.isEmpty(roleOidCollection)){
|
return new DataGrid<>();
|
}
|
return gridFunctionByRoleOid(roleOidCollection.stream().collect(Collectors.joining(",")), queryMap,pageHelper,resourceControlTypeEnum,false);
|
}
|
|
/**
|
* 清除缓存
|
*/
|
@Override
|
public void clearCache() {
|
|
}
|
|
/**
|
* 通过模块ID获取子级列表
|
* @param isAll 是否包括无效的模块，true则包括
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public List<MenuVO> getSysModelAuthTreeMenuByPID(boolean isAll) throws VciBaseException, PLException {
|
SessionInfo sessionInfo = WebUtil.getCurrentUserSessionInfoNotException();
|
boolean adminOrDeveloperOrRoot = rightControlUtil.isAdminOrDeveloperOrRoot(sessionInfo.getUserId());
|
String parentId;
|
if (adminOrDeveloperOrRoot) {
|
//系统菜单
|
parentId = SYSTEMMANAGMENTNODE;
|
} else {
|
//普通用户只返回业务功能模块相关的菜单
|
parentId = ROOT_MENU_ID;
|
}
|
List<MenuVO> functionVOList = new ArrayList<>();
|
FunctionInfo[] moduleListByParentId = getModuleListByParentId(parentId, isAll);
|
for (FunctionInfo menu : moduleListByParentId) {
|
if(!menu.isValid){
|
continue;
|
}
|
MenuVO functionVO = new MenuVO();
|
functionVO.setId(menu.id);
|
functionVO.setSource(menu.image);
|
functionVO.setPath(menu.resourceB);
|
functionVO.setParentId(menu.parentId);
|
functionVO.setCode(menu.aliasName);
|
functionVO.setAlias(menu.aliasName);
|
functionVO.setName(menu.name);
|
functionVO.getMeta().put("keepAlive",false);
|
functionVO.setSort((int) menu.seq);
|
findChildAuthFunctionVO(functionVO, isAll);
|
if(functionVO.getChildren().size() > 0){
|
functionVO.setHasChildren(true);
|
}else {
|
functionVO.setHasChildren(false);
|
}
|
functionVOList.add(functionVO);
|
}
|
return functionVOList;
|
}
|
|
/**
|
* 通过模块ID获取子级列表
|
* @param parentId
|
* @param isAll 是否包括无效的模块，true则包括
|
* @return
|
* @throws VciException
|
*/
|
public FunctionInfo[] getModuleListByParentId(String parentId,boolean isAll) throws PLException {
|
FunctionInfo[] funcInfos = null;
|
funcInfos = platformClientUtil.getFrameworkService().getModuleListByParentId(parentId, isAll);
|
return funcInfos;
|
}
|
|
}
|
