lbqms.git - Gitblit

			@@ -1,562 +1,488 @@
			package com.ruoyi.system.service.impl;

			import java.util.ArrayList;
			import java.util.List;
			import org.slf4j.Logger;
			import org.slf4j.LoggerFactory;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;
			import com.ruoyi.common.annotation.DataScope;
			import com.ruoyi.common.constant.UserConstants;
			import com.ruoyi.common.core.domain.entity.SysRole;
			import com.ruoyi.common.core.domain.entity.SysUser;
			import com.ruoyi.common.exception.ServiceException;
			import com.ruoyi.common.utils.SecurityUtils;
			import com.ruoyi.common.utils.StringUtils;
			import com.ruoyi.common.utils.spring.SpringUtils;
			import com.ruoyi.system.domain.SysPost;
			import com.ruoyi.system.domain.SysUserPost;
			import com.ruoyi.system.domain.SysUserRole;
			import com.ruoyi.system.mapper.SysPostMapper;
			import com.ruoyi.system.mapper.SysRoleMapper;
			import com.ruoyi.system.mapper.SysUserMapper;
			import com.ruoyi.system.mapper.SysUserPostMapper;
			import com.ruoyi.system.mapper.SysUserRoleMapper;
			import com.ruoyi.system.service.ISysConfigService;
			import com.ruoyi.system.service.ISysUserService;

			/**
			* 用户业务层处理
			*
			* @author ruoyi
			*/
			@Service
			public class SysUserServiceImpl implements ISysUserService
			{
			private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);

			@Autowired
			private SysUserMapper userMapper;

			@Autowired
			private SysRoleMapper roleMapper;

			@Autowired
			private SysPostMapper postMapper;

			@Autowired
			private SysUserRoleMapper userRoleMapper;

			@Autowired
			private SysUserPostMapper userPostMapper;

			@Autowired
			private ISysConfigService configService;

			/**
			* 根据条件分页查询用户列表
			*
			* @param user 用户信息
			* @return 用户信息集合信息
			*/
			@Override
			@DataScope(deptAlias = "d", userAlias = "u")
			public List<SysUser> selectUserList(SysUser user)
			{
			return userMapper.selectUserList(user);
			}

			/**
			* 根据条件分页查询已分配用户角色列表
			*
			* @param user 用户信息
			* @return 用户信息集合信息
			*/
			@Override
			@DataScope(deptAlias = "d", userAlias = "u")
			public List<SysUser> selectAllocatedList(SysUser user)
			{
			return userMapper.selectAllocatedList(user);
			}

			/**
			* 根据条件分页查询未分配用户角色列表
			*
			* @param user 用户信息
			* @return 用户信息集合信息
			*/
			@Override
			@DataScope(deptAlias = "d", userAlias = "u")
			public List<SysUser> selectUnallocatedList(SysUser user)
			{
			return userMapper.selectUnallocatedList(user);
			}

			/**
			* 通过用户名查询用户
			*
			* @param userName 用户名
			* @return 用户对象信息
			*/
			@Override
			public SysUser selectUserByUserName(String userName)
			{
			return userMapper.selectUserByUserName(userName);
			}

			/**
			* 通过用户ID查询用户
			*
			* @param userId 用户ID
			* @return 用户对象信息
			*/
			@Override
			public SysUser selectUserById(Long userId)
			{
			return userMapper.selectUserById(userId);
			}

			/**
			* 查询用户所属角色组
			*
			* @param userName 用户名
			* @return 结果
			*/
			@Override
			public String selectUserRoleGroup(String userName)
			{
			List<SysRole> list = roleMapper.selectRolesByUserName(userName);
			StringBuffer idsStr = new StringBuffer();
			for (SysRole role : list)
			{
			idsStr.append(role.getRoleName()).append(",");
			}
			if (StringUtils.isNotEmpty(idsStr.toString()))
			{
			return idsStr.substring(0, idsStr.length() - 1);
			}
			return idsStr.toString();
			}

			/**
			* 查询用户所属岗位组
			*
			* @param userName 用户名
			* @return 结果
			*/
			@Override
			public String selectUserPostGroup(String userName)
			{
			List<SysPost> list = postMapper.selectPostsByUserName(userName);
			StringBuffer idsStr = new StringBuffer();
			for (SysPost post : list)
			{
			idsStr.append(post.getPostName()).append(",");
			}
			if (StringUtils.isNotEmpty(idsStr.toString()))
			{
			return idsStr.substring(0, idsStr.length() - 1);
			}
			return idsStr.toString();
			}

			/**
			* 校验用户名称是否唯一
			*
			* @param userName 用户名称
			* @return 结果
			*/
			@Override
			public String checkUserNameUnique(String userName)
			{
			int count = userMapper.checkUserNameUnique(userName);
			if (count > 0)
			{
			return UserConstants.NOT_UNIQUE;
			}
			return UserConstants.UNIQUE;
			}

			/**
			* 校验手机号码是否唯一
			*
			* @param user 用户信息
			* @return
			*/
			@Override
			public String checkPhoneUnique(SysUser user)
			{
			Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
			SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber());
			if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
			{
			return UserConstants.NOT_UNIQUE;
			}
			return UserConstants.UNIQUE;
			}

			/**
			* 校验email是否唯一
			*
			* @param user 用户信息
			* @return
			*/
			@Override
			public String checkEmailUnique(SysUser user)
			{
			Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
			SysUser info = userMapper.checkEmailUnique(user.getEmail());
			if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
			{
			return UserConstants.NOT_UNIQUE;
			}
			return UserConstants.UNIQUE;
			}

			/**
			* 校验用户是否允许操作
			*
			* @param user 用户信息
			*/
			@Override
			public void checkUserAllowed(SysUser user)
			{
			if (StringUtils.isNotNull(user.getUserId()) && user.isAdmin())
			{
			throw new ServiceException("不允许操作超级管理员用户");
			}
			}

			/**
			* 校验用户是否有数据权限
			*
			* @param userId 用户id
			*/
			@Override
			public void checkUserDataScope(Long userId)
			{
			if (!SysUser.isAdmin(SecurityUtils.getUserId()))
			{
			SysUser user = new SysUser();
			user.setUserId(userId);
			List<SysUser> users = SpringUtils.getAopProxy(this).selectUserList(user);
			if (StringUtils.isEmpty(users))
			{
			throw new ServiceException("没有权限访问用户数据！");
			}
			}
			}

			/**
			* 新增保存用户信息
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			@Transactional
			public int insertUser(SysUser user)
			{
			// 新增用户信息
			int rows = userMapper.insertUser(user);
			// 新增用户岗位关联
			insertUserPost(user);
			// 新增用户与角色管理
			insertUserRole(user);
			return rows;
			}

			/**
			* 注册用户信息
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			public boolean registerUser(SysUser user)
			{
			return userMapper.insertUser(user) > 0;
			}

			/**
			* 修改保存用户信息
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			@Transactional
			public int updateUser(SysUser user)
			{
			Long userId = user.getUserId();
			// 删除用户与角色关联
			userRoleMapper.deleteUserRoleByUserId(userId);
			// 新增用户与角色管理
			insertUserRole(user);
			// 删除用户与岗位关联
			userPostMapper.deleteUserPostByUserId(userId);
			// 新增用户与岗位管理
			insertUserPost(user);
			return userMapper.updateUser(user);
			}

			/**
			* 用户授权角色
			*
			* @param userId 用户ID
			* @param roleIds 角色组
			*/
			@Override
			@Transactional
			public void insertUserAuth(Long userId, Long[] roleIds)
			{
			userRoleMapper.deleteUserRoleByUserId(userId);
			insertUserRole(userId, roleIds);
			}

			/**
			* 修改用户状态
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			public int updateUserStatus(SysUser user)
			{
			return userMapper.updateUser(user);
			}

			/**
			* 修改用户基本信息
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			public int updateUserProfile(SysUser user)
			{
			return userMapper.updateUser(user);
			}

			/**
			* 修改用户头像
			*
			* @param userName 用户名
			* @param avatar 头像地址
			* @return 结果
			*/
			@Override
			public boolean updateUserAvatar(String userName, String avatar)
			{
			return userMapper.updateUserAvatar(userName, avatar) > 0;
			}

			/**
			* 重置用户密码
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			public int resetPwd(SysUser user)
			{
			return userMapper.updateUser(user);
			}

			/**
			* 重置用户密码
			*
			* @param userName 用户名
			* @param password 密码
			* @return 结果
			*/
			@Override
			public int resetUserPwd(String userName, String password)
			{
			return userMapper.resetUserPwd(userName, password);
			}

			/**
			* 新增用户角色信息
			*
			* @param user 用户对象
			*/
			public void insertUserRole(SysUser user)
			{
			Long[] roles = user.getRoleIds();
			if (StringUtils.isNotNull(roles))
			{
			// 新增用户与角色管理
			List<SysUserRole> list = new ArrayList<SysUserRole>();
			for (Long roleId : roles)
			{
			SysUserRole ur = new SysUserRole();
			ur.setUserId(user.getUserId());
			ur.setRoleId(roleId);
			list.add(ur);
			}
			if (list.size() > 0)
			{
			userRoleMapper.batchUserRole(list);
			}
			}
			}

			/**
			* 新增用户岗位信息
			*
			* @param user 用户对象
			*/
			public void insertUserPost(SysUser user)
			{
			Long[] posts = user.getPostIds();
			if (StringUtils.isNotNull(posts))
			{
			// 新增用户与岗位管理
			List<SysUserPost> list = new ArrayList<SysUserPost>();
			for (Long postId : posts)
			{
			SysUserPost up = new SysUserPost();
			up.setUserId(user.getUserId());
			up.setPostId(postId);
			list.add(up);
			}
			if (list.size() > 0)
			{
			userPostMapper.batchUserPost(list);
			}
			}
			}

			/**
			* 新增用户角色信息
			*
			* @param userId 用户ID
			* @param roleIds 角色组
			*/
			public void insertUserRole(Long userId, Long[] roleIds)
			{
			if (StringUtils.isNotNull(roleIds))
			{
			// 新增用户与角色管理
			List<SysUserRole> list = new ArrayList<SysUserRole>();
			for (Long roleId : roleIds)
			{
			SysUserRole ur = new SysUserRole();
			ur.setUserId(userId);
			ur.setRoleId(roleId);
			list.add(ur);
			}
			if (list.size() > 0)
			{
			userRoleMapper.batchUserRole(list);
			}
			}
			}

			/**
			* 通过用户ID删除用户
			*
			* @param userId 用户ID
			* @return 结果
			*/
			@Override
			@Transactional
			public int deleteUserById(Long userId)
			{
			// 删除用户与角色关联
			userRoleMapper.deleteUserRoleByUserId(userId);
			// 删除用户与岗位表
			userPostMapper.deleteUserPostByUserId(userId);
			return userMapper.deleteUserById(userId);
			}

			/**
			* 批量删除用户信息
			*
			* @param userIds 需要删除的用户ID
			* @return 结果
			*/
			@Override
			@Transactional
			public int deleteUserByIds(Long[] userIds)
			{
			for (Long userId : userIds)
			{
			checkUserAllowed(new SysUser(userId));
			}
			// 删除用户与角色关联
			userRoleMapper.deleteUserRole(userIds);
			// 删除用户与岗位关联
			userPostMapper.deleteUserPost(userIds);
			return userMapper.deleteUserByIds(userIds);
			}

			/**
			* 导入用户数据
			*
			* @param userList 用户数据列表
			* @param isUpdateSupport 是否更新支持，如果已存在，则进行更新数据
			* @param operName 操作用户
			* @return 结果
			*/
			@Override
			public String importUser(List<SysUser> userList, Boolean isUpdateSupport, String operName)
			{
			if (StringUtils.isNull(userList) \|\| userList.size() == 0)
			{
			throw new ServiceException("导入用户数据不能为空！");
			}
			int successNum = 0;
			int failureNum = 0;
			StringBuilder successMsg = new StringBuilder();
			StringBuilder failureMsg = new StringBuilder();
			String password = configService.selectConfigByKey("sys.user.initPassword");
			for (SysUser user : userList)
			{
			try
			{
			// 验证是否存在这个用户
			SysUser u = userMapper.selectUserByUserName(user.getUserName());
			if (StringUtils.isNull(u))
			{
			user.setPassword(SecurityUtils.encryptPassword(password));
			user.setCreateBy(operName);
			this.insertUser(user);
			successNum++;
			successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 导入成功");
			}
			else if (isUpdateSupport)
			{
			user.setUpdateBy(operName);
			this.updateUser(user);
			successNum++;
			successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 更新成功");
			}
			else
			{
			failureNum++;
			failureMsg.append("<br/>" + failureNum + "、账号 " + user.getUserName() + " 已存在");
			}
			}
			catch (Exception e)
			{
			failureNum++;
			String msg = "<br/>" + failureNum + "、账号 " + user.getUserName() + " 导入失败：";
			failureMsg.append(msg + e.getMessage());
			log.error(msg, e);
			}
			}
			if (failureNum > 0)
			{
			failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
			throw new ServiceException(failureMsg.toString());
			}
			else
			{
			successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
			}
			return successMsg.toString();
			}
			}
			package com.ruoyi.system.service.impl;

			import cn.hutool.core.collection.CollUtil;
			import cn.hutool.core.util.ArrayUtil;
			import cn.hutool.core.util.ObjectUtil;
			import com.baomidou.mybatisplus.core.conditions.Wrapper;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
			import com.baomidou.mybatisplus.core.toolkit.Wrappers;
			import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
			import com.ruoyi.common.constant.UserConstants;
			import com.ruoyi.common.core.domain.PageQuery;
			import com.ruoyi.system.domain.SysDept;
			import com.ruoyi.system.domain.SysRole;
			import com.ruoyi.system.domain.SysUser;
			import com.ruoyi.common.core.page.TableDataInfo;
			import com.ruoyi.common.exception.ServiceException;
			import com.ruoyi.common.helper.DataBaseHelper;
			import com.ruoyi.common.helper.LoginHelper;
			import com.ruoyi.common.utils.StreamUtils;
			import com.ruoyi.common.utils.StringUtils;
			import com.ruoyi.system.domain.SysPost;
			import com.ruoyi.system.domain.SysUserPost;
			import com.ruoyi.system.domain.SysUserRole;
			import com.ruoyi.system.mapper.*;
			import com.ruoyi.system.service.ISysUserService;
			import lombok.RequiredArgsConstructor;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;

			import java.util.ArrayList;
			import java.util.Arrays;
			import java.util.List;
			import java.util.Map;

			/**
			* 用户业务层处理
			*
			* @author Lion Li
			*/
			@Slf4j
			@RequiredArgsConstructor
			@Service
			public class SysUserServiceImpl implements ISysUserService {

			private final SysUserMapper baseMapper;
			private final SysDeptMapper deptMapper;
			private final SysRoleMapper roleMapper;
			private final SysPostMapper postMapper;
			private final SysUserRoleMapper userRoleMapper;
			private final SysUserPostMapper userPostMapper;

			@Override
			public TableDataInfo<SysUser> selectPageUserList(SysUser user, PageQuery pageQuery) {
			Page<SysUser> page = baseMapper.selectPageUserList(pageQuery.build(), this.buildQueryWrapper(user));
			return TableDataInfo.build(page);
			}

			/**
			* 根据条件分页查询用户列表
			*
			* @param user 用户信息
			* @return 用户信息集合信息
			*/
			@Override
			public List<SysUser> selectUserList(SysUser user) {
			return baseMapper.selectUserList(this.buildQueryWrapper(user));
			}

			private Wrapper<SysUser> buildQueryWrapper(SysUser user) {
			Map<String, Object> params = user.getParams();
			QueryWrapper<SysUser> wrapper = Wrappers.query();
			wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
			.eq(ObjectUtil.isNotNull(user.getUserId()), "u.user_id", user.getUserId())
			.like(StringUtils.isNotBlank(user.getUserName()), "u.user_name", user.getUserName())
			.eq(StringUtils.isNotBlank(user.getStatus()), "u.status", user.getStatus())
			.like(StringUtils.isNotBlank(user.getPhonenumber()), "u.phonenumber", user.getPhonenumber())
			.between(params.get("beginTime") != null && params.get("endTime") != null,
			"u.create_time", params.get("beginTime"), params.get("endTime"))
			.and(ObjectUtil.isNotNull(user.getDeptId()), w -> {
			List<SysDept> deptList = deptMapper.selectList(new LambdaQueryWrapper<SysDept>()
			.select(SysDept::getDeptId)
			.apply(DataBaseHelper.findInSet(user.getDeptId(), "ancestors")));
			List<Long> ids = StreamUtils.toList(deptList, SysDept::getDeptId);
			ids.add(user.getDeptId());
			w.in("u.dept_id", ids);
			});
			return wrapper;
			}

			/**
			* 根据条件分页查询已分配用户角色列表
			*
			* @param user 用户信息
			* @return 用户信息集合信息
			*/
			@Override
			public TableDataInfo<SysUser> selectAllocatedList(SysUser user, PageQuery pageQuery) {
			QueryWrapper<SysUser> wrapper = Wrappers.query();
			wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
			.eq(ObjectUtil.isNotNull(user.getRoleId()), "r.role_id", user.getRoleId())
			.like(StringUtils.isNotBlank(user.getUserName()), "u.user_name", user.getUserName())
			.eq(StringUtils.isNotBlank(user.getStatus()), "u.status", user.getStatus())
			.like(StringUtils.isNotBlank(user.getPhonenumber()), "u.phonenumber", user.getPhonenumber());
			Page<SysUser> page = baseMapper.selectAllocatedList(pageQuery.build(), wrapper);
			return TableDataInfo.build(page);
			}

			/**
			* 根据条件分页查询未分配用户角色列表
			*
			* @param user 用户信息
			* @return 用户信息集合信息
			*/
			@Override
			public TableDataInfo<SysUser> selectUnallocatedList(SysUser user, PageQuery pageQuery) {
			List<Long> userIds = userRoleMapper.selectUserIdsByRoleId(user.getRoleId());
			QueryWrapper<SysUser> wrapper = Wrappers.query();
			wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
			.and(w -> w.ne("r.role_id", user.getRoleId()).or().isNull("r.role_id"))
			.notIn(CollUtil.isNotEmpty(userIds), "u.user_id", userIds)
			.like(StringUtils.isNotBlank(user.getUserName()), "u.user_name", user.getUserName())
			.like(StringUtils.isNotBlank(user.getPhonenumber()), "u.phonenumber", user.getPhonenumber());
			Page<SysUser> page = baseMapper.selectUnallocatedList(pageQuery.build(), wrapper);
			return TableDataInfo.build(page);
			}

			/**
			* 通过用户名查询用户
			*
			* @param userName 用户名
			* @return 用户对象信息
			*/
			@Override
			public SysUser selectUserByUserName(String userName) {
			return baseMapper.selectUserByUserName(userName);
			}

			/**
			* 通过手机号查询用户
			*
			* @param phonenumber 手机号
			* @return 用户对象信息
			*/
			@Override
			public SysUser selectUserByPhonenumber(String phonenumber) {
			return baseMapper.selectUserByPhonenumber(phonenumber);
			}

			/**
			* 通过用户ID查询用户
			*
			* @param userId 用户ID
			* @return 用户对象信息
			*/
			@Override
			public SysUser selectUserById(Long userId) {
			return baseMapper.selectUserById(userId);
			}

			/**
			* 查询用户所属角色组
			*
			* @param userName 用户名
			* @return 结果
			*/
			@Override
			public String selectUserRoleGroup(String userName) {
			List<SysRole> list = roleMapper.selectRolesByUserName(userName);
			if (CollUtil.isEmpty(list)) {
			return StringUtils.EMPTY;
			}
			return StreamUtils.join(list, SysRole::getRoleName);
			}

			/**
			* 查询用户所属岗位组
			*
			* @param userName 用户名
			* @return 结果
			*/
			@Override
			public String selectUserPostGroup(String userName) {
			List<SysPost> list = postMapper.selectPostsByUserName(userName);
			if (CollUtil.isEmpty(list)) {
			return StringUtils.EMPTY;
			}
			return StreamUtils.join(list, SysPost::getPostName);
			}

			/**
			* 校验用户名称是否唯一
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			public String checkUserNameUnique(SysUser user) {
			boolean exist = baseMapper.exists(new LambdaQueryWrapper<SysUser>()
			.eq(SysUser::getUserName, user.getUserName())
			.ne(ObjectUtil.isNotNull(user.getUserId()), SysUser::getUserId, user.getUserId()));
			if (exist) {
			return UserConstants.NOT_UNIQUE;
			}
			return UserConstants.UNIQUE;
			}

			/**
			* 校验手机号码是否唯一
			*
			* @param user 用户信息
			* @return
			*/
			@Override
			public String checkPhoneUnique(SysUser user) {
			boolean exist = baseMapper.exists(new LambdaQueryWrapper<SysUser>()
			.eq(SysUser::getPhonenumber, user.getPhonenumber())
			.ne(ObjectUtil.isNotNull(user.getUserId()), SysUser::getUserId, user.getUserId()));
			if (exist) {
			return UserConstants.NOT_UNIQUE;
			}
			return UserConstants.UNIQUE;
			}

			/**
			* 校验email是否唯一
			*
			* @param user 用户信息
			* @return
			*/
			@Override
			public String checkEmailUnique(SysUser user) {
			boolean exist = baseMapper.exists(new LambdaQueryWrapper<SysUser>()
			.eq(SysUser::getEmail, user.getEmail())
			.ne(ObjectUtil.isNotNull(user.getUserId()), SysUser::getUserId, user.getUserId()));
			if (exist) {
			return UserConstants.NOT_UNIQUE;
			}
			return UserConstants.UNIQUE;
			}

			/**
			* 校验用户是否允许操作
			*
			* @param user 用户信息
			*/
			@Override
			public void checkUserAllowed(SysUser user) {
			if (ObjectUtil.isNotNull(user.getUserId()) && user.isAdmin()) {
			throw new ServiceException("不允许操作超级管理员用户");
			}
			}

			/**
			* 校验用户是否有数据权限
			*
			* @param userId 用户id
			*/
			@Override
			public void checkUserDataScope(Long userId) {
			if (!LoginHelper.isAdmin()) {
			SysUser user = new SysUser();
			user.setUserId(userId);
			List<SysUser> users = this.selectUserList(user);
			if (CollUtil.isEmpty(users)) {
			throw new ServiceException("没有权限访问用户数据！");
			}
			}
			}

			/**
			* 新增保存用户信息
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public int insertUser(SysUser user) {
			// 新增用户信息
			int rows = baseMapper.insert(user);
			// 新增用户岗位关联
			insertUserPost(user);
			// 新增用户与角色管理
			insertUserRole(user);
			return rows;
			}

			/**
			* 注册用户信息
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			public boolean registerUser(SysUser user) {
			user.setCreateBy(user.getUserName());
			user.setUpdateBy(user.getUserName());
			return baseMapper.insert(user) > 0;
			}

			/**
			* 修改保存用户信息
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public int updateUser(SysUser user) {
			Long userId = user.getUserId();
			// 删除用户与角色关联
			userRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, userId));
			// 新增用户与角色管理
			insertUserRole(user);
			// 删除用户与岗位关联
			userPostMapper.delete(new LambdaQueryWrapper<SysUserPost>().eq(SysUserPost::getUserId, userId));
			// 新增用户与岗位管理
			insertUserPost(user);
			return baseMapper.updateById(user);
			}

			/**
			* 用户授权角色
			*
			* @param userId 用户ID
			* @param roleIds 角色组
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public void insertUserAuth(Long userId, Long[] roleIds) {
			userRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>()
			.eq(SysUserRole::getUserId, userId));
			insertUserRole(userId, roleIds);
			}

			/**
			* 修改用户状态
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			public int updateUserStatus(SysUser user) {
			return baseMapper.updateById(user);
			}

			/**
			* 修改用户基本信息
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			public int updateUserProfile(SysUser user) {
			return baseMapper.updateById(user);
			}

			/**
			* 修改用户头像
			*
			* @param userName 用户名
			* @param avatar 头像地址
			* @return 结果
			*/
			@Override
			public boolean updateUserAvatar(String userName, String avatar) {
			return baseMapper.update(null,
			new LambdaUpdateWrapper<SysUser>()
			.set(SysUser::getAvatar, avatar)
			.eq(SysUser::getUserName, userName)) > 0;
			}

			/**
			* 重置用户密码
			*
			* @param user 用户信息
			* @return 结果
			*/
			@Override
			public int resetPwd(SysUser user) {
			return baseMapper.updateById(user);
			}

			/**
			* 重置用户密码
			*
			* @param userName 用户名
			* @param password 密码
			* @return 结果
			*/
			@Override
			public int resetUserPwd(String userName, String password) {
			return baseMapper.update(null,
			new LambdaUpdateWrapper<SysUser>()
			.set(SysUser::getPassword, password)
			.eq(SysUser::getUserName, userName));
			}

			/**
			* 新增用户角色信息
			*
			* @param user 用户对象
			*/
			public void insertUserRole(SysUser user) {
			this.insertUserRole(user.getUserId(), user.getRoleIds());
			}

			/**
			* 新增用户岗位信息
			*
			* @param user 用户对象
			*/
			public void insertUserPost(SysUser user) {
			Long[] posts = user.getPostIds();
			if (ArrayUtil.isNotEmpty(posts)) {
			// 新增用户与岗位管理
			List<SysUserPost> list = new ArrayList<>(posts.length);
			for (Long postId : posts) {
			SysUserPost up = new SysUserPost();
			up.setUserId(user.getUserId());
			up.setPostId(postId);
			list.add(up);
			}
			userPostMapper.insertBatch(list);
			}
			}

			/**
			* 新增用户角色信息
			*
			* @param userId 用户ID
			* @param roleIds 角色组
			*/
			public void insertUserRole(Long userId, Long[] roleIds) {
			if (ArrayUtil.isNotEmpty(roleIds)) {
			// 新增用户与角色管理
			List<SysUserRole> list = new ArrayList<>(roleIds.length);
			for (Long roleId : roleIds) {
			SysUserRole ur = new SysUserRole();
			ur.setUserId(userId);
			ur.setRoleId(roleId);
			list.add(ur);
			}
			userRoleMapper.insertBatch(list);
			}
			}

			/**
			* 通过用户ID删除用户
			*
			* @param userId 用户ID
			* @return 结果
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public int deleteUserById(Long userId) {
			// 删除用户与角色关联
			userRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, userId));
			// 删除用户与岗位表
			userPostMapper.delete(new LambdaQueryWrapper<SysUserPost>().eq(SysUserPost::getUserId, userId));
			return baseMapper.deleteById(userId);
			}

			/**
			* 批量删除用户信息
			*
			* @param userIds 需要删除的用户ID
			* @return 结果
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public int deleteUserByIds(Long[] userIds) {
			for (Long userId : userIds) {
			checkUserAllowed(new SysUser(userId));
			checkUserDataScope(userId);
			}
			List<Long> ids = Arrays.asList(userIds);
			// 删除用户与角色关联
			userRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>().in(SysUserRole::getUserId, ids));
			// 删除用户与岗位表
			userPostMapper.delete(new LambdaQueryWrapper<SysUserPost>().in(SysUserPost::getUserId, ids));
			return baseMapper.deleteBatchIds(ids);
			}

			}