Jcdm041-MesCVT.git

yyt

2024-06-26 0cceb649e1dc443c2a91d26d81eacb0867c96db3

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