Jcdm041-Mes.git

懒羊羊

2024-01-08 fd220719968cd03cf50bb43dfca021ad0d256b4e

提交 \| 用户 \| 时间
fd2207	1	package com.jcdm.system.service.impl;
懒	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.jcdm.common.annotation.DataScope;
	12	import com.jcdm.common.constant.UserConstants;
	13	import com.jcdm.common.core.domain.entity.SysRole;
	14	import com.jcdm.common.core.domain.entity.SysUser;
	15	import com.jcdm.common.exception.ServiceException;
	16	import com.jcdm.common.utils.SecurityUtils;
	17	import com.jcdm.common.utils.StringUtils;
	18	import com.jcdm.common.utils.spring.SpringUtils;
	19	import com.jcdm.system.domain.SysRoleDept;
	20	import com.jcdm.system.domain.SysRoleMenu;
	21	import com.jcdm.system.domain.SysUserRole;
	22	import com.jcdm.system.mapper.SysRoleDeptMapper;
	23	import com.jcdm.system.mapper.SysRoleMapper;
	24	import com.jcdm.system.mapper.SysRoleMenuMapper;
	25	import com.jcdm.system.mapper.SysUserRoleMapper;
	26	import com.jcdm.system.service.ISysRoleService;
	27
	28	/**
	29	* 角色业务层处理
	30	*
	31	* @author jc
	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 roleId 角色id
	196	*/
	197	@Override
	198	public void checkRoleDataScope(Long roleId)
	199	{
	200	if (!SysUser.isAdmin(SecurityUtils.getUserId()))
	201	{
	202	SysRole role = new SysRole();
	203	role.setRoleId(roleId);
	204	List<SysRole> roles = SpringUtils.getAopProxy(this).selectRoleList(role);
	205	if (StringUtils.isEmpty(roles))
	206	{
	207	throw new ServiceException("没有权限访问角色数据！");
	208	}
	209	}
	210	}
	211
	212	/**
	213	* 通过角色ID查询角色使用数量
	214	*
	215	* @param roleId 角色ID
	216	* @return 结果
	217	*/
	218	@Override
	219	public int countUserRoleByRoleId(Long roleId)
	220	{
	221	return userRoleMapper.countUserRoleByRoleId(roleId);
	222	}
	223
	224	/**
	225	* 新增保存角色信息
	226	*
	227	* @param role 角色信息
	228	* @return 结果
	229	*/
	230	@Override
	231	@Transactional
	232	public int insertRole(SysRole role)
	233	{
	234	// 新增角色信息
	235	roleMapper.insertRole(role);
	236	return insertRoleMenu(role);
	237	}
	238
	239	/**
	240	* 修改保存角色信息
	241	*
	242	* @param role 角色信息
	243	* @return 结果
	244	*/
	245	@Override
	246	@Transactional
	247	public int updateRole(SysRole role)
	248	{
	249	// 修改角色信息
	250	roleMapper.updateRole(role);
	251	// 删除角色与菜单关联
	252	roleMenuMapper.deleteRoleMenuByRoleId(role.getRoleId());
	253	return insertRoleMenu(role);
	254	}
	255
	256	/**
	257	* 修改角色状态
	258	*
	259	* @param role 角色信息
	260	* @return 结果
	261	*/
	262	@Override
	263	public int updateRoleStatus(SysRole role)
	264	{
	265	return roleMapper.updateRole(role);
	266	}
	267
	268	/**
	269	* 修改数据权限信息
	270	*
	271	* @param role 角色信息
	272	* @return 结果
	273	*/
	274	@Override
	275	@Transactional
	276	public int authDataScope(SysRole role)
	277	{
	278	// 修改角色信息
	279	roleMapper.updateRole(role);
	280	// 删除角色与部门关联
	281	roleDeptMapper.deleteRoleDeptByRoleId(role.getRoleId());
	282	// 新增角色和部门信息（数据权限）
	283	return insertRoleDept(role);
	284	}
	285
	286	/**
	287	* 新增角色菜单信息
	288	*
	289	* @param role 角色对象
	290	*/
	291	public int insertRoleMenu(SysRole role)
	292	{
	293	int rows = 1;
	294	// 新增用户与角色管理
	295	List<SysRoleMenu> list = new ArrayList<SysRoleMenu>();
	296	for (Long menuId : role.getMenuIds())
	297	{
	298	SysRoleMenu rm = new SysRoleMenu();
	299	rm.setRoleId(role.getRoleId());
	300	rm.setMenuId(menuId);
	301	list.add(rm);
	302	}
	303	if (list.size() > 0)
	304	{
	305	rows = roleMenuMapper.batchRoleMenu(list);
	306	}
	307	return rows;
	308	}
	309
	310	/**
	311	* 新增角色部门信息(数据权限)
	312	*
	313	* @param role 角色对象
	314	*/
	315	public int insertRoleDept(SysRole role)
	316	{
	317	int rows = 1;
	318	// 新增角色与部门（数据权限）管理
	319	List<SysRoleDept> list = new ArrayList<SysRoleDept>();
	320	for (Long deptId : role.getDeptIds())
	321	{
	322	SysRoleDept rd = new SysRoleDept();
	323	rd.setRoleId(role.getRoleId());
	324	rd.setDeptId(deptId);
	325	list.add(rd);
	326	}
	327	if (list.size() > 0)
	328	{
	329	rows = roleDeptMapper.batchRoleDept(list);
	330	}
	331	return rows;
	332	}
	333
	334	/**
	335	* 通过角色ID删除角色
	336	*
	337	* @param roleId 角色ID
	338	* @return 结果
	339	*/
	340	@Override
	341	@Transactional
	342	public int deleteRoleById(Long roleId)
	343	{
	344	// 删除角色与菜单关联
	345	roleMenuMapper.deleteRoleMenuByRoleId(roleId);
	346	// 删除角色与部门关联
	347	roleDeptMapper.deleteRoleDeptByRoleId(roleId);
	348	return roleMapper.deleteRoleById(roleId);
	349	}
	350
	351	/**
	352	* 批量删除角色信息
	353	*
	354	* @param roleIds 需要删除的角色ID
	355	* @return 结果
	356	*/
	357	@Override
	358	@Transactional
	359	public int deleteRoleByIds(Long[] roleIds)
	360	{
	361	for (Long roleId : roleIds)
	362	{
	363	checkRoleAllowed(new SysRole(roleId));
	364	checkRoleDataScope(roleId);
	365	SysRole role = selectRoleById(roleId);
	366	if (countUserRoleByRoleId(roleId) > 0)
	367	{
	368	throw new ServiceException(String.format("%1$s已分配,不能删除", role.getRoleName()));
	369	}
	370	}
	371	// 删除角色与菜单关联
	372	roleMenuMapper.deleteRoleMenu(roleIds);
	373	// 删除角色与部门关联
	374	roleDeptMapper.deleteRoleDept(roleIds);
	375	return roleMapper.deleteRoleByIds(roleIds);
	376	}
	377
	378	/**
	379	* 取消授权用户角色
	380	*
	381	* @param userRole 用户和角色关联信息
	382	* @return 结果
	383	*/
	384	@Override
	385	public int deleteAuthUser(SysUserRole userRole)
	386	{
	387	return userRoleMapper.deleteUserRoleInfo(userRole);
	388	}
	389
	390	/**
	391	* 批量取消授权用户角色
	392	*
	393	* @param roleId 角色ID
	394	* @param userIds 需要取消授权的用户数据ID
	395	* @return 结果
	396	*/
	397	@Override
	398	public int deleteAuthUsers(Long roleId, Long[] userIds)
	399	{
	400	return userRoleMapper.deleteUserRoleInfos(roleId, userIds);
	401	}
	402
	403	/**
	404	* 批量选择授权用户角色
	405	*
	406	* @param roleId 角色ID
	407	* @param userIds 需要授权的用户数据ID
	408	* @return 结果
	409	*/
	410	@Override
	411	public int insertAuthUsers(Long roleId, Long[] userIds)
	412	{
	413	// 新增用户与角色管理
	414	List<SysUserRole> list = new ArrayList<SysUserRole>();
	415	for (Long userId : userIds)
	416	{
	417	SysUserRole ur = new SysUserRole();
	418	ur.setUserId(userId);
	419	ur.setRoleId(roleId);
	420	list.add(ur);
	421	}
	422	return userRoleMapper.batchUserRole(list);
	423	}
	424	}