odcc/CpzIdc.git

YZFG

2024-09-30 43dc2996fd2033991539ed35a0429238829a5417

commit \| author \| age
43dc29	1	package com.odcc.cpzidc.system.service.impl;
Y	2
	3	import java.util.ArrayList;
	4	import java.util.Arrays;
	5	import java.util.HashSet;
	6	import java.util.Iterator;
	7	import java.util.LinkedList;
	8	import java.util.List;
	9	import java.util.Set;
	10	import java.util.stream.Collectors;
	11	import org.springframework.beans.factory.annotation.Autowired;
	12	import org.springframework.stereotype.Service;
	13	import com.odcc.cpzidc.common.constant.Constants;
	14	import com.odcc.cpzidc.common.constant.UserConstants;
	15	import com.odcc.cpzidc.common.core.domain.TreeSelect;
	16	import com.odcc.cpzidc.common.core.domain.entity.SysMenu;
	17	import com.odcc.cpzidc.common.core.domain.entity.SysRole;
	18	import com.odcc.cpzidc.common.core.domain.entity.SysUser;
	19	import com.odcc.cpzidc.common.utils.SecurityUtils;
	20	import com.odcc.cpzidc.common.utils.StringUtils;
	21	import com.odcc.cpzidc.system.domain.vo.MetaVo;
	22	import com.odcc.cpzidc.system.domain.vo.RouterVo;
	23	import com.odcc.cpzidc.system.mapper.SysMenuMapper;
	24	import com.odcc.cpzidc.system.mapper.SysRoleMapper;
	25	import com.odcc.cpzidc.system.mapper.SysRoleMenuMapper;
	26	import com.odcc.cpzidc.system.service.ISysMenuService;
	27
	28	/**
	29	* 菜单业务层处理
	30	*
	31	* @author ruoyi
	32	*/
	33	@Service
	34	public class SysMenuServiceImpl implements ISysMenuService
	35	{
	36	public static final String PREMISSION_STRING = "perms[\"{0}\"]";
	37
	38	@Autowired
	39	private SysMenuMapper menuMapper;
	40
	41	@Autowired
	42	private SysRoleMapper roleMapper;
	43
	44	@Autowired
	45	private SysRoleMenuMapper roleMenuMapper;
	46
	47	/**
	48	* 根据用户查询系统菜单列表
	49	*
	50	* @param userId 用户ID
	51	* @return 菜单列表
	52	*/
	53	@Override
	54	public List<SysMenu> selectMenuList(Long userId)
	55	{
	56	return selectMenuList(new SysMenu(), userId);
	57	}
	58
	59	/**
	60	* 查询系统菜单列表
	61	*
	62	* @param menu 菜单信息
	63	* @return 菜单列表
	64	*/
	65	@Override
	66	public List<SysMenu> selectMenuList(SysMenu menu, Long userId)
	67	{
	68	List<SysMenu> menuList = null;
	69	// 管理员显示所有菜单信息
	70	if (SysUser.isAdmin(userId))
	71	{
	72	menuList = menuMapper.selectMenuList(menu);
	73	}
	74	else
	75	{
	76	menu.getParams().put("userId", userId);
	77	menuList = menuMapper.selectMenuListByUserId(menu);
	78	}
	79	return menuList;
	80	}
	81
	82	/**
	83	* 根据用户ID查询权限
	84	*
	85	* @param userId 用户ID
	86	* @return 权限列表
	87	*/
	88	@Override
	89	public Set<String> selectMenuPermsByUserId(Long userId)
	90	{
	91	List<String> perms = menuMapper.selectMenuPermsByUserId(userId);
	92	Set<String> permsSet = new HashSet<>();
	93	for (String perm : perms)
	94	{
	95	if (StringUtils.isNotEmpty(perm))
	96	{
	97	permsSet.addAll(Arrays.asList(perm.trim().split(",")));
	98	}
	99	}
	100	return permsSet;
	101	}
	102
	103	/**
	104	* 根据角色ID查询权限
	105	*
	106	* @param roleId 角色ID
	107	* @return 权限列表
	108	*/
	109	@Override
	110	public Set<String> selectMenuPermsByRoleId(Long roleId)
	111	{
	112	List<String> perms = menuMapper.selectMenuPermsByRoleId(roleId);
	113	Set<String> permsSet = new HashSet<>();
	114	for (String perm : perms)
	115	{
	116	if (StringUtils.isNotEmpty(perm))
	117	{
	118	permsSet.addAll(Arrays.asList(perm.trim().split(",")));
	119	}
	120	}
	121	return permsSet;
	122	}
	123
	124	/**
	125	* 根据用户ID查询菜单
	126	*
	127	* @param userId 用户名称
	128	* @return 菜单列表
	129	*/
	130	@Override
	131	public List<SysMenu> selectMenuTreeByUserId(Long userId)
	132	{
	133	List<SysMenu> menus = null;
	134	if (SecurityUtils.isAdmin(userId))
	135	{
	136	menus = menuMapper.selectMenuTreeAll();
	137	}
	138	else
	139	{
	140	menus = menuMapper.selectMenuTreeByUserId(userId);
	141	}
	142	return getChildPerms(menus, 0);
	143	}
	144
	145	/**
	146	* 根据角色ID查询菜单树信息
	147	*
	148	* @param roleId 角色ID
	149	* @return 选中菜单列表
	150	*/
	151	@Override
	152	public List<Long> selectMenuListByRoleId(Long roleId)
	153	{
	154	SysRole role = roleMapper.selectRoleById(roleId);
	155	return menuMapper.selectMenuListByRoleId(roleId, role.isMenuCheckStrictly());
	156	}
	157
	158	/**
	159	* 构建前端路由所需要的菜单
	160	*
	161	* @param menus 菜单列表
	162	* @return 路由列表
	163	*/
	164	@Override
	165	public List<RouterVo> buildMenus(List<SysMenu> menus)
	166	{
	167	List<RouterVo> routers = new LinkedList<RouterVo>();
	168	for (SysMenu menu : menus)
	169	{
	170	RouterVo router = new RouterVo();
	171	router.setHidden("1".equals(menu.getVisible()));
	172	router.setName(getRouteName(menu));
	173	router.setPath(getRouterPath(menu));
	174	router.setComponent(getComponent(menu));
	175	router.setQuery(menu.getQuery());
	176	router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath()));
	177	List<SysMenu> cMenus = menu.getChildren();
	178	if (StringUtils.isNotEmpty(cMenus) && UserConstants.TYPE_DIR.equals(menu.getMenuType()))
	179	{
	180	router.setAlwaysShow(true);
	181	router.setRedirect("noRedirect");
	182	router.setChildren(buildMenus(cMenus));
	183	}
	184	else if (isMenuFrame(menu))
	185	{
	186	router.setMeta(null);
	187	List<RouterVo> childrenList = new ArrayList<RouterVo>();
	188	RouterVo children = new RouterVo();
	189	children.setPath(menu.getPath());
	190	children.setComponent(menu.getComponent());
	191	children.setName(getRouteName(menu.getRouteName(), menu.getPath()));
	192	children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath()));
	193	children.setQuery(menu.getQuery());
	194	childrenList.add(children);
	195	router.setChildren(childrenList);
	196	}
	197	else if (menu.getParentId().intValue() == 0 && isInnerLink(menu))
	198	{
	199	router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon()));
	200	router.setPath("/");
	201	List<RouterVo> childrenList = new ArrayList<RouterVo>();
	202	RouterVo children = new RouterVo();
	203	String routerPath = innerLinkReplaceEach(menu.getPath());
	204	children.setPath(routerPath);
	205	children.setComponent(UserConstants.INNER_LINK);
	206	children.setName(getRouteName(menu.getRouteName(), routerPath));
	207	children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), menu.getPath()));
	208	childrenList.add(children);
	209	router.setChildren(childrenList);
	210	}
	211	routers.add(router);
	212	}
	213	return routers;
	214	}
	215
	216	/**
	217	* 构建前端所需要树结构
	218	*
	219	* @param menus 菜单列表
	220	* @return 树结构列表
	221	*/
	222	@Override
	223	public List<SysMenu> buildMenuTree(List<SysMenu> menus)
	224	{
	225	List<SysMenu> returnList = new ArrayList<SysMenu>();
	226	List<Long> tempList = menus.stream().map(SysMenu::getMenuId).collect(Collectors.toList());
	227	for (Iterator<SysMenu> iterator = menus.iterator(); iterator.hasNext();)
	228	{
	229	SysMenu menu = (SysMenu) iterator.next();
	230	// 如果是顶级节点, 遍历该父节点的所有子节点
	231	if (!tempList.contains(menu.getParentId()))
	232	{
	233	recursionFn(menus, menu);
	234	returnList.add(menu);
	235	}
	236	}
	237	if (returnList.isEmpty())
	238	{
	239	returnList = menus;
	240	}
	241	return returnList;
	242	}
	243
	244	/**
	245	* 构建前端所需要下拉树结构
	246	*
	247	* @param menus 菜单列表
	248	* @return 下拉树结构列表
	249	*/
	250	@Override
	251	public List<TreeSelect> buildMenuTreeSelect(List<SysMenu> menus)
	252	{
	253	List<SysMenu> menuTrees = buildMenuTree(menus);
	254	return menuTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
	255	}
	256
	257	/**
	258	* 根据菜单ID查询信息
	259	*
	260	* @param menuId 菜单ID
	261	* @return 菜单信息
	262	*/
	263	@Override
	264	public SysMenu selectMenuById(Long menuId)
	265	{
	266	return menuMapper.selectMenuById(menuId);
	267	}
	268
	269	/**
	270	* 是否存在菜单子节点
	271	*
	272	* @param menuId 菜单ID
	273	* @return 结果
	274	*/
	275	@Override
	276	public boolean hasChildByMenuId(Long menuId)
	277	{
	278	int result = menuMapper.hasChildByMenuId(menuId);
	279	return result > 0;
	280	}
	281
	282	/**
	283	* 查询菜单使用数量
	284	*
	285	* @param menuId 菜单ID
	286	* @return 结果
	287	*/
	288	@Override
	289	public boolean checkMenuExistRole(Long menuId)
	290	{
	291	int result = roleMenuMapper.checkMenuExistRole(menuId);
	292	return result > 0;
	293	}
	294
	295	/**
	296	* 新增保存菜单信息
	297	*
	298	* @param menu 菜单信息
	299	* @return 结果
	300	*/
	301	@Override
	302	public int insertMenu(SysMenu menu)
	303	{
	304	return menuMapper.insertMenu(menu);
	305	}
	306
	307	/**
	308	* 修改保存菜单信息
	309	*
	310	* @param menu 菜单信息
	311	* @return 结果
	312	*/
	313	@Override
	314	public int updateMenu(SysMenu menu)
	315	{
	316	return menuMapper.updateMenu(menu);
	317	}
	318
	319	/**
	320	* 删除菜单管理信息
	321	*
	322	* @param menuId 菜单ID
	323	* @return 结果
	324	*/
	325	@Override
	326	public int deleteMenuById(Long menuId)
	327	{
	328	return menuMapper.deleteMenuById(menuId);
	329	}
	330
	331	/**
	332	* 校验菜单名称是否唯一
	333	*
	334	* @param menu 菜单信息
	335	* @return 结果
	336	*/
	337	@Override
	338	public boolean checkMenuNameUnique(SysMenu menu)
	339	{
	340	Long menuId = StringUtils.isNull(menu.getMenuId()) ? -1L : menu.getMenuId();
	341	SysMenu info = menuMapper.checkMenuNameUnique(menu.getMenuName(), menu.getParentId());
	342	if (StringUtils.isNotNull(info) && info.getMenuId().longValue() != menuId.longValue())
	343	{
	344	return UserConstants.NOT_UNIQUE;
	345	}
	346	return UserConstants.UNIQUE;
	347	}
	348
	349	/**
	350	* 获取路由名称
	351	*
	352	* @param menu 菜单信息
	353	* @return 路由名称
	354	*/
	355	public String getRouteName(SysMenu menu)
	356	{
	357	// 非外链并且是一级目录（类型为目录）
	358	if (isMenuFrame(menu))
	359	{
	360	return StringUtils.EMPTY;
	361	}
	362	return getRouteName(menu.getRouteName(), menu.getPath());
	363	}
	364
	365	/**
	366	* 获取路由名称，如没有配置路由名称则取路由地址
	367	*
	368	* @param routerName 路由名称
	369	* @param path 路由地址
	370	* @return 路由名称（驼峰格式）
	371	*/
	372	public String getRouteName(String name, String path)
	373	{
	374	String routerName = StringUtils.isNotEmpty(name) ? name : path;
	375	return StringUtils.capitalize(routerName);
	376	}
	377
	378	/**
	379	* 获取路由地址
	380	*
	381	* @param menu 菜单信息
	382	* @return 路由地址
	383	*/
	384	public String getRouterPath(SysMenu menu)
	385	{
	386	String routerPath = menu.getPath();
	387	// 内链打开外网方式
	388	if (menu.getParentId().intValue() != 0 && isInnerLink(menu))
	389	{
	390	routerPath = innerLinkReplaceEach(routerPath);
	391	}
	392	// 非外链并且是一级目录（类型为目录）
	393	if (0 == menu.getParentId().intValue() && UserConstants.TYPE_DIR.equals(menu.getMenuType())
	394	&& UserConstants.NO_FRAME.equals(menu.getIsFrame()))
	395	{
	396	routerPath = "/" + menu.getPath();
	397	}
	398	// 非外链并且是一级目录（类型为菜单）
	399	else if (isMenuFrame(menu))
	400	{
	401	routerPath = "/";
	402	}
	403	return routerPath;
	404	}
	405
	406	/**
	407	* 获取组件信息
	408	*
	409	* @param menu 菜单信息
	410	* @return 组件信息
	411	*/
	412	public String getComponent(SysMenu menu)
	413	{
	414	String component = UserConstants.LAYOUT;
	415	if (StringUtils.isNotEmpty(menu.getComponent()) && !isMenuFrame(menu))
	416	{
	417	component = menu.getComponent();
	418	}
	419	else if (StringUtils.isEmpty(menu.getComponent()) && menu.getParentId().intValue() != 0 && isInnerLink(menu))
	420	{
	421	component = UserConstants.INNER_LINK;
	422	}
	423	else if (StringUtils.isEmpty(menu.getComponent()) && isParentView(menu))
	424	{
	425	component = UserConstants.PARENT_VIEW;
	426	}
	427	return component;
	428	}
	429
	430	/**
	431	* 是否为菜单内部跳转
	432	*
	433	* @param menu 菜单信息
	434	* @return 结果
	435	*/
	436	public boolean isMenuFrame(SysMenu menu)
	437	{
	438	return menu.getParentId().intValue() == 0 && UserConstants.TYPE_MENU.equals(menu.getMenuType())
	439	&& menu.getIsFrame().equals(UserConstants.NO_FRAME);
	440	}
	441
	442	/**
	443	* 是否为内链组件
	444	*
	445	* @param menu 菜单信息
	446	* @return 结果
	447	*/
	448	public boolean isInnerLink(SysMenu menu)
	449	{
	450	return menu.getIsFrame().equals(UserConstants.NO_FRAME) && StringUtils.ishttp(menu.getPath());
	451	}
	452
	453	/**
	454	* 是否为parent_view组件
	455	*
	456	* @param menu 菜单信息
	457	* @return 结果
	458	*/
	459	public boolean isParentView(SysMenu menu)
	460	{
	461	return menu.getParentId().intValue() != 0 && UserConstants.TYPE_DIR.equals(menu.getMenuType());
	462	}
	463
	464	/**
	465	* 根据父节点的ID获取所有子节点
	466	*
	467	* @param list 分类表
	468	* @param parentId 传入的父节点ID
	469	* @return String
	470	*/
	471	public List<SysMenu> getChildPerms(List<SysMenu> list, int parentId)
	472	{
	473	List<SysMenu> returnList = new ArrayList<SysMenu>();
	474	for (Iterator<SysMenu> iterator = list.iterator(); iterator.hasNext();)
	475	{
	476	SysMenu t = (SysMenu) iterator.next();
	477	// 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
	478	if (t.getParentId() == parentId)
	479	{
	480	recursionFn(list, t);
	481	returnList.add(t);
	482	}
	483	}
	484	return returnList;
	485	}
	486
	487	/**
	488	* 递归列表
	489	*
	490	* @param list 分类表
	491	* @param t 子节点
	492	*/
	493	private void recursionFn(List<SysMenu> list, SysMenu t)
	494	{
	495	// 得到子节点列表
	496	List<SysMenu> childList = getChildList(list, t);
	497	t.setChildren(childList);
	498	for (SysMenu tChild : childList)
	499	{
	500	if (hasChild(list, tChild))
	501	{
	502	recursionFn(list, tChild);
	503	}
	504	}
	505	}
	506
	507	/**
	508	* 得到子节点列表
	509	*/
	510	private List<SysMenu> getChildList(List<SysMenu> list, SysMenu t)
	511	{
	512	List<SysMenu> tlist = new ArrayList<SysMenu>();
	513	Iterator<SysMenu> it = list.iterator();
	514	while (it.hasNext())
	515	{
	516	SysMenu n = (SysMenu) it.next();
	517	if (n.getParentId().longValue() == t.getMenuId().longValue())
	518	{
	519	tlist.add(n);
	520	}
	521	}
	522	return tlist;
	523	}
	524
	525	/**
	526	* 判断是否有子节点
	527	*/
	528	private boolean hasChild(List<SysMenu> list, SysMenu t)
	529	{
	530	return getChildList(list, t).size() > 0;
	531	}
	532
	533	/**
	534	* 内链域名特殊字符替换
	535	*
	536	* @return 替换后的内链域名
	537	*/
	538	public String innerLinkReplaceEach(String path)
	539	{
	540	return StringUtils.replaceEach(path, new String[] { Constants.HTTP, Constants.HTTPS, Constants.WWW, ".", ":" },
	541	new String[] { "", "", "", "/", "/" });
	542	}
	543	}