Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/frameworkcore/compatibility/impl/SmFunctionQueryServicePlatformImpl.java

@@ -8,11 +8,16 @@
import com.vci.common.exception.VciException;
import com.vci.common.locale.LocaleDisplay;
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.RoleRightDTO;
import com.vci.dto.RoleRightParamDTO;
import com.vci.frameworkcore.compatibility.ISmFunctionQueryService;
import com.vci.frameworkcore.enumpck.ResourceControlTypeEnum;
import com.vci.model.RoleRightDO;
import com.vci.model.SmFunctionForPlatform1;
import com.vci.model.SmRoleForPlatform1;
import com.vci.pagemodel.MenuVO;
@@ -527,6 +532,7 @@
                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);
@@ -545,6 +551,7 @@
                menuVO.setIsValid(info.isValid);
                menuVO.setHasChildren(false);
                functionVO.getChildren().add(menuVO);
                functionVO.setHasChildren(true);
            }
        }else{
            functionVO.setHasChildren(false);
@@ -564,6 +571,188 @@
            }
        }
        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);
                    }
                }
            }
        }
    }

    /**
@@ -903,32 +1092,24 @@

    /**
     * 通过模块ID获取子级列表
     * @param parentId
     * @param modeType 模块类型
     * @param isAll 是否包括无效的模块，true则包括
     * @return
     * @throws VciBaseException
     */
    @Override
    public List<MenuVO> getSysModelAuthTreeMenuByPID(String parentId,String modeType,boolean isAll) throws VciBaseException, PLException {
        List<MenuVO> menuVOList = new ArrayList<>();
//        if(Func.isBlank(parentId)){
//            return menuVOList;
//        }
    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 if (rightControlUtil.isThreeAdminCurUser()) {
            //三员返回管理功能模块相关的菜单
            parentId = SYSTEMMANAGMENTNODE;
        } else {
            //普通用户只返回业务功能模块相关的菜单
            parentId = ROOT_MENU_ID;
        }
        List<MenuVO> functionVOList = new ArrayList<>();
        FunctionInfo[] moduleListByParentId = getModuleListByParentId(parentId, false);
        FunctionInfo[] moduleListByParentId = getModuleListByParentId(parentId, isAll);
        for (FunctionInfo menu : moduleListByParentId) {
            if(!menu.isValid){
                continue;
@@ -944,14 +1125,6 @@
            functionVO.getMeta().put("keepAlive",false);
            functionVO.setSort((int) menu.seq);
            findChildAuthFunctionVO(functionVO, isAll);
//            try {
//                functionVO.setChildren(findChildAuthFunctionVO(menu.id));
//            } 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 {
@@ -960,185 +1133,6 @@
            functionVOList.add(functionVO);
        }
        return functionVOList;



//        RoleRightInfo[] userRoleRights = rightControlUtil.getRoleRightByUserName(sessionInfo.getUserId());
//        Map<String, List<FunctionInfo>> map = rightControlUtil.getAllChildrenFunctionsByUserName(
//                parentId, sessionInfo.getUserId(), userRoleRights);
//
//        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",false);
//            functionVO.setSort((int) menu.seq);
////            try {
////                functionVO.setChildren(findChildAuthFunctionVO(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());





//
//
//
//
//        boolean isFunctionObject = Func.isNotBlank(modeType) && modeType.equalsIgnoreCase("FunctionObject");
//        if(parentId.equals("systemManagmentNode") || parentId.equals("modelManagmentNode") || 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.length)){
//                                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);
//                                    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");
//                                    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("systemManagmentNode".equals(parentId)){
//                        parentNode = JsonConfigReader.getSysModuleConf().getSystemManagmentNode();
//                    }else if("modelManagmentNode".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");
//                        menuVO.setChildType(childType);
//                        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(2);
//                    menuVO.setChildType(0);
//                    menuVO.setRemark(operateInfo.desc);
//                    menuVO.getMeta().put("keepAlive",false);
//                    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 null;
//        return menuVOList.stream().sorted(Comparator.comparing(s -> s.getSort())).collect(Collectors.toList());
    }