Billion-Mes.git

admin

2024-11-12 a6316ee0ab82a0f3fc2691f8b5ddbd79e1567086

提交 \| 用户 \| 时间
a6316e	1	package com.billion.system.service.impl;
A	2
	3	import java.util.ArrayList;
	4	import java.util.List;
	5	import java.util.stream.Collectors;
	6	import javax.validation.Validator;
	7	import org.slf4j.Logger;
	8	import org.slf4j.LoggerFactory;
	9	import org.springframework.beans.factory.annotation.Autowired;
	10	import org.springframework.stereotype.Service;
	11	import org.springframework.transaction.annotation.Transactional;
	12	import org.springframework.util.CollectionUtils;
	13	import com.billion.common.annotation.DataScope;
	14	import com.billion.common.constant.UserConstants;
	15	import com.billion.common.core.domain.entity.SysRole;
	16	import com.billion.common.core.domain.entity.SysUser;
	17	import com.billion.common.exception.ServiceException;
	18	import com.billion.common.utils.SecurityUtils;
	19	import com.billion.common.utils.StringUtils;
	20	import com.billion.common.utils.bean.BeanValidators;
	21	import com.billion.common.utils.spring.SpringUtils;
	22	import com.billion.system.domain.SysPost;
	23	import com.billion.system.domain.SysUserPost;
	24	import com.billion.system.domain.SysUserRole;
	25	import com.billion.system.mapper.SysPostMapper;
	26	import com.billion.system.mapper.SysRoleMapper;
	27	import com.billion.system.mapper.SysUserMapper;
	28	import com.billion.system.mapper.SysUserPostMapper;
	29	import com.billion.system.mapper.SysUserRoleMapper;
	30	import com.billion.system.service.ISysConfigService;
	31	import com.billion.system.service.ISysDeptService;
	32	import com.billion.system.service.ISysUserService;
	33
	34	/**
	35	* 用户业务层处理
	36	*
	37	* @author ruoyi
	38	*/
	39	@Service
	40	public class SysUserServiceImpl implements ISysUserService
	41	{
	42	private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);
	43
	44	@Autowired
	45	private SysUserMapper userMapper;
	46
	47	@Autowired
	48	private SysRoleMapper roleMapper;
	49
	50	@Autowired
	51	private SysPostMapper postMapper;
	52
	53	@Autowired
	54	private SysUserRoleMapper userRoleMapper;
	55
	56	@Autowired
	57	private SysUserPostMapper userPostMapper;
	58
	59	@Autowired
	60	private ISysConfigService configService;
	61
	62	@Autowired
	63	private ISysDeptService deptService;
	64
	65	@Autowired
	66	protected Validator validator;
	67
	68	/**
	69	* 根据条件分页查询用户列表
	70	*
	71	* @param user 用户信息
	72	* @return 用户信息集合信息
	73	*/
	74	@Override
	75	@DataScope(deptAlias = "d", userAlias = "u")
	76	public List<SysUser> selectUserList(SysUser user)
	77	{
	78	return userMapper.selectUserList(user);
	79	}
	80
	81	/**
	82	* 根据条件分页查询已分配用户角色列表
	83	*
	84	* @param user 用户信息
	85	* @return 用户信息集合信息
	86	*/
	87	@Override
	88	@DataScope(deptAlias = "d", userAlias = "u")
	89	public List<SysUser> selectAllocatedList(SysUser user)
	90	{
	91	return userMapper.selectAllocatedList(user);
	92	}
	93
	94	/**
	95	* 根据条件分页查询未分配用户角色列表
	96	*
	97	* @param user 用户信息
	98	* @return 用户信息集合信息
	99	*/
	100	@Override
	101	@DataScope(deptAlias = "d", userAlias = "u")
	102	public List<SysUser> selectUnallocatedList(SysUser user)
	103	{
	104	return userMapper.selectUnallocatedList(user);
	105	}
	106
	107	/**
	108	* 通过用户名查询用户
	109	*
	110	* @param userName 用户名
	111	* @return 用户对象信息
	112	*/
	113	@Override
	114	public SysUser selectUserByUserName(String userName)
	115	{
	116	return userMapper.selectUserByUserName(userName);
	117	}
	118
	119	/**
	120	* 通过用户ID查询用户
	121	*
	122	* @param userId 用户ID
	123	* @return 用户对象信息
	124	*/
	125	@Override
	126	public SysUser selectUserById(Long userId)
	127	{
	128	return userMapper.selectUserById(userId);
	129	}
	130
	131	/**
	132	* 查询用户所属角色组
	133	*
	134	* @param userName 用户名
	135	* @return 结果
	136	*/
	137	@Override
	138	public String selectUserRoleGroup(String userName)
	139	{
	140	List<SysRole> list = roleMapper.selectRolesByUserName(userName);
	141	if (CollectionUtils.isEmpty(list))
	142	{
	143	return StringUtils.EMPTY;
	144	}
	145	return list.stream().map(SysRole::getRoleName).collect(Collectors.joining(","));
	146	}
	147
	148	/**
	149	* 查询用户所属岗位组
	150	*
	151	* @param userName 用户名
	152	* @return 结果
	153	*/
	154	@Override
	155	public String selectUserPostGroup(String userName)
	156	{
	157	List<SysPost> list = postMapper.selectPostsByUserName(userName);
	158	if (CollectionUtils.isEmpty(list))
	159	{
	160	return StringUtils.EMPTY;
	161	}
	162	return list.stream().map(SysPost::getPostName).collect(Collectors.joining(","));
	163	}
	164
	165	/**
	166	* 校验用户名称是否唯一
	167	*
	168	* @param user 用户信息
	169	* @return 结果
	170	*/
	171	@Override
	172	public boolean checkUserNameUnique(SysUser user)
	173	{
	174	Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
	175	SysUser info = userMapper.checkUserNameUnique(user.getUserName());
	176	if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
	177	{
	178	return UserConstants.NOT_UNIQUE;
	179	}
	180	return UserConstants.UNIQUE;
	181	}
	182
	183	/**
	184	* 校验手机号码是否唯一
	185	*
	186	* @param user 用户信息
	187	* @return
	188	*/
	189	@Override
	190	public boolean checkPhoneUnique(SysUser user)
	191	{
	192	Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
	193	SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber());
	194	if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
	195	{
	196	return UserConstants.NOT_UNIQUE;
	197	}
	198	return UserConstants.UNIQUE;
	199	}
	200
	201	/**
	202	* 校验email是否唯一
	203	*
	204	* @param user 用户信息
	205	* @return
	206	*/
	207	@Override
	208	public boolean checkEmailUnique(SysUser user)
	209	{
	210	Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
	211	SysUser info = userMapper.checkEmailUnique(user.getEmail());
	212	if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
	213	{
	214	return UserConstants.NOT_UNIQUE;
	215	}
	216	return UserConstants.UNIQUE;
	217	}
	218
	219	/**
	220	* 校验用户是否允许操作
	221	*
	222	* @param user 用户信息
	223	*/
	224	@Override
	225	public void checkUserAllowed(SysUser user)
	226	{
	227	if (StringUtils.isNotNull(user.getUserId()) && user.isAdmin())
	228	{
	229	throw new ServiceException("不允许操作超级管理员用户");
	230	}
	231	}
	232
	233	/**
	234	* 校验用户是否有数据权限
	235	*
	236	* @param userId 用户id
	237	*/
	238	@Override
	239	public void checkUserDataScope(Long userId)
	240	{
	241	if (!SysUser.isAdmin(SecurityUtils.getUserId()))
	242	{
	243	SysUser user = new SysUser();
	244	user.setUserId(userId);
	245	List<SysUser> users = SpringUtils.getAopProxy(this).selectUserList(user);
	246	if (StringUtils.isEmpty(users))
	247	{
	248	throw new ServiceException("没有权限访问用户数据！");
	249	}
	250	}
	251	}
	252
	253	/**
	254	* 新增保存用户信息
	255	*
	256	* @param user 用户信息
	257	* @return 结果
	258	*/
	259	@Override
	260	@Transactional
	261	public int insertUser(SysUser user)
	262	{
	263	// 新增用户信息
	264	int rows = userMapper.insertUser(user);
	265	// 新增用户岗位关联
	266	insertUserPost(user);
	267	// 新增用户与角色管理
	268	insertUserRole(user);
	269	return rows;
	270	}
	271
	272	/**
	273	* 注册用户信息
	274	*
	275	* @param user 用户信息
	276	* @return 结果
	277	*/
	278	@Override
	279	public boolean registerUser(SysUser user)
	280	{
	281	return userMapper.insertUser(user) > 0;
	282	}
	283
	284	/**
	285	* 修改保存用户信息
	286	*
	287	* @param user 用户信息
	288	* @return 结果
	289	*/
	290	@Override
	291	@Transactional
	292	public int updateUser(SysUser user)
	293	{
	294	Long userId = user.getUserId();
	295	// 删除用户与角色关联
	296	userRoleMapper.deleteUserRoleByUserId(userId);
	297	// 新增用户与角色管理
	298	insertUserRole(user);
	299	// 删除用户与岗位关联
	300	userPostMapper.deleteUserPostByUserId(userId);
	301	// 新增用户与岗位管理
	302	insertUserPost(user);
	303	return userMapper.updateUser(user);
	304	}
	305
	306	/**
	307	* 用户授权角色
	308	*
	309	* @param userId 用户ID
	310	* @param roleIds 角色组
	311	*/
	312	@Override
	313	@Transactional
	314	public void insertUserAuth(Long userId, Long[] roleIds)
	315	{
	316	userRoleMapper.deleteUserRoleByUserId(userId);
	317	insertUserRole(userId, roleIds);
	318	}
	319
	320	/**
	321	* 修改用户状态
	322	*
	323	* @param user 用户信息
	324	* @return 结果
	325	*/
	326	@Override
	327	public int updateUserStatus(SysUser user)
	328	{
	329	return userMapper.updateUser(user);
	330	}
	331
	332	/**
	333	* 修改用户基本信息
	334	*
	335	* @param user 用户信息
	336	* @return 结果
	337	*/
	338	@Override
	339	public int updateUserProfile(SysUser user)
	340	{
	341	return userMapper.updateUser(user);
	342	}
	343
	344	/**
	345	* 修改用户头像
	346	*
	347	* @param userName 用户名
	348	* @param avatar 头像地址
	349	* @return 结果
	350	*/
	351	@Override
	352	public boolean updateUserAvatar(String userName, String avatar)
	353	{
	354	return userMapper.updateUserAvatar(userName, avatar) > 0;
	355	}
	356
	357	/**
	358	* 重置用户密码
	359	*
	360	* @param user 用户信息
	361	* @return 结果
	362	*/
	363	@Override
	364	public int resetPwd(SysUser user)
	365	{
	366	return userMapper.updateUser(user);
	367	}
	368
	369	/**
	370	* 重置用户密码
	371	*
	372	* @param userName 用户名
	373	* @param password 密码
	374	* @return 结果
	375	*/
	376	@Override
	377	public int resetUserPwd(String userName, String password)
	378	{
	379	return userMapper.resetUserPwd(userName, password);
	380	}
	381
	382	/**
	383	* 新增用户角色信息
	384	*
	385	* @param user 用户对象
	386	*/
	387	public void insertUserRole(SysUser user)
	388	{
	389	this.insertUserRole(user.getUserId(), user.getRoleIds());
	390	}
	391
	392	/**
	393	* 新增用户岗位信息
	394	*
	395	* @param user 用户对象
	396	*/
	397	public void insertUserPost(SysUser user)
	398	{
	399	Long[] posts = user.getPostIds();
	400	if (StringUtils.isNotEmpty(posts))
	401	{
	402	// 新增用户与岗位管理
	403	List<SysUserPost> list = new ArrayList<SysUserPost>(posts.length);
	404	for (Long postId : posts)
	405	{
	406	SysUserPost up = new SysUserPost();
	407	up.setUserId(user.getUserId());
	408	up.setPostId(postId);
	409	list.add(up);
	410	}
	411	userPostMapper.batchUserPost(list);
	412	}
	413	}
	414
	415	/**
	416	* 新增用户角色信息
	417	*
	418	* @param userId 用户ID
	419	* @param roleIds 角色组
	420	*/
	421	public void insertUserRole(Long userId, Long[] roleIds)
	422	{
	423	if (StringUtils.isNotEmpty(roleIds))
	424	{
	425	// 新增用户与角色管理
	426	List<SysUserRole> list = new ArrayList<SysUserRole>(roleIds.length);
	427	for (Long roleId : roleIds)
	428	{
	429	SysUserRole ur = new SysUserRole();
	430	ur.setUserId(userId);
	431	ur.setRoleId(roleId);
	432	list.add(ur);
	433	}
	434	userRoleMapper.batchUserRole(list);
	435	}
	436	}
	437
	438	/**
	439	* 通过用户ID删除用户
	440	*
	441	* @param userId 用户ID
	442	* @return 结果
	443	*/
	444	@Override
	445	@Transactional
	446	public int deleteUserById(Long userId)
	447	{
	448	// 删除用户与角色关联
	449	userRoleMapper.deleteUserRoleByUserId(userId);
	450	// 删除用户与岗位表
	451	userPostMapper.deleteUserPostByUserId(userId);
	452	return userMapper.deleteUserById(userId);
	453	}
	454
	455	/**
	456	* 批量删除用户信息
	457	*
	458	* @param userIds 需要删除的用户ID
	459	* @return 结果
	460	*/
	461	@Override
	462	@Transactional
	463	public int deleteUserByIds(Long[] userIds)
	464	{
	465	for (Long userId : userIds)
	466	{
	467	checkUserAllowed(new SysUser(userId));
	468	checkUserDataScope(userId);
	469	}
	470	// 删除用户与角色关联
	471	userRoleMapper.deleteUserRole(userIds);
	472	// 删除用户与岗位关联
	473	userPostMapper.deleteUserPost(userIds);
	474	return userMapper.deleteUserByIds(userIds);
	475	}
	476
	477	/**
	478	* 导入用户数据
	479	*
	480	* @param userList 用户数据列表
	481	* @param isUpdateSupport 是否更新支持，如果已存在，则进行更新数据
	482	* @param operName 操作用户
	483	* @return 结果
	484	*/
	485	@Override
	486	public String importUser(List<SysUser> userList, Boolean isUpdateSupport, String operName)
	487	{
	488	if (StringUtils.isNull(userList) \|\| userList.size() == 0)
	489	{
	490	throw new ServiceException("导入用户数据不能为空！");
	491	}
	492	int successNum = 0;
	493	int failureNum = 0;
	494	StringBuilder successMsg = new StringBuilder();
	495	StringBuilder failureMsg = new StringBuilder();
	496	for (SysUser user : userList)
	497	{
	498	try
	499	{
	500	// 验证是否存在这个用户
	501	SysUser u = userMapper.selectUserByUserName(user.getUserName());
	502	if (StringUtils.isNull(u))
	503	{
	504	BeanValidators.validateWithException(validator, user);
	505	deptService.checkDeptDataScope(user.getDeptId());
	506	String password = configService.selectConfigByKey("sys.user.initPassword");
	507	user.setPassword(SecurityUtils.encryptPassword(password));
	508	user.setCreateBy(operName);
	509	userMapper.insertUser(user);
	510	successNum++;
	511	successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 导入成功");
	512	}
	513	else if (isUpdateSupport)
	514	{
	515	BeanValidators.validateWithException(validator, user);
	516	checkUserAllowed(u);
	517	checkUserDataScope(u.getUserId());
	518	deptService.checkDeptDataScope(user.getDeptId());
	519	user.setUserId(u.getUserId());
	520	user.setUpdateBy(operName);
	521	userMapper.updateUser(user);
	522	successNum++;
	523	successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 更新成功");
	524	}
	525	else
	526	{
	527	failureNum++;
	528	failureMsg.append("<br/>" + failureNum + "、账号 " + user.getUserName() + " 已存在");
	529	}
	530	}
	531	catch (Exception e)
	532	{
	533	failureNum++;
	534	String msg = "<br/>" + failureNum + "、账号 " + user.getUserName() + " 导入失败：";
	535	failureMsg.append(msg + e.getMessage());
	536	log.error(msg, e);
	537	}
	538	}
	539	if (failureNum > 0)
	540	{
	541	failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
	542	throw new ServiceException(failureMsg.toString());
	543	}
	544	else
	545	{
	546	successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
	547	}
	548	return successMsg.toString();
	549	}
	550	}