package com.monkeylessey.sys.service.impl;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
|
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.monkeylessey.constant.RedisKeyPrefixConstants;
|
import com.monkeylessey.sys.domain.entity.*;
|
import com.monkeylessey.sys.domain.form.ResetPwdForm;
|
import com.monkeylessey.sys.domain.form.SysUserForm;
|
import com.monkeylessey.sys.domain.form.SysUserStatusForm;
|
import com.monkeylessey.sys.domain.query.SysUserQuery;
|
import com.monkeylessey.sys.domain.vo.SysMenuVO;
|
import com.monkeylessey.sys.domain.vo.SysUserVO;
|
import com.monkeylessey.sys.domain.vo.UserRolePermissionVO;
|
import com.monkeylessey.enums.general.MenuTypeEnum;
|
import com.monkeylessey.enums.general.StatusEnum;
|
import com.monkeylessey.enums.general.UserStatusEnum;
|
import com.monkeylessey.exception.ServiceException;
|
import com.monkeylessey.sys.mapper.*;
|
import com.monkeylessey.response.Result;
|
import com.monkeylessey.sys.service.SysUserService;
|
import com.monkeylessey.framework.utils.RedisUtil;
|
import com.monkeylessey.framework.utils.SecurityUtil;
|
import com.monkeylessey.utils.PageUtil;
|
import com.monkeylessey.utils.TreeUtil;
|
import lombok.RequiredArgsConstructor;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.security.crypto.password.PasswordEncoder;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 系统用户 服务实现类
|
*
|
* @author 向培
|
* @since 2022-05-30
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements SysUserService {
|
|
private final SysUserMapper sysUserMapper;
|
private final SysMenuMapper sysMenuMapper;
|
private final SysRoleMenuMapper roleMenuMapper;
|
private final SysRoleMapper roleMapper;
|
private final RedisUtil redisUtil;
|
private final PasswordEncoder passwordEncoder;
|
private final SysOrgMapper sysOrgMapper;
|
|
@Override
|
public Result addSysUser(SysUserForm form) {
|
SysUser entity = SysUserForm.getSysUser(null, form);
|
// 加密密码
|
entity.setPassword(passwordEncoder.encode(form.getPassword()));
|
// 默认禁用
|
entity.setStatus(UserStatusEnum.INACTIVE);
|
String s = SecurityUtil.getCurrentUserName();
|
entity.setCreateBy(s);
|
try {
|
if (baseMapper.insert(entity) > 0) {
|
return Result.ok("添加成功");
|
}
|
return Result.error("添加失败");
|
} catch (Exception e) {
|
e.printStackTrace();
|
return Result.error("添加失败");
|
}
|
}
|
|
@Override
|
public Result editSysUser(SysUserForm form) {
|
SysUser user = baseMapper.selectById(form.getId());
|
if (Objects.isNull(user)) {
|
return Result.error("修改用户不存在");
|
}
|
SysUser entity = SysUserForm.getSysUser(user, form);
|
String s = SecurityUtil.getCurrentUserName();
|
entity.setUpdateBy(s);
|
baseMapper.updateById(entity);
|
SysUserVO vo = SysUserVO.getVoByEntity(entity, null);
|
vo.setPassword("");
|
return Result.ok("修改成功").data(vo);
|
}
|
|
@Override
|
public Result deleteSysUserById(String id) {
|
try {
|
if (baseMapper.deleteById(id) > 0) {
|
return Result.ok("删除成功");
|
}
|
return Result.error("删除失败");
|
} catch (Exception e) {
|
e.printStackTrace();
|
return Result.error("删除失败");
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Result deleteSysUserByIds(List<String> ids) {
|
if (baseMapper.deleteBatchIds(ids) > 0) {
|
return Result.ok("删除成功");
|
}
|
return Result.error("删除失败");
|
}
|
|
@Override
|
public Result getSysUserByPage(SysUserQuery query) {
|
List<SysUserVO> vos = new ArrayList<>();
|
Long total = 0L;
|
try {
|
IPage<SysUser> page = PageUtil.getPage(query, SysUser.class);
|
new LambdaQueryChainWrapper<>(this.baseMapper)
|
.eq(StringUtils.isNotBlank(query.getUserName()), SysUser::getUserName, query.getUserName())
|
.eq(StringUtils.isNotBlank(query.getNickName()), SysUser::getNickName, query.getNickName())
|
.page(page);
|
page.getRecords().stream()
|
.map(sysUser -> SysUserVO.getVoByEntity(sysUser, null))
|
.forEach(user -> {
|
if (StringUtils.isNotBlank(user.getBelongOrg())) {
|
SysOrg org = new LambdaQueryChainWrapper<>(sysOrgMapper)
|
.select(SysOrg::getOrgName)
|
.eq(SysOrg::getId, user.getBelongOrg())
|
.one();
|
if (Objects.nonNull(org)) {
|
user.setBelongOrgName(org.getOrgName());
|
}
|
}
|
vos.add(user);
|
});
|
total = page.getTotal();
|
return Result.ok().data(vos).total(total);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return Result.error("查询错误");
|
}
|
|
@Override
|
public Result getSysUserById(String id) {
|
SysUser entity = baseMapper.selectById(id);
|
if (Objects.isNull(entity)) {
|
return Result.error("用户不存在");
|
}
|
SysUserVO vo = SysUserVO.getVoByEntity(entity, null);
|
// 获取组织
|
if (StringUtils.isNotBlank(entity.getBelongOrg())) {
|
SysOrg org = sysOrgMapper.selectById(entity.getBelongOrg());
|
if (Objects.nonNull(org)) {
|
vo.setBelongOrgName(org.getOrgName());
|
}
|
}
|
return Result.ok().data(vo);
|
}
|
|
@Override
|
public List<String> getUserMenuPermissions(String username) {
|
List<String> permissions = new ArrayList();
|
// 先查出用户所有角色
|
String roleString = sysUserMapper.getRoleString(username);
|
if (StringUtils.isNotBlank(roleString)) {
|
// 通过角色查找拥有的菜单id
|
String[] split = roleString.split(",");
|
List<SysRoleMenu> list = new LambdaQueryChainWrapper<>(roleMenuMapper)
|
.select(SysRoleMenu::getMenuId)
|
.in(SysRoleMenu::getRoleId, split)
|
.list();
|
Set<String> set = new HashSet();
|
for (SysRoleMenu sysRoleMenu : list) {
|
if (StringUtils.isNotBlank(sysRoleMenu.getMenuId())) {
|
for (String s : sysRoleMenu.getMenuId().split(",")) {
|
set.add(s);
|
}
|
}
|
}
|
// 根据id查出对应菜单
|
List<SysMenu> sysMenus = new LambdaQueryChainWrapper<>(sysMenuMapper)
|
.ne(SysMenu::getStatus, StatusEnum.INACTIVE.getCode())
|
.in(SysMenu::getId, set)
|
.list();
|
for (SysMenu sysMenu : sysMenus) {
|
if (StringUtils.isNotBlank(sysMenu.getPermission())) {
|
permissions.add(sysMenu.getPermission());
|
}
|
}
|
}
|
return permissions;
|
}
|
|
@Override
|
public List<String> getUserRolePermissions(String username) {
|
List<String> permissions = new ArrayList();
|
// 先查出用户所有角色
|
String roleString = sysUserMapper.getRoleString(username);
|
if (StringUtils.isNotBlank(roleString)) {
|
String[] roleIds = roleString.split(",");
|
List<SysRole> roleList = new LambdaQueryChainWrapper<>(roleMapper)
|
.select(SysRole::getRoleKey)
|
.in(SysRole::getId, roleIds)
|
.list();
|
roleList.stream()
|
.map(SysRole::getRoleKey)
|
.forEach(roleKey -> permissions.add(roleKey));
|
}
|
return permissions;
|
}
|
|
@Override
|
public UserRolePermissionVO getMenus(String username) {
|
UserRolePermissionVO userRolePermissionVO = new UserRolePermissionVO();
|
Set<String> set = new HashSet();
|
// 先查出用户所有角色
|
String roleString = sysUserMapper.getRoleString(username);
|
if (StringUtils.isNotBlank(roleString)) {
|
// 通过角色查找拥有的菜单id
|
String[] split = roleString.split(",");
|
List<SysRoleMenu> list = new LambdaQueryChainWrapper<>(roleMenuMapper)
|
.select(SysRoleMenu::getMenuId)
|
.in(SysRoleMenu::getRoleId, split)
|
.list();
|
for (SysRoleMenu sysRoleMenu : list) {
|
if (StringUtils.isNotBlank(sysRoleMenu.getMenuId())) {
|
for (String s : sysRoleMenu.getMenuId().split(",")) {
|
set.add(s);
|
}
|
}
|
}
|
}
|
// 根据id查出对应菜单(正常和隐藏的菜单)
|
List<SysMenuVO> sysMenuVOS = new ArrayList<>();
|
// 菜单为空直接返回
|
if (set.isEmpty()) {
|
return userRolePermissionVO;
|
}
|
List<SysMenu> sysMenus = new LambdaQueryChainWrapper<>(sysMenuMapper)
|
.ne(SysMenu::getStatus, StatusEnum.INACTIVE)
|
.in(SysMenu::getId, set)
|
.orderByAsc(SysMenu::getOrderNum)
|
.list();
|
|
// 转化为VO
|
for (SysMenu sysMenu : sysMenus) {
|
SysMenuVO sysMenuVO = new SysMenuVO();
|
BeanUtils.copyProperties(sysMenu, sysMenuVO);
|
sysMenuVOS.add(sysMenuVO);
|
}
|
// 获取到按钮权限
|
List<String> buttonPermissions = sysMenuVOS.stream()
|
.filter(menu -> MenuTypeEnum.BUTTON.equals(menu.getMenuType()))
|
.map(SysMenuVO::getPermission)
|
.collect(Collectors.toList());
|
userRolePermissionVO.setButtonPermissions(buttonPermissions);
|
|
// 获取动态菜单
|
List<SysMenuVO> dynMenus = sysMenuVOS.stream().filter(menu -> !MenuTypeEnum.BUTTON.equals(menu.getMenuType())).collect(Collectors.toList());
|
List<SysMenuVO> tree = TreeUtil.buildMenuTree(dynMenus);
|
tree.sort(Comparator.comparing(SysMenuVO::getOrderNum));
|
userRolePermissionVO.setMenuPermissions(tree);
|
return userRolePermissionVO;
|
}
|
|
@Override
|
public Result editSysUserStatus(SysUserStatusForm form) {
|
SysUser sysUser = baseMapper.selectById(form.getId());
|
if (sysUser == null) {
|
throw new ServiceException("用户不存在");
|
}
|
// 校验：自己不能修改自己
|
if (sysUser.getId().equals(SecurityUtil.getCurrentUserId())) {
|
throw new ServiceException("自己不能修改自己的状态");
|
}
|
sysUser.setStatus(form.getStatus());
|
if (baseMapper.updateById(sysUser) > 0) {
|
if (form.getStatus().equals(UserStatusEnum.INACTIVE)) {
|
// 如果禁用，清空该用户redis中的token
|
redisUtil.deleteKey(RedisKeyPrefixConstants.TOKEN_PREFIX + sysUser.getId());
|
}
|
return Result.ok("修改成功");
|
}
|
return Result.error("修改失败");
|
}
|
|
@Override
|
public Result updatePwd(ResetPwdForm form) {
|
String userId = SecurityUtil.getCurrentUserId();
|
SysUser user = new LambdaQueryChainWrapper<>(baseMapper)
|
.eq(SysUser::getId, userId)
|
.eq(SysUser::getStatus, UserStatusEnum.ACTIVE.getCode())
|
.one();
|
if (user == null) {
|
throw new ServiceException("用户不存在或被禁用");
|
}
|
form.setNewPwd(passwordEncoder.encode(form.getNewPwd()));
|
form.setOldPwd(passwordEncoder.encode(form.getOldPwd()));
|
|
if (passwordEncoder.matches(form.getOldPwd(), user.getPassword())) {
|
throw new ServiceException("旧密码不正确");
|
}
|
user.setPassword(form.getNewPwd());
|
if (baseMapper.updateById(user) > 0) {
|
// 清除现有token
|
redisUtil.deleteKey(RedisKeyPrefixConstants.TOKEN_PREFIX + user.getId());
|
return Result.ok("密码修改成功，请重新登录");
|
}
|
return Result.error("修改失败");
|
}
|
|
@Override
|
public Result resetUserPwd(Integer userId) {
|
new LambdaUpdateChainWrapper<>(sysUserMapper)
|
.eq(SysUser::getId, userId)
|
.set(SysUser::getPassword, passwordEncoder.encode("123456"))
|
.update();
|
return Result.ok("操作成功");
|
}
|
|
}
|
