package com.iplatform.base.cache;
|
|
import com.iplatform.base.Constants;
|
import com.iplatform.base.SecurityConstants;
|
import com.iplatform.base.service.MenuServiceImpl;
|
import com.iplatform.base.util.MenuUtils;
|
import com.iplatform.base.util.menu.MenuOrderNumComparator;
|
import com.iplatform.base.util.menu.ParentMenuComparator;
|
import com.iplatform.base.util.menu.SystemMenu;
|
import com.iplatform.model.po.S_menu;
|
import com.iplatform.model.vo.MetaVo;
|
import com.iplatform.model.vo.RouterVo;
|
import com.walker.cache.AbstractCacheProvider;
|
import com.walker.cache.Cachable;
|
import com.walker.cache.Cache;
|
import com.walker.infrastructure.utils.StringUtils;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.HashSet;
|
import java.util.Iterator;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
/**
|
* 菜单本地缓存，因为不需要集群环境，因此只有内存模式(没有redis方式)
|
* @author 时克英
|
* @date 2022-11-01
|
*/
|
public class MenuCacheProvider extends AbstractCacheProvider<S_menu> {
|
|
private MenuServiceImpl menuService;
|
|
public void setMenuService(MenuServiceImpl menuService) {
|
this.menuService = menuService;
|
}
|
|
@Override
|
protected int loadDataToCache(Cache cache) {
|
List<S_menu> list = this.menuService.selectAll(new S_menu());
|
if(!StringUtils.isEmptyList(list)){
|
for(S_menu h : list){
|
cache.put(h.getMenu_id(), h);
|
}
|
return list.size();
|
}
|
return 0;
|
}
|
|
@Override
|
public String getProviderName() {
|
return Constants.CACHE_NAME_MENU;
|
}
|
|
@Override
|
public Class<?> getProviderType() {
|
return S_menu.class;
|
}
|
|
/**
|
* 给定的菜单，是否包含子菜单。
|
* @param menuId 给定菜单ID
|
* @return
|
* @date 2022-12-29
|
*/
|
public boolean isHasChildren(String menuId){
|
List<S_menu> menuAll = this.getCacheMenuList(true, MenuUtils.MENU_SCOPE_PLATFORM);
|
for(S_menu menu : menuAll){
|
if(menu.getParent_id().equals(menuId)){
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/**
|
* 返回菜单集合列表(不是树结构)，目前该方法在代码生成功能中使用，展示选择生成在哪个菜单模块。
|
* @param roleIdList
|
* @param menuScope 菜单范围：0 平台（目前也有3），4 独立单位， -1 表示显示所有菜单，>4 表示机构特定菜单，如班主任菜单。
|
* @return
|
* @date 2022-11-27
|
* @date 2023-06-05 添加参数 menuScope
|
* @date 2023-10-11 menuScope 参数增加值（-1）可以展示所有菜单，邮政集团模式
|
* @date 2023-10-24 menuScope 参数增加值（大于4），表示特定人员的特定菜单（如：班主任的菜单）
|
*/
|
public List<SystemMenu> getMenuList(List<String> roleIdList, int menuScope){
|
if(StringUtils.isEmptyList(roleIdList)){
|
// 没有给定角色集合，说明是管理员，显示所有菜单数据
|
return this.toSystemMenuList(this.getCacheMenuList(true, menuScope));
|
}
|
// 根据角色权限加载不同菜单集合
|
List<SystemMenu> menuList = new ArrayList<>(32);
|
List<String> menuIdList = this.menuService.queryRoleMenuIdList(roleIdList);
|
if(StringUtils.isEmptyList(menuIdList)){
|
logger.warn("用户没有任何权限，menuIdList = null, roleIdList = {}", roleIdList);
|
return menuList;
|
}
|
|
S_menu menu = null;
|
for(String menuId : menuIdList){
|
menu = this.getCacheData(menuId);
|
// 2023-10-11 增加这个if判断，如果是不区分范围，则加载所有菜单
|
// if(menuScope != MenuUtils.MENU_SCOPE_ALL){
|
// if(menuScope == MenuUtils.MENU_SCOPE_PLATFORM){
|
// // 如果要展示菜单范围是：平台，则菜单中 >= 4的分类都不要，这些是顶级机构业务独立菜单。
|
// if(menu.getType().intValue() >= MenuUtils.MENU_SCOPE_ORG){
|
// continue;
|
// }
|
// } else if(menuScope == MenuUtils.MENU_SCOPE_ORG){
|
//// if(menu.getType().intValue() < MenuUtils.MENU_SCOPE_ORG){
|
// if(menu.getType().intValue() != MenuUtils.MENU_SCOPE_ORG){
|
// // 如果要展示菜单范围是：顶级机构业务的独立菜单，则平台菜单不显示。2023-06-01
|
// continue;
|
// }
|
// } else if(menuScope > MenuUtils.MENU_SCOPE_ORG){
|
// // 对于大于机构菜单的，都属于机构特定菜单，必须与传入范围完全一致，如：班主任菜单等。2023-10-24
|
// if(menu.getType().intValue() != menuScope){
|
// continue;
|
// }
|
// }
|
// }
|
if(MenuUtils.menuScopeNotMatch(menuScope, menu)){
|
continue;
|
}
|
menuList.add(new SystemMenu(menu));
|
}
|
|
// 2023-10-13，查找每个菜单上级，如果上级范围类型与下级菜单不一致，也需要加入列表中
|
for(String menuId : menuIdList){
|
if(MenuUtils.containMenu(menuList, menuId)){
|
continue;
|
}
|
menu = this.getCacheData(menuId);
|
menuList.add(new SystemMenu(menu));
|
}
|
// if(!StringUtils.isEmptyList(menuList)){
|
// String pid = null;
|
// for(SystemMenu systemMenu : menuList){
|
// pid = systemMenu.getParent_id();
|
// if(pid.equals(MenuUtils.MENU_ID_ROOT)){
|
// continue;
|
// }
|
// if(menuIdList.contains(pid)){
|
// this.addParentMenu2Collection(menuList, pid);
|
// }
|
// }
|
// }
|
|
Collections.sort(menuList, new ParentMenuComparator());
|
Collections.sort(menuList, new MenuOrderNumComparator());
|
return menuList;
|
}
|
|
// private List<SystemMenu> addParentMenu2Collection(List<SystemMenu> menuList, String menuId){
|
// List<SystemMenu> addList = null;
|
// boolean exist = false;
|
// for(SystemMenu menu : menuList){
|
// if(menu.getMenu_id().equals(menuId)){
|
// exist = true;
|
// break;
|
// }
|
// }
|
// if(!exist){
|
// S_menu menu = this.getCacheData(menuId);
|
// if(addList == null){
|
// addList = new ArrayList<>(8);
|
// }
|
// addList.add(new SystemMenu(menu));
|
// }
|
// return addList;
|
// }
|
|
public List<SystemMenu> toSystemMenuList(List<S_menu> srcMenuList){
|
List<SystemMenu> list = new ArrayList<>(32);
|
if(StringUtils.isEmptyList(srcMenuList)){
|
return list;
|
}
|
for(S_menu menu : srcMenuList){
|
list.add(new SystemMenu(menu));
|
}
|
return list;
|
}
|
|
/**
|
* 获得缓存菜单列表
|
* @param containButton 是否包含按钮权限菜单
|
* @param menuScope 菜单范围，对独立顶级机构，可以显示机构设置的分类菜单范围，目前有：0-平台（包含3），4-顶级单位独立菜单
|
* @return
|
* @date 2023-06-01
|
*/
|
public List<S_menu> getCacheMenuList(boolean containButton, int menuScope){
|
List<S_menu> data = new ArrayList<>();
|
S_menu menu = null;
|
for(Iterator<Cachable> it = this.getCache().getIterator(); it.hasNext();){
|
menu = (S_menu) it.next().getValue();
|
|
// 2023-10-11 增加这个if判断，如果是不区分范围，则加载所有菜单
|
// if(menuScope != MenuUtils.MENU_SCOPE_ALL){
|
|
// if(menuScope == MenuUtils.MENU_SCOPE_PLATFORM){
|
// // 如果要展示菜单范围是：平台，则菜单中 >= 4的分类都不要，这些是顶级机构业务独立菜单。
|
// if(menu.getType().intValue() >= MenuUtils.MENU_SCOPE_ORG){
|
// continue;
|
// }
|
// } else if(menu.getType().intValue() < MenuUtils.MENU_SCOPE_ORG){
|
// // 如果要展示菜单范围是：顶级机构业务的独立菜单，则平台菜单不显示。2023-06-01
|
// continue;
|
// }
|
// }
|
// 2023-10-24
|
if(MenuUtils.menuScopeNotMatch(menuScope, menu)){
|
continue;
|
}
|
|
if(menu.getStatus().intValue() == MenuUtils.MENU_STATUS_DISABLED){
|
// 去掉禁用菜单
|
continue;
|
}
|
if(menu.getMenu_type().equals(MenuUtils.MENU_TYPE_BUTTON)){
|
if(containButton){
|
data.add(menu);
|
}
|
} else {
|
data.add(menu);
|
}
|
}
|
Collections.sort(data, new ParentMenuComparator());
|
Collections.sort(data, new MenuOrderNumComparator());
|
return data;
|
}
|
|
/**
|
* 根据父节点的ID获取所有子节点
|
*
|
* @param list 分类表
|
* @param parentId 传入的父节点ID
|
* @return String
|
*/
|
public List<SystemMenu> getChildPerms(List<SystemMenu> list, String parentId) {
|
List<SystemMenu> returnList = new ArrayList<>();
|
for (Iterator<SystemMenu> iterator = list.iterator(); iterator.hasNext();) {
|
SystemMenu t = iterator.next();
|
// 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
|
if (t.getParent_id().equals(parentId)) {
|
recursionFn(list, t);
|
returnList.add(t);
|
}
|
}
|
return returnList;
|
}
|
|
/**
|
* 递归列表
|
*
|
* @param list
|
* @param t
|
*/
|
private void recursionFn(List<SystemMenu> list, SystemMenu t) {
|
// 得到子节点列表
|
List<SystemMenu> childList = getChildList(list, t);
|
t.setChildren(childList);
|
for (SystemMenu tChild : childList) {
|
if (hasChild(list, tChild)) {
|
recursionFn(list, tChild);
|
}
|
}
|
}
|
|
/**
|
* 得到子节点列表
|
*/
|
private List<SystemMenu> getChildList(List<SystemMenu> list, SystemMenu t) {
|
List<SystemMenu> tlist = new ArrayList<>();
|
Iterator<SystemMenu> it = list.iterator();
|
while (it.hasNext()) {
|
SystemMenu n = it.next();
|
if (n.getParent_id().equals(t.getMenu_id())) {
|
tlist.add(n);
|
}
|
}
|
return tlist;
|
}
|
|
/**
|
* 判断是否有子节点
|
*/
|
private boolean hasChild(List<SystemMenu> list, SystemMenu t) {
|
return getChildList(list, t).size() > 0;
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
//~ 以下为用户登录菜单展示使用，2022-11-12
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
/**
|
* 返回菜单权限标识字符串集合，该方法若依前端使用。<p></p>
|
* 后续会去掉前端对权限点的依赖。
|
* @param menuIdList
|
* @param showAll 是否显示所有权限点
|
* @param menuScope 菜单范围，对独立顶级机构，可以显示机构设置的分类菜单范围，目前有：0-平台（包含3），4-顶级单位独立菜单
|
* @return
|
* @date 2022-11-12
|
* @date 2023-03-20 如果给定菜单id为空，则不返回任何权限点信息。时克英
|
* @date 2023-06-07 对于独立单位（商户）则会显示所有该单位的菜单权限信息
|
*/
|
public Set<String> getPermissionSet(List<String> menuIdList, boolean showAll, int menuScope){
|
if(StringUtils.isEmptyList(menuIdList) && !showAll){
|
return new HashSet<>();
|
}
|
List<String> permsList = new ArrayList<>(64);
|
// List<S_menu> menuAll = this.getCacheMenuList(true, MenuUtils.MENU_SCOPE_PLATFORM);
|
List<S_menu> menuAll = this.getCacheMenuList(true, menuScope);
|
if(!StringUtils.isEmptyList(menuAll)){
|
for(S_menu menu : menuAll){
|
|
// 2023-10-11 增加这个if判断，如果是不区分范围，则加载所有菜单
|
// if(menuScope != MenuUtils.MENU_SCOPE_ALL){
|
//
|
// // 2023-06-07
|
// if(menuScope == MenuUtils.MENU_SCOPE_PLATFORM){
|
// // 如果要展示菜单范围是：平台，则菜单中 >= 4的分类都不要，这些是顶级机构业务独立菜单。
|
// if(menu.getType().intValue() >= MenuUtils.MENU_SCOPE_ORG){
|
// continue;
|
// }
|
// } else if(menu.getType().intValue() < MenuUtils.MENU_SCOPE_ORG){
|
// // 如果要展示菜单范围是：顶级机构业务的独立菜单，则平台菜单不显示。2023-06-01
|
// continue;
|
// }
|
// }
|
// 2023-10-24
|
if(MenuUtils.menuScopeNotMatch(menuScope, menu)){
|
continue;
|
}
|
|
if(StringUtils.isEmpty(menu.getPerms())){
|
continue;
|
}
|
if(StringUtils.isEmptyList(menuIdList)){
|
// 如果没有限制，全部加上
|
permsList.add(menu.getPerms());
|
} else if(menuIdList.contains(menu.getMenu_id())){
|
// 如果限制有，则只添加给定的
|
permsList.add(menu.getPerms());
|
}
|
}
|
}
|
|
Set<String> permsSet = new HashSet<>();
|
for(String perms : permsList){
|
if (StringUtils.isNotEmpty(perms)) {
|
permsSet.addAll(Arrays.asList(perms.trim().split(",")));
|
}
|
}
|
return permsSet;
|
}
|
|
/**
|
* 返回菜单树形结果，列表中包含多个菜单根节点，menuIdList 为空时，允许返回所有的。
|
* @param menuIdList
|
* @param containButton
|
* @return
|
* @date 2023-03-22
|
*/
|
public List<SystemMenu> getMenuTreeAll(List<String> menuIdList, boolean containButton, int menuScope){
|
return this.getMenuTree(menuIdList, containButton, true, menuScope);
|
}
|
|
/**
|
* 返回菜单树形结果，列表中包含多个菜单根节点。
|
* @param menuIdList 指定显示的菜单，如果为空表示不特别限制
|
* @param containButton 是否包含按钮权限
|
* @param showAll 当给定'menuIdList'为空时，是否显示所有菜单
|
* @return
|
* @date 2022-12-18 更新
|
* @date 2023-03-22 添加参数'showAll'
|
*/
|
public List<SystemMenu> getMenuTree(List<String> menuIdList, boolean containButton, boolean showAll, int menuScope){
|
List<SystemMenu> menuGroupList = new ArrayList<>(32);
|
if(StringUtils.isEmptyList(menuIdList) && !showAll){
|
// 2023-03-22 给定为空菜单id，并且不允许显示所有，返回空菜单树。
|
return getChildPerms(menuGroupList, "0");
|
}
|
// List<S_menu> menuAll = this.getCacheMenuList(false);
|
List<S_menu> menuAll = this.getCacheMenuList(containButton, menuScope);
|
if(!StringUtils.isEmptyList(menuAll)){
|
for(S_menu menu : menuAll){
|
if(menuIdList == null){
|
// 如果没有限制，全部加上
|
menuGroupList.add(new SystemMenu(menu));
|
} else if(menuIdList.contains(menu.getMenu_id())){
|
// 如果限制有，则只添加给定的
|
menuGroupList.add(new SystemMenu(menu));
|
}
|
}
|
}
|
return getChildPerms(menuGroupList, "0");
|
}
|
|
|
/**
|
* 构建前端路由所需要的菜单（若依）
|
*
|
* @param menus 菜单列表
|
* @return 路由列表
|
*/
|
@Deprecated
|
public List<RouterVo> buildMenus(List<SystemMenu> menus) {
|
List<RouterVo> routers = new LinkedList<RouterVo>();
|
for (SystemMenu menu : menus) {
|
RouterVo router = new RouterVo();
|
router.setHidden(MenuUtils.MENU_INVISIBLE.equals(menu.getVisible()));
|
router.setName(MenuUtils.getRouteName(menu));
|
router.setPath(MenuUtils.getRouterPath(menu));
|
router.setComponent(MenuUtils.getComponent(menu));
|
router.setQuery(menu.getQuery());
|
router.setMeta(new MetaVo(menu.getMenu_name(), menu.getIcon(), menu.getIs_cache().intValue() == MenuUtils.MENU_CACHE_DISABLE, menu.getPath()));
|
List<SystemMenu> cMenus = menu.getChildren();
|
if (!cMenus.isEmpty() && cMenus.size() > 0 && menu.getMenu_type().equals(MenuUtils.MENU_TYPE_FOLDER)) {
|
router.setAlwaysShow(true);
|
router.setRedirect("noRedirect");
|
router.setChildren(buildMenus(cMenus));
|
}
|
else if (MenuUtils.isMenuFrame(menu)) {
|
router.setMeta(null);
|
List<RouterVo> childrenList = new ArrayList<RouterVo>();
|
RouterVo children = new RouterVo();
|
children.setPath(menu.getPath());
|
children.setComponent(menu.getComponent());
|
children.setName(StringUtils.capitalize(menu.getPath()));
|
children.setMeta(new MetaVo(menu.getMenu_name(), menu.getIcon(), menu.getIs_cache().intValue() == MenuUtils.MENU_CACHE_DISABLE, menu.getPath()));
|
children.setQuery(menu.getQuery());
|
childrenList.add(children);
|
router.setChildren(childrenList);
|
}
|
else if (menu.getParent_id().equals(MenuUtils.MENU_ID_ROOT) && MenuUtils.isInnerLink(menu)) {
|
router.setMeta(new MetaVo(menu.getMenu_name(), menu.getIcon()));
|
router.setPath("/");
|
List<RouterVo> childrenList = new ArrayList<RouterVo>();
|
RouterVo children = new RouterVo();
|
String routerPath = MenuUtils.innerLinkReplaceEach(menu.getPath());
|
children.setPath(routerPath);
|
children.setComponent(MenuUtils.INNER_LINK);
|
children.setName(StringUtils.capitalize(routerPath));
|
children.setMeta(new MetaVo(menu.getMenu_name(), menu.getIcon(), menu.getPath()));
|
childrenList.add(children);
|
router.setChildren(childrenList);
|
}
|
routers.add(router);
|
}
|
return routers;
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
//~ 以下为系统权限管理使用，2022-11-02
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
/**
|
* 返回系统所有角色与url关联数据，security权限配置实用。<p></p>
|
* 该方法会有重复数据，例如:多个角色具有相同的URL，由业务去除重复。<p></p>
|
* list[0] = role_id, list[1] = url <p></p>
|
* 因为Map对象相同key会覆盖value，所以换成List集合返回。
|
* @return
|
* @date 2022-11-02
|
*/
|
public List<String[]> getAllRoleMenuMap(){
|
List<String[]> result = new ArrayList<>();
|
List<Map<String, Object>> list = this.menuService.queryRolesPermList();
|
if(StringUtils.isEmptyList(list)){
|
return result;
|
}
|
|
String perms = null;
|
String menuId = null;
|
S_menu menu = null;
|
|
for(Map<String, Object> map : list){
|
menuId = map.get("menu_id").toString();
|
menu = this.getCacheData(menuId);
|
if(menu == null){
|
throw new IllegalArgumentException("缓存中未找到菜单:" + menuId);
|
}
|
perms = menu.getPerms();
|
if(StringUtils.isEmpty(perms)){
|
continue;
|
}
|
// result.put(map.get("role_id").toString(), MenuUtils.acquireUrlFromPerms(perms));
|
result.add(new String[]{map.get("role_id").toString(), MenuUtils.acquireUrlFromPerms(perms)});
|
}
|
|
// 2023-06-07
|
// 商户（顶级机构）特有的菜单，也需要加入到角色中，设置默认三方角色：ROLE_MERCHANT
|
Set<String> merchantPermSet = this.getPermissionSet(null, true, MenuUtils.MENU_SCOPE_ORG);
|
if(merchantPermSet != null){
|
for(String onePerms : merchantPermSet){
|
result.add(new String[]{SecurityConstants.ROLE_MERCHANT, MenuUtils.acquireUrlFromPerms(onePerms)});
|
}
|
logger.debug("添加商户（顶级机构）角色权限：{}", merchantPermSet.size());
|
}
|
return result;
|
}
|
|
/**
|
* 返回系统所有菜单包含权限的url集合，即:所有perms存在的菜单。
|
* @return
|
* @date 2022-11-02
|
*/
|
public List<String> getAllMenuUrlList(){
|
List<String> urlList = new ArrayList<>(32);
|
S_menu menu = null;
|
String perms = null;
|
for(Iterator<Cachable> it = this.getCache().getIterator(); it.hasNext();){
|
menu = (S_menu) it.next().getValue();
|
perms = menu.getPerms();
|
if(StringUtils.isEmpty(perms)){
|
continue;
|
}
|
urlList.add(MenuUtils.acquireUrlFromPerms(perms));
|
}
|
return urlList;
|
}
|
}
|
