PLTWEB.git - Gitblit

			@@ -8,11 +8,15 @@
			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.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;
			@@ -567,6 +571,163 @@
			}

			/**
			* 获取授权的模块
			* @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));
			String parentId;
			SessionInfo sessionInfo = WebUtil.getCurrentUserSessionInfoNotException();
			boolean adminOrDeveloperOrRoot = rightControlUtil.isAdminOrDeveloperOrRoot(sessionInfo.getUserId());
			if (adminOrDeveloperOrRoot) {
			//系统菜单
			parentId = SYSTEMMANAGMENTNODE;
			} else if (rightControlUtil.isThreeAdminCurUser()) {
			//三员返回管理功能模块相关的菜单
			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();
			}

			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 树查询对象
			@@ -903,20 +1064,15 @@

			/**
			* 通过模块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;
			@@ -928,7 +1084,7 @@
			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 +1100,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 +1108,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());
			}