hhyykk/ipms-sjy
1
1
Fork 0
mirror of https://gitee.com/hhyykk/ipms-sjy.git synced 2025-07-14 11:05:06 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

整理 permission、user 模块的 url

Browse Source
This commit is contained in:
YunaiV
2021-03-14 22:46:39 +08:00
parent 378f5834cc
commit f4818d26d6
25 changed files with 1417 additions and 927 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/cn/iocoder/dashboard/modules/system/controller/auth/SysAuthController.java
View File

@ -65,7 +65,7 @@ public class SysAuthController {
return null;
}
// 获得角色列表
List<SysRoleDO> roleList = roleService.listRolesFromCache(getLoginUserRoleIds());
List<SysRoleDO> roleList = roleService.getRolesFromCache(getLoginUserRoleIds());
// 获得菜单列表
List<SysMenuDO> menuList = permissionService.getRoleMenusFromCache(
getLoginUserRoleIds(), // 注意，基于登陆的角色，因为后续的权限判断也是基于它

92
src/main/java/cn/iocoder/dashboard/modules/system/controller/permission/SysMenuController.java
View File

@ -9,10 +9,12 @@ import cn.iocoder.dashboard.modules.system.service.permission.SysMenuService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.Comparator;
import java.util.List;
@ -21,78 +23,64 @@ import static cn.iocoder.dashboard.common.pojo.CommonResult.success;
@Api(tags = "菜单")
@RestController
@RequestMapping("/system/menu")
@Validated
public class SysMenuController {
@Resource
private SysMenuService menuService;
@ApiOperation("获取菜单列表")
// @PreAuthorize("@ss.hasPermi('system:menu:list')")
@GetMapping("/list")
public CommonResult<List<SysMenuRespVO>> listMenus(SysMenuListReqVO reqVO) {
List<SysMenuDO> list = menuService.listMenus(reqVO);
list.sort(Comparator.comparing(SysMenuDO::getSort));
return success(SysMenuConvert.INSTANCE.convertList(list));
}
@ApiOperation(value = "获取菜单精简信息列表", notes = "只包含被开启的菜单，主要用于前端的下拉选项")
@GetMapping("/list-all-simple")
public CommonResult<List<SysMenuSimpleRespVO>> listSimpleMenus() {
// 获得菜单列表，只要开启状态的
SysMenuListReqVO reqVO = new SysMenuListReqVO();
reqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
List<SysMenuDO> list = menuService.listMenus(reqVO);
// 排序后，返回个诶前端
list.sort(Comparator.comparing(SysMenuDO::getSort));
return success(SysMenuConvert.INSTANCE.convertList02(list));
}
@ApiOperation("获取菜单信息")
@GetMapping("/get")
// @PreAuthorize("@ss.hasPermi('system:menu:query')")
public CommonResult<SysMenuRespVO> getMenu(Long id) {
SysMenuDO menu = menuService.getMenu(id);
return success(SysMenuConvert.INSTANCE.convert(menu));
}
// /**
// * 加载对应角色菜单列表树
// */
// @GetMapping(value = "/roleMenuTreeselect/{roleId}")
// public AjaxResult roleMenuTreeselect(@PathVariable("roleId") Long roleId) {
// LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
// List<SysMenu> menus = menuService.selectMenuList(loginUser.getUser().getUserId());
// AjaxResult ajax = AjaxResult.success();
// ajax.put("checkedKeys", menuService.selectMenuListByRoleId(roleId));
// ajax.put("menus", menuService.buildMenuTreeSelect(menus));
// return ajax;
// }
@ApiOperation("创建菜单")
// @PreAuthorize("@ss.hasPermi('system:menu:add')")
// @Log(title = "菜单管理", businessType = BusinessType.INSERT)
@PostMapping("/create")
public CommonResult<Long> createMenu(@Validated @RequestBody SysMenuCreateReqVO reqVO) {
@ApiOperation("创建菜单")
@PreAuthorize("@ss.hasPermission('system:menu:create')")
public CommonResult<Long> createMenu(@Valid @RequestBody SysMenuCreateReqVO reqVO) {
Long menuId = menuService.createMenu(reqVO);
return success(menuId);
}
@PutMapping("/update")
@ApiOperation("修改菜单")
// @PreAuthorize("@ss.hasPermi('system:menu:edit')")
// @Log(title = "菜单管理", businessType = BusinessType.UPDATE)
@PostMapping("/update")
public CommonResult<Boolean> updateMenu(@Validated @RequestBody SysMenuUpdateReqVO reqVO) {
@PreAuthorize("@ss.hasPermission('system:menu:update')")
public CommonResult<Boolean> updateMenu(@Valid @RequestBody SysMenuUpdateReqVO reqVO) {
menuService.updateMenu(reqVO);
return success(true);
}
@DeleteMapping("/delete")
@ApiOperation("删除菜单")
@PostMapping("/delete")
@ApiImplicitParam(name = "id", value = "角色编号", required= true, example = "1024", dataTypeClass = Long.class)
// @Log(title = "菜单管理", businessType = BusinessType.DELETE)
@PreAuthorize("@ss.hasPermission('system:menu:delete')")
public CommonResult<Boolean> deleteMenu(@RequestParam("id") Long id) {
menuService.deleteMenu(id);
return success(true);
}
@GetMapping("/list")
@ApiOperation("获取菜单列表")
@PreAuthorize("@ss.hasPermission('system:menu:query')")
public CommonResult<List<SysMenuRespVO>> getMenus(SysMenuListReqVO reqVO) {
List<SysMenuDO> list = menuService.getMenus(reqVO);
list.sort(Comparator.comparing(SysMenuDO::getSort));
return success(SysMenuConvert.INSTANCE.convertList(list));
}
@GetMapping("/list-all-simple")
@ApiOperation(value = "获取菜单精简信息列表", notes = "只包含被开启的菜单，主要用于前端的下拉选项")
public CommonResult<List<SysMenuSimpleRespVO>> getSimpleMenus() {
// 获得菜单列表，只要开启状态的
SysMenuListReqVO reqVO = new SysMenuListReqVO();
reqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
List<SysMenuDO> list = menuService.getMenus(reqVO);
// 排序后，返回个诶前端
list.sort(Comparator.comparing(SysMenuDO::getSort));
return success(SysMenuConvert.INSTANCE.convertList02(list));
}
@GetMapping("/get")
@ApiOperation("获取菜单信息")
@PreAuthorize("@ss.hasPermission('system:menu:query')")
public CommonResult<SysMenuRespVO> getMenu(Long id) {
SysMenuDO menu = menuService.getMenu(id);
return success(SysMenuConvert.INSTANCE.convert(menu));
}
}

86
src/main/java/cn/iocoder/dashboard/modules/system/controller/permission/SysRoleController.java
View File

@ -4,6 +4,7 @@ import cn.iocoder.dashboard.common.enums.CommonStatusEnum;
import cn.iocoder.dashboard.common.pojo.CommonResult;
import cn.iocoder.dashboard.common.pojo.PageResult;
import cn.iocoder.dashboard.framework.excel.core.util.ExcelUtils;
import cn.iocoder.dashboard.framework.logger.operatelog.core.annotations.OperateLog;
import cn.iocoder.dashboard.modules.system.controller.permission.vo.role.*;
import cn.iocoder.dashboard.modules.system.convert.permission.SysRoleConvert;
import cn.iocoder.dashboard.modules.system.dal.dataobject.permission.SysRoleDO;
@ -11,96 +12,95 @@ import cn.iocoder.dashboard.modules.system.service.permission.SysRoleService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.io.IOException;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import static cn.iocoder.dashboard.common.pojo.CommonResult.success;
import static cn.iocoder.dashboard.framework.logger.operatelog.core.enums.OperateTypeEnum.EXPORT;
@Api(tags = "角色")
@RestController
@RequestMapping("/system/role")
@Validated
public class SysRoleController {
@Resource
private SysRoleService roleService;
@ApiOperation("获得角色分页")
@GetMapping("/page")
// @PreAuthorize("@ss.hasPermi('system:role:list')")
public CommonResult<PageResult<SysRoleDO>> list(SysRolePageReqVO reqVO) {
return success(roleService.pageRole(reqVO));
}
@ApiOperation(value = "获取角色精简信息列表", notes = "只包含被开启的角色，主要用于前端的下拉选项")
@GetMapping("/list-all-simple")
public CommonResult<List<SysRoleSimpleRespVO>> listSimpleRoles() {
// 获得角色列表，只要开启状态的
List<SysRoleDO> list = roleService.listRoles(Collections.singleton(CommonStatusEnum.ENABLE.getStatus()));
// 排序后，返回个诶前端
list.sort(Comparator.comparing(SysRoleDO::getSort));
return success(SysRoleConvert.INSTANCE.convertList02(list));
}
@ApiOperation("创建角色")
@PostMapping("/create")
// @PreAuthorize("@ss.hasPermi('system:role:add')")
// @Log(title = "角色管理", businessType = BusinessType.INSERT)
public CommonResult<Long> add(@Validated @RequestBody SysRoleCreateReqVO reqVO) {
@ApiOperation("创建角色")
@PreAuthorize("@ss.hasPermission('system:role:create')")
public CommonResult<Long> createRole(@Valid @RequestBody SysRoleCreateReqVO reqVO) {
return success(roleService.createRole(reqVO));
}
@PutMapping("/update")
@ApiOperation("修改角色")
// @PreAuthorize("@ss.hasPermi('system:role:edit')")
// @Log(title = "角色管理", businessType = BusinessType.UPDATE)
@PostMapping("/update")
public CommonResult<Boolean> update(@Validated @RequestBody SysRoleUpdateReqVO reqVO) {
@PreAuthorize("@ss.hasPermission('system:role:update')")
public CommonResult<Boolean> updateRole(@Valid @RequestBody SysRoleUpdateReqVO reqVO) {
roleService.updateRole(reqVO);
return success(true);
}
@PutMapping("/update-status")
@ApiOperation("修改角色状态")
@PreAuthorize("@ss.hasPermission('system:role:update')")
public CommonResult<Boolean> updateRoleStatus(@Valid @RequestBody SysRoleUpdateStatusReqVO reqVO) {
roleService.updateRoleStatus(reqVO.getId(), reqVO.getStatus());
return success(true);
}
@DeleteMapping("/delete")
@ApiOperation("删除角色")
@PostMapping("/delete")
@ApiImplicitParam(name = "id", value = "角色编号", required = true, example = "1024", dataTypeClass = Long.class)
// @PreAuthorize("@ss.hasPermi('system:role:remove')")
// @Log(title = "角色管理", businessType = BusinessType.DELETE)
@PreAuthorize("@ss.hasPermission('system:role:delete')")
public CommonResult<Boolean> deleteRole(@RequestParam("id") Long id) {
roleService.deleteRole(id);
return success(true);
}
@ApiOperation("获得角色信息")
@GetMapping("/get")
// @PreAuthorize("@ss.hasPermi('system:role:query')")
@ApiOperation("获得角色信息")
@PreAuthorize("@ss.hasPermission('system:role:query')")
public CommonResult<SysRoleRespVO> getRole(@RequestParam("id") Long id) {
SysRoleDO role = roleService.getRole(id);
return success(SysRoleConvert.INSTANCE.convert(role));
}
@ApiOperation("修改角色状态")
@PostMapping("/update-status")
// @PreAuthorize("@ss.hasPermi('system:role:edit')")
// @Log(title = "角色管理", businessType = BusinessType.UPDATE)
public CommonResult<Boolean> updateRoleStatus(@Validated @RequestBody SysRoleUpdateStatusReqVO reqVO) {
roleService.updateRoleStatus(reqVO.getId(), reqVO.getStatus());
return success(true);
@GetMapping("/page")
@ApiOperation("获得角色分页")
@PreAuthorize("@ss.hasPermission('system:role:query')")
public CommonResult<PageResult<SysRoleDO>> getRolePage(SysRolePageReqVO reqVO) {
return success(roleService.getRolePage(reqVO));
}
@GetMapping("/list-all-simple")
@ApiOperation(value = "获取角色精简信息列表", notes = "只包含被开启的角色，主要用于前端的下拉选项")
public CommonResult<List<SysRoleSimpleRespVO>> getSimpleRoles() {
// 获得角色列表，只要开启状态的
List<SysRoleDO> list = roleService.getRoles(Collections.singleton(CommonStatusEnum.ENABLE.getStatus()));
// 排序后，返回个诶前端
list.sort(Comparator.comparing(SysRoleDO::getSort));
return success(SysRoleConvert.INSTANCE.convertList02(list));
}
@GetMapping("/export")
// @Log(title = "角色管理", businessType = BusinessType.EXPORT)
// @PreAuthorize("@ss.hasPermi('system:role:export')")
@OperateLog(type = EXPORT)
@PreAuthorize("@ss.hasPermission('system:role:export')")
public void export(HttpServletResponse response, @Validated SysRoleExportReqVO reqVO) throws IOException {
List<SysRoleDO> list = roleService.listRoles(reqVO);
List<SysRoleExcelVO> excelDataList = SysRoleConvert.INSTANCE.convertList03(list);
List<SysRoleDO> list = roleService.getRoles(reqVO);
List<SysRoleExcelVO> data = SysRoleConvert.INSTANCE.convertList03(list);
// 输出
ExcelUtils.write(response, "角色数据.xls", "角色列表",
SysRoleExcelVO.class, excelDataList);
ExcelUtils.write(response, "角色数据.xls", "角色列表", SysRoleExcelVO.class, data);
}
}

121
src/main/java/cn/iocoder/dashboard/modules/system/controller/user/SysUserController.java
View File

@ -5,6 +5,7 @@ import cn.iocoder.dashboard.common.enums.CommonStatusEnum;
import cn.iocoder.dashboard.common.pojo.CommonResult;
import cn.iocoder.dashboard.common.pojo.PageResult;
import cn.iocoder.dashboard.framework.excel.core.util.ExcelUtils;
import cn.iocoder.dashboard.framework.logger.operatelog.core.annotations.OperateLog;
import cn.iocoder.dashboard.modules.system.controller.user.vo.user.*;
import cn.iocoder.dashboard.modules.system.convert.user.SysUserConvert;
import cn.iocoder.dashboard.modules.system.dal.dataobject.dept.SysDeptDO;
@ -25,14 +26,17 @@ import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.io.IOException;
import java.util.*;
import static cn.iocoder.dashboard.common.pojo.CommonResult.success;
import static cn.iocoder.dashboard.framework.logger.operatelog.core.enums.OperateTypeEnum.EXPORT;
@Api(tags = "用户")
@RestController
@RequestMapping("/system/user")
@Validated
public class SysUserController {
@Resource
@ -40,12 +44,53 @@ public class SysUserController {
@Resource
private SysDeptService deptService;
@PostMapping("/create")
@ApiOperation("新增用户")
@PreAuthorize("@ss.hasPermission('system:user:create')")
public CommonResult<Long> createUser(@Valid @RequestBody SysUserCreateReqVO reqVO) {
Long id = userService.createUser(reqVO);
return success(id);
}
@PutMapping("update")
@ApiOperation("修改用户")
@PreAuthorize("@ss.hasPermission('system:user:update')")
public CommonResult<Boolean> updateUser(@Valid @RequestBody SysUserUpdateReqVO reqVO) {
userService.updateUser(reqVO);
return success(true);
}
@DeleteMapping("/delete")
@ApiOperation("删除用户")
@ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
@PreAuthorize("@ss.hasPermission('system:user:delete')")
public CommonResult<Boolean> deleteUser(@RequestParam("id") Long id) {
userService.deleteUser(id);
return success(true);
}
@PutMapping("/update-password")
@ApiOperation("重置用户密码")
@PreAuthorize("@ss.hasPermission('system:user:update-password')")
public CommonResult<Boolean> updateUserPassword(@Valid @RequestBody SysUserUpdatePasswordReqVO reqVO) {
userService.updateUserPassword(reqVO.getId(), reqVO.getPassword());
return success(true);
}
@PutMapping("/update-status")
@ApiOperation("修改用户状态")
@PreAuthorize("@ss.hasPermission('system:user:update')")
public CommonResult<Boolean> updateUserStatus(@Valid @RequestBody SysUserUpdateStatusReqVO reqVO) {
userService.updateUserStatus(reqVO.getId(), reqVO.getStatus());
return success(true);
}
@GetMapping("/page")
@ApiOperation("获得用户分页列表")
@PreAuthorize("@ss.hasPermission('system:user:list')")
public CommonResult<PageResult<SysUserPageItemRespVO>> pageUsers(@Validated SysUserPageReqVO reqVO) {
public CommonResult<PageResult<SysUserPageItemRespVO>> getUserPage(@Valid SysUserPageReqVO reqVO) {
// 获得用户分页列表
PageResult<SysUserDO> pageResult = userService.pageUsers(reqVO);
PageResult<SysUserDO> pageResult = userService.getUserPage(reqVO);
if (CollUtil.isEmpty(pageResult.getList())) {
return success(new PageResult<>(pageResult.getTotal())); // 返回空
}
@ -63,71 +108,22 @@ public class SysUserController {
return success(new PageResult<>(userList, pageResult.getTotal()));
}
/**
* 根据用户编号获取详细信息
*/
@GetMapping("/get")
@ApiOperation("获得用户详情")
@ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
// @PreAuthorize("@ss.hasPermi('system:user:query')")
@PreAuthorize("@ss.hasPermission('system:user:query')")
public CommonResult<SysUserRespVO> getInfo(@RequestParam("id") Long id) {
return success(SysUserConvert.INSTANCE.convert(userService.getUser(id)));
}
@ApiOperation("新增用户")
@PostMapping("/create")
// @PreAuthorize("@ss.hasPermi('system:user:add')")
// @Log(title = "用户管理", businessType = BusinessType.INSERT)
public CommonResult<Long> createUser(@Validated @RequestBody SysUserCreateReqVO reqVO) {
Long id = userService.createUser(reqVO);
return success(id);
}
@ApiOperation("修改用户")
@PostMapping("update")
// @PreAuthorize("@ss.hasPermi('system:user:edit')")
// @Log(title = "用户管理", businessType = BusinessType.UPDATE)
public CommonResult<Boolean> updateUser(@Validated @RequestBody SysUserUpdateReqVO reqVO) {
userService.updateUser(reqVO);
return success(true);
}
@ApiOperation("删除用户")
@ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
@PostMapping("/delete")
// @PreAuthorize("@ss.hasPermi('system:user:remove')")
// @Log(title = "用户管理", businessType = BusinessType.DELETE)
public CommonResult<Boolean> deleteUser(@RequestParam("id") Long id) {
userService.deleteUser(id);
return success(true);
}
@ApiOperation("重置用户密码")
@PostMapping("/update-password")
// @PreAuthorize("@ss.hasPermi('system:user:resetPwd')")
// @Log(title = "用户管理", businessType = BusinessType.UPDATE)
public CommonResult<Boolean> updateUserPassword(@Validated @RequestBody SysUserUpdatePasswordReqVO reqVO) {
userService.updateUserPassword(reqVO.getId(), reqVO.getPassword());
return success(true);
}
@ApiOperation("修改用户状态")
@PostMapping("/update-status")
// @PreAuthorize("@ss.hasPermi('system:user:edit')")
// @Log(title = "用户管理", businessType = BusinessType.UPDATE)
public CommonResult<Boolean> updateUserStatus(@Validated @RequestBody SysUserUpdateStatusReqVO reqVO) {
userService.updateUserStatus(reqVO.getId(), reqVO.getStatus());
return success(true);
}
@ApiOperation("导出用户")
@GetMapping("/export")
// @PreAuthorize("@ss.hasPermi('system:user:export')") , @Validated SysUserExportReqVO reqVO
// @Log(title = "用户管理", businessType = BusinessType.EXPORT)
@ApiOperation("导出用户")
@PreAuthorize("@ss.hasPermission('system:user:export')")
@OperateLog(type = EXPORT)
public void exportUsers(@Validated SysUserExportReqVO reqVO,
HttpServletResponse response) throws IOException {
// 获得用户列表
List<SysUserDO> users = userService.listUsers(reqVO);
List<SysUserDO> users = userService.getUsers(reqVO);
// 获得拼接需要的数据
Collection<Long> deptIds = CollectionUtils.convertList(users, SysUserDO::getDeptId);
@ -147,8 +143,8 @@ public class SysUserController {
ExcelUtils.write(response, "用户数据.xls", "用户列表", SysUserExcelVO.class, excelUsers);
}
@ApiOperation("获得导入用户模板")
@GetMapping("/get-import-template")
@ApiOperation("获得导入用户模板")
public void importTemplate(HttpServletResponse response) throws IOException {
// 手动创建导出 demo
List<SysUserImportExcelVO> list = Arrays.asList(
@ -159,21 +155,18 @@ public class SysUserController {
);
// 输出
ExcelUtils.write(response, "用户导入模板.xls", "用户列表",
SysUserImportExcelVO.class, list);
ExcelUtils.write(response, "用户导入模板.xls", "用户列表", SysUserImportExcelVO.class, list);
}
@PostMapping("/import")
@ApiOperation("导入用户")
@ApiImplicitParams({
@ApiImplicitParam(name = "file", value = "Excel 文件", required = true, dataTypeClass = MultipartFile.class),
@ApiImplicitParam(name = "updateSupport", value = "是否支持更新，默认为 false", example = "true", dataTypeClass = Boolean.class)
})
@PostMapping("/import")
// @Log(title = "用户管理", businessType = BusinessType.IMPORT)
// @PreAuthorize("@ss.hasPermi('system:user:import')")
@PreAuthorize("@ss.hasPermission('system:user:import')")
public CommonResult<SysUserImportRespVO> importExcel(@RequestParam("file") MultipartFile file,
@RequestParam(value = "updateSupport", required = false, defaultValue = "false") Boolean updateSupport) throws Exception {
@RequestParam(value = "updateSupport", required = false, defaultValue = "false") Boolean updateSupport) throws Exception {
List<SysUserImportExcelVO> list = ExcelUtils.raed(file, SysUserImportExcelVO.class);
return success(userService.importUsers(list, updateSupport));
}

20
src/main/java/cn/iocoder/dashboard/modules/system/controller/user/SysUserProfileController.java
View File

@ -16,12 +16,7 @@ import cn.iocoder.dashboard.util.collection.CollectionUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
@ -55,26 +50,27 @@ public class SysUserProfileController {
Long userId = SecurityFrameworkUtils.getLoginUserId();
SysUserDO user = userService.getUser(userId);
SysUserProfileRespVO userProfileRespVO = SysUserConvert.INSTANCE.convert03(user);
List<SysRoleDO> userRoles = roleService.listRolesFromCache(permissionService.listUserRoleIs(userId));
List<SysRoleDO> userRoles = roleService.getRolesFromCache(permissionService.listUserRoleIs(userId));
userProfileRespVO.setRoles(CollectionUtils.convertSet(userRoles, SysUserConvert.INSTANCE::convert));
return success(userProfileRespVO);
}
@PostMapping("/update")
@PutMapping("/update")
@ApiOperation("修改用户个人信息")
public CommonResult<Boolean> updateProfile(@RequestBody SysUserProfileUpdateReqVO reqVO, HttpServletRequest request) {
public CommonResult<Boolean> updateUserProfile(@RequestBody SysUserProfileUpdateReqVO reqVO, HttpServletRequest request) {
userService.updateUserProfile(reqVO);
SecurityFrameworkUtils.setLoginUser(SysAuthConvert.INSTANCE.convert(reqVO), request);
return success(true);
}
@PostMapping("/upload-avatar")
@PutMapping("/upload-avatar")
@ApiOperation("上传用户个人头像")
public CommonResult<Boolean> uploadAvatar(@RequestParam("avatarFile") MultipartFile file) throws IOException {
public CommonResult<Boolean> updateUserAvatar(@RequestParam("avatarFile") MultipartFile file) throws IOException {
if (file.isEmpty()) {
throw ServiceExceptionUtil.exception(FILE_IS_EMPTY);
}
userService.updateAvatar(SecurityFrameworkUtils.getLoginUserId(), file.getInputStream());
userService.updateUserAvatar(SecurityFrameworkUtils.getLoginUserId(), file.getInputStream());
return success(true);
}
}

2
src/main/java/cn/iocoder/dashboard/modules/system/service/auth/impl/SysAuthServiceImpl.java
View File

@ -61,7 +61,7 @@ public class SysAuthServiceImpl implements SysAuthService {
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
// 获取 username 对应的 SysUserDO
SysUserDO user = userService.getUserByUserName(username);
SysUserDO user = userService.getUserByUsername(username);
if (user == null) {
throw new UsernameNotFoundException(username);
}

2
src/main/java/cn/iocoder/dashboard/modules/system/service/auth/impl/SysUserSessionServiceImpl.java
View File

@ -101,7 +101,7 @@ public class SysUserSessionServiceImpl implements SysUserSessionService {
// 处理基于用户昵称的查询
Collection<Long> userIds = null;
if (StrUtil.isNotEmpty(reqVO.getUsername())) {
userIds = convertSet(userService.listUsersByUsername(reqVO.getUsername()), SysUserDO::getId);
userIds = convertSet(userService.getUsersByUsername(reqVO.getUsername()), SysUserDO::getId);
if (CollUtil.isEmpty(userIds)) {
return PageResult.empty();
}

4
src/main/java/cn/iocoder/dashboard/modules/system/service/logger/impl/SysOperateLogServiceImpl.java
View File

@ -59,7 +59,7 @@ public class SysOperateLogServiceImpl implements SysOperateLogService {
// 处理基于用户昵称的查询
Collection<Long> userIds = null;
if (StrUtil.isNotEmpty(reqVO.getUserNickname())) {
userIds = convertSet(userService.listUsersByNickname(reqVO.getUserNickname()), SysUserDO::getId);
userIds = convertSet(userService.getUsersByNickname(reqVO.getUserNickname()), SysUserDO::getId);
if (CollUtil.isEmpty(userIds)) {
return PageResult.empty();
}
@ -73,7 +73,7 @@ public class SysOperateLogServiceImpl implements SysOperateLogService {
// 处理基于用户昵称的查询
Collection<Long> userIds = null;
if (StrUtil.isNotEmpty(reqVO.getUserNickname())) {
userIds = convertSet(userService.listUsersByNickname(reqVO.getUserNickname()), SysUserDO::getId);
userIds = convertSet(userService.getUsersByNickname(reqVO.getUserNickname()), SysUserDO::getId);
if (CollUtil.isEmpty(userIds)) {
return Collections.emptyList();
}

48
src/main/java/cn/iocoder/dashboard/modules/system/service/permission/SysMenuService.java
View File

@ -20,12 +20,34 @@ public interface SysMenuService {
*/
void initLocalCache();
/**
* 创建菜单
*
* @param reqVO 菜单信息
* @return 创建出来的菜单编号
*/
Long createMenu(SysMenuCreateReqVO reqVO);
/**
* 更新菜单
*
* @param reqVO 菜单信息
*/
void updateMenu(SysMenuUpdateReqVO reqVO);
/**
* 删除菜单
*
* @param id 菜单编号
*/
void deleteMenu(Long id);
/**
* 获得所有菜单列表
*
* @return 菜单列表
*/
List<SysMenuDO> listMenus();
List<SysMenuDO> getMenus();
/**
* 筛选菜单列表
@ -33,7 +55,7 @@ public interface SysMenuService {
* @param reqVO 筛选条件请求 VO
* @return 菜单列表
*/
List<SysMenuDO> listMenus(SysMenuListReqVO reqVO);
List<SysMenuDO> getMenus(SysMenuListReqVO reqVO);
/**
* 获得所有菜单，从缓存中
@ -67,28 +89,6 @@ public interface SysMenuService {
*/
List<SysMenuDO> getMenuListByPermissionFromCache(String permission);
/*
* 创建菜单
*
* @param reqVO 菜单信息
* @return 创建出来的菜单编号
*/
Long createMenu(SysMenuCreateReqVO reqVO);
/**
* 更新菜单
*
* @param reqVO 菜单信息
*/
void updateMenu(SysMenuUpdateReqVO reqVO);
/**
* 删除菜单
*
* @param id 菜单编号
*/
void deleteMenu(Long id);
/**
* 获得菜单
*

132
src/main/java/cn/iocoder/dashboard/modules/system/service/permission/SysRoleService.java
View File

@ -24,48 +24,6 @@ public interface SysRoleService {
*/
void initLocalCache();
/**
* 获得角色，从缓存中
*
* @param id 角色编号
* @return 角色
*/
SysRoleDO getRoleFromCache(Long id);
/**
* 获得角色列表
*
* @param statuses 筛选的状态。允许空，空时不筛选
* @return 角色列表
*/
List<SysRoleDO> listRoles(@Nullable Collection<Integer> statuses);
/**
* 获得角色数组，从缓存中
*
* @param ids 角色编号数组
* @return 角色数组
*/
List<SysRoleDO> listRolesFromCache(Collection<Long> ids);
/**
* 判断角色数组中，是否有管理员
*
* @param roleList 角色数组
* @return 是否有管理员
*/
boolean hasAnyAdmin(Collection<SysRoleDO> roleList);
/**
* 判断角色编号数组中，是否有管理员
*
* @param ids 角色编号数组
* @return 是否有管理员
*/
default boolean hasAnyAdmin(Set<Long> ids) {
return hasAnyAdmin(listRolesFromCache(ids));
}
/**
* 创建角色
*
@ -88,30 +46,6 @@ public interface SysRoleService {
*/
void deleteRole(Long id);
/**
* 获得角色
*
* @param id 角色编号
* @return 角色
*/
SysRoleDO getRole(Long id);
/**
* 获得角色分页
*
* @param reqVO 角色分页查询
* @return 角色分页结果
*/
PageResult<SysRoleDO> pageRole(SysRolePageReqVO reqVO);
/**
* 获得角色列表
*
* @param reqVO 列表查询
* @return 角色列表
*/
List<SysRoleDO> listRoles(SysRoleExportReqVO reqVO);
/**
* 更新角色状态
*
@ -129,4 +63,70 @@ public interface SysRoleService {
*/
void updateRoleDataScope(Long id, Integer dataScope, Set<Long> dataScopeDeptIds);
/**
* 获得角色，从缓存中
*
* @param id 角色编号
* @return 角色
*/
SysRoleDO getRoleFromCache(Long id);
/**
* 获得角色列表
*
* @param statuses 筛选的状态。允许空，空时不筛选
* @return 角色列表
*/
List<SysRoleDO> getRoles(@Nullable Collection<Integer> statuses);
/**
* 获得角色数组，从缓存中
*
* @param ids 角色编号数组
* @return 角色数组
*/
List<SysRoleDO> getRolesFromCache(Collection<Long> ids);
/**
* 判断角色数组中，是否有管理员
*
* @param roleList 角色数组
* @return 是否有管理员
*/
boolean hasAnyAdmin(Collection<SysRoleDO> roleList);
/**
* 判断角色编号数组中，是否有管理员
*
* @param ids 角色编号数组
* @return 是否有管理员
*/
default boolean hasAnyAdmin(Set<Long> ids) {
return hasAnyAdmin(getRolesFromCache(ids));
}
/**
* 获得角色
*
* @param id 角色编号
* @return 角色
*/
SysRoleDO getRole(Long id);
/**
* 获得角色分页
*
* @param reqVO 角色分页查询
* @return 角色分页结果
*/
PageResult<SysRoleDO> getRolePage(SysRolePageReqVO reqVO);
/**
* 获得角色列表
*
* @param reqVO 列表查询
* @return 角色列表
*/
List<SysRoleDO> getRoles(SysRoleExportReqVO reqVO);
}

80
src/main/java/cn/iocoder/dashboard/modules/system/service/permission/impl/SysMenuServiceImpl.java
View File

@ -127,46 +127,6 @@ public class SysMenuServiceImpl implements SysMenuService {
return menuMapper.selectList();
}
@Override
public List<SysMenuDO> listMenus() {
return menuMapper.selectList();
}
@Override
public List<SysMenuDO> listMenus(SysMenuListReqVO reqVO) {
return menuMapper.selectList(reqVO);
}
@Override
public List<SysMenuDO> listMenusFromCache(Collection<Integer> menuTypes, Collection<Integer> menusStatuses) {
// 任一一个参数为空，则返回空
if (CollectionUtils.isAnyEmpty(menuTypes, menusStatuses)) {
return Collections.emptyList();
}
// 创建新数组，避免缓存被修改
return menuCache.values().stream().filter(menu -> menuTypes.contains(menu.getType())
&& menusStatuses.contains(menu.getStatus()))
.collect(Collectors.toList());
}
@Override
public List<SysMenuDO> listMenusFromCache(Collection<Long> menuIds, Collection<Integer> menuTypes,
Collection<Integer> menusStatuses) {
// 任一一个参数为空，则返回空
if (CollectionUtils.isAnyEmpty(menuIds, menuTypes, menusStatuses)) {
return Collections.emptyList();
}
return menuCache.values().stream().filter(menu -> menuIds.contains(menu.getId())
&& menuTypes.contains(menu.getType())
&& menusStatuses.contains(menu.getStatus()))
.collect(Collectors.toList());
}
@Override
public List<SysMenuDO> getMenuListByPermissionFromCache(String permission) {
return new ArrayList<>(permissionMenuCache.get(permission));
}
@Override
public Long createMenu(SysMenuCreateReqVO reqVO) {
// 校验父菜单存在
@ -235,6 +195,46 @@ public class SysMenuServiceImpl implements SysMenuService {
});
}
@Override
public List<SysMenuDO> getMenus() {
return menuMapper.selectList();
}
@Override
public List<SysMenuDO> getMenus(SysMenuListReqVO reqVO) {
return menuMapper.selectList(reqVO);
}
@Override
public List<SysMenuDO> listMenusFromCache(Collection<Integer> menuTypes, Collection<Integer> menusStatuses) {
// 任一一个参数为空，则返回空
if (CollectionUtils.isAnyEmpty(menuTypes, menusStatuses)) {
return Collections.emptyList();
}
// 创建新数组，避免缓存被修改
return menuCache.values().stream().filter(menu -> menuTypes.contains(menu.getType())
&& menusStatuses.contains(menu.getStatus()))
.collect(Collectors.toList());
}
@Override
public List<SysMenuDO> listMenusFromCache(Collection<Long> menuIds, Collection<Integer> menuTypes,
Collection<Integer> menusStatuses) {
// 任一一个参数为空，则返回空
if (CollectionUtils.isAnyEmpty(menuIds, menuTypes, menusStatuses)) {
return Collections.emptyList();
}
return menuCache.values().stream().filter(menu -> menuIds.contains(menu.getId())
&& menuTypes.contains(menu.getType())
&& menusStatuses.contains(menu.getStatus()))
.collect(Collectors.toList());
}
@Override
public List<SysMenuDO> getMenuListByPermissionFromCache(String permission) {
return new ArrayList<>(permissionMenuCache.get(permission));
}
@Override
public SysMenuDO getMenu(Long id) {
return menuMapper.selectById(id);

6
src/main/java/cn/iocoder/dashboard/modules/system/service/permission/impl/SysPermissionServiceImpl.java
View File

@ -140,7 +140,7 @@ public class SysPermissionServiceImpl implements SysPermissionService {
return Collections.emptyList();
}
// 判断角色是否包含管理员
List<SysRoleDO> roleList = roleService.listRolesFromCache(roleIds);
List<SysRoleDO> roleList = roleService.getRolesFromCache(roleIds);
boolean hasAdmin = roleService.hasAnyAdmin(roleList);
// 获得角色拥有的菜单关联
if (hasAdmin) { // 管理员，获取到全部
@ -168,7 +168,7 @@ public class SysPermissionServiceImpl implements SysPermissionService {
// 如果是管理员的情况下，获取全部菜单编号
SysRoleDO role = roleService.getRole(roleId);
if (roleService.hasAnyAdmin(Collections.singletonList(role))) {
return CollectionUtils.convertSet(menuService.listMenus(), SysMenuDO::getId);
return CollectionUtils.convertSet(menuService.getMenus(), SysMenuDO::getId);
}
// 如果是非管理员的情况下，获得拥有的菜单编号
return CollectionUtils.convertSet(roleMenuMapper.selectListByRoleId(roleId),
@ -305,7 +305,7 @@ public class SysPermissionServiceImpl implements SysPermissionService {
if (roleService.hasAnyAdmin(roleIds)) {
return true;
}
Set<String> userRoles = CollectionUtils.convertSet(roleService.listRolesFromCache(roleIds),
Set<String> userRoles = CollectionUtils.convertSet(roleService.getRolesFromCache(roleIds),
SysRoleDO::getCode);
return CollUtil.containsAny(userRoles, Sets.newHashSet(roles));
}

132
src/main/java/cn/iocoder/dashboard/modules/system/service/permission/impl/SysRoleServiceImpl.java
View File

@ -118,33 +118,6 @@ public class SysRoleServiceImpl implements SysRoleService {
return roleMapper.selectList();
}
@Override
public SysRoleDO getRoleFromCache(Long id) {
return roleCache.get(id);
}
@Override
public List<SysRoleDO> listRoles(@Nullable Collection<Integer> statuses) {
return roleMapper.selectListByStatus(statuses);
}
@Override
public List<SysRoleDO> listRolesFromCache(Collection<Long> ids) {
if (CollectionUtil.isEmpty(ids)) {
return Collections.emptyList();
}
return roleCache.values().stream().filter(roleDO -> ids.contains(roleDO.getId()))
.collect(Collectors.toList());
}
@Override
public boolean hasAnyAdmin(Collection<SysRoleDO> roleList) {
if (CollectionUtil.isEmpty(roleList)) {
return false;
}
return roleList.stream().anyMatch(roleDO -> RoleCodeEnum.ADMIN.getKey().equals(roleDO.getCode()));
}
@Override
public Long createRole(SysRoleCreateReqVO reqVO) {
// 校验角色
@ -173,41 +146,6 @@ public class SysRoleServiceImpl implements SysRoleService {
roleProducer.sendRoleRefreshMessage();
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteRole(Long id) {
// 校验是否可以更新
this.checkUpdateRole(id);
// 标记删除
roleMapper.deleteById(id);
// 删除相关数据
permissionService.processRoleDeleted(id);
// 发送刷新消息. 注意，需要事务提交后，在进行发送刷新消息。不然 db 还未提交，结果缓存先刷新了
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCommit() {
roleProducer.sendRoleRefreshMessage();
}
});
}
@Override
public SysRoleDO getRole(Long id) {
return roleMapper.selectById(id);
}
@Override
public PageResult<SysRoleDO> pageRole(SysRolePageReqVO reqVO) {
return roleMapper.selectPage(reqVO);
}
@Override
public List<SysRoleDO> listRoles(SysRoleExportReqVO reqVO) {
return roleMapper.listRoles(reqVO);
}
@Override
public void updateRoleStatus(Long id, Integer status) {
// 校验是否可以更新
@ -235,6 +173,68 @@ public class SysRoleServiceImpl implements SysRoleService {
roleProducer.sendRoleRefreshMessage();
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteRole(Long id) {
// 校验是否可以更新
this.checkUpdateRole(id);
// 标记删除
roleMapper.deleteById(id);
// 删除相关数据
permissionService.processRoleDeleted(id);
// 发送刷新消息. 注意，需要事务提交后，在进行发送刷新消息。不然 db 还未提交，结果缓存先刷新了
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCommit() {
roleProducer.sendRoleRefreshMessage();
}
});
}
@Override
public SysRoleDO getRoleFromCache(Long id) {
return roleCache.get(id);
}
@Override
public List<SysRoleDO> getRoles(@Nullable Collection<Integer> statuses) {
return roleMapper.selectListByStatus(statuses);
}
@Override
public List<SysRoleDO> getRolesFromCache(Collection<Long> ids) {
if (CollectionUtil.isEmpty(ids)) {
return Collections.emptyList();
}
return roleCache.values().stream().filter(roleDO -> ids.contains(roleDO.getId()))
.collect(Collectors.toList());
}
@Override
public boolean hasAnyAdmin(Collection<SysRoleDO> roleList) {
if (CollectionUtil.isEmpty(roleList)) {
return false;
}
return roleList.stream().anyMatch(roleDO -> RoleCodeEnum.ADMIN.getKey().equals(roleDO.getCode()));
}
@Override
public SysRoleDO getRole(Long id) {
return roleMapper.selectById(id);
}
@Override
public PageResult<SysRoleDO> getRolePage(SysRolePageReqVO reqVO) {
return roleMapper.selectPage(reqVO);
}
@Override
public List<SysRoleDO> getRoles(SysRoleExportReqVO reqVO) {
return roleMapper.listRoles(reqVO);
}
/**
* 校验角色的唯一字段是否重复
*
@ -278,16 +278,10 @@ public class SysRoleServiceImpl implements SysRoleService {
}
}
// /**
// * 根据条件分页查询角色数据
// *
// * @param role 角色信息
// * @return 角色数据集合信息
// */
// @Override
// @DataScope(deptAlias = "d")
// public List<SysRole> selectRoleList(SysRole role) {
// return roleMapper.selectRoleList(role);
// }
}

204
src/main/java/cn/iocoder/dashboard/modules/system/service/user/SysUserService.java
View File

@ -2,13 +2,7 @@ package cn.iocoder.dashboard.modules.system.service.user;
import cn.hutool.core.collection.CollUtil;
import cn.iocoder.dashboard.common.pojo.PageResult;
import cn.iocoder.dashboard.modules.system.controller.user.vo.user.SysUserCreateReqVO;
import cn.iocoder.dashboard.modules.system.controller.user.vo.user.SysUserExportReqVO;
import cn.iocoder.dashboard.modules.system.controller.user.vo.user.SysUserImportExcelVO;
import cn.iocoder.dashboard.modules.system.controller.user.vo.user.SysUserImportRespVO;
import cn.iocoder.dashboard.modules.system.controller.user.vo.user.SysUserPageReqVO;
import cn.iocoder.dashboard.modules.system.controller.user.vo.user.SysUserProfileUpdateReqVO;
import cn.iocoder.dashboard.modules.system.controller.user.vo.user.SysUserUpdateReqVO;
import cn.iocoder.dashboard.modules.system.controller.user.vo.user.*;
import cn.iocoder.dashboard.modules.system.dal.dataobject.user.SysUserDO;
import cn.iocoder.dashboard.util.collection.CollectionUtils;
@ -25,75 +19,6 @@ import java.util.Map;
*/
public interface SysUserService {
/**
* 通过用户名查询用户
*
* @param username 用户名
* @return 用户对象信息
*/
SysUserDO getUserByUserName(String username);
/**
* 通过用户 ID 查询用户
*
* @param id 用户ID
* @return 用户对象信息
*/
SysUserDO getUser(Long id);
/**
* 获得用户分页列表
*
* @param reqVO 分页条件
* @return 分页列表
*/
PageResult<SysUserDO> pageUsers(SysUserPageReqVO reqVO);
/**
* 获得用户列表
*
* @param reqVO 列表请求
* @return 用户列表
*/
List<SysUserDO> listUsers(SysUserExportReqVO reqVO);
/**
* 获得用户列表
*
* @param ids 用户编号数组
* @return 用户列表
*/
List<SysUserDO> listUsers(Collection<Long> ids);
/**
* 获得用户 Map
*
* @param ids 用户编号数组
* @return 用户 Map
*/
default Map<Long, SysUserDO> getUserMap(Collection<Long> ids) {
if (CollUtil.isEmpty(ids)) {
return new HashMap<>();
}
return CollectionUtils.convertMap(listUsers(ids), SysUserDO::getId);
}
/**
* 获得用户列表，基于昵称模糊匹配
*
* @param nickname 昵称
* @return 用户列表
*/
List<SysUserDO> listUsersByNickname(String nickname);
/**
* 获得用户列表，基于用户账号模糊匹配
*
* @param username 用户账号
* @return 用户列表
*/
List<SysUserDO> listUsersByUsername(String username);
/**
* 创建用户
*
@ -113,16 +38,16 @@ public interface SysUserService {
* 修改用户个人信息
*
* @param reqVO 用户个人信息
* @return 修改结果
*/
void updateUserProfile(SysUserProfileUpdateReqVO reqVO);
/**
* 删除用户
* 更新用户头像
*
* @param id 用户编号
* @param id 用户 id
* @param avatarFile 头像文件
*/
void deleteUser(Long id);
void updateUserAvatar(Long id, InputStream avatarFile);
/**
* 修改密码
@ -140,6 +65,82 @@ public interface SysUserService {
*/
void updateUserStatus(Long id, Integer status);
/**
* 删除用户
*
* @param id 用户编号
*/
void deleteUser(Long id);
/**
* 通过用户名查询用户
*
* @param username 用户名
* @return 用户对象信息
*/
SysUserDO getUserByUsername(String username);
/**
* 通过用户 ID 查询用户
*
* @param id 用户ID
* @return 用户对象信息
*/
SysUserDO getUser(Long id);
/**
* 获得用户分页列表
*
* @param reqVO 分页条件
* @return 分页列表
*/
PageResult<SysUserDO> getUserPage(SysUserPageReqVO reqVO);
/**
* 获得用户列表
*
* @param reqVO 列表请求
* @return 用户列表
*/
List<SysUserDO> getUsers(SysUserExportReqVO reqVO);
/**
* 获得用户列表
*
* @param ids 用户编号数组
* @return 用户列表
*/
List<SysUserDO> getUsers(Collection<Long> ids);
/**
* 获得用户 Map
*
* @param ids 用户编号数组
* @return 用户 Map
*/
default Map<Long, SysUserDO> getUserMap(Collection<Long> ids) {
if (CollUtil.isEmpty(ids)) {
return new HashMap<>();
}
return CollectionUtils.convertMap(getUsers(ids), SysUserDO::getId);
}
/**
* 获得用户列表，基于昵称模糊匹配
*
* @param nickname 昵称
* @return 用户列表
*/
List<SysUserDO> getUsersByNickname(String nickname);
/**
* 获得用户列表，基于用户账号模糊匹配
*
* @param username 用户账号
* @return 用户列表
*/
List<SysUserDO> getUsersByUsername(String username);
/**
* 批量导入用户
*
@ -149,47 +150,4 @@ public interface SysUserService {
*/
SysUserImportRespVO importUsers(List<SysUserImportExcelVO> importUsers, boolean isUpdateSupport);
/**
* 更新用户头像
*
* @param id 用户 id
* @param avatarFile 头像文件
*/
void updateAvatar(Long id, InputStream avatarFile);
//
// /**
// * 修改用户基本信息
// *
// * @param user 用户信息
// * @return 结果
// */
// public int updateUserProfile(SysUser user);
//
// /**
// * 修改用户头像
// *
// * @param userName 用户名
// * @param avatar 头像地址
// * @return 结果
// */
// public boolean updateUserAvatar(String userName, String avatar);
//
// /**
// * 重置用户密码
// *
// * @param user 用户信息
// * @return 结果
// */
// public int resetPwd(SysUser user);
//
// /**
// * 重置用户密码
// *
// * @param userName 用户名
// * @param password 密码
// * @return 结果
// */
// public int resetUserPwd(String userName, String password);
}

140
src/main/java/cn/iocoder/dashboard/modules/system/service/user/SysUserServiceImpl.java
View File

@ -61,69 +61,16 @@ public class SysUserServiceImpl implements SysUserService {
private SysPostService postService;
@Resource
private SysPermissionService permissionService;
@Resource
private PasswordEncoder passwordEncoder;
@Resource
private InfFileService fileService;
@Override
public SysUserDO getUserByUserName(String username) {
return userMapper.selectByUsername(username);
}
@Override
public SysUserDO getUser(Long id) {
return userMapper.selectById(id);
}
@Override
public PageResult<SysUserDO> pageUsers(SysUserPageReqVO reqVO) {
return userMapper.selectPage(reqVO, this.getDeptCondition(reqVO.getDeptId()));
}
@Override
public List<SysUserDO> listUsers(SysUserExportReqVO reqVO) {
return userMapper.selectList(reqVO, this.getDeptCondition(reqVO.getDeptId()));
}
@Override
public List<SysUserDO> listUsers(Collection<Long> ids) {
return userMapper.selectBatchIds(ids);
}
@Override
public List<SysUserDO> listUsersByNickname(String nickname) {
return userMapper.selectListByNickname(nickname);
}
@Override
public List<SysUserDO> listUsersByUsername(String username) {
return userMapper.selectListByUsername(username);
}
/**
* 获得部门条件：查询指定部门的子部门编号们，包括自身
*
* @param deptId 部门编号
* @return 部门编号集合
*/
private Set<Long> getDeptCondition(Long deptId) {
if (deptId == null) {
return Collections.emptySet();
}
Set<Long> deptIds = CollectionUtils.convertSet(deptService.getDeptsByParentIdFromCache(
deptId, true), SysDeptDO::getId);
deptIds.add(deptId); // 包括自身
return deptIds;
}
@Override
public Long createUser(SysUserCreateReqVO reqVO) {
// 校验正确性
this.checkCreateOrUpdate(null, reqVO.getUsername(), reqVO.getMobile(), reqVO.getEmail(),
reqVO.getDeptId(), reqVO.getPostIds());
reqVO.getDeptId(), reqVO.getPostIds());
// 插入用户
SysUserDO user = SysUserConvert.INSTANCE.convert(reqVO);
user.setStatus(CommonStatusEnum.ENABLE.getStatus()); // 默认开启
@ -136,7 +83,7 @@ public class SysUserServiceImpl implements SysUserService {
public void updateUser(SysUserUpdateReqVO reqVO) {
// 校验正确性
this.checkCreateOrUpdate(reqVO.getId(), reqVO.getUsername(), reqVO.getMobile(), reqVO.getEmail(),
reqVO.getDeptId(), reqVO.getPostIds());
reqVO.getDeptId(), reqVO.getPostIds());
// 更新用户
SysUserDO updateObj = SysUserConvert.INSTANCE.convert(reqVO);
userMapper.updateById(updateObj);
@ -162,11 +109,15 @@ public class SysUserServiceImpl implements SysUserService {
}
@Override
public void deleteUser(Long id) {
// 校验用户存在
public void updateUserAvatar(Long id, InputStream avatarFile) {
this.checkUserExists(id);
// 删除用户
userMapper.deleteById(id);
// 存储文件
String avatar = fileService.createFile(IdUtil.fastUUID(), IoUtil.readBytes(avatarFile));
// 更新路径
SysUserDO sysUserDO = new SysUserDO();
sysUserDO.setId(id);
sysUserDO.setAvatar(avatar);
userMapper.updateById(sysUserDO);
}
@Override
@ -193,6 +144,65 @@ public class SysUserServiceImpl implements SysUserService {
permissionService.processUserDeleted(id);
}
@Override
public void deleteUser(Long id) {
// 校验用户存在
this.checkUserExists(id);
// 删除用户
userMapper.deleteById(id);
}
@Override
public SysUserDO getUserByUsername(String username) {
return userMapper.selectByUsername(username);
}
@Override
public SysUserDO getUser(Long id) {
return userMapper.selectById(id);
}
@Override
public PageResult<SysUserDO> getUserPage(SysUserPageReqVO reqVO) {
return userMapper.selectPage(reqVO, this.getDeptCondition(reqVO.getDeptId()));
}
@Override
public List<SysUserDO> getUsers(SysUserExportReqVO reqVO) {
return userMapper.selectList(reqVO, this.getDeptCondition(reqVO.getDeptId()));
}
@Override
public List<SysUserDO> getUsers(Collection<Long> ids) {
return userMapper.selectBatchIds(ids);
}
@Override
public List<SysUserDO> getUsersByNickname(String nickname) {
return userMapper.selectListByNickname(nickname);
}
@Override
public List<SysUserDO> getUsersByUsername(String username) {
return userMapper.selectListByUsername(username);
}
/**
* 获得部门条件：查询指定部门的子部门编号们，包括自身
*
* @param deptId 部门编号
* @return 部门编号集合
*/
private Set<Long> getDeptCondition(Long deptId) {
if (deptId == null) {
return Collections.emptySet();
}
Set<Long> deptIds = CollectionUtils.convertSet(deptService.getDeptsByParentIdFromCache(
deptId, true), SysDeptDO::getId);
deptIds.add(deptId); // 包括自身
return deptIds;
}
private void checkCreateOrUpdate(Long id, String username, String mobile, String email,
Long deptId, Set<Long> postIds) {
// 校验用户存在
@ -364,16 +374,4 @@ public class SysUserServiceImpl implements SysUserService {
return respVO;
}
@Override
public void updateAvatar(Long id, InputStream avatarFile) {
this.checkUserExists(id);
// 存储文件
String avatar = fileService.createFile(IdUtil.fastUUID(), IoUtil.readBytes(avatarFile));
// 更新路径
SysUserDO sysUserDO = new SysUserDO();
sysUserDO.setId(id);
sysUserDO.setAvatar(avatar);
userMapper.updateById(sysUserDO);
}
}

2
src/test/java/cn/iocoder/dashboard/modules/system/service/auth/SysAuthServiceImplTest.java
View File

@ -55,7 +55,7 @@ public class SysAuthServiceImplTest extends BaseDbUnitTest {
String username = randomString();
// mock 方法
SysUserDO user = randomUserDO(o -> o.setUsername(username));
when(userService.getUserByUserName(eq(username))).thenReturn(user);
when(userService.getUserByUsername(eq(username))).thenReturn(user);
// 调用
LoginUser loginUser = (LoginUser) authService.loadUserByUsername(username);