完成用户管理功能。

2026-03-13 11:36:23 +08:00
parent 8504fa121d
commit 112413f7d4
13 changed files with 420 additions and 50 deletions
--- a/src/main/java/com/niuan/erp/module/sys/controller/SysRoleController.java
+++ b/src/main/java/com/niuan/erp/module/sys/controller/SysRoleController.java
@@ -6,25 +6,33 @@ import com.niuan.erp.common.base.BaseDeleteBody;
 import com.niuan.erp.common.base.BasePageReqParams;
 import com.niuan.erp.common.base.BaseResult;
 import com.niuan.erp.common.base.BaseStatusBody;
-import com.niuan.erp.common.base.CommonValidateGroup.DeleteBatch;
-import com.niuan.erp.common.base.CommonValidateGroup.DeleteOne;
+import com.niuan.erp.common.base.CommonValidateGroup;
 import com.niuan.erp.module.sys.controller.dto.SysRoleDto;
+import com.niuan.erp.module.sys.controller.dto.SysRoleSelectDto;
 import com.niuan.erp.module.sys.entity.SysRole;
 import com.niuan.erp.module.sys.service.SysRoleService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.util.StringUtils;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;

+import java.util.List;
+
@RestController
@RequestMapping("/sys/sysrole")
@RequiredArgsConstructor
+@Tag(name = "系统角色管理", description = "系统角色的增删改查及状态管理")
 public class SysRoleController {

    private final SysRoleService sysRoleService;

    @GetMapping("/getSysRolePage")
+    @Operation(summary = "分页查询角色列表")
+    @PreAuthorize("hasAnyAuthority('sysrole:index')")
    public BaseResult<IPage<SysRoleDto>> getSysRolePage(BasePageReqParams dto, SysRoleDto searchParams) {
        var wrapper = new LambdaQueryWrapper<SysRole>();
        if (searchParams != null) {
@@ -35,31 +43,50 @@ public class SysRoleController {
        return BaseResult.successWithData(sysRoleService.getSysRolePage(dto, wrapper));
    }

+    @GetMapping("/getSysRoleSelectList")
+    @Operation(summary = "获取角色下拉列表")
+    @PreAuthorize("hasAnyAuthority('sysuser:index', 'sysuser:add', 'sysuser:edit')")
+    public BaseResult<List<SysRoleSelectDto>> getSysRoleSelectList() {
+        return BaseResult.successWithData(sysRoleService.getSysRoleSelectList());
+    }
+
    @PostMapping("/addSysRole")
+    @Operation(summary = "新增角色")
+    @PreAuthorize("hasAnyAuthority('sysrole:add')")
    public BaseResult<?> addSysRole(@Valid @RequestBody SysRoleDto dto) {
        sysRoleService.addSysRole(dto);
        return BaseResult.success();
    }

    @PostMapping("/updateSysRole")
+    @Operation(summary = "编辑角色")
+    @PreAuthorize("hasAnyAuthority('sysrole:edit')")
    public BaseResult<?> updateSysRole(@Valid @RequestBody SysRoleDto dto) {
        sysRoleService.updateSysRole(dto);
        return BaseResult.success();
    }

    @PostMapping("/deleteSysRole")
-    public BaseResult<?> deleteSysRole(@Validated(DeleteOne.class) @RequestBody BaseDeleteBody req) {
+    @Operation(summary = "删除角色")
+    @PreAuthorize("hasAnyAuthority('sysrole:remove')")
+    public BaseResult<?> deleteSysRole(
+            @Validated(CommonValidateGroup.DeleteOne.class) @RequestBody BaseDeleteBody req) {
        sysRoleService.deleteSysRole(req.id());
        return BaseResult.success();
    }

    @PostMapping("/deleteBatch")
-    public BaseResult<?> deleteBatch(@Validated(DeleteBatch.class) @RequestBody BaseDeleteBody req) {
+    @Operation(summary = "批量删除角色")
+    @PreAuthorize("hasAnyAuthority('sysrole:remove')")
+    public BaseResult<?> deleteBatch(
+            @Validated(CommonValidateGroup.DeleteBatch.class) @RequestBody BaseDeleteBody req) {
        sysRoleService.deleteBatch(req.ids());
        return BaseResult.success();
    }

    @PostMapping("/setStatus")
+    @Operation(summary = "修改角色状态")
+    @PreAuthorize("hasAnyAuthority('sysrole:enable', 'sysrole:disable')")
    public BaseResult<?> setStatus(@Valid @RequestBody BaseStatusBody req) {
        sysRoleService.setStatus(req.id(), req.status());
        return BaseResult.success();
--- a/src/main/java/com/niuan/erp/module/sys/controller/SysUserController.java
+++ b/src/main/java/com/niuan/erp/module/sys/controller/SysUserController.java
@@ -1,45 +1,85 @@
 package com.niuan.erp.module.sys.controller;

+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.niuan.erp.common.base.BaseDeleteBody;
 import com.niuan.erp.common.base.BasePageReqParams;
 import com.niuan.erp.common.base.BaseResult;
+import com.niuan.erp.common.base.BaseStatusBody;
 import com.niuan.erp.module.sys.controller.dto.SysUserDto;
+import com.niuan.erp.module.sys.controller.dto.SysUserSearchDto;
+import com.niuan.erp.module.sys.controller.dto.SysUserUpdateDto;
+import com.niuan.erp.module.sys.entity.SysUser;
 import com.niuan.erp.module.sys.service.SysUserService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.util.StringUtils;
 import org.springframework.web.bind.annotation.*;

-import java.util.List;
-
@RestController
@RequestMapping("/sys/sysuser")
@RequiredArgsConstructor
+@Tag(name = "系统用户管理", description = "系统用户的增删改查及状态管理")
 public class SysUserController {

    private final SysUserService userService;

    @GetMapping("/getSysUserPage")
-    public BaseResult<?> getUserPage(BasePageReqParams dto) {
-        return BaseResult.successWithData(userService.getUserPage(dto, null));
+    @Operation(summary = "分页查询用户列表")
+    @PreAuthorize("hasAnyAuthority('sysuser:index')")
+    public BaseResult<IPage<SysUserDto>> getUserPage(BasePageReqParams pageParams, SysUserSearchDto searchParams) {
+        var wrapper = new LambdaQueryWrapper<SysUser>();
+        if (searchParams != null) {
+            if (StringUtils.hasText(searchParams.loginName())) {
+                wrapper.like(SysUser::getLoginName, searchParams.loginName());
+            }
+            if (StringUtils.hasText(searchParams.userName())) {
+                wrapper.like(SysUser::getUserName, searchParams.userName());
+            }
+        }
+        return BaseResult.successWithData(userService.getUserPage(pageParams, wrapper));
    }

-    @PostMapping
-    public void addUser(@Valid @RequestBody SysUserDto dto) {
+    @PostMapping("/addSysUser")
+    @Operation(summary = "新增用户")
+    @PreAuthorize("hasAnyAuthority('sysuser:add')")
+    public BaseResult<?> addUser(@Valid @RequestBody SysUserDto dto) {
        userService.addUser(dto);
-    }
-
-    @PutMapping("/{id}")
-    public BaseResult<?> updateUser(@PathVariable Long id, @Valid @RequestBody SysUserDto dto) {
-        userService.updateUser(id, dto);
        return BaseResult.success();
    }

-    @DeleteMapping("/{id}")
-    public void deleteUser(@PathVariable Long id) {
-        userService.deleteUser(id);
+    @PostMapping("/updateSysUser")
+    @Operation(summary = "编辑用户")
+    @PreAuthorize("hasAnyAuthority('sysuser:edit')")
+    public BaseResult<?> updateUser(@Valid @RequestBody SysUserUpdateDto dto) {
+        userService.updateUser(dto.id(), dto.dto());
+        return BaseResult.success();
    }

-    @DeleteMapping("/batch")
-    public void deleteBatch(@RequestBody List<Long> ids) {
-        userService.deleteBatch(ids);
+    @PostMapping("/deleteSysUser")
+    @Operation(summary = "删除用户")
+    @PreAuthorize("hasAnyAuthority('sysuser:remove')")
+    public BaseResult<?> deleteUser(@Valid @RequestBody BaseDeleteBody req) {
+        userService.deleteUser(req.id());
+        return BaseResult.success();
+    }
+
+    @PostMapping("/deleteBatch")
+    @Operation(summary = "批量删除用户")
+    @PreAuthorize("hasAnyAuthority('sysuser:remove')")
+    public BaseResult<?> deleteBatch(@Valid @RequestBody BaseDeleteBody req) {
+        userService.deleteBatch(req.ids());
+        return BaseResult.success();
+    }
+
+    @PostMapping("/setStatus")
+    @Operation(summary = "修改用户状态")
+    @PreAuthorize("hasAnyAuthority('sysuser:enable', 'sysuser:disable')")
+    public BaseResult<?> setStatus(@Valid @RequestBody BaseStatusBody req) {
+        userService.setStatus(req.id(), req.status());
+        return BaseResult.success();
    }
 }
--- a/src/main/java/com/niuan/erp/module/sys/controller/dto/SysRoleDto.java
+++ b/src/main/java/com/niuan/erp/module/sys/controller/dto/SysRoleDto.java
@@ -15,5 +15,5 @@ public record SysRoleDto(
        Integer roleType,
        String roleName,
        String remark,
-        List<Long> channelIds
+        List<Long> permissionIds
 ) {}
--- a/src/main/java/com/niuan/erp/module/sys/controller/dto/SysUserDto.java
+++ b/src/main/java/com/niuan/erp/module/sys/controller/dto/SysUserDto.java
@@ -1,28 +1,94 @@
 package com.niuan.erp.module.sys.controller.dto;

-import java.time.LocalDateTime;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;

+import java.time.LocalDateTime;
+import java.util.List;
+
+@Schema(description = "系统用户 DTO")
 public record SysUserDto(
+        @Schema(description = "用户 ID")
        Long id,
+
+        @Schema(description = "状态: 0-禁用, 1-启用")
        Integer status,
+
+        @Schema(description = "创建时间")
        LocalDateTime createDate,
+
+        @Schema(description = "创建人 ID")
        Long createUserId,
+
+        @Schema(description = "创建人名称")
        String createUserName,
+
+        @Schema(description = "更新时间")
        LocalDateTime updateDate,
+
+        @Schema(description = "更新人 ID")
        Long updateUserId,
+
+        @Schema(description = "更新人名称")
        String updateUserName,
+
+        @Schema(description = "用户类型: 0-普通用户, 5-系统管理员")
+        @NotNull(message = "sys.sysuser.validate.user_type.not_null")
        Long userType,
+
+        @Schema(description = "登录账号")
+        @NotBlank(message = "sys.sysuser.validate.login_name.not_null")
        String loginName,
+
+        @Schema(description = "密码")
+        String passWord,
+
+        @Schema(description = "确认密码")
+        String confirmPassword,
+
+        @Schema(description = "姓名")
+        @NotBlank(message = "sys.sysuser.validate.user_name.not_null")
        String userName,
+
+        @Schema(description = "登录次数")
        Integer loginCount,
+
+        @Schema(description = "登录时间")
        LocalDateTime loginDate,
+
+        @Schema(description = "登录 IP")
        String loginIp,
+
+        @Schema(description = "项目 ID")
        Long projectId,
+
+        @Schema(description = "联系人")
        String contactPerson,
+
+        @Schema(description = "电话")
        String tel,
+
+        @Schema(description = "地址")
        String address,
+
+        @Schema(description = "客户标识")
        String customerMark,
+
+        @Schema(description = "是否客户: 0-否, 1-是")
        Integer isCustomer,
+
+        @Schema(description = "客户 ID")
        Integer customerId,
-        String openid
+
+        @Schema(description = "微信 openid")
+        String openid,
+
+        @Schema(description = "角色 ID 列表")
+        @NotEmpty(message = "sys.sysuser.validate.role_ids.not_null")
+        List<Long> roleIds,
+
+        @Schema(description = "角色名称列表(用于展示)")
+        String roleNames
 ) {}
--- a/src/main/java/com/niuan/erp/module/sys/entity/SysRole.java
+++ b/src/main/java/com/niuan/erp/module/sys/entity/SysRole.java
@@ -47,5 +47,5 @@ public class SysRole {
    private String remark;

    @TableField(exist = false)
-    private List<Long> channelIds;
+    private List<Long> permissionIds;
 }
--- a/src/main/java/com/niuan/erp/module/sys/mapper/UserRoleMapper.java
+++ b/src/main/java/com/niuan/erp/module/sys/mapper/UserRoleMapper.java
@@ -3,7 +3,14 @@ package com.niuan.erp.module.sys.mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.niuan.erp.module.sys.entity.UserRole;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;

@Mapper
 public interface UserRoleMapper extends BaseMapper<UserRole> {
+
+    @Select("SELECT RoleId FROM yy_usersrolemapping WHERE UserId = #{userId}")
+    List<Long> selectRoleIdsByUserId(@Param("userId") Long userId);
 }
--- a/src/main/java/com/niuan/erp/module/sys/service/SysRoleService.java
+++ b/src/main/java/com/niuan/erp/module/sys/service/SysRoleService.java
@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.niuan.erp.common.base.BasePageReqParams;
 import com.niuan.erp.module.sys.controller.dto.SysRoleDto;
+import com.niuan.erp.module.sys.controller.dto.SysRoleSelectDto;
 import com.niuan.erp.module.sys.entity.SysRole;

 import java.util.List;
@@ -22,4 +23,5 @@ public interface SysRoleService {

    void setStatus(Long id, Integer status);

+    List<SysRoleSelectDto> getSysRoleSelectList();
 }
--- a/src/main/java/com/niuan/erp/module/sys/service/SysUserService.java
+++ b/src/main/java/com/niuan/erp/module/sys/service/SysUserService.java
@@ -20,4 +20,5 @@ public interface SysUserService {

    void deleteBatch(List<Long> ids);

+    void setStatus(Long id, Integer status);
 }
--- a/src/main/java/com/niuan/erp/module/sys/service/impl/SysRoleServiceImpl.java
+++ b/src/main/java/com/niuan/erp/module/sys/service/impl/SysRoleServiceImpl.java
@@ -7,11 +7,12 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.niuan.erp.common.base.BasePageReqParams;
 import com.niuan.erp.common.utils.SecurityUtils;
 import com.niuan.erp.module.sys.controller.dto.SysRoleDto;
+import com.niuan.erp.module.sys.controller.dto.SysRoleSelectDto;
 import com.niuan.erp.module.sys.converter.SysRoleConverter;
+import com.niuan.erp.module.sys.entity.RolePermission;
 import com.niuan.erp.module.sys.entity.SysRole;
-import com.niuan.erp.module.sys.entity.SysRoleChannel;
-import com.niuan.erp.module.sys.mapper.SysChannelMapper;
-import com.niuan.erp.module.sys.mapper.SysRoleChannelMapper;
+import com.niuan.erp.module.sys.mapper.RolePermissionMapper;
+import com.niuan.erp.module.sys.mapper.SysPermissionMapper;
 import com.niuan.erp.module.sys.mapper.SysRoleMapper;
 import com.niuan.erp.module.sys.service.SysRoleService;
 import lombok.RequiredArgsConstructor;
@@ -29,15 +30,15 @@ public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> impl

    private final SysRoleConverter sysRoleConverter;

-    private final SysChannelMapper sysChannelMapper;
+    private final SysPermissionMapper sysPermissionMapper;

-    private final SysRoleChannelMapper sysRoleChannelMapper;
+    private final RolePermissionMapper rolePermissionMapper;

    @Override
    public IPage<SysRoleDto> getSysRolePage(BasePageReqParams dto, LambdaQueryWrapper<SysRole> wrapper) {
        IPage<SysRole> result = this.baseMapper.selectPage(new Page<>(dto.page(), dto.pageSize()), wrapper);
        result.getRecords().forEach(sysRole -> {
-            sysRole.setChannelIds(sysChannelMapper.selectChannelIdByRoleId(sysRole.getId()));
+            sysRole.setPermissionIds(sysPermissionMapper.selectPermissionIdByRoleId(sysRole.getId()));
        });
        return result.convert(sysRoleConverter::toDto);
    }
@@ -50,11 +51,16 @@ public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> impl
        entity.setCreateDate(LocalDateTime.now());
        entity.setStatus(1);
        this.baseMapper.insert(entity);
-        if (dto.channelIds() != null && !dto.channelIds().isEmpty()) {
-            List<SysRoleChannel> roleChannels = dto.channelIds().stream()
-                    .map(channelId -> SysRoleChannel.newRoleChannel(channelId, entity.getId()))
+        if (dto.permissionIds() != null && !dto.permissionIds().isEmpty()) {
+            List<RolePermission> rolePermissions = dto.permissionIds().stream()
+                    .map(permissionId -> {
+                        RolePermission rp = new RolePermission();
+                        rp.setRoleId(entity.getId());
+                        rp.setPermissionId(permissionId);
+                        return rp;
+                    })
                    .toList();
-            sysRoleChannelMapper.insert(roleChannels);
+            rolePermissionMapper.insert(rolePermissions);
        }
    }

@@ -65,14 +71,19 @@ public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> impl
        entity.setUpdateUserName(SecurityUtils.getUserName());
        entity.setUpdateDate(LocalDateTime.now());
        this.baseMapper.updateById(entity);
-        var roleChannelWrapper = new LambdaQueryWrapper<SysRoleChannel>();
-        roleChannelWrapper.eq(SysRoleChannel::getRoleId, entity.getId());
-        sysRoleChannelMapper.delete(roleChannelWrapper);
-        if (dto.channelIds() != null && !dto.channelIds().isEmpty()) {
-            List<SysRoleChannel> newChannels = dto.channelIds().stream()
-                    .map(id -> SysRoleChannel.newRoleChannel(id, entity.getId()))
+        var rolePermissionWrapper = new LambdaQueryWrapper<RolePermission>();
+        rolePermissionWrapper.eq(RolePermission::getRoleId, entity.getId());
+        rolePermissionMapper.delete(rolePermissionWrapper);
+        if (dto.permissionIds() != null && !dto.permissionIds().isEmpty()) {
+            List<RolePermission> newPermissions = dto.permissionIds().stream()
+                    .map(permissionId -> {
+                        RolePermission rp = new RolePermission();
+                        rp.setRoleId(entity.getId());
+                        rp.setPermissionId(permissionId);
+                        return rp;
+                    })
                    .toList();
-            sysRoleChannelMapper.insert(newChannels);
+            rolePermissionMapper.insert(newPermissions);
        }
    }

@@ -92,4 +103,14 @@ public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> impl
        entity.setStatus(status);
        this.baseMapper.updateById(entity);
    }
+
+    @Override
+    public List<SysRoleSelectDto> getSysRoleSelectList() {
+        LambdaQueryWrapper<SysRole> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(SysRole::getStatus, 1);
+        List<SysRole> roles = this.baseMapper.selectList(wrapper);
+        return roles.stream()
+                .map(role -> new SysRoleSelectDto(role.getId(), role.getRoleName()))
+                .toList();
+    }
 }
--- a/src/main/java/com/niuan/erp/module/sys/service/impl/SysUserServiceImpl.java
+++ b/src/main/java/com/niuan/erp/module/sys/service/impl/SysUserServiceImpl.java
@@ -5,21 +5,27 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.niuan.erp.common.base.BasePageReqParams;
+import com.niuan.erp.common.exception.BusinessException;
 import com.niuan.erp.common.utils.SecurityUtils;
 import com.niuan.erp.module.sys.controller.dto.SysUserDto;
 import com.niuan.erp.module.sys.converter.SysUserConverter;
+import com.niuan.erp.module.sys.entity.SysRole;
 import com.niuan.erp.module.sys.entity.SysUser;
+import com.niuan.erp.module.sys.entity.UserRole;
+import com.niuan.erp.module.sys.mapper.SysRoleMapper;
 import com.niuan.erp.module.sys.mapper.SysUserMapper;
 import com.niuan.erp.module.sys.mapper.UserRoleMapper;
-import com.niuan.erp.module.sys.service.SysRoleService;
 import com.niuan.erp.module.sys.service.SysUserService;
 import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;

 import java.time.LocalDateTime;
 import java.util.List;
-
+import java.util.stream.Collectors;

@Service
@Transactional
@@ -28,41 +34,228 @@ public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> impl

    private final SysUserConverter sysUserConverter;

-    private final SysRoleService sysRoleService;
+    private final UserRoleMapper userRoleMapper;

-    private final UserRoleMapper  userRoleMapper;
+    private final SysRoleMapper sysRoleMapper;
+
+    private final PasswordEncoder passwordEncoder;

    @Override
    public IPage<SysUserDto> getUserPage(BasePageReqParams dto, LambdaQueryWrapper<SysUser> wrapper) {
-        IPage<SysUser> result = this.baseMapper.selectPage(new Page<>(dto.page(), dto.pageSize()), null);
-        return result.convert(sysUserConverter::toDto);
+        IPage<SysUser> result = this.baseMapper.selectPage(new Page<>(dto.page(), dto.pageSize()), wrapper);
+        return result.convert(user -> {
+            SysUserDto userDto = sysUserConverter.toDto(user);
+
+            // 查询用户角色
+            List<Long> roleIds = userRoleMapper.selectRoleIdsByUserId(user.getId());
+
+            // 查询角色名称
+            if (!CollectionUtils.isEmpty(roleIds)) {
+                List<SysRole> roles = sysRoleMapper.selectBatchIds(roleIds);
+                String roleNames = roles.stream()
+                        .map(SysRole::getRoleName)
+                        .collect(Collectors.joining(", "));
+                return new SysUserDto(
+                        userDto.id(),
+                        userDto.status(),
+                        userDto.createDate(),
+                        userDto.createUserId(),
+                        userDto.createUserName(),
+                        userDto.updateDate(),
+                        userDto.updateUserId(),
+                        userDto.updateUserName(),
+                        userDto.userType(),
+                        userDto.loginName(),
+                        null, // 密码不返回
+                        null, // 确认密码不返回
+                        userDto.userName(),
+                        userDto.loginCount(),
+                        userDto.loginDate(),
+                        userDto.loginIp(),
+                        userDto.projectId(),
+                        userDto.contactPerson(),
+                        userDto.tel(),
+                        userDto.address(),
+                        userDto.customerMark(),
+                        userDto.isCustomer(),
+                        userDto.customerId(),
+                        userDto.openid(),
+                        roleIds,
+                        roleNames
+                );
+            }
+
+            return new SysUserDto(
+                    userDto.id(),
+                    userDto.status(),
+                    userDto.createDate(),
+                    userDto.createUserId(),
+                    userDto.createUserName(),
+                    userDto.updateDate(),
+                    userDto.updateUserId(),
+                    userDto.updateUserName(),
+                    userDto.userType(),
+                    userDto.loginName(),
+                    null, // 密码不返回
+                    null, // 确认密码不返回
+                    userDto.userName(),
+                    userDto.loginCount(),
+                    userDto.loginDate(),
+                    userDto.loginIp(),
+                    userDto.projectId(),
+                    userDto.contactPerson(),
+                    userDto.tel(),
+                    userDto.address(),
+                    userDto.customerMark(),
+                    userDto.isCustomer(),
+                    userDto.customerId(),
+                    userDto.openid(),
+                    roleIds,
+                    null
+            );
+        });
    }

    @Override
    public void addUser(SysUserDto dto) {
+        // 检查登录账号是否已存在
+        checkLoginNameExists(dto.loginName(), null);
+
+        // 密码校验
+        if (!StringUtils.hasText(dto.passWord())) {
+            throw new BusinessException("sys.sysuser.validate.password.not_null");
+        }
+        if (!dto.passWord().equals(dto.confirmPassword())) {
+            throw new BusinessException("sys.sysuser.validate.password.not_match");
+        }
+
        SysUser entity = sysUserConverter.toEntity(dto);
        entity.setCreateUserId(SecurityUtils.getUserId());
        entity.setCreateUserName(SecurityUtils.getUserName());
        entity.setCreateDate(LocalDateTime.now());
+        entity.setStatus(1);
+
+        // 密码加密
+        entity.setPassWord(passwordEncoder.encode(dto.passWord()));
+
        this.baseMapper.insert(entity);
+
+        // 保存用户角色关联
+        saveUserRoles(entity.getId(), dto.roleIds());
    }

    @Override
    public void updateUser(Long id, SysUserDto dto) {
+        SysUser existUser = this.baseMapper.selectById(id);
+        if (existUser == null) {
+            throw new BusinessException("sys.sysuser.exception.not_exists");
+        }
+
+        // 检查登录账号是否已存在
+        checkLoginNameExists(dto.loginName(), id);
+
        SysUser entity = sysUserConverter.toEntity(dto);
+        entity.setId(id);
        entity.setUpdateUserId(SecurityUtils.getUserId());
        entity.setUpdateUserName(SecurityUtils.getUserName());
        entity.setUpdateDate(LocalDateTime.now());
+
+        // 如果传了密码，则更新密码
+        if (StringUtils.hasText(dto.passWord())) {
+            if (!dto.passWord().equals(dto.confirmPassword())) {
+                throw new BusinessException("sys.sysuser.validate.password.not_match");
+            }
+            entity.setPassWord(passwordEncoder.encode(dto.passWord()));
+        } else {
+            // 不更新密码字段
+            entity.setPassWord(null);
+        }
+
        this.baseMapper.updateById(entity);
+
+        // 更新用户角色关联
+        updateUserRoles(id, dto.roleIds());
    }

    @Override
    public void deleteUser(Long id) {
+        // 删除用户角色关联
+        LambdaQueryWrapper<UserRole> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(UserRole::getUserId, id);
+        userRoleMapper.delete(wrapper);
+
+        // 删除用户
        this.baseMapper.deleteById(id);
    }

    @Override
    public void deleteBatch(List<Long> ids) {
+        if (CollectionUtils.isEmpty(ids)) {
+            return;
+        }
+
+        // 删除用户角色关联
+        LambdaQueryWrapper<UserRole> wrapper = new LambdaQueryWrapper<>();
+        wrapper.in(UserRole::getUserId, ids);
+        userRoleMapper.delete(wrapper);
+
+        // 删除用户
        this.baseMapper.deleteByIds(ids);
    }
+
+    @Override
+    public void setStatus(Long id, Integer status) {
+        SysUser user = this.baseMapper.selectById(id);
+        if (user == null) {
+            throw new BusinessException("sys.sysuser.exception.not_exists");
+        }
+
+        SysUser updateUser = new SysUser();
+        updateUser.setId(id);
+        updateUser.setStatus(status);
+        updateUser.setUpdateUserId(SecurityUtils.getUserId());
+        updateUser.setUpdateUserName(SecurityUtils.getUserName());
+        updateUser.setUpdateDate(LocalDateTime.now());
+
+        this.baseMapper.updateById(updateUser);
+    }
+
+    private void checkLoginNameExists(String loginName, Long excludeId) {
+        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(SysUser::getLoginName, loginName);
+        if (excludeId != null) {
+            wrapper.ne(SysUser::getId, excludeId);
+        }
+        Long count = this.baseMapper.selectCount(wrapper);
+        if (count > 0) {
+            throw new BusinessException("sys.sysuser.exception.login_name_exists");
+        }
+    }
+
+    private void saveUserRoles(Long userId, List<Long> roleIds) {
+        if (CollectionUtils.isEmpty(roleIds)) {
+            return;
+        }
+
+        List<UserRole> userRoles = roleIds.stream()
+                .map(roleId -> {
+                    UserRole userRole = new UserRole();
+                    userRole.setUserId(userId);
+                    userRole.setRoleId(roleId);
+                    return userRole;
+                })
+                .collect(Collectors.toList());
+
+        userRoleMapper.insert(userRoles);
+    }
+
+    private void updateUserRoles(Long userId, List<Long> roleIds) {
+        // 删除原有角色关联
+        LambdaQueryWrapper<UserRole> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(UserRole::getUserId, userId);
+        userRoleMapper.delete(wrapper);
+
+        // 保存新的角色关联
+        saveUserRoles(userId, roleIds);
+    }
 }
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -14,6 +14,7 @@ spring:
 # mybatis 设置
 mybatis-plus:
  type-aliases-package: com.niuan.erp.module.*.entity,com.niuan.erp.module.*.controller.dto,com.niuan.erp.common.base
+  mapper-locations: classpath*:mapper/**/*.xml
  configuration:
    map-underscore-to-camel-case: false
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
--- a/src/main/resources/i18n/messages_zh_CN.properties
+++ b/src/main/resources/i18n/messages_zh_CN.properties
@@ -194,3 +194,11 @@ purchase.purchase_order.exception.order_already_completed=采购订单已完成
 purchase.purchase_order.exception.item_not_exists=订单明细不存在
 purchase.purchase_order.exception.inbound_count_exceed=入库数量超过剩余待入库量
 purchase.purchase_order.exception.order_has_inbound=订单已入库，不能删除
+sys.sysuser.validate.user_type.not_null=用户类型不能为空
+sys.sysuser.validate.login_name.not_null=登录账号不能为空
+sys.sysuser.validate.user_name.not_null=姓名不能为空
+sys.sysuser.validate.password.not_null=密码不能为空
+sys.sysuser.validate.password.not_match=两次输入的密码不一致
+sys.sysuser.validate.role_ids.not_null=请至少选择一个角色
+sys.sysuser.exception.not_exists=用户不存在
+sys.sysuser.exception.login_name_exists=登录账号已存在
--- a/src/main/resources/mapper/sys/SysPermissionMapper.xml
+++ b/src/main/resources/mapper/sys/SysPermissionMapper.xml
@@ -34,4 +34,8 @@
        WHERE ur.UserId = #{userId} AND r.status = 1 AND p.status = 0
    </select>

+    <select id="selectPermissionIdByRoleId" parameterType="Long" resultType="Long">
+        SELECT permission_id FROM role_permission WHERE role_id = #{roleId}
+    </select>
+
 </mapper>