修改:<用户权限>

src/main/java/com/jtzx/crm/module/api/web/auth/AdminAuthController.java

@@ -16,7 +16,6 @@ import com.jtzx.crm.aspect.extension.SysLogAspectExtensionForSmsCodeLogin;
 import com.jtzx.crm.aspect.extension.SysLogAspectExtensionForSysUserAccountLogin;
 import com.jtzx.crm.aspect.extension.SysLogAspectExtensionForSysUserSmsCodeLogin;
 import com.jtzx.crm.helper.CaptchaHelper;
-import com.jtzx.crm.helper.RolePermissionCacheHelper;
 import com.jtzx.crm.module.api.constant.ApiConstant;
 import com.jtzx.crm.module.api.constant.LimitConstant;
 import com.jtzx.crm.module.api.constant.RedisConstant;
@@ -59,8 +58,6 @@ public class AdminAuthController {
 
     private final SysUserService sysUserService;
 
-    private final RolePermissionCacheHelper rolePermissionCacheHelper;
-
     private final CaptchaHelper captchaHelper;
 
     private final RedisTemplate<String, Object> stringSetRedisTemplate;
@@ -85,6 +82,7 @@ public class AdminAuthController {
         //计算封禁结束时间
         DateTime dateTime = DateUtil.offsetSecond(DateUtil.date(), LimitConstant.login_duration);
         resultData.setEndDateTime(DateUtil.formatDateTime(dateTime));
+
         //前两次不返回图形验证码，如果第三次还失败，就返回图形验证码
         if (LimitConstant.login_fail_count > 0 && resultData.getCommitCount() >= LimitConstant.login_fail_count) {
             resultData.setShowPicCode(true);
@@ -105,6 +103,7 @@ public class AdminAuthController {
         SysUserLoginBO userInfo = sysUserService.adminLogin(dto.getUsername(), dto.getPassword());
         if (userInfo == null || StrUtil.isEmpty(userInfo.getPhoneNo())) {
             resultData.setStatus(false);
+
             if(userInfo == null){
                 return ApiResult.data("账号或密码错误", resultData).setCode(401);
             }
@@ -114,6 +113,9 @@ public class AdminAuthController {
         }
         //设置手机号
         resultData.setMobile(userInfo.getPhoneNo());
+        resultData.setShowPicCode(false);
+        //返回图形验证码
+        resultData.setCaptchaVO(null);
 
         return ApiResult.data("登录成功", resultData);
     }
@@ -151,13 +153,13 @@ public class AdminAuthController {
                 }
             }
         }
-
         //账号密码查询用户信息
 //        SysUserLoginBO userInfo = this.getLoginUserInfo(dto.getMobile());
         SysUserLoginBO userInfo = sysUserService.adminLogin(dto.getUsername(), dto.getPassword());
         if (userInfo == null || StrUtil.isEmpty(userInfo.getPhoneNo()) || !userInfo.getPhoneNo().equals(dto.getMobile())) {
             resultData.setStatus(false);
 
+
             if (userInfo == null) {
                 //跳到账号密码登陆页面
                 return ApiResult.data("账号不存在", resultData).setCode(401);
@@ -177,8 +179,12 @@ public class AdminAuthController {
         SmsResponse smsResponse = SmsFactory.getSmsBlend().sendMessage(dto.getMobile(), messages);
         if (smsResponse.isSuccess()) {
             service.set(RedisConstant.SMS_CODE_PREFIX + dto.getMobile(), smsCode, RedisConstant.SMS_CODE_DURATION);
+            resultData.setShowPicCode(false);
+            //返回图形验证码
+            resultData.setCaptchaVO(null);
             return ApiResult.data("发送成功", resultData);
         }
+
         return ApiResult.data("发送失败", resultData).setCode(406);
 
     }
@@ -210,13 +216,11 @@ public class AdminAuthController {
                 }
             }
         }
-
         SysUserLoginBO userInfo = sysUserService.adminLogin(dto.getUsername(), dto.getPassword());
-
         Object cacheData = service.get(RedisConstant.SMS_CODE_PREFIX + dto.getMobile());
-
         if (userInfo == null || !userInfo.getPhoneNo().equals(dto.getMobile()) || cacheData == null) {
             resultData.setStatus(false);
+
             if (userInfo == null) {
                 //跳到账号密码登陆页面
                 return ApiResult.data("账号不存在", resultData).setCode(401);
@@ -260,6 +264,9 @@ public class AdminAuthController {
                 .permissions(userInfo.getPermissions())
                 .build();
         resultData.setTokenInfo(tokenInfo);
+        resultData.setShowPicCode(false);
+        //返回图形验证码
+        resultData.setCaptchaVO(null);
 
         return ApiResult.data("登录成功", resultData);
     }

src/main/java/com/jtzx/crm/module/api/web/sys/AdminSysMenuController.java

@@ -1,94 +1,94 @@
-package com.jtzx.crm.module.api.web.sys;
-
-import cc.uncarbon.framework.core.constant.HelioConstant;
-import cc.uncarbon.framework.web.model.request.IdsDTO;
-import cc.uncarbon.framework.web.model.response.ApiResult;
-import com.jtzx.crm.module.api.constant.ApiConstant;
-import com.jtzx.crm.module.sys.annotation.SysLog;
-import com.jtzx.crm.module.sys.model.request.AdminInsertOrUpdateSysMenuDTO;
-import com.jtzx.crm.module.sys.model.response.SysMenuBO;
-import com.jtzx.crm.module.sys.service.SysMenuService;
-import com.jtzx.crm.module.api.util.CrmAdminStpUtil;
-import cn.dev33.satoken.annotation.SaCheckLogin;
-import cn.dev33.satoken.annotation.SaCheckPermission;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import io.swagger.v3.oas.annotations.Operation;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.web.bind.annotation.*;
-
-import jakarta.validation.Valid;
-import java.util.List;
-
-
-@SaCheckLogin(type = CrmAdminStpUtil.TYPE)
-@Tag(name = "后台菜单管理接口")
-@RequestMapping(value = ApiConstant.HTTP_API_URL_PREFIX + "/api/v1")
-@RequiredArgsConstructor
-@RestController
-@Slf4j
-public class AdminSysMenuController {
-
-    private static final String PERMISSION_PREFIX = "SysMenu:";
-
-    private final SysMenuService sysMenuService;
-
-
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.RETRIEVE)
-    @Operation(summary = "列表")
-    @GetMapping(value = "/sys/menus")
-    public ApiResult<List<SysMenuBO>> list() {
-        return ApiResult.data(sysMenuService.adminList());
-    }
-
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.RETRIEVE)
-    @Operation(summary = "详情")
-    @GetMapping(value = "/sys/menus/{id}")
-    public ApiResult<SysMenuBO> getById(@PathVariable Long id) {
-        return ApiResult.data(sysMenuService.getOneById(id, true));
-    }
-
-    @SysLog(value = "新增后台菜单")
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.CREATE)
-    @Operation(summary = "新增")
-    @PostMapping(value = "/sys/menus")
-    public ApiResult<Void> insert(@RequestBody @Valid AdminInsertOrUpdateSysMenuDTO dto) {
-        sysMenuService.adminInsert(dto);
-
-        return ApiResult.success();
-    }
-
-    @SysLog(value = "编辑后台菜单")
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.UPDATE)
-    @Operation(summary = "编辑")
-    @PutMapping(value = "/sys/menus/{id}")
-    public ApiResult<Void> update(@PathVariable Long id, @RequestBody @Valid AdminInsertOrUpdateSysMenuDTO dto) {
-        dto.setId(id);
-        sysMenuService.adminUpdate(dto);
-
-        return ApiResult.success();
-    }
-
-    @SysLog(value = "删除后台菜单")
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.DELETE)
-    @Operation(summary = "删除")
-    @DeleteMapping(value = "/sys/menus")
-    public ApiResult<Void> delete(@RequestBody @Valid IdsDTO<Long> dto) {
-        sysMenuService.adminDelete(dto.getIds());
-
-        return ApiResult.success();
-    }
-
-    @Operation(summary = "取侧边菜单")
-    @GetMapping("/sys/menus/side")
-    public ApiResult<List<SysMenuBO>> adminListSideMenu() {
-        return ApiResult.data(sysMenuService.adminListSideMenu());
-    }
-
-    @Operation(summary = "取所有可见菜单")
-    @GetMapping("/sys/menus/all")
-    public ApiResult<List<SysMenuBO>> adminListVisibleMenu() {
-        return ApiResult.data(sysMenuService.adminListVisibleMenu());
-    }
-
-}
+//package com.jtzx.crm.module.api.web.sys;
+//
+//import cc.uncarbon.framework.core.constant.HelioConstant;
+//import cc.uncarbon.framework.web.model.request.IdsDTO;
+//import cc.uncarbon.framework.web.model.response.ApiResult;
+//import com.jtzx.crm.module.api.constant.ApiConstant;
+//import com.jtzx.crm.module.sys.annotation.SysLog;
+//import com.jtzx.crm.module.sys.model.request.AdminInsertOrUpdateSysMenuDTO;
+//import com.jtzx.crm.module.sys.model.response.SysMenuBO;
+//import com.jtzx.crm.module.sys.service.SysMenuService;
+//import com.jtzx.crm.module.api.util.CrmAdminStpUtil;
+//import cn.dev33.satoken.annotation.SaCheckLogin;
+//import cn.dev33.satoken.annotation.SaCheckPermission;
+//import io.swagger.v3.oas.annotations.tags.Tag;
+//import io.swagger.v3.oas.annotations.Operation;
+//import lombok.RequiredArgsConstructor;
+//import lombok.extern.slf4j.Slf4j;
+//import org.springframework.web.bind.annotation.*;
+//
+//import jakarta.validation.Valid;
+//import java.util.List;
+//
+//
+//@SaCheckLogin(type = CrmAdminStpUtil.TYPE)
+//@Tag(name = "后台菜单管理接口")
+//@RequestMapping(value = ApiConstant.HTTP_API_URL_PREFIX + "/api/v1")
+//@RequiredArgsConstructor
+//@RestController
+//@Slf4j
+//public class AdminSysMenuController {
+//
+//    private static final String PERMISSION_PREFIX = "SysMenu:";
+//
+//    private final SysMenuService sysMenuService;
+//
+//
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.RETRIEVE)
+//    @Operation(summary = "列表")
+//    @GetMapping(value = "/sys/menus")
+//    public ApiResult<List<SysMenuBO>> list() {
+//        return ApiResult.data(sysMenuService.adminList());
+//    }
+//
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.RETRIEVE)
+//    @Operation(summary = "详情")
+//    @GetMapping(value = "/sys/menus/{id}")
+//    public ApiResult<SysMenuBO> getById(@PathVariable Long id) {
+//        return ApiResult.data(sysMenuService.getOneById(id, true));
+//    }
+//
+//    @SysLog(value = "新增后台菜单")
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.CREATE)
+//    @Operation(summary = "新增")
+//    @PostMapping(value = "/sys/menus")
+//    public ApiResult<Void> insert(@RequestBody @Valid AdminInsertOrUpdateSysMenuDTO dto) {
+//        sysMenuService.adminInsert(dto);
+//
+//        return ApiResult.success();
+//    }
+//
+//    @SysLog(value = "编辑后台菜单")
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.UPDATE)
+//    @Operation(summary = "编辑")
+//    @PutMapping(value = "/sys/menus/{id}")
+//    public ApiResult<Void> update(@PathVariable Long id, @RequestBody @Valid AdminInsertOrUpdateSysMenuDTO dto) {
+//        dto.setId(id);
+//        sysMenuService.adminUpdate(dto);
+//
+//        return ApiResult.success();
+//    }
+//
+//    @SysLog(value = "删除后台菜单")
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.DELETE)
+//    @Operation(summary = "删除")
+//    @DeleteMapping(value = "/sys/menus")
+//    public ApiResult<Void> delete(@RequestBody @Valid IdsDTO<Long> dto) {
+//        sysMenuService.adminDelete(dto.getIds());
+//
+//        return ApiResult.success();
+//    }
+//
+//    @Operation(summary = "取侧边菜单")
+//    @GetMapping("/sys/menus/side")
+//    public ApiResult<List<SysMenuBO>> adminListSideMenu() {
+//        return ApiResult.data(sysMenuService.adminListSideMenu());
+//    }
+//
+//    @Operation(summary = "取所有可见菜单")
+//    @GetMapping("/sys/menus/all")
+//    public ApiResult<List<SysMenuBO>> adminListVisibleMenu() {
+//        return ApiResult.data(sysMenuService.adminListVisibleMenu());
+//    }
+//
+//}

src/main/java/com/jtzx/crm/module/api/web/sys/AdminSysRoleController.java

@@ -1,106 +1,106 @@
-package com.jtzx.crm.module.api.web.sys;
-
-import cc.uncarbon.framework.core.constant.HelioConstant;
-import cc.uncarbon.framework.core.page.PageParam;
-import cc.uncarbon.framework.core.page.PageResult;
-import cc.uncarbon.framework.web.model.request.IdsDTO;
-import cc.uncarbon.framework.web.model.response.ApiResult;
-import com.jtzx.crm.helper.RolePermissionCacheHelper;
-import com.jtzx.crm.module.api.constant.ApiConstant;
-import com.jtzx.crm.module.sys.annotation.SysLog;
-import com.jtzx.crm.module.sys.model.request.AdminBindRoleMenuRelationDTO;
-import com.jtzx.crm.module.sys.model.request.AdminInsertOrUpdateSysRoleDTO;
-import com.jtzx.crm.module.sys.model.request.AdminListSysRoleDTO;
-import com.jtzx.crm.module.sys.model.response.SysRoleBO;
-import com.jtzx.crm.module.sys.service.SysRoleService;
-import com.jtzx.crm.module.api.util.CrmAdminStpUtil;
-import cn.dev33.satoken.annotation.SaCheckLogin;
-import cn.dev33.satoken.annotation.SaCheckPermission;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import io.swagger.v3.oas.annotations.Operation;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.web.bind.annotation.*;
-
-import jakarta.validation.Valid;
-import java.util.Set;
-
-
-@SaCheckLogin(type = CrmAdminStpUtil.TYPE)
-@Tag(name = "后台角色管理接口")
-@RequestMapping(value = ApiConstant.HTTP_API_URL_PREFIX + "/api/v1")
-@RequiredArgsConstructor
-@RestController
-@Slf4j
-public class AdminSysRoleController {
-
-    private static final String PERMISSION_PREFIX = "SysRole:";
-
-    private final SysRoleService sysRoleService;
-
-    private final RolePermissionCacheHelper rolePermissionCacheHelper;
-
-
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.RETRIEVE)
-    @Operation(summary = "分页列表")
-    @GetMapping(value = "/sys/roles")
-    public ApiResult<PageResult<SysRoleBO>> list(PageParam pageParam, AdminListSysRoleDTO dto) {
-        return ApiResult.data(sysRoleService.adminList(pageParam, dto));
-    }
-
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.RETRIEVE)
-    @Operation(summary = "详情")
-    @GetMapping(value = "/sys/roles/{id}")
-    public ApiResult<SysRoleBO> getById(@PathVariable Long id) {
-        return ApiResult.data(sysRoleService.getOneById(id, true));
-    }
-
-    @SysLog(value = "新增后台角色")
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.CREATE)
-    @Operation(summary = "新增")
-    @PostMapping(value = "/sys/roles")
-    public ApiResult<Void> insert(@RequestBody @Valid AdminInsertOrUpdateSysRoleDTO dto) {
-        sysRoleService.adminInsert(dto);
-
-        return ApiResult.success();
-    }
-
-    @SysLog(value = "编辑后台角色")
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.UPDATE)
-    @Operation(summary = "编辑")
-    @PutMapping(value = "/sys/roles/{id}")
-    public ApiResult<Void> update(@PathVariable Long id, @RequestBody @Valid AdminInsertOrUpdateSysRoleDTO dto) {
-        dto.setId(id);
-        sysRoleService.adminUpdate(dto);
-
-        return ApiResult.success();
-    }
-
-    @SysLog(value = "删除后台角色")
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.DELETE)
-    @Operation(summary = "删除")
-    @DeleteMapping(value = "/sys/roles")
-    public ApiResult<Void> delete(@RequestBody @Valid IdsDTO<Long> dto) {
-        sysRoleService.adminDelete(dto.getIds());
-
-        // 角色删除时，删除对应缓存键
-        rolePermissionCacheHelper.deleteCache(dto.getIds());
-
-        return ApiResult.success();
-    }
-
-    @SysLog(value = "绑定角色与菜单关联关系")
-    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + "bindMenus")
-    @Operation(summary = "绑定角色与菜单关联关系")
-    @PutMapping(value = "/sys/roles/{id}/menus")
-    public ApiResult<Void> bindMenus(@PathVariable Long id, @RequestBody @Valid AdminBindRoleMenuRelationDTO dto) {
-        dto.setRoleId(id);
-        Set<String> newPermissions = sysRoleService.adminBindMenus(dto);
-
-        // 覆盖更新缓存
-        rolePermissionCacheHelper.putCache(dto.getRoleId(), newPermissions);
-
-        return ApiResult.success();
-    }
-
-}
+//package com.jtzx.crm.module.api.web.sys;
+//
+//import cc.uncarbon.framework.core.constant.HelioConstant;
+//import cc.uncarbon.framework.core.page.PageParam;
+//import cc.uncarbon.framework.core.page.PageResult;
+//import cc.uncarbon.framework.web.model.request.IdsDTO;
+//import cc.uncarbon.framework.web.model.response.ApiResult;
+//import com.jtzx.crm.helper.RolePermissionCacheHelper;
+//import com.jtzx.crm.module.api.constant.ApiConstant;
+//import com.jtzx.crm.module.sys.annotation.SysLog;
+//import com.jtzx.crm.module.sys.model.request.AdminBindRoleMenuRelationDTO;
+//import com.jtzx.crm.module.sys.model.request.AdminInsertOrUpdateSysRoleDTO;
+//import com.jtzx.crm.module.sys.model.request.AdminListSysRoleDTO;
+//import com.jtzx.crm.module.sys.model.response.SysRoleBO;
+//import com.jtzx.crm.module.sys.service.SysRoleService;
+//import com.jtzx.crm.module.api.util.CrmAdminStpUtil;
+//import cn.dev33.satoken.annotation.SaCheckLogin;
+//import cn.dev33.satoken.annotation.SaCheckPermission;
+//import io.swagger.v3.oas.annotations.tags.Tag;
+//import io.swagger.v3.oas.annotations.Operation;
+//import lombok.RequiredArgsConstructor;
+//import lombok.extern.slf4j.Slf4j;
+//import org.springframework.web.bind.annotation.*;
+//
+//import jakarta.validation.Valid;
+//import java.util.Set;
+//
+//
+//@SaCheckLogin(type = CrmAdminStpUtil.TYPE)
+//@Tag(name = "后台角色管理接口")
+//@RequestMapping(value = ApiConstant.HTTP_API_URL_PREFIX + "/api/v1")
+//@RequiredArgsConstructor
+//@RestController
+//@Slf4j
+//public class AdminSysRoleController {
+//
+//    private static final String PERMISSION_PREFIX = "SysRole:";
+//
+//    private final SysRoleService sysRoleService;
+//
+//    private final RolePermissionCacheHelper rolePermissionCacheHelper;
+//
+//
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.RETRIEVE)
+//    @Operation(summary = "分页列表")
+//    @GetMapping(value = "/sys/roles")
+//    public ApiResult<PageResult<SysRoleBO>> list(PageParam pageParam, AdminListSysRoleDTO dto) {
+//        return ApiResult.data(sysRoleService.adminList(pageParam, dto));
+//    }
+//
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.RETRIEVE)
+//    @Operation(summary = "详情")
+//    @GetMapping(value = "/sys/roles/{id}")
+//    public ApiResult<SysRoleBO> getById(@PathVariable Long id) {
+//        return ApiResult.data(sysRoleService.getOneById(id, true));
+//    }
+//
+//    @SysLog(value = "新增后台角色")
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.CREATE)
+//    @Operation(summary = "新增")
+//    @PostMapping(value = "/sys/roles")
+//    public ApiResult<Void> insert(@RequestBody @Valid AdminInsertOrUpdateSysRoleDTO dto) {
+//        sysRoleService.adminInsert(dto);
+//
+//        return ApiResult.success();
+//    }
+//
+//    @SysLog(value = "编辑后台角色")
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.UPDATE)
+//    @Operation(summary = "编辑")
+//    @PutMapping(value = "/sys/roles/{id}")
+//    public ApiResult<Void> update(@PathVariable Long id, @RequestBody @Valid AdminInsertOrUpdateSysRoleDTO dto) {
+//        dto.setId(id);
+//        sysRoleService.adminUpdate(dto);
+//
+//        return ApiResult.success();
+//    }
+//
+//    @SysLog(value = "删除后台角色")
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + HelioConstant.Permission.DELETE)
+//    @Operation(summary = "删除")
+//    @DeleteMapping(value = "/sys/roles")
+//    public ApiResult<Void> delete(@RequestBody @Valid IdsDTO<Long> dto) {
+//        sysRoleService.adminDelete(dto.getIds());
+//
+//        // 角色删除时，删除对应缓存键
+//        rolePermissionCacheHelper.deleteCache(dto.getIds());
+//
+//        return ApiResult.success();
+//    }
+//
+//    @SysLog(value = "绑定角色与菜单关联关系")
+//    @SaCheckPermission(type = CrmAdminStpUtil.TYPE, value = PERMISSION_PREFIX + "bindMenus")
+//    @Operation(summary = "绑定角色与菜单关联关系")
+//    @PutMapping(value = "/sys/roles/{id}/menus")
+//    public ApiResult<Void> bindMenus(@PathVariable Long id, @RequestBody @Valid AdminBindRoleMenuRelationDTO dto) {
+//        dto.setRoleId(id);
+//        Set<String> newPermissions = sysRoleService.adminBindMenus(dto);
+//
+//        // 覆盖更新缓存
+//        rolePermissionCacheHelper.putCache(dto.getRoleId(), newPermissions);
+//
+//        return ApiResult.success();
+//    }
+//
+//}

src/main/java/com/jtzx/crm/module/api/web/sys/AdminUserGroupController.java

@@ -0,0 +1,108 @@
+package com.jtzx.crm.module.api.web.sys;
+
+
+import cc.uncarbon.framework.core.page.PageResult;
+import cc.uncarbon.framework.web.model.response.ApiResult;
+import cn.dev33.satoken.annotation.SaCheckLogin;
+import com.jtzx.crm.module.api.constant.ApiConstant;
+import com.jtzx.crm.module.api.util.CrmAdminStpUtil;
+import com.jtzx.crm.module.sys.model.request.AdminSysGroupInsertOrUpdateDTO;
+import com.jtzx.crm.module.sys.model.request.AdminSysUserGroupRelationDTO;
+import com.jtzx.crm.module.sys.model.response.GroupUserProvinceBO;
+import com.jtzx.crm.module.sys.model.response.SysGroupBO;
+import com.jtzx.crm.module.sys.model.response.SysUserGroupRelationPageListBO;
+import com.jtzx.crm.module.sys.model.response.SysUserListBO;
+import com.jtzx.crm.module.sys.service.SysGroupService;
+import com.jtzx.crm.module.sys.service.SysUserGroupRelationService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@SaCheckLogin(type = CrmAdminStpUtil.TYPE)
+@Tag(name = "分组管理接口")
+@RequestMapping(value = ApiConstant.HTTP_API_URL_PREFIX + "/api/v1")
+@RequiredArgsConstructor
+@RestController
+@Slf4j
+public class AdminUserGroupController {
+
+
+    private final SysUserGroupRelationService sysUserGroupRelationService;
+
+    private final SysGroupService sysGroupService;
+
+    @Operation(summary = "左侧所有用户列表查询接口")
+    @GetMapping(value = "/group/users/list")
+    public ApiResult<List<SysUserListBO>> queryAllSysUserList(@RequestParam(value = "username", required = false) String username) {
+        List<SysUserListBO> sysUserListBOS = sysUserGroupRelationService.queryAllSysUserList(username);
+        return ApiResult.data(sysUserListBOS);
+    }
+
+
+    @Operation(summary = "表格查询接口")
+    @GetMapping(value = "/group/tableData")
+    public ApiResult<List<GroupUserProvinceBO>> queryTableData() {
+        List<GroupUserProvinceBO> tableData = sysUserGroupRelationService.queryTableData();
+        return ApiResult.data(tableData);
+    }
+
+    @Operation(summary = "设置分组用户数据接口")
+    @PostMapping(value = "/group/userAdd")
+    public ApiResult<Void> userAdd(@RequestBody AdminSysUserGroupRelationDTO dto) {
+        sysUserGroupRelationService.adminInsert(dto);
+        return ApiResult.success();
+    }
+
+    @Operation(summary = "删除分组用户数据接口")
+    @PostMapping(value = "/group/userDel/{id}")
+    public ApiResult<Void> userDel(@PathVariable Long id) {
+        sysUserGroupRelationService.adminDelete(id);
+        return ApiResult.success();
+    }
+
+
+
+
+    @Operation(summary = "列表分页查询接口")
+    @GetMapping(value = "/group/pageListData")
+    public ApiResult<PageResult<SysUserGroupRelationPageListBO>> queryListByPage(AdminSysUserGroupRelationDTO dto) {
+        PageResult<SysUserGroupRelationPageListBO> tableData = sysUserGroupRelationService.queryListByPage(dto);
+        return ApiResult.data(tableData);
+    }
+
+
+    @Operation(summary = "分组列表查询接口")
+    @GetMapping(value = "/group/manager/groupList")
+    public ApiResult<List<SysGroupBO>> queryGroupList() {
+        List<SysGroupBO> groupList = sysGroupService.queryGroupList();
+        return ApiResult.data(groupList);
+    }
+
+
+    @Operation(summary = "新增分组数据接口")
+    @PostMapping(value = "/group/manager/groupAdd")
+    public ApiResult<Void> groupAdd(@RequestBody AdminSysGroupInsertOrUpdateDTO dto) {
+        sysGroupService.adminInsert(dto);
+        return ApiResult.success();
+    }
+
+    @Operation(summary = "修改分组数据接口")
+    @PostMapping(value = "/group/manager/groupUpdate")
+    public ApiResult<Void> groupUpdate(@RequestBody AdminSysGroupInsertOrUpdateDTO dto) {
+        sysGroupService.adminUpdate(dto);
+        return ApiResult.success();
+    }
+
+
+    @Operation(summary = "删除分组数据接口")
+    @GetMapping(value = "/group/manager/groupDel/{id}")
+    public ApiResult<Void> groupDel(@PathVariable Long id) {
+        sysGroupService.adminDelete(id);
+        return ApiResult.success();
+    }
+
+}

src/main/java/com/jtzx/crm/module/api/web/sys/AdminUserRoleController.java

@@ -0,0 +1,88 @@
+package com.jtzx.crm.module.api.web.sys;
+
+
+import cc.uncarbon.framework.core.page.PageResult;
+import cc.uncarbon.framework.web.model.response.ApiResult;
+import cn.dev33.satoken.annotation.SaCheckLogin;
+import com.jtzx.crm.module.api.constant.ApiConstant;
+import com.jtzx.crm.module.api.util.CrmAdminStpUtil;
+import com.jtzx.crm.module.sys.model.request.UserRoleRelationDTO;
+import com.jtzx.crm.module.sys.model.request.UserRoleRelationInsertDTO;
+import com.jtzx.crm.module.sys.model.response.*;
+import com.jtzx.crm.module.sys.service.SysGroupService;
+import com.jtzx.crm.module.sys.service.SysUserGroupRelationService;
+import com.jtzx.crm.module.sys.service.SysUserRoleRelationService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@SaCheckLogin(type = CrmAdminStpUtil.TYPE)
+@Tag(name = "权限管理接口")
+@RequestMapping(value = ApiConstant.HTTP_API_URL_PREFIX + "/api/v1")
+@RequiredArgsConstructor
+@RestController
+@Slf4j
+public class AdminUserRoleController {
+
+
+    private final SysUserGroupRelationService sysUserGroupRelationService;
+
+    private final SysGroupService sysGroupService;
+
+    private final SysUserRoleRelationService sysUserRoleRelationService;
+
+    @Operation(summary = "左侧所有用户列表查询接口")
+    @GetMapping(value = "/role/users/list")
+    public ApiResult<List<SysUserListBO>> queryAllSysUserList(@RequestParam(value = "username", required = false) String username) {
+        List<SysUserListBO> sysUserListBOS = sysUserGroupRelationService.queryAllSysUserList(username);
+        return ApiResult.data(sysUserListBOS);
+    }
+
+    @Operation(summary = "权限列表查询角色下拉接口")
+    @GetMapping(value = "/role/List")
+    public ApiResult<List<SysRoleListBO>> queryRoleData() {
+        List<SysRoleListBO> groupList = sysUserRoleRelationService.queryRoleData();
+        return ApiResult.data(groupList);
+    }
+
+    @Operation(summary = "权限列表查询分组下拉接口")
+    @GetMapping(value = "/role/groupList")
+    public ApiResult<List<SysGroupBO>> queryGroupList() {
+        List<SysGroupBO> groupList = sysGroupService.queryGroupList();
+        return ApiResult.data(groupList);
+    }
+
+
+    @Operation(summary = "表格查询接口")
+    @GetMapping(value = "/role/tableData")
+    public ApiResult<List<UserRoleRelationBO>> queryTableData() {
+        List<UserRoleRelationBO> tableData = sysUserRoleRelationService.queryTableData();
+        return ApiResult.data(tableData);
+    }
+
+    @Operation(summary = "设置角色用户数据接口")
+    @PostMapping(value = "/role/userAdd")
+    public ApiResult<Void> userAdd(@RequestBody UserRoleRelationInsertDTO dto) {
+        sysUserRoleRelationService.adminInsert(dto);
+        return ApiResult.success();
+    }
+
+    @Operation(summary = "删除角色用户数据接口")
+    @PostMapping(value = "/role/userDel/{id}")
+    public ApiResult<Void> userDel(@PathVariable Long id) {
+        sysUserRoleRelationService.delete(id);
+        return ApiResult.success();
+    }
+
+
+    @Operation(summary = "列表分页查询接口")
+    @GetMapping(value = "/role/pageListData")
+    public ApiResult<PageResult<UserRoleRelationPageListBO>> queryListByPage(@RequestBody UserRoleRelationDTO dto) {
+        PageResult<UserRoleRelationPageListBO> tableData = sysUserRoleRelationService.queryTableListByPage(dto);
+        return ApiResult.data(tableData);
+    }
+}

src/main/java/com/jtzx/crm/module/sys/entity/SysGroupEntity.java

@@ -28,15 +28,11 @@ public class SysGroupEntity extends HelioBaseEntity<Long> {
     @TableField(value = "title")
     private String title;
 
-    @Schema(description = "省份表主id")
-    @TableField(value = "region_id")
-    private Long regionId;
-
     @Schema(description = "编号(前端会进行排序，前端传过来)")
     @TableField(value = "sort_code")
     private Integer sortCode;
 
-    @Schema(description = "逻辑删除标识",title = "0=否 1=是")
+    @Schema(description = "逻辑删除标识", title = "0=否 1=是")
     @TableField("del_flag")
     private Integer delFlag;
 

src/main/java/com/jtzx/crm/module/sys/entity/SysRoleEntity.java

@@ -40,6 +40,9 @@ public class SysRoleEntity extends HelioBaseEntity<Long> {
 	@TableField("del_flag")
 	private Integer delFlag;
 
+	@TableField("sort_code")
+	private Integer sortCode;
+
 	/**
 	 * 管理员
 	 */

src/main/java/com/jtzx/crm/module/sys/entity/SysUserGroupRelationEntity.java

@@ -0,0 +1,46 @@
+package com.jtzx.crm.module.sys.entity;
+
+import cc.uncarbon.framework.crud.entity.HelioBaseEntity;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+
+
+/**
+ * 数据表注释
+ */
+@EqualsAndHashCode(callSuper = true)
+@Accessors(chain = true)
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+@TableName(value = "sys_user_group_relation")
+public class SysUserGroupRelationEntity extends HelioBaseEntity<Long> {
+
+    @Schema(description = "sys_group表主id")
+    @TableField(value = "group_id")
+    private Long groupId;
+
+    @Schema(description = "sys_user表主id")
+    @TableField(value = "user_id")
+    private Long userId;
+
+    @Schema(description = "province表主id")
+    @TableField(value = "province_id")
+    private Long provinceId;
+
+    @Schema(description = "dict_city表id")
+    @TableField(value = "city_id")
+    private Long cityId;
+
+    @Schema(description = "逻辑删除标识", title = "0=否 1=是")
+    @TableField("del_flag")
+    private Integer delFlag;
+}

src/main/java/com/jtzx/crm/module/sys/mapper/SysUserGroupRelationMapper.java

@@ -0,0 +1,15 @@
+package com.jtzx.crm.module.sys.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+
+import com.jtzx.crm.module.sys.entity.SysUserGroupRelationEntity;
+
+
+/**
+ * 数据表注释
+ */
+@Mapper
+public interface SysUserGroupRelationMapper extends BaseMapper<SysUserGroupRelationEntity> {
+
+}

src/main/java/com/jtzx/crm/module/sys/mapper/xml/SysUserGroupRelationMapper.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.jtzx.crm.module.sys.mapper.SysUserGroupRelationMapper">
+
+</mapper>

src/main/java/com/jtzx/crm/module/sys/model/request/AdminSysGroupInsertOrUpdateDTO.java

@@ -1,17 +1,15 @@
 package com.jtzx.crm.module.sys.model.request;
 
 import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.Accessors;
 import lombok.experimental.SuperBuilder;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Size;
+
 import java.io.Serializable;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
 
 
 /**
@@ -24,7 +22,7 @@ import java.time.LocalDateTime;
 @Data
 public class AdminSysGroupInsertOrUpdateDTO implements Serializable {
 
-    @Schema(description = "主键ID", hidden = true, title = "仅更新时使用")
+    @Schema(description = "主键ID", title = "仅更新时使用")
     private Long id;
 
     @Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED)
@@ -32,9 +30,6 @@ public class AdminSysGroupInsertOrUpdateDTO implements Serializable {
     @NotBlank(message = "名称不能为空")
     private String title;
 
-    @Schema(description = "省份表主id")
-    private Long regionId;
-
     @Schema(description = "编号(前端会进行排序，前端传过来)")
     private Integer sortCode;
 

src/main/java/com/jtzx/crm/module/sys/model/request/AdminSysUserGroupRelationDTO.java

@@ -0,0 +1,44 @@
+package com.jtzx.crm.module.sys.model.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+
+import java.io.Serializable;
+
+
+/**
+ * 后台管理-新增/编辑数据表注释 DTO
+ */
+@Accessors(chain = true)
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class AdminSysUserGroupRelationDTO implements Serializable {
+
+
+    @Schema(description = "sys_group表主id")
+    private Long groupId;
+
+    @Schema(description = "sys_user表主id")
+    private Long userId;
+
+    @Schema(description = "province表主id")
+    private Long provinceId;
+
+    @Schema(description = "dict_city表id")
+    private Long cityId;
+
+    @Schema(description = "查询条件")
+    private String queryStr;
+
+    @Schema(description = "页码")
+    private Integer pageNum;
+
+    @Schema(description = "每页数据")
+    private Integer pageSize;
+}

src/main/java/com/jtzx/crm/module/sys/model/request/UserRoleRelationDTO.java

@@ -0,0 +1,40 @@
+package com.jtzx.crm.module.sys.model.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+
+/**
+ * 后台管理-绑定用户与角色关联关系
+ */
+@Accessors(chain = true)
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class UserRoleRelationDTO implements Serializable {
+
+    @Schema(description = "角色id")
+    private Long roleId;
+
+    @Schema(description = "用户ID")
+    private Long userId;
+
+    @Schema(description = "分组id")
+    private Long groupId;
+
+    @Schema(description = "查询条件")
+    private String queryStr;
+
+    @Schema(description = "页码")
+    private Integer pageNum;
+
+    @Schema(description = "每页数据")
+    private Integer pageSize;
+}

src/main/java/com/jtzx/crm/module/sys/model/request/UserRoleRelationInsertDTO.java

@@ -0,0 +1,32 @@
+package com.jtzx.crm.module.sys.model.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+
+/**
+ * 后台管理-绑定用户与角色关联关系
+ */
+@Accessors(chain = true)
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class UserRoleRelationInsertDTO implements Serializable {
+
+    @Schema(description = "角色id")
+    private Long roleId;
+
+    @Schema(description = "用户ID")
+    private Long userId;
+
+    @Schema(description = "分组id")
+    private Long groupId;
+
+}

src/main/java/com/jtzx/crm/module/sys/model/response/GroupUserBO.java

@@ -0,0 +1,45 @@
+package com.jtzx.crm.module.sys.model.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+
+import java.io.Serializable;
+
+
+/**
+ * 数据表注释 BO
+ */
+@Accessors(chain = true)
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class GroupUserBO implements Serializable {
+
+    @Schema(description = "主键ID")
+    private Long id;
+
+    @Schema(description = "sys_user表主id")
+    private Long userId;
+
+    @Schema(description = "用户名称")
+    private String userName;
+
+    @Schema(description = "用户账号")
+    private String account;
+
+    @Schema(description = "sys_group表主id")
+    private Long groupId;
+
+
+    @Schema(description = "province表主id")
+    private Long provinceId;
+
+    @Schema(description = "dict_city表id")
+    private Long cityId;
+
+}

src/main/java/com/jtzx/crm/module/sys/model/response/GroupUserCityBO.java

@@ -0,0 +1,32 @@
+package com.jtzx.crm.module.sys.model.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+
+import java.io.Serializable;
+import java.util.Map;
+
+
+/**
+ * 数据表注释 BO
+ */
+@Accessors(chain = true)
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class GroupUserCityBO implements Serializable {
+
+    @Schema(description = "城市id")
+    private Long cityId;
+
+    @Schema(description = "城市名称")
+    private String cityName;
+
+    @Schema(description = "用户信息,key-组id，value-组下的用户")
+    private Map<Long,Object> userData;
+}

src/main/java/com/jtzx/crm/module/sys/model/response/GroupUserProvinceBO.java

@@ -0,0 +1,41 @@
+package com.jtzx.crm.module.sys.model.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+
+import java.io.Serializable;
+import java.util.List;
+
+
+/**
+ * 数据表注释 BO
+ */
+@Accessors(chain = true)
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class GroupUserProvinceBO implements Serializable {
+
+    @Schema(description = "省份id")
+    private Long provinceId;
+
+    @Schema(description = "省份名称")
+    private String provinceName;
+
+    @Schema(description = "省份排序")
+    private Integer sortCode;
+
+    @Schema(description = "城市信息")
+    private List<GroupUserCityBO> cityData;
+
+    @Schema(description = "分组信息")
+    private List<SysGroupBO>  groupData;
+
+
+
+}

src/main/java/com/jtzx/crm/module/sys/model/response/RoleUserBO.java

@@ -0,0 +1,37 @@
+package com.jtzx.crm.module.sys.model.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+
+import java.io.Serializable;
+
+
+/**
+ * 数据表注释 BO
+ */
+@Accessors(chain = true)
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class RoleUserBO implements Serializable {
+
+    @Schema(description = "主键ID")
+    private Long id;
+
+    @Schema(description = "sys_user表主id")
+    private Long userId;
+
+    @Schema(description = "用户名称")
+    private String userName;
+
+    @Schema(description = "用户账号")
+    private String account;
+
+    @Schema(description = "sys_group表主id")
+    private Long groupId;
+}

src/main/java/com/jtzx/crm/module/sys/model/response/SysGroupBO.java

@@ -1,17 +1,13 @@
 package com.jtzx.crm.module.sys.model.response;
 
-import cc.uncarbon.framework.core.constant.HelioConstant;
-import com.fasterxml.jackson.annotation.JsonFormat;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.Accessors;
 import lombok.experimental.SuperBuilder;
-import org.springframework.format.annotation.DateTimeFormat;
+
 import java.io.Serializable;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
 
 
 /**
@@ -27,23 +23,12 @@ public class SysGroupBO implements Serializable {
     @Schema(description = "主键ID")
     private Long id;
 
-    @Schema(description = "创建时刻")
-    @DateTimeFormat(pattern = HelioConstant.Jackson.DATE_TIME_FORMAT)
-    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = HelioConstant.Jackson.DATE_TIME_FORMAT)
-    private LocalDateTime createdAt;
-
-    @Schema(description = "更新时刻")
-    @DateTimeFormat(pattern = HelioConstant.Jackson.DATE_TIME_FORMAT)
-    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = HelioConstant.Jackson.DATE_TIME_FORMAT)
-    private LocalDateTime updatedAt;
-
     @Schema(description = "名称")
     private String title;
 
-    @Schema(description = "省份表主id")
-    private Long regionId;
-
     @Schema(description = "编号(前端会进行排序，前端传过来)")
     private Integer sortCode;
 
+    @Schema(description = "是否可删除，0-是，1-否")
+    private Integer delStatus;
 }

src/main/java/com/jtzx/crm/module/sys/model/response/SysRoleListBO.java

@@ -0,0 +1,29 @@
+package com.jtzx.crm.module.sys.model.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+
+/**
+ * 后台角色BO
+ */
+@Accessors(chain = true)
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class SysRoleListBO implements Serializable {
+
+    @Schema(description = "主键ID")
+    private Long id;
+
+    @Schema(description = "角色名")
+    private String title;
+
+}

src/main/java/com/jtzx/crm/module/sys/model/request/AdminSysGroupListDTO.java → src/main/java/com/jtzx/crm/module/sys/model/response/SysUserGroupRelationBO.java

@@ -1,4 +1,4 @@
-package com.jtzx.crm.module.sys.model.request;
+package com.jtzx.crm.module.sys.model.response;
 
 import cc.uncarbon.framework.core.constant.HelioConstant;
 import com.fasterxml.jackson.annotation.JsonFormat;
@@ -15,32 +15,38 @@ import java.time.LocalDateTime;
 
 
 /**
- * 后台管理-分页列表后台分组数据 DTO
+ * 数据表注释 BO
  */
 @Accessors(chain = true)
 @SuperBuilder
 @AllArgsConstructor
 @NoArgsConstructor
 @Data
-public class AdminSysGroupListDTO implements Serializable {
+public class SysUserGroupRelationBO implements Serializable {
 
-    @Schema(description = "名称(关键词)")
-    private String title;
+    @Schema(description = "主键ID")
+    private Long id;
 
-    @Schema(description = "省份表主id")
-    private Long regionId;
-
-    @Schema(description = "编号(前端会进行排序，前端传过来)")
-    private Integer sortCode;
-
-    @Schema(description = "时间区间起")
-    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = HelioConstant.Jackson.DATE_TIME_FORMAT)
+    @Schema(description = "创建时刻")
     @DateTimeFormat(pattern = HelioConstant.Jackson.DATE_TIME_FORMAT)
-    private LocalDateTime beginAt;
-
-    @Schema(description = "时间区间止")
     @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = HelioConstant.Jackson.DATE_TIME_FORMAT)
+    private LocalDateTime createdAt;
+
+    @Schema(description = "更新时刻")
     @DateTimeFormat(pattern = HelioConstant.Jackson.DATE_TIME_FORMAT)
-    private LocalDateTime endAt;
+    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = HelioConstant.Jackson.DATE_TIME_FORMAT)
+    private LocalDateTime updatedAt;
+
+    @Schema(description = "sys_group表主id")
+    private Long groupId;
+
+    @Schema(description = "sys_user表主id")
+    private Long userId;
+
+    @Schema(description = "province表主id")
+    private Long provinceId;
+
+    @Schema(description = "dict_city表id")
+    private Long cityId;
 
 }

src/main/java/com/jtzx/crm/module/sys/model/response/SysUserGroupRelationPageListBO.java

@@ -0,0 +1,56 @@
+package com.jtzx.crm.module.sys.model.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+
+import java.io.Serializable;
+
+
+/**
+ * 数据表注释 BO
+ */
+@Accessors(chain = true)
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class SysUserGroupRelationPageListBO implements Serializable {
+
+    @Schema(description = "主键ID")
+    private Long id;
+
+    @Schema(description = "sys_group表主id")
+    private Long groupId;
+
+    @Schema(description = "分组名称")
+    private String groupName;
+
+    @Schema(description = "sys_user表主id")
+    private Long userId;
+
+    @Schema(description = "用户姓名")
+    private String userName;
+
+    @Schema(description = "账号")
+    private String account;
+
+    @Schema(description = "province表主id")
+    private Long provinceId;
+
+    @Schema(description = "省份名称")
+    private String provinceName;
+
+    @Schema(description = "dict_city表id")
+    private Long cityId;
+
+    @Schema(description = "城市名称")
+    private String cityName;
+
+    @Schema(description = "删除状态，0-可删除，1-不可删除")
+    private Integer delStatus;
+
+}

src/main/java/com/jtzx/crm/module/sys/model/response/SysUserListBO.java

@@ -0,0 +1,32 @@
+package com.jtzx.crm.module.sys.model.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+
+/**
+ * 后台用户BO
+ */
+@Accessors(chain = true)
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class SysUserListBO implements Serializable {
+
+    @Schema(description = "主键ID")
+    private Long id;
+
+    @Schema(description = "姓名")
+    private String username;
+
+    @Schema(description = "账号")
+    private String account;
+
+}

src/main/java/com/jtzx/crm/module/sys/model/response/UserRoleRelationBO.java

@@ -0,0 +1,41 @@
+package com.jtzx.crm.module.sys.model.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+
+import java.io.Serializable;
+import java.util.List;
+
+
+/**
+ * 数据表注释 BO
+ */
+@Accessors(chain = true)
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class UserRoleRelationBO implements Serializable {
+
+    @Schema(description = "角色id")
+    private Long roleId;
+
+    @Schema(description = "角色名称")
+    private String roleName;
+
+    @Schema(description = "省份排序")
+    private Integer sortCode;
+
+    @Schema(description = "用户信息")
+    private List<RoleUserBO> userData;
+
+    @Schema(description = "分组信息")
+    private List<SysGroupBO>  groupData;
+
+
+
+}

src/main/java/com/jtzx/crm/module/sys/model/response/UserRoleRelationPageListBO.java

@@ -0,0 +1,50 @@
+package com.jtzx.crm.module.sys.model.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+
+import java.io.Serializable;
+
+
+/**
+ * 数据表注释 BO
+ */
+@Accessors(chain = true)
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class UserRoleRelationPageListBO implements Serializable {
+
+    @Schema(description = "主键ID")
+    private Long id;
+
+    @Schema(description = "sys_group表主id")
+    private Long groupId;
+
+    @Schema(description = "分组名称")
+    private String groupName;
+
+    @Schema(description = "sys_user表主id")
+    private Long userId;
+
+    @Schema(description = "用户姓名")
+    private String userName;
+
+    @Schema(description = "账号")
+    private String account;
+
+    @Schema(description = "角色id")
+    private Long roleId;
+
+    @Schema(description = "角色名称")
+    private String roleName;
+
+    @Schema(description = "删除状态，0-可删除，1-不可删除")
+    private Integer delStatus;
+
+}

src/main/java/com/jtzx/crm/module/sys/service/SysGroupService.java

@@ -1,14 +1,15 @@
 package com.jtzx.crm.module.sys.service;
 
 import cc.uncarbon.framework.core.exception.BusinessException;
-import cc.uncarbon.framework.core.page.PageParam;
-import cc.uncarbon.framework.core.page.PageResult;
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.jtzx.crm.module.sys.entity.SysGroupEntity;
+import com.jtzx.crm.module.sys.entity.SysUserGroupRelationEntity;
+import com.jtzx.crm.module.sys.entity.SysUserRoleRelationEntity;
 import com.jtzx.crm.module.sys.mapper.SysGroupMapper;
+import com.jtzx.crm.module.sys.mapper.SysUserGroupRelationMapper;
+import com.jtzx.crm.module.sys.mapper.SysUserRoleRelationMapper;
 import com.jtzx.crm.module.sys.model.request.AdminSysGroupInsertOrUpdateDTO;
 import com.jtzx.crm.module.sys.model.response.SysGroupBO;
 import lombok.RequiredArgsConstructor;
@@ -17,7 +18,6 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
@@ -32,45 +32,34 @@ public class SysGroupService {
 
     private final SysGroupMapper sysGroupMapper;
 
+    private final SysUserGroupRelationMapper sysUserGroupRelationMapper;
 
-    /**
-     * 后台管理-分页列表
-     */
-    public PageResult<SysGroupBO> adminList(PageParam pageParam) {
-        Page<SysGroupEntity> entityPage = sysGroupMapper.selectPage(
-                new Page<>(pageParam.getPageNum(), pageParam.getPageSize()),
-                new QueryWrapper<SysGroupEntity>()
-                        .lambda()
-                        // 排序
-                        .orderByDesc(SysGroupEntity::getCreatedAt)
-        );
-
-        return this.entityPage2BOPage(entityPage);
-    }
+    private final SysUserRoleRelationMapper sysUserRoleRelationMapper;
 
     /**
-     * 根据 ID 取详情
-     *
-     * @param id 主键ID
-     * @return null or BO
+     * 查询分组列表数据
+     * @return
      */
-    public SysGroupBO getOneById(Long id) {
-        return this.getOneById(id, false);
+    public List<SysGroupBO> queryGroupList() {
+        List<SysGroupEntity> groupEntityList =
+                sysGroupMapper.selectList(
+                        new LambdaQueryWrapper<>(SysGroupEntity.class)
+                                .orderByAsc(SysGroupEntity::getSortCode)
+                );
+        return this.entityList2BOs(groupEntityList);
     }
 
     /**
      * 根据 ID 取详情
      *
      * @param id 主键ID
-     * @param throwIfInvalidId 是否在 ID 无效时抛出异常
      * @return null or BO
      */
-    public SysGroupBO getOneById(Long id, boolean throwIfInvalidId) throws BusinessException {
+    public SysGroupBO getOneById(Long id) throws BusinessException {
         SysGroupEntity entity = sysGroupMapper.selectById(id);
-        if (throwIfInvalidId && entity == null) {
+        if (entity == null) {
             throw new BusinessException(400, "无效后台分组数据ID");
         }
-
         return this.entity2BO(entity);
     }
 
@@ -80,14 +69,10 @@ public class SysGroupService {
     @Transactional(rollbackFor = Exception.class)
     public Long adminInsert(AdminSysGroupInsertOrUpdateDTO dto) {
         log.info("[后台管理-后台分组数据-新增] >> DTO={}", dto);
-        this.checkExistence(dto);
-
         dto.setId(null);
         SysGroupEntity entity = new SysGroupEntity();
         BeanUtil.copyProperties(dto, entity);
-
         sysGroupMapper.insert(entity);
-
         return entity.getId();
     }
 
@@ -97,8 +82,6 @@ public class SysGroupService {
     @Transactional(rollbackFor = Exception.class)
     public void adminUpdate(AdminSysGroupInsertOrUpdateDTO dto) {
         log.info("[后台管理-后台分组数据-编辑] >> DTO={}", dto);
-        this.checkExistence(dto);
-
         SysGroupEntity entity = new SysGroupEntity();
         BeanUtil.copyProperties(dto, entity);
 
@@ -109,9 +92,37 @@ public class SysGroupService {
      * 后台管理-删除
      */
     @Transactional(rollbackFor = Exception.class)
-    public void adminDelete(Collection<Long> ids) {
-        log.info("[后台管理-后台分组数据-删除] >> ids={}", ids);
-        sysGroupMapper.deleteByIds(ids);
+    public void adminDelete(Long id) {
+        log.info("[后台管理-后台分组数据-删除] >> id={}", id);
+        //分组下面有人员就不能删除
+        long size =
+                sysUserGroupRelationMapper.selectCount(
+                        new LambdaQueryWrapper<>(SysUserGroupRelationEntity.class)
+                                .select(
+                                        SysUserGroupRelationEntity::getGroupId
+                                )
+                                .eq(SysUserGroupRelationEntity::getGroupId, id)
+                );
+        if (size > 0) {
+            throw new BusinessException(400, "分组不能删除");
+        }
+
+        long count =
+                sysUserRoleRelationMapper.selectCount(
+                        new LambdaQueryWrapper<>(SysUserRoleRelationEntity.class)
+                                .select(
+                                        SysUserRoleRelationEntity::getGroupId
+                                )
+                                .eq(SysUserRoleRelationEntity::getGroupId, id)
+                );
+        if (count > 0) {
+            throw new BusinessException(400, "分组不能删除");
+        }
+
+
+        //删除分组
+        sysGroupMapper.deleteById(id);
+
     }
 
 
@@ -151,50 +162,36 @@ public class SysGroupService {
             return Collections.emptyList();
         }
 
+        List<SysUserGroupRelationEntity> groupRelationEntityList =
+                sysUserGroupRelationMapper.selectList(
+                        new LambdaQueryWrapper<>(SysUserGroupRelationEntity.class)
+                                .select(
+                                        SysUserGroupRelationEntity::getGroupId
+                                )
+                                .in(SysUserGroupRelationEntity::getGroupId, entityList.stream().map(SysGroupEntity::getId).toList())
+                );
+
         // 深拷贝
         List<SysGroupBO> ret = new ArrayList<>(entityList.size());
         entityList.forEach(
-            entity -> ret.add(this.entity2BO(entity))
+                entity -> {
+
+                    SysGroupBO sysGroupBO = this.entity2BO(entity);
+                    sysGroupBO.setDelStatus(0);
+                    if (CollUtil.isNotEmpty(groupRelationEntityList)) {
+                        int size =
+                                groupRelationEntityList.stream()
+                                        .map(SysUserGroupRelationEntity::getGroupId)
+                                        .filter(groupId -> groupId.equals(sysGroupBO.getId())).distinct()
+                                        .toList().size();
+                        if (size > 0) {
+                            sysGroupBO.setDelStatus(1);
+                        }
+                    }
+                    ret.add(sysGroupBO);
+                }
         );
 
         return ret;
     }
-
-    /**
-     * 实体分页转 BO 分页
-     *
-     * @param entityPage 实体分页
-     * @return BO 分页
-     */
-    private PageResult<SysGroupBO> entityPage2BOPage(Page<SysGroupEntity> entityPage) {
-        return new PageResult<SysGroupBO>()
-            .setCurrent(entityPage.getCurrent())
-            .setSize(entityPage.getSize())
-            .setTotal(entityPage.getTotal())
-            .setRecords(this.entityList2BOs(entityPage.getRecords()));
-    }
-
-    /**
-     * 检查是否已存在同名数据
-     *
-     * @param dto DTO
-     */
-    private void checkExistence(AdminSysGroupInsertOrUpdateDTO dto) {
-        /*
-        可以根据自己业务需要，解禁这段代码，修改判断条件和文案
-
-        SysGroupEntity existingEntity = sysGroupMapper.selectOne(
-                new QueryWrapper<SysGroupEntity>()
-                        .lambda()
-                        .select(SysGroupEntity::getId)
-                        .eq(SysGroupEntity::getTitle, dto.getTitle())
-                        .last(HelioConstant.CRUD.SQL_LIMIT_1)
-        );
-
-        if (existingEntity != null && !existingEntity.getId().equals(dto.getId())) {
-            throw new BusinessException(400, "已存在相同后台分组数据，请重新输入");
-        }
-        */
-    }
-
 }

src/main/java/com/jtzx/crm/module/sys/service/SysUserGroupRelationService.java

@@ -0,0 +1,477 @@
+package com.jtzx.crm.module.sys.service;
+
+import cc.uncarbon.framework.core.exception.BusinessException;
+import cc.uncarbon.framework.core.page.PageResult;
+import cc.uncarbon.framework.crud.entity.HelioBaseEntity;
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.jtzx.crm.module.sys.entity.*;
+import com.jtzx.crm.module.sys.mapper.*;
+import com.jtzx.crm.module.sys.model.request.AdminSysUserGroupRelationDTO;
+import com.jtzx.crm.module.sys.model.response.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * 数据表注释
+ */
+@RequiredArgsConstructor
+@Service
+@Slf4j
+public class SysUserGroupRelationService {
+
+    private final SysGroupMapper sysGroupMapper;
+
+    private final SysUserGroupRelationMapper sysUserGroupRelationMapper;
+
+    private final DictProvinceRegionMapper dictProvinceRegionMapper;
+
+    private final DictCityRegionMapper dictCityRegionMapper;
+
+    private final SysUserMapper sysUserMapper;
+
+
+    /**
+     * 查询所有用户（左侧列表数据）
+     * @return
+     */
+    public List<SysUserListBO> queryAllSysUserList(String username) {
+        List<SysUserListBO> sysUserListBOList = Lists.newArrayList();
+        List<SysUserEntity> sysUserEntities =
+                sysUserMapper.selectList(
+                        new LambdaQueryWrapper<>(SysUserEntity.class)
+                                .eq(StrUtil.isNotEmpty(username), SysUserEntity::getUserName, username)
+                                .eq(SysUserEntity::getStatus, 1)
+                                .orderByAsc(HelioBaseEntity::getCreatedAt)
+                );
+        if (CollUtil.isNotEmpty(sysUserEntities)) {
+            sysUserEntities.forEach(entity -> {
+                SysUserListBO bo = SysUserListBO.builder().build();
+                bo.setId(entity.getId());
+                bo.setUsername(entity.getUserName());
+                bo.setAccount(entity.getPin());
+                sysUserListBOList.add(bo);
+            });
+        }
+        return sysUserListBOList;
+    }
+
+
+    /**
+     * 分页查询表格数据
+     * @param dto
+     * @return
+     */
+    public PageResult<SysUserGroupRelationPageListBO> queryListByPage(AdminSysUserGroupRelationDTO dto) {
+        //查询分组
+        List<SysGroupEntity> groupEntityList =
+                sysGroupMapper.selectList(
+                        new LambdaQueryWrapper<>(SysGroupEntity.class)
+                                .select(
+                                        SysGroupEntity::getSortCode,
+                                        SysGroupEntity::getId,
+                                        SysGroupEntity::getTitle
+                                )
+                                .eq(dto.getGroupId() != null, SysGroupEntity::getId, dto.getGroupId())
+                                .orderByAsc(SysGroupEntity::getSortCode)
+                );
+
+        if (CollUtil.isEmpty(groupEntityList)) {
+            return new PageResult<SysUserGroupRelationPageListBO>()
+                    .setCurrent(1)
+                    .setSize(dto.getPageSize())
+                    .setTotal(0)
+                    .setRecords(Lists.newArrayList());
+        }
+        //查询已开通使用的省份数据
+        List<DictProvinceRegionEntity> provinceRegionEntityList = dictProvinceRegionMapper.selectList(
+                new LambdaQueryWrapper<>(DictProvinceRegionEntity.class)
+                        .select(
+                                DictProvinceRegionEntity::getId,
+                                DictProvinceRegionEntity::getCode,
+                                DictProvinceRegionEntity::getName,
+                                DictProvinceRegionEntity::getSortCode
+                        )
+                        .eq(dto.getProvinceId() != null, DictProvinceRegionEntity::getId, dto.getProvinceId())
+                        .eq(DictProvinceRegionEntity::getUseStatus, 1)
+        );
+        if (CollUtil.isEmpty(provinceRegionEntityList)) {
+            return new PageResult<SysUserGroupRelationPageListBO>()
+                    .setCurrent(1)
+                    .setSize(dto.getPageSize())
+                    .setTotal(0)
+                    .setRecords(Lists.newArrayList());
+        }
+
+        //查询城市数据
+        List<DictCityRegionEntity> cityRegionEntityList = dictCityRegionMapper.selectList(
+                new LambdaQueryWrapper<>(DictCityRegionEntity.class)
+                        .select(
+                                DictCityRegionEntity::getParentCode,
+                                DictCityRegionEntity::getId,
+                                DictCityRegionEntity::getName
+                        )
+                        .eq(dto.getCityId() != null, DictCityRegionEntity::getId, dto.getCityId())
+                        .in(DictCityRegionEntity::getParentCode, provinceRegionEntityList.stream().map(DictProvinceRegionEntity::getCode).toList())
+        );
+        if (CollUtil.isEmpty(cityRegionEntityList)) {
+            return new PageResult<SysUserGroupRelationPageListBO>()
+                    .setCurrent(1)
+                    .setSize(dto.getPageSize())
+                    .setTotal(0)
+                    .setRecords(Lists.newArrayList());
+        }
+        //查询用户数据
+        List<SysUserEntity> sysUserEntityList =
+                sysUserMapper.selectList(
+                        new LambdaQueryWrapper<>(SysUserEntity.class)
+                                .select(
+                                        SysUserEntity::getUserName,
+                                        SysUserEntity::getId,
+                                        SysUserEntity::getPin
+                                )
+                                .eq(SysUserEntity::getStatus, 1)
+                                .eq(dto.getUserId() != null, SysUserEntity::getId, dto.getUserId())
+                                .and(StrUtil.isNotEmpty(dto.getQueryStr()), z -> z.like(SysUserEntity::getUserName, dto.getQueryStr())
+                                        .or().like(SysUserEntity::getPin, dto.getQueryStr())
+                                )
+
+                );
+        if (CollUtil.isEmpty(sysUserEntityList)) {
+            return new PageResult<SysUserGroupRelationPageListBO>()
+                    .setCurrent(1)
+                    .setSize(dto.getPageSize())
+                    .setTotal(0)
+                    .setRecords(Lists.newArrayList());
+        }
+        List<Long> userIds = sysUserEntityList.stream()
+                .sorted(Comparator.comparing(SysUserEntity::getId))
+                .map(SysUserEntity::getId)
+                .toList();
+
+        Page<SysUserGroupRelationEntity> pageData = sysUserGroupRelationMapper.selectPage(
+                new Page<>(dto.getPageNum(), dto.getPageSize()),
+                new LambdaQueryWrapper<>(SysUserGroupRelationEntity.class)
+                        .eq(dto.getProvinceId() != null, SysUserGroupRelationEntity::getProvinceId, dto.getProvinceId())
+                        .eq(dto.getCityId() != null, SysUserGroupRelationEntity::getCityId, dto.getCityId())
+                        .eq(dto.getGroupId() != null, SysUserGroupRelationEntity::getGroupId, dto.getGroupId())
+                        .eq(dto.getUserId() != null && StrUtil.isEmpty(dto.getQueryStr()), SysUserGroupRelationEntity::getUserId, dto.getUserId())
+                        .in(StrUtil.isNotEmpty(dto.getQueryStr()), SysUserGroupRelationEntity::getUserId, userIds)
+                        .orderByDesc(SysUserGroupRelationEntity::getCreatedAt)
+        );
+        if (CollUtil.isEmpty(pageData.getRecords())) {
+            return new PageResult<SysUserGroupRelationPageListBO>()
+                    .setCurrent(1)
+                    .setSize(dto.getPageSize())
+                    .setTotal(0)
+                    .setRecords(Lists.newArrayList());
+        }
+
+        List<SysUserGroupRelationPageListBO> result = Lists.newArrayList();
+        PageResult<SysUserGroupRelationPageListBO> pageResult = new PageResult<SysUserGroupRelationPageListBO>()
+                .setCurrent(pageData.getCurrent())
+                .setSize(pageData.getSize())
+                .setTotal(pageData.getTotal());
+        pageData.getRecords().forEach(entity -> {
+            SysUserGroupRelationPageListBO bo = SysUserGroupRelationPageListBO.builder().build();
+            bo.setId(entity.getId());
+            groupEntityList.stream()
+                    .filter(x -> x.getId().equals(entity.getGroupId()))
+                    .findFirst()
+                    .ifPresent(x -> {
+                        bo.setGroupId(x.getId());
+                        bo.setGroupName(x.getTitle());
+                    });
+            sysUserEntityList.stream()
+                    .filter(x -> x.getId().equals(entity.getUserId()))
+                    .findFirst()
+                    .ifPresent(x -> {
+                        bo.setUserId(x.getId());
+                        bo.setUserName(x.getUserName());
+                        bo.setAccount(x.getPin());
+                    });
+
+            provinceRegionEntityList.stream()
+                    .filter(x -> x.getId().equals(entity.getProvinceId()))
+                    .findFirst()
+                    .ifPresent(x -> {
+                        bo.setProvinceId(x.getId());
+                        bo.setProvinceName(x.getName());
+                    });
+
+            cityRegionEntityList.stream()
+                    .filter(x -> x.getId().equals(entity.getCityId()))
+                    .findFirst()
+                    .ifPresent(x -> {
+                        bo.setCityId(x.getId());
+                        bo.setCityName(x.getName());
+                    });
+            bo.setDelStatus(0);
+            result.add(bo);
+        });
+        pageResult.setRecords(result);
+        return pageResult;
+    }
+
+
+    /**
+     * 分组管理，查询表格数据(第一种表格形式的数据)
+     * @return
+     */
+    public List<GroupUserProvinceBO> queryTableData() {
+
+        List<GroupUserProvinceBO> result = Lists.newArrayList();
+        //查询分组
+        List<SysGroupEntity> groupEntityList = Lists.newArrayList();
+        //查询用户和分组数据的关系数据
+        List<SysUserGroupRelationEntity> groupRelationEntityList = Lists.newArrayList();
+        //查询用户数据
+        List<SysUserEntity> sysUserEntityList = Lists.newArrayList();
+        //查询已开通使用的省份数据
+        List<DictProvinceRegionEntity> provinceRegionEntityList = Lists.newArrayList();
+        //查询城市数据
+        List<DictCityRegionEntity> cityRegionEntityList = Lists.newArrayList();
+        //公共查询数据
+        this.commonQueryData(groupEntityList, groupRelationEntityList, sysUserEntityList, provinceRegionEntityList, cityRegionEntityList);
+        //按省份处理
+        if (CollUtil.isNotEmpty(provinceRegionEntityList)) {
+            //循环省份
+            provinceRegionEntityList.forEach(provinceRegionEntity -> {
+                //过滤省份下的城市
+                List<DictCityRegionEntity> cityRegionEntities =
+                        cityRegionEntityList.stream()
+                                .filter(x -> x.getParentCode().equals(provinceRegionEntity.getCode()))
+                                .sorted(Comparator.comparing(DictCityRegionEntity::getCode)).toList();
+                List<SysUserGroupRelationEntity> userGroupRelationEntityList = Lists.newArrayList();
+                //过滤省份下的用户关系
+                if (CollUtil.isNotEmpty(groupRelationEntityList)) {
+                    userGroupRelationEntityList.addAll(groupRelationEntityList.stream()
+                            .filter(x -> x.getProvinceId().equals(provinceRegionEntity.getId()))
+                            .toList());
+                }
+                //过滤每个省份下的用户数据信息
+                List<SysUserEntity> sysUserEntities = Lists.newArrayList();
+                if (CollUtil.isNotEmpty(userGroupRelationEntityList) && CollUtil.isNotEmpty(sysUserEntityList)) {
+                    List<Long> userIds =
+                            userGroupRelationEntityList.stream()
+                                    .map(SysUserGroupRelationEntity::getUserId)
+                                    .distinct().toList();
+                    sysUserEntities.addAll(sysUserEntityList.stream()
+                            .filter(x -> userIds.contains(x.getId()))
+                            .toList());
+                }
+                //处理返回数据
+                result.add(
+                        this.handleTableData(provinceRegionEntity, cityRegionEntities,
+                                groupEntityList, userGroupRelationEntityList, sysUserEntities));
+            });
+        }
+        return result;
+    }
+
+
+    public GroupUserProvinceBO handleTableData(DictProvinceRegionEntity dictProvinceRegionEntity,
+                                               List<DictCityRegionEntity> cityRegionEntities,
+                                               List<SysGroupEntity> groupEntityList,
+                                               List<SysUserGroupRelationEntity> userGroupRelationEntityList,
+                                               List<SysUserEntity> sysUserEntities) {
+        GroupUserProvinceBO provinceBO = GroupUserProvinceBO.builder().build();
+        provinceBO.setProvinceId(dictProvinceRegionEntity.getId());
+        provinceBO.setProvinceName(dictProvinceRegionEntity.getName());
+        provinceBO.setSortCode(dictProvinceRegionEntity.getSortCode());
+        List<SysGroupBO> groupData = Lists.newArrayList();
+        if (CollUtil.isNotEmpty(groupEntityList)) {
+            groupEntityList.stream()
+                    .sorted(Comparator.comparing(SysGroupEntity::getSortCode))
+                    .forEach(groupEntity -> {
+                        SysGroupBO sysGroupBO = SysGroupBO.builder().build();
+                        BeanUtils.copyProperties(groupEntity, sysGroupBO);
+                        groupData.add(sysGroupBO);
+                    });
+        }
+        provinceBO.setGroupData(groupData);
+        //处理表格数据
+        List<GroupUserCityBO> cityData = Lists.newArrayList();
+        cityRegionEntities.stream()
+                .sorted(Comparator.comparing(DictCityRegionEntity::getCode))
+                .forEach(cityRegionEntity -> {
+                    GroupUserCityBO groupUserCityBO = GroupUserCityBO.builder().build();
+                    groupUserCityBO.setCityId(cityRegionEntity.getId());
+                    groupUserCityBO.setCityName(cityRegionEntity.getName());
+                    Map<Long, Object> userData = Maps.newHashMap();
+                    if (CollUtil.isNotEmpty(groupEntityList)) {
+                        groupEntityList.stream()
+                                .sorted(Comparator.comparing(SysGroupEntity::getSortCode))
+                                .forEach(groupEntity -> {
+                                    //设置默认
+                                    userData.put(groupEntity.getId(), "-");
+                                    if (CollUtil.isNotEmpty(userGroupRelationEntityList)) {
+                                        List<GroupUserBO> userBOS = Lists.newArrayList();
+                                        userGroupRelationEntityList.stream()
+                                                .filter(x -> x.getCityId().equals(cityRegionEntity.getId()))
+                                                .filter(x -> x.getGroupId().equals(groupEntity.getId()))
+                                                .sorted(Comparator.comparing(HelioBaseEntity::getCreatedAt))
+                                                .forEach(groupRelationEntity -> {
+                                                    if (CollUtil.isNotEmpty(sysUserEntities)) {
+                                                        sysUserEntities.stream()
+                                                                .filter(x -> x.getId().equals(groupRelationEntity.getUserId()))
+                                                                .findFirst()
+                                                                .ifPresent(d -> {
+                                                                    if (CollUtil.isEmpty(userBOS) || userBOS.stream().map(GroupUserBO::getUserId).noneMatch(groupRelationEntity.getUserId()::equals)) {
+                                                                        GroupUserBO bo = GroupUserBO.builder().build();
+                                                                        bo.setId(groupRelationEntity.getId());
+                                                                        bo.setUserId(groupRelationEntity.getUserId());
+                                                                        bo.setUserName(d.getUserName());
+                                                                        bo.setAccount(d.getPin());
+                                                                        bo.setGroupId(groupEntity.getId());
+                                                                        bo.setProvinceId(dictProvinceRegionEntity.getId());
+                                                                        bo.setCityId(cityRegionEntity.getId());
+                                                                        userBOS.add(bo);
+                                                                    }
+                                                                });
+                                                    }
+                                                });
+                                        userData.put(groupEntity.getId(), userBOS);
+                                    }
+                                });
+                    }
+                    groupUserCityBO.setUserData(userData);
+                    cityData.add(groupUserCityBO);
+                });
+        provinceBO.setCityData(cityData);
+        return provinceBO;
+    }
+
+
+    /**
+     * 后台管理-新增
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public Long adminInsert(AdminSysUserGroupRelationDTO dto) {
+        log.info("[后台管理-数据表注释-新增] >> DTO={}", dto);
+        //先判断有没有同个人有没有重复
+        long count =
+                sysUserGroupRelationMapper.selectCount(
+                        new LambdaQueryWrapper<>(SysUserGroupRelationEntity.class)
+                                .select(
+                                        SysUserGroupRelationEntity::getId
+                                )
+                                .eq(SysUserGroupRelationEntity::getProvinceId, dto.getProvinceId())
+                                .eq(SysUserGroupRelationEntity::getCityId, dto.getCityId())
+                                .eq(SysUserGroupRelationEntity::getGroupId, dto.getGroupId())
+                                .eq(SysUserGroupRelationEntity::getUserId, dto.getUserId())
+                );
+        if (count > 0) {
+            throw new BusinessException(400, "请勿重复设置");
+        }
+        SysUserGroupRelationEntity entity = new SysUserGroupRelationEntity();
+        BeanUtil.copyProperties(dto, entity);
+        sysUserGroupRelationMapper.insert(entity);
+        return entity.getId();
+    }
+
+    /**
+     * 后台管理-删除
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public void adminDelete(Long id) {
+        log.info("[后台管理-数据表注释-删除] >> id={}", id);
+        sysUserGroupRelationMapper.deleteById(id);
+    }
+
+
+    public void commonQueryData(List<SysGroupEntity> groupEntityList,
+                                List<SysUserGroupRelationEntity> groupRelationEntityList,
+                                List<SysUserEntity> sysUserEntityList,
+                                List<DictProvinceRegionEntity> provinceRegionEntityList,
+                                List<DictCityRegionEntity> cityRegionEntityList) {
+        List<SysGroupEntity> groupEntityList1 =
+                sysGroupMapper.selectList(
+                        new LambdaQueryWrapper<>(SysGroupEntity.class)
+                                .select(
+                                        SysGroupEntity::getId,
+                                        SysGroupEntity::getSortCode,
+                                        SysGroupEntity::getTitle
+                                )
+                                .orderByAsc(SysGroupEntity::getSortCode)
+                );
+        if (CollUtil.isNotEmpty(groupEntityList1)) {
+            groupEntityList.addAll(groupEntityList1);
+        }
+
+
+        //查询用户和分组数据的关系数据
+        List<SysUserGroupRelationEntity> groupRelationEntityList1 = sysUserGroupRelationMapper.selectList(
+                new LambdaQueryWrapper<>(SysUserGroupRelationEntity.class)
+                        .select(
+                                SysUserGroupRelationEntity::getId,
+                                SysUserGroupRelationEntity::getCityId,
+                                SysUserGroupRelationEntity::getProvinceId,
+                                SysUserGroupRelationEntity::getGroupId,
+                                SysUserGroupRelationEntity::getUserId
+                        )
+                        .orderByAsc(SysUserGroupRelationEntity::getCreatedAt)
+        );
+        if (CollUtil.isNotEmpty(groupRelationEntityList1)) {
+            groupRelationEntityList.addAll(groupRelationEntityList1);
+            List<SysUserEntity> sysUserEntities = sysUserMapper.selectList(
+                    new LambdaQueryWrapper<>(SysUserEntity.class)
+                            .eq(SysUserEntity::getStatus, 1)
+                            .in(SysUserEntity::getId, groupRelationEntityList1.stream()
+                                    .map(SysUserGroupRelationEntity::getUserId).distinct().toList())
+            );
+            if (CollUtil.isNotEmpty(sysUserEntities)) {
+                sysUserEntityList.addAll(sysUserEntities);
+            }
+        }
+
+
+        List<DictProvinceRegionEntity> regionEntityList = dictProvinceRegionMapper.selectList(
+                new LambdaQueryWrapper<>(DictProvinceRegionEntity.class)
+                        .select(
+                                DictProvinceRegionEntity::getId,
+                                DictProvinceRegionEntity::getSortCode,
+                                DictProvinceRegionEntity::getName,
+                                DictProvinceRegionEntity::getCode
+                        )
+                        .eq(DictProvinceRegionEntity::getUseStatus, 1)
+                        .orderByAsc(DictProvinceRegionEntity::getSortCode)
+        );
+        if (CollUtil.isNotEmpty(regionEntityList)) {
+            provinceRegionEntityList.addAll(regionEntityList);
+
+            List<String> provinceCode =
+                    regionEntityList.stream()
+                            .map(DictProvinceRegionEntity::getCode)
+                            .distinct()
+                            .toList();
+
+            List<DictCityRegionEntity> dictCityRegionEntities = dictCityRegionMapper.selectList(
+                    new LambdaQueryWrapper<>(DictCityRegionEntity.class)
+                            .select(
+                                    DictCityRegionEntity::getId,
+                                    DictCityRegionEntity::getCode,
+                                    DictCityRegionEntity::getName,
+                                    DictCityRegionEntity::getParentCode
+                            )
+                            .in(DictCityRegionEntity::getParentCode, provinceCode)
+            );
+            if (CollUtil.isNotEmpty(dictCityRegionEntities)) {
+                cityRegionEntityList.addAll(dictCityRegionEntities);
+            }
+        }
+    }
+}

src/main/java/com/jtzx/crm/module/sys/service/SysUserRoleRelationService.java

@@ -1,18 +1,30 @@
 package com.jtzx.crm.module.sys.service;
 
+import cc.uncarbon.framework.core.page.PageResult;
+import cc.uncarbon.framework.crud.entity.HelioBaseEntity;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.google.common.collect.Lists;
+import com.jtzx.crm.module.sys.entity.SysGroupEntity;
+import com.jtzx.crm.module.sys.entity.SysRoleEntity;
+import com.jtzx.crm.module.sys.entity.SysUserEntity;
 import com.jtzx.crm.module.sys.entity.SysUserRoleRelationEntity;
+import com.jtzx.crm.module.sys.mapper.SysGroupMapper;
+import com.jtzx.crm.module.sys.mapper.SysRoleMapper;
+import com.jtzx.crm.module.sys.mapper.SysUserMapper;
 import com.jtzx.crm.module.sys.mapper.SysUserRoleRelationMapper;
-import cn.hutool.core.collection.CollUtil;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.jtzx.crm.module.sys.model.request.UserRoleRelationDTO;
+import com.jtzx.crm.module.sys.model.request.UserRoleRelationInsertDTO;
+import com.jtzx.crm.module.sys.model.response.*;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Set;
-import java.util.stream.Collectors;
+import java.util.Comparator;
+import java.util.List;
 
 
 /**
@@ -25,82 +37,319 @@ public class SysUserRoleRelationService {
 
     private final SysUserRoleRelationMapper sysUserRoleRelationMapper;
 
+    private final SysRoleMapper sysRoleMapper;
+
+    private final SysUserMapper sysUserMapper;
+
+    private final SysGroupMapper sysGroupMapper;
 
     /**
-     * 后台管理-新增
-     * 注：本方法较为特殊，仅供SysTenantFacadeImpl调用
+     * 查询角色下拉数据列表
+     * @return
      */
-    @Transactional(rollbackFor = Exception.class)
-    public Long adminInsert(Long tenantId, Long userId, Long roleId) {
-        SysUserRoleRelationEntity entity = new SysUserRoleRelationEntity()
-                .setUserId(userId).setRoleId(roleId);
-        entity.setTenantId(tenantId);
+    public List<SysRoleListBO> queryRoleData() {
+        List<SysRoleEntity> sysRoleEntities = sysRoleMapper.selectList(null);
+        List<SysRoleListBO> result = Lists.newArrayList();
+        sysRoleEntities.stream()
+                .sorted(Comparator.comparing(SysRoleEntity::getSortCode).reversed())
+                .forEach(sysRoleEntity -> {
+                    SysRoleListBO bo = SysRoleListBO.builder().build();
+                    bo.setId(sysRoleEntity.getId());
+                    bo.setTitle(sysRoleEntity.getTitle());
+                    result.add(bo);
+                });
+        return result;
+    }
 
-        sysUserRoleRelationMapper.insert(entity);
+    /**
+     * 分页查询表格数据列表
+     * @param dto
+     * @return
+     */
+    public PageResult<UserRoleRelationPageListBO> queryTableListByPage(UserRoleRelationDTO dto) {
+        //查询角色数据
+        List<SysRoleEntity> roleEntityList =
+                sysRoleMapper.selectList(
+                        new LambdaQueryWrapper<>(SysRoleEntity.class)
+                                .select(
+                                        SysRoleEntity::getSortCode,
+                                        SysRoleEntity::getId,
+                                        SysRoleEntity::getValue,
+                                        SysRoleEntity::getTitle
+                                )
+                                .eq(dto.getRoleId() != null, SysRoleEntity::getId, dto.getRoleId())
+                );
+        if (CollUtil.isEmpty(roleEntityList)) {
+            return new PageResult<UserRoleRelationPageListBO>()
+                    .setCurrent(1)
+                    .setSize(dto.getPageSize())
+                    .setTotal(0)
+                    .setRecords(Lists.newArrayList());
+        }
+        //查询分组数据
+        List<SysGroupEntity> groupEntityList =
+                sysGroupMapper.selectList(
+                        new LambdaQueryWrapper<>(SysGroupEntity.class)
+                                .select(
+                                        SysGroupEntity::getSortCode,
+                                        SysGroupEntity::getId,
+                                        SysGroupEntity::getTitle
+                                )
+                                .eq(dto.getGroupId() != null, HelioBaseEntity::getId, dto.getGroupId())
+                );
+        if (CollUtil.isEmpty(groupEntityList)) {
+            return new PageResult<UserRoleRelationPageListBO>()
+                    .setCurrent(1)
+                    .setSize(dto.getPageSize())
+                    .setTotal(0)
+                    .setRecords(Lists.newArrayList());
+        }
+        //查询用户
+        List<SysUserEntity> userEntityList =
+                sysUserMapper.selectList(
+                        new LambdaQueryWrapper<>(SysUserEntity.class)
+                                .select(
+                                        SysUserEntity::getUserName,
+                                        SysUserEntity::getId,
+                                        SysUserEntity::getPin
+                                )
+                                .eq(dto.getUserId() != null, SysUserEntity::getId, dto.getUserId())
+                                .eq(SysUserEntity::getStatus, 1)
+                                .and(StrUtil.isNotEmpty(dto.getQueryStr()), z -> z.like(SysUserEntity::getUserName, dto.getQueryStr())
+                                        .or().like(SysUserEntity::getPin, dto.getQueryStr())
+                                )
+                );
+        if (CollUtil.isEmpty(userEntityList)) {
+            return new PageResult<UserRoleRelationPageListBO>()
+                    .setCurrent(1)
+                    .setSize(dto.getPageSize())
+                    .setTotal(0)
+                    .setRecords(Lists.newArrayList());
+        }
 
-        return entity.getId();
-    }
+        List<Long> userIds =
+                userEntityList.stream()
+                        .sorted(Comparator.comparing(SysUserEntity::getId))
+                        .map(SysUserEntity::getId)
+                        .toList();
+
+        Page<SysUserRoleRelationEntity> entityPage =
+                sysUserRoleRelationMapper.selectPage(
+                        new Page<>(dto.getPageNum(), dto.getPageSize()),
+                        new LambdaQueryWrapper<>(SysUserRoleRelationEntity.class)
+                                .eq(dto.getRoleId() != null, SysUserRoleRelationEntity::getRoleId, dto.getRoleId())
+                                .eq(dto.getGroupId() != null, SysUserRoleRelationEntity::getGroupId, dto.getGroupId())
+                                .eq(dto.getUserId() != null && StrUtil.isEmpty(dto.getQueryStr()), SysUserRoleRelationEntity::getUserId, dto.getUserId())
+                                .in(StrUtil.isNotEmpty(dto.getQueryStr()), SysUserRoleRelationEntity::getUserId, userIds)
+                                .orderByDesc(SysUserRoleRelationEntity::getCreatedAt)
+                );
+        if (CollUtil.isEmpty(entityPage.getRecords())) {
+            return new PageResult<UserRoleRelationPageListBO>()
+                    .setCurrent(1)
+                    .setSize(dto.getPageSize())
+                    .setTotal(0)
+                    .setRecords(Lists.newArrayList());
+        }
 
 
+        List<UserRoleRelationPageListBO> result = Lists.newArrayList();
+        entityPage.getRecords().forEach(record -> {
+            UserRoleRelationPageListBO bo = UserRoleRelationPageListBO.builder().build();
+            bo.setId(record.getId());
+            bo.setGroupId(null);
+            bo.setGroupName("-");
+            if (record.getGroupId() != null) {
+                groupEntityList.stream()
+                        .filter(x -> x.getId().equals(record.getGroupId()))
+                        .findFirst()
+                        .ifPresent(group -> {
+                            bo.setGroupId(group.getId());
+                            bo.setGroupName(group.getTitle());
+                        });
+            }
+            userEntityList.stream()
+                    .filter(x -> x.getId().equals(record.getUserId()))
+                    .findFirst()
+                    .ifPresent(user -> {
+                        bo.setUserId(user.getId());
+                        bo.setUserName(user.getUserName());
+                        bo.setAccount(user.getPin());
+                    });
+            roleEntityList.stream()
+                    .filter(x -> x.getId().equals(record.getRoleId()))
+                    .findFirst()
+                    .ifPresent(role -> {
+                        bo.setRoleId(role.getId());
+                        bo.setRoleName(role.getTitle());
+                    });
+            bo.setDelStatus(0);
+            result.add(bo);
+        });
+        return new PageResult<UserRoleRelationPageListBO>()
+                .setCurrent(entityPage.getCurrent())
+                .setSize(entityPage.getSize())
+                .setTotal(entityPage.getTotal())
+                .setRecords(result);
+    }
+
     /**
-     * 先清理用户ID所有关联关系, 再绑定用户ID与角色ID
+     * 查询权限表格数据
      */
-    @Transactional(rollbackFor = Exception.class)
-    public void cleanAndBind(Long userId, Collection<Long> roleIds) {
-        sysUserRoleRelationMapper.delete(
-                new QueryWrapper<SysUserRoleRelationEntity>()
-                        .lambda()
-                        .eq(SysUserRoleRelationEntity::getUserId, userId)
-        );
-
-        if (CollUtil.isNotEmpty(roleIds)) {
-            // 需要绑定角色
-            roleIds.forEach(
-                    roleId -> sysUserRoleRelationMapper.insert(
-                            SysUserRoleRelationEntity.builder()
-                                    .userId(userId)
-                                    .roleId(roleId)
-                                    .build()
-                    )
-            );
+    public List<UserRoleRelationBO> queryTableData() {
+        List<UserRoleRelationBO> userRoleRelationBOList = Lists.newArrayList();
+        //查询关系数据
+        List<SysUserRoleRelationEntity> relationEntityList = sysUserRoleRelationMapper.selectList(null);
+        //查询角色
+        List<SysRoleEntity> sysRoleEntities = sysRoleMapper.selectList(null);
+        //查询用户
+        List<SysUserEntity> sysUserEntityList =
+                sysUserMapper.selectList(
+                        new LambdaQueryWrapper<>(SysUserEntity.class)
+                                .eq(SysUserEntity::getStatus, 1)
+                );
+        //查询分组数据
+        List<SysGroupEntity> groupEntityList = sysGroupMapper.selectList(null);
+
+        //数据处理
+        if (CollUtil.isNotEmpty(sysRoleEntities)) {
+            sysRoleEntities.stream()
+                    .sorted(Comparator.comparing(SysRoleEntity::getSortCode).reversed())
+                    .forEach(roleEntity -> {
+                        List<SysUserRoleRelationEntity> roleRelationEntityList = Lists.newArrayList();
+                        if (CollUtil.isNotEmpty(relationEntityList)) {
+                            roleRelationEntityList.addAll(
+                                    relationEntityList.stream()
+                                            .filter(relationEntity -> relationEntity.getRoleId().equals(roleEntity.getId()))
+                                            .toList());
+                        }
+                        List<SysUserEntity> sysUserEntities = Lists.newArrayList();
+                        if (CollUtil.isNotEmpty(roleRelationEntityList) && CollUtil.isNotEmpty(sysUserEntityList)) {
+                            List<Long> userIds =
+                                    roleRelationEntityList.stream()
+                                            .map(SysUserRoleRelationEntity::getUserId)
+                                            .distinct().toList();
+                            sysUserEntities.addAll(
+                                    sysUserEntityList.stream()
+                                            .filter(x -> userIds.contains(x.getId()))
+                                            .toList());
+                        }
+                        //处理数据
+                        userRoleRelationBOList.add(
+                                this.handleResultData(roleEntity, groupEntityList, roleRelationEntityList, sysUserEntities));
+                    });
         }
+
+        return userRoleRelationBOList;
     }
 
     /**
-     * 取拥有角色Ids
-     *
-     * @param userId 用户ID
-     * @return 失败返回空列表
+     * 处理数据
+     * @param roleEntity
+     * @param groupEntityList
+     * @param roleRelationEntityList
+     * @param sysUserEntities
+     * @return
      */
-    public Set<Long> listRoleIdsByUserId(Long userId) throws IllegalArgumentException {
-        if (userId == null) {
-            throw new IllegalArgumentException("userId不能为空");
+    public UserRoleRelationBO handleResultData(SysRoleEntity roleEntity,
+                                               List<SysGroupEntity> groupEntityList,
+                                               List<SysUserRoleRelationEntity> roleRelationEntityList,
+                                               List<SysUserEntity> sysUserEntities) {
+
+        UserRoleRelationBO roleRelationBO = UserRoleRelationBO.builder().build();
+
+        roleRelationBO.setRoleId(roleEntity.getId());
+        roleRelationBO.setRoleName(roleEntity.getTitle());
+        roleRelationBO.setSortCode(roleEntity.getSortCode());
+        //处理分组数据
+        List<SysGroupBO> groupData = Lists.newArrayList();
+        if (roleEntity.getValue().equals("GroupManager")) {
+            groupEntityList.stream()
+                    .sorted(Comparator.comparing(SysGroupEntity::getSortCode))
+                    .forEach(groupEntity -> {
+                        SysGroupBO sysGroupBO = SysGroupBO.builder().build();
+                        sysGroupBO.setId(groupEntity.getId());
+                        sysGroupBO.setTitle(groupEntity.getTitle());
+                        sysGroupBO.setSortCode(groupEntity.getSortCode());
+                        groupData.add(sysGroupBO);
+                    });
         }
+        roleRelationBO.setGroupData(groupData);
 
-        return sysUserRoleRelationMapper.selectList(
-                new QueryWrapper<SysUserRoleRelationEntity>()
-                        .lambda()
-                        .select(SysUserRoleRelationEntity::getRoleId)
-                        .eq(SysUserRoleRelationEntity::getUserId, userId)
-        ).stream().map(SysUserRoleRelationEntity::getRoleId).collect(Collectors.toSet());
+        //处理用户数据
+        List<RoleUserBO> userData = Lists.newArrayList();
+        if (CollUtil.isNotEmpty(roleRelationEntityList)) {
+            if (CollUtil.isNotEmpty(groupData)) {
+                groupData.stream()
+                        .sorted(Comparator.comparing(SysGroupBO::getSortCode))
+                        .forEach(sysGroupBO -> {
+                            List<SysUserRoleRelationEntity> userRoleRelationEntities =
+                                    roleRelationEntityList.stream()
+                                            .filter(x -> x.getGroupId().equals(sysGroupBO.getId()))
+                                            .toList();
+                            if (CollUtil.isNotEmpty(userRoleRelationEntities)) {
+                                //处理用户数据
+                                userData.addAll(
+                                        this.handleUserData(userRoleRelationEntities, sysUserEntities));
+                            }
+                        });
+            } else {
+                //处理用户数据
+                userData.addAll(
+                        this.handleUserData(roleRelationEntityList, sysUserEntities));
+            }
+        }
+        roleRelationBO.setUserData(userData);
+        return roleRelationBO;
     }
 
     /**
-     * 取角色IDs关联的用户IDs
-     *
-     * @param roleIds 角色IDs
-     * @return 空集合or用户IDs
+     * 处理用户数据
+     * @param roleRelationEntityList
+     * @param sysUserEntities
+     * @return
      */
-    public Set<Long> listUserIdsByRoleIds(Collection<Long> roleIds) {
-        if (CollUtil.isEmpty(roleIds)) {
-            return Collections.emptySet();
-        }
+    public List<RoleUserBO> handleUserData(List<SysUserRoleRelationEntity> roleRelationEntityList,
+                                           List<SysUserEntity> sysUserEntities) {
+        List<RoleUserBO> userData = Lists.newArrayList();
+        roleRelationEntityList.stream()
+                .sorted(Comparator.comparing(HelioBaseEntity::getCreatedAt))
+                .forEach(roleRelation -> {
+                    if (CollUtil.isNotEmpty(sysUserEntities)) {
+                        sysUserEntities.stream()
+                                .filter(x -> x.getId().equals(roleRelation.getUserId()))
+                                .findFirst()
+                                .ifPresent(user -> {
+                                    if (CollUtil.isEmpty(userData) || userData.stream().map(RoleUserBO::getUserId).noneMatch(user.getId()::equals)) {
+                                        RoleUserBO roleUserBO = RoleUserBO.builder().build();
+                                        roleUserBO.setId(roleRelation.getId());
+                                        roleUserBO.setUserId(user.getId());
+                                        roleUserBO.setUserName(user.getUserName());
+                                        roleUserBO.setAccount(user.getPin());
+                                        roleUserBO.setGroupId(roleRelation.getGroupId());
+                                        userData.add(roleUserBO);
+                                    }
+                                });
+                    }
+                });
+        return userData;
+    }
+
 
-        return sysUserRoleRelationMapper.selectList(
-                new QueryWrapper<SysUserRoleRelationEntity>()
-                        .lambda()
-                        .select(SysUserRoleRelationEntity::getUserId)
-                        .in(SysUserRoleRelationEntity::getRoleId, roleIds)
-        ).stream().map(SysUserRoleRelationEntity::getUserId).collect(Collectors.toSet());
+    /**
+     * 后台管理-新增
+     * 注：本方法较为特殊，仅供SysTenantFacadeImpl调用
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public Long adminInsert(UserRoleRelationInsertDTO dto) {
+        SysUserRoleRelationEntity entity = new SysUserRoleRelationEntity()
+                .setUserId(dto.getUserId()).setRoleId(dto.getRoleId()).setGroupId(dto.getGroupId());
+        sysUserRoleRelationMapper.insert(entity);
+        return entity.getId();
     }
+
+
+    public void delete(Long id) {
+        sysUserRoleRelationMapper.deleteById(id);
+    }
+
 }

src/main/java/com/jtzx/crm/module/sys/service/SysUserService.java

@@ -13,7 +13,9 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.jtzx.crm.module.sys.entity.SysUserEntity;
+import com.jtzx.crm.module.sys.entity.SysUserGroupRelationEntity;
 import com.jtzx.crm.module.sys.enums.SysErrorEnum;
+import com.jtzx.crm.module.sys.mapper.SysUserGroupRelationMapper;
 import com.jtzx.crm.module.sys.mapper.SysUserMapper;
 import com.jtzx.crm.module.sys.model.request.AdminListSysUserDTO;
 import com.jtzx.crm.module.sys.model.request.InsertOrUpdateSysUserDTO;
@@ -41,6 +43,7 @@ public class SysUserService {
 
     private final SysUserMapper sysUserMapper;
     private final SysRoleService sysRoleService;
+    private final SysUserGroupRelationMapper sysUserGroupRelationMapper;
 
     /**
      * 后台管理-分页列表
@@ -123,6 +126,11 @@ public class SysUserService {
     public void adminDelete(Collection<Long> ids) {
         log.info("[后台管理-删除后台用户] >> 入参={}", ids);
         preDeleteCheck(ids);
+        //删除关系
+        sysUserGroupRelationMapper.delete(
+                new LambdaQueryWrapper<>(SysUserGroupRelationEntity.class)
+                        .in(SysUserGroupRelationEntity::getUserId,ids)
+        );
         sysUserMapper.deleteByIds(ids);
     }