odcc/CpzIdc.git

yanzhaofeige

3 days ago 5cc82f45d73865489cc39e5ffbf521bf4279ec53

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.List;
	7	import java.util.Set;
	8	import org.springframework.beans.factory.annotation.Autowired;
	9	import org.springframework.stereotype.Service;
	10	import org.springframework.transaction.annotation.Transactional;
	11	import com.odcc.cpzidc.common.annotation.DataScope;
	12	import com.odcc.cpzidc.common.constant.UserConstants;
	13	import com.odcc.cpzidc.common.core.domain.entity.SysRole;
	14	import com.odcc.cpzidc.common.core.domain.entity.SysUser;
	15	import com.odcc.cpzidc.common.exception.ServiceException;
	16	import com.odcc.cpzidc.common.utils.SecurityUtils;
	17	import com.odcc.cpzidc.common.utils.StringUtils;
	18	import com.odcc.cpzidc.common.utils.spring.SpringUtils;
	19	import com.odcc.cpzidc.system.domain.SysRoleDept;
	20	import com.odcc.cpzidc.system.domain.SysRoleMenu;
	21	import com.odcc.cpzidc.system.domain.SysUserRole;
	22	import com.odcc.cpzidc.system.mapper.SysRoleDeptMapper;
	23	import com.odcc.cpzidc.system.mapper.SysRoleMapper;
	24	import com.odcc.cpzidc.system.mapper.SysRoleMenuMapper;
	25	import com.odcc.cpzidc.system.mapper.SysUserRoleMapper;
	26	import com.odcc.cpzidc.system.service.ISysRoleService;
	27
	28	/**
	29	* 角色业务层处理
	30	*
	31	* @author ruoyi
	32	*/
	33	@Service
	34	public class SysRoleServiceImpl implements ISysRoleService
	35	{
	36	@Autowired
	37	private SysRoleMapper roleMapper;
	38
	39	@Autowired
	40	private SysRoleMenuMapper roleMenuMapper;
	41
	42	@Autowired
	43	private SysUserRoleMapper userRoleMapper;
	44
	45	@Autowired
	46	private SysRoleDeptMapper roleDeptMapper;
	47
	48	/**
	49	* 根据条件分页查询角色数据
	50	*
	51	* @param role 角色信息
	52	* @return 角色数据集合信息
	53	*/
	54	@Override
	55	@DataScope(deptAlias = "d")
	56	public List<SysRole> selectRoleList(SysRole role)
	57	{
	58	return roleMapper.selectRoleList(role);
	59	}
	60
	61	/**
	62	* 根据用户ID查询角色
	63	*
	64	* @param userId 用户ID
	65	* @return 角色列表
	66	*/
	67	@Override
	68	public List<SysRole> selectRolesByUserId(Long userId)
	69	{
	70	List<SysRole> userRoles = roleMapper.selectRolePermissionByUserId(userId);
	71	List<SysRole> roles = selectRoleAll();
	72	for (SysRole role : roles)
	73	{
	74	for (SysRole userRole : userRoles)
	75	{
	76	if (role.getRoleId().longValue() == userRole.getRoleId().longValue())
	77	{
	78	role.setFlag(true);
	79	break;
	80	}
	81	}
	82	}
	83	return roles;
	84	}
	85
	86	/**
	87	* 根据用户ID查询权限
	88	*
	89	* @param userId 用户ID
	90	* @return 权限列表
	91	*/
	92	@Override
	93	public Set<String> selectRolePermissionByUserId(Long userId)
	94	{
	95	List<SysRole> perms = roleMapper.selectRolePermissionByUserId(userId);
	96	Set<String> permsSet = new HashSet<>();
	97	for (SysRole perm : perms)
	98	{
	99	if (StringUtils.isNotNull(perm))
	100	{
	101	permsSet.addAll(Arrays.asList(perm.getRoleKey().trim().split(",")));
	102	}
	103	}
	104	return permsSet;
	105	}
	106
	107	/**
	108	* 查询所有角色
	109	*
	110	* @return 角色列表
	111	*/
	112	@Override
	113	public List<SysRole> selectRoleAll()
	114	{
	115	return SpringUtils.getAopProxy(this).selectRoleList(new SysRole());
	116	}
	117
	118	/**
	119	* 根据用户ID获取角色选择框列表
	120	*
	121	* @param userId 用户ID
	122	* @return 选中角色ID列表
	123	*/
	124	@Override
	125	public List<Long> selectRoleListByUserId(Long userId)
	126	{
	127	return roleMapper.selectRoleListByUserId(userId);
	128	}
	129
	130	/**
	131	* 通过角色ID查询角色
	132	*
	133	* @param roleId 角色ID
	134	* @return 角色对象信息
	135	*/
	136	@Override
	137	public SysRole selectRoleById(Long roleId)
	138	{
	139	return roleMapper.selectRoleById(roleId);
	140	}
	141
	142	/**
	143	* 校验角色名称是否唯一
	144	*
	145	* @param role 角色信息
	146	* @return 结果
	147	*/
	148	@Override
	149	public boolean checkRoleNameUnique(SysRole role)
	150	{
	151	Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
	152	SysRole info = roleMapper.checkRoleNameUnique(role.getRoleName());
	153	if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue())
	154	{
	155	return UserConstants.NOT_UNIQUE;
	156	}
	157	return UserConstants.UNIQUE;
	158	}
	159
	160	/**
	161	* 校验角色权限是否唯一
	162	*
	163	* @param role 角色信息
	164	* @return 结果
	165	*/
	166	@Override
	167	public boolean checkRoleKeyUnique(SysRole role)
	168	{
	169	Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
	170	SysRole info = roleMapper.checkRoleKeyUnique(role.getRoleKey());
	171	if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue())
	172	{
	173	return UserConstants.NOT_UNIQUE;
	174	}
	175	return UserConstants.UNIQUE;
	176	}
	177
	178	/**
	179	* 校验角色是否允许操作
	180	*
	181	* @param role 角色信息
	182	*/
	183	@Override
	184	public void checkRoleAllowed(SysRole role)
	185	{
	186	if (StringUtils.isNotNull(role.getRoleId()) && role.isAdmin())
	187	{
	188	throw new ServiceException("不允许操作超级管理员角色");
	189	}
	190	}
	191
	192	/**
	193	* 校验角色是否有数据权限
	194	*
	195	* @param roleIds 角色id
	196	*/
	197	@Override
	198	public void checkRoleDataScope(Long... roleIds)
	199	{
	200	if (!SysUser.isAdmin(SecurityUtils.getUserId()))
	201	{
	202	for (Long roleId : roleIds)
	203	{
	204	SysRole role = new SysRole();
	205	role.setRoleId(roleId);
	206	List<SysRole> roles = SpringUtils.getAopProxy(this).selectRoleList(role);
	207	if (StringUtils.isEmpty(roles))
	208	{
	209	throw new ServiceException("没有权限访问角色数据！");
	210	}
	211	}
	212	}
	213	}
	214
	215	/**
	216	* 通过角色ID查询角色使用数量
	217	*
	218	* @param roleId 角色ID
	219	* @return 结果
	220	*/
	221	@Override
	222	public int countUserRoleByRoleId(Long roleId)
	223	{
	224	return userRoleMapper.countUserRoleByRoleId(roleId);
	225	}
	226
	227	/**
	228	* 新增保存角色信息
	229	*
	230	* @param role 角色信息
	231	* @return 结果
	232	*/
	233	@Override
	234	@Transactional
	235	public int insertRole(SysRole role)
	236	{
	237	// 新增角色信息
	238	roleMapper.insertRole(role);
	239	return insertRoleMenu(role);
	240	}
	241
	242	/**
	243	* 修改保存角色信息
	244	*
	245	* @param role 角色信息
	246	* @return 结果
	247	*/
	248	@Override
	249	@Transactional
	250	public int updateRole(SysRole role)
	251	{
	252	// 修改角色信息
	253	roleMapper.updateRole(role);
	254	// 删除角色与菜单关联
	255	roleMenuMapper.deleteRoleMenuByRoleId(role.getRoleId());
	256	return insertRoleMenu(role);
	257	}
	258
	259	/**
	260	* 修改角色状态
	261	*
	262	* @param role 角色信息
	263	* @return 结果
	264	*/
	265	@Override
	266	public int updateRoleStatus(SysRole role)
	267	{
	268	return roleMapper.updateRole(role);
	269	}
	270
	271	/**
	272	* 修改数据权限信息
	273	*
	274	* @param role 角色信息
	275	* @return 结果
	276	*/
	277	@Override
	278	@Transactional
	279	public int authDataScope(SysRole role)
	280	{
	281	// 修改角色信息
	282	roleMapper.updateRole(role);
	283	// 删除角色与部门关联
	284	roleDeptMapper.deleteRoleDeptByRoleId(role.getRoleId());
	285	// 新增角色和部门信息（数据权限）
	286	return insertRoleDept(role);
	287	}
	288
	289	/**
	290	* 新增角色菜单信息
	291	*
	292	* @param role 角色对象
	293	*/
	294	public int insertRoleMenu(SysRole role)
	295	{
	296	int rows = 1;
	297	// 新增用户与角色管理
	298	List<SysRoleMenu> list = new ArrayList<SysRoleMenu>();
	299	for (Long menuId : role.getMenuIds())
	300	{
	301	SysRoleMenu rm = new SysRoleMenu();
	302	rm.setRoleId(role.getRoleId());
	303	rm.setMenuId(menuId);
	304	list.add(rm);
	305	}
	306	if (list.size() > 0)
	307	{
	308	rows = roleMenuMapper.batchRoleMenu(list);
	309	}
	310	return rows;
	311	}
	312
	313	/**
	314	* 新增角色部门信息(数据权限)
	315	*
	316	* @param role 角色对象
	317	*/
	318	public int insertRoleDept(SysRole role)
	319	{
	320	int rows = 1;
	321	// 新增角色与部门（数据权限）管理
	322	List<SysRoleDept> list = new ArrayList<SysRoleDept>();
	323	for (Long deptId : role.getDeptIds())
	324	{
	325	SysRoleDept rd = new SysRoleDept();
	326	rd.setRoleId(role.getRoleId());
	327	rd.setDeptId(deptId);
	328	list.add(rd);
	329	}
	330	if (list.size() > 0)
	331	{
	332	rows = roleDeptMapper.batchRoleDept(list);
	333	}
	334	return rows;
	335	}
	336
	337	/**
	338	* 通过角色ID删除角色
	339	*
	340	* @param roleId 角色ID
	341	* @return 结果
	342	*/
	343	@Override
	344	@Transactional
	345	public int deleteRoleById(Long roleId)
	346	{
	347	// 删除角色与菜单关联
	348	roleMenuMapper.deleteRoleMenuByRoleId(roleId);
	349	// 删除角色与部门关联
	350	roleDeptMapper.deleteRoleDeptByRoleId(roleId);
	351	return roleMapper.deleteRoleById(roleId);
	352	}
	353
	354	/**
	355	* 批量删除角色信息
	356	*
	357	* @param roleIds 需要删除的角色ID
	358	* @return 结果
	359	*/
	360	@Override
	361	@Transactional
	362	public int deleteRoleByIds(Long[] roleIds)
	363	{
	364	for (Long roleId : roleIds)
	365	{
	366	checkRoleAllowed(new SysRole(roleId));
	367	checkRoleDataScope(roleId);
	368	SysRole role = selectRoleById(roleId);
	369	if (countUserRoleByRoleId(roleId) > 0)
	370	{
	371	throw new ServiceException(String.format("%1$s已分配,不能删除", role.getRoleName()));
	372	}
	373	}
	374	// 删除角色与菜单关联
	375	roleMenuMapper.deleteRoleMenu(roleIds);
	376	// 删除角色与部门关联
	377	roleDeptMapper.deleteRoleDept(roleIds);
	378	return roleMapper.deleteRoleByIds(roleIds);
	379	}
	380
	381	/**
	382	* 取消授权用户角色
	383	*
	384	* @param userRole 用户和角色关联信息
	385	* @return 结果
	386	*/
	387	@Override
	388	public int deleteAuthUser(SysUserRole userRole)
	389	{
	390	return userRoleMapper.deleteUserRoleInfo(userRole);
	391	}
	392
	393	/**
	394	* 批量取消授权用户角色
	395	*
	396	* @param roleId 角色ID
	397	* @param userIds 需要取消授权的用户数据ID
	398	* @return 结果
	399	*/
	400	@Override
	401	public int deleteAuthUsers(Long roleId, Long[] userIds)
	402	{
	403	return userRoleMapper.deleteUserRoleInfos(roleId, userIds);
	404	}
	405
	406	/**
	407	* 批量选择授权用户角色
	408	*
	409	* @param roleId 角色ID
	410	* @param userIds 需要授权的用户数据ID
	411	* @return 结果
	412	*/
	413	@Override
	414	public int insertAuthUsers(Long roleId, Long[] userIds)
	415	{
	416	// 新增用户与角色管理
	417	List<SysUserRole> list = new ArrayList<SysUserRole>();
	418	for (Long userId : userIds)
	419	{
	420	SysUserRole ur = new SysUserRole();
	421	ur.setUserId(userId);
	422	ur.setRoleId(roleId);
	423	list.add(ur);
	424	}
	425	return userRoleMapper.batchUserRole(list);
	426	}
	427	}