简柏林 / thingskit · Commits

Commit cdbe21506c6fc3802c465f9a049fb85976baab94

Authored by xp.Huang
1 parent ed43d3dd

fix: 使用中的角色不能被禁用

Inline Side-by-side
Showing 2 changed files with 239 additions and 208 deletions
... ... @@ -101,6 +101,7 @@ public enum ErrorMessage {
101 101 NAME_OR_IDENTIFIER_IS_EMPTY(400077,"【%s】的名称或标识符不能为空或空字符串"),
102 102 IDENTIFIER_ALREADY_EXISTS(400078,"标识符【%s】已经存在"),
103 103 DEVICE_IDENTIFIER_REPEATED(400079,"设备地址码或标识码【%s】与设备【%s】重复"),
  104 + CURRENT_ROLE_IN_USE(400080,"当前角色正在被【%s】使用,不能被禁用"),
104 105 HAVE_NO_PERMISSION(500002,"没有修改权限");
105 106 private final int code;
106 107 private String message;
... ...
1 1 package org.thingsboard.server.dao.yunteng.impl;
2 2
  3 +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
3 4 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
4 5 import com.baomidou.mybatisplus.core.metadata.IPage;
5 6 import com.google.common.collect.Sets;
... ... @@ -17,11 +18,9 @@ import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
17 18 import org.thingsboard.server.common.data.yunteng.dto.RoleDTO;
18 19 import org.thingsboard.server.common.data.yunteng.dto.request.RoleReqDTO;
19 20 import org.thingsboard.server.common.data.yunteng.enums.RoleEnum;
  21 +import org.thingsboard.server.common.data.yunteng.enums.StatusEnum;
20 22 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
21   -import org.thingsboard.server.dao.yunteng.entities.SysRoleEntity;
22   -import org.thingsboard.server.dao.yunteng.entities.SysTenantMenuEntity;
23   -import org.thingsboard.server.dao.yunteng.entities.SysTenantRoleEntity;
24   -import org.thingsboard.server.dao.yunteng.entities.SysUserRoleEntity;
  23 +import org.thingsboard.server.dao.yunteng.entities.*;
25 24 import org.thingsboard.server.dao.yunteng.mapper.*;
26 25 import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
27 26 import org.thingsboard.server.dao.yunteng.service.MenuService;
... ... @@ -33,224 +32,255 @@ import java.util.stream.Collectors;
33 32 @Service
34 33 @Slf4j
35 34 @RequiredArgsConstructor
36   -public class SysRoleServiceImpl extends AbstractBaseService<RoleMapper, SysRoleEntity> implements RoleService {
  35 +public class SysRoleServiceImpl extends AbstractBaseService<RoleMapper, SysRoleEntity>
  36 + implements RoleService {
37 37
38   - private final MenuMapper menuMapper;
39   - private final CacheUtils cacheUtils;
40   - private final MenuService menuService;
41   - private final TenantMenuMapper tenantMenuMapper;
42   - private final TenantRoleMapper tenantRoleMapper;
43   - private final UserRoleMapper userRoleMapper;
  38 + private final MenuMapper menuMapper;
  39 + private final CacheUtils cacheUtils;
  40 + private final MenuService menuService;
  41 + private final TenantMenuMapper tenantMenuMapper;
  42 + private final TenantRoleMapper tenantRoleMapper;
  43 + private final UserRoleMapper userRoleMapper;
  44 + private final UserMapper userMapper;
44 45
45   - @Override
46   - public TkPageData<RoleDTO> page(String tenantId, Map<String, Object> queryMap) {
47   - IPage<SysRoleEntity> roleIPage =
48   - baseMapper.selectPage(
49   - getPage(queryMap, "create_time", false),
50   - new QueryWrapper<SysRoleEntity>()
51   - .lambda()
52   - .eq(queryMap.get("status") != null, SysRoleEntity::isEnabled, queryMap.get("status"))
53   - .eq(queryMap.get("roleType") != null, SysRoleEntity::getRoleType, queryMap.get("roleType"))
54   - .ne(queryMap.get("roleType") == null, SysRoleEntity::getRoleType, RoleEnum.TENANT_ADMIN.name())
55   - .eq(SysRoleEntity::getTenantId, tenantId)
56   - .like(
57   - queryMap.get("roleName") != null,
58   - SysRoleEntity::getName,
59   - String.valueOf(queryMap.get("roleName"))));
60   - return getPageData(roleIPage, RoleDTO.class);
  46 + @Override
  47 + public TkPageData<RoleDTO> page(String tenantId, Map<String, Object> queryMap) {
  48 + IPage<SysRoleEntity> roleIPage =
  49 + baseMapper.selectPage(
  50 + getPage(queryMap, "create_time", false),
  51 + new QueryWrapper<SysRoleEntity>()
  52 + .lambda()
  53 + .eq(
  54 + queryMap.get("status") != null,
  55 + SysRoleEntity::isEnabled,
  56 + queryMap.get("status"))
  57 + .eq(
  58 + queryMap.get("roleType") != null,
  59 + SysRoleEntity::getRoleType,
  60 + queryMap.get("roleType"))
  61 + .ne(
  62 + queryMap.get("roleType") == null,
  63 + SysRoleEntity::getRoleType,
  64 + RoleEnum.TENANT_ADMIN.name())
  65 + .eq(SysRoleEntity::getTenantId, tenantId)
  66 + .like(
  67 + queryMap.get("roleName") != null,
  68 + SysRoleEntity::getName,
  69 + String.valueOf(queryMap.get("roleName"))));
  70 + return getPageData(roleIPage, RoleDTO.class);
  71 + }
  72 +
  73 + @Override
  74 + @Transactional
  75 + public boolean deleteRole(String[] roleIds, String tenantId) {
  76 + Set<String> ids = Set.of(roleIds);
  77 + int notTenantMenuCount =
  78 + baseMapper.selectCount(
  79 + new QueryWrapper<SysRoleEntity>()
  80 + .lambda()
  81 + .ne(SysRoleEntity::getTenantId, tenantId)
  82 + .in(SysRoleEntity::getId, ids));
  83 + if (notTenantMenuCount > 0) {
  84 + throw new AccessDeniedException("只能删除自己创建的角色");
  85 + }
  86 + // 判断该角色下面是否有用户
  87 + Set<String> userIds = baseMapper.checkRoleUserMappingByRoleIds(ids);
  88 + if (null != userIds && userIds.size() > 0) {
  89 + throw new TkDataValidationException(ErrorMessage.ROLE_IN_USE.getMessage());
61 90 }
  91 + // delete sys_role_menu mapping
  92 + baseMapper.deleteRoleMenuMappingByRoleIds(ids);
  93 + // delete role
  94 + baseMapper.deleteBatchIds(ids);
  95 + // FIXME 频繁删除role造成缓存效果不大
  96 + cacheUtils.invalidateCacheName(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY);
  97 + return true;
  98 + }
62 99
63   - @Override
64   - @Transactional
65   - public boolean deleteRole(String[] roleIds, String tenantId) {
66   - Set<String> ids = Set.of(roleIds);
67   - int notTenantMenuCount =
68   - baseMapper.selectCount(
69   - new QueryWrapper<SysRoleEntity>().lambda().ne(SysRoleEntity::getTenantId, tenantId).in(SysRoleEntity::getId, ids));
70   - if (notTenantMenuCount > 0) {
71   - throw new AccessDeniedException("只能删除自己创建的角色");
72   - }
73   - // 判断该角色下面是否有用户
74   - Set<String> userIds = baseMapper.checkRoleUserMappingByRoleIds(ids);
75   - if (null != userIds && userIds.size() > 0) {
76   - throw new TkDataValidationException(ErrorMessage.ROLE_IN_USE.getMessage());
77   - }
78   - // delete sys_role_menu mapping
79   - baseMapper.deleteRoleMenuMappingByRoleIds(ids);
80   - // delete role
81   - baseMapper.deleteBatchIds(ids);
82   - // FIXME 频繁删除role造成缓存效果不大
83   - cacheUtils.invalidateCacheName(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY);
84   - return true;
  100 + @Override
  101 + public Set<String> getPermissions(
  102 + boolean isSysadmin, boolean isTenantAdmin, String tenantId, String useerId) {
  103 + Set<String> permissions = Sets.newHashSet();
  104 + Set<String> allPermission;
  105 + String cacheKey;
  106 + boolean cachePresent;
  107 + if (isSysadmin) {
  108 + cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + RoleEnum.SYS_ADMIN.name();
  109 + Optional<Set<String>> optionalPermission =
  110 + cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);
  111 + cachePresent = optionalPermission.isPresent();
  112 + allPermission = optionalPermission.orElseGet(menuMapper::getAllPermission);
  113 + } else if (isTenantAdmin) {
  114 + cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + tenantId;
  115 + Optional<Set<String>> optionalPermission =
  116 + cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);
  117 + cachePresent = optionalPermission.isPresent();
  118 + allPermission =
  119 + optionalPermission.orElseGet(() -> menuMapper.getAllPermissionsByTenantId(tenantId));
  120 + } else {
  121 + cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + useerId;
  122 + Optional<Set<String>> optionalPermission =
  123 + cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);
  124 + cachePresent = optionalPermission.isPresent();
  125 + allPermission =
  126 + optionalPermission.orElseGet(() -> menuMapper.getAllPermissionsByUserId(useerId));
  127 + }
  128 + if (cachePresent) {
  129 + return allPermission;
  130 + } else {
  131 + allPermission.forEach(
  132 + permission -> permissions.addAll(Sets.newHashSet(permission.split(","))));
  133 + cacheUtils.put(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey, permissions);
85 134 }
  135 + return permissions;
  136 + }
86 137
87   - @Override
88   - public Set<String> getPermissions(
89   - boolean isSysadmin, boolean isTenantAdmin, String tenantId, String useerId) {
90   - Set<String> permissions = Sets.newHashSet();
91   - Set<String> allPermission;
92   - String cacheKey;
93   - boolean cachePresent;
94   - if (isSysadmin) {
95   - cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + RoleEnum.SYS_ADMIN.name();
96   - Optional<Set<String>> optionalPermission =
97   - cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);
98   - cachePresent = optionalPermission.isPresent();
99   - allPermission = optionalPermission.orElseGet(menuMapper::getAllPermission);
100   - } else if (isTenantAdmin) {
101   - cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + tenantId;
102   - Optional<Set<String>> optionalPermission =
103   - cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);
104   - cachePresent = optionalPermission.isPresent();
105   - allPermission =
106   - optionalPermission.orElseGet(() -> menuMapper.getAllPermissionsByTenantId(tenantId));
107   - } else {
108   - cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + useerId;
109   - Optional<Set<String>> optionalPermission =
110   - cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);
111   - cachePresent = optionalPermission.isPresent();
112   - allPermission =
113   - optionalPermission.orElseGet(() -> menuMapper.getAllPermissionsByUserId(useerId));
  138 + @Override
  139 + @Transactional
  140 + public void updateRoleStatus(String roleId, int status, boolean isSysadmin, String tenantId) {
  141 + if (status == StatusEnum.DISABLE.getIndex()) {
  142 + List<SysUserRoleEntity> entities =
  143 + userRoleMapper.selectList(
  144 + new LambdaQueryWrapper<SysUserRoleEntity>().eq(SysUserRoleEntity::getRoleId, roleId));
  145 + if (null != entities && !entities.isEmpty()) {
  146 + SysUserEntity entity = userMapper.selectById(entities.get(0).getUserId());
  147 + if (null != entity) {
  148 + throw new TkDataValidationException(
  149 + String.format(ErrorMessage.CURRENT_ROLE_IN_USE.getMessage(), entity.getRealName()));
114 150 }
115   - if (cachePresent) {
116   - return allPermission;
117   - } else {
118   - allPermission.forEach(
119   - permission -> permissions.addAll(Sets.newHashSet(permission.split(","))));
120   - cacheUtils.put(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey, permissions);
121   - }
122   - return permissions;
  151 + }
123 152 }
  153 + Optional.ofNullable(
  154 + baseMapper.selectOne(
  155 + new QueryWrapper<SysRoleEntity>()
  156 + .lambda()
  157 + .eq(SysRoleEntity::getId, roleId)
  158 + .eq(!isSysadmin, SysRoleEntity::getTenantId, tenantId)))
  159 + .ifPresent(
  160 + role -> {
  161 + role.setEnabled(status == 1);
  162 + baseMapper.updateById(role);
  163 + });
  164 + }
124 165
125   - @Override
126   - @Transactional
127   - public void updateRoleStatus(String roleId, int status, boolean isSysadmin, String tenantId) {
128   - Optional.ofNullable(
129   - baseMapper.selectOne(
130   - new QueryWrapper<SysRoleEntity>()
131   - .lambda()
132   - .eq(SysRoleEntity::getId, roleId)
133   - .eq(!isSysadmin, SysRoleEntity::getTenantId, tenantId)))
134   - .ifPresent(
135   - role -> {
136   - role.setEnabled(status == 1);
137   - baseMapper.updateById(role);
138   - });
  166 + @Override
  167 + @Transactional
  168 + public RoleDTO saveOrUpdateRoleInfoWithMenu(
  169 + RoleReqDTO roleReqDTO, boolean isSysadmin, boolean isPlatformAdmin, String tenantId) {
  170 + SysRoleEntity role;
  171 + // 默认普通管理员角色,即租户管理员添加的角色
  172 + var roleType = RoleEnum.CUSTOMER_USER.name();
  173 + if (null != roleReqDTO.getRoleType()) {
  174 + roleType = roleReqDTO.getRoleType().name();
  175 + } else {
  176 + if (isSysadmin || isPlatformAdmin) {
  177 + roleType = RoleEnum.PLATFORM_ADMIN.name();
  178 + }
139 179 }
140   -
141   - @Override
142   - @Transactional
143   - public RoleDTO saveOrUpdateRoleInfoWithMenu(
144   - RoleReqDTO roleReqDTO, boolean isSysadmin, boolean isPlatformAdmin, String tenantId) {
145   - SysRoleEntity role;
146   - // 默认普通管理员角色,即租户管理员添加的角色
147   - var roleType = RoleEnum.CUSTOMER_USER.name();
148   - if (null != roleReqDTO.getRoleType()) {
149   - roleType = roleReqDTO.getRoleType().name();
150   - } else {
151   - if (isSysadmin || isPlatformAdmin) {
152   - roleType = RoleEnum.PLATFORM_ADMIN.name();
153   - }
154   - }
155   - boolean update = StringUtils.isNotBlank(roleReqDTO.getId());
156   - if (update) {
157   - // do update
158   - role =
159   - baseMapper.selectOne(
160   - new QueryWrapper<SysRoleEntity>()
161   - .lambda()
162   - .eq(SysRoleEntity::getId, roleReqDTO.getId())
163   - .eq(!isSysadmin, SysRoleEntity::getTenantId, tenantId));
164   - if (role == null) {
165   - return null;
166   - } else {
167   - role.setRemark(roleReqDTO.getRemark());
168   - role.setName(roleReqDTO.getName());
169   - role.setEnabled(roleReqDTO.getStatus() == 1);
170   - baseMapper.updateById(role);
171   - }
  180 + boolean update = StringUtils.isNotBlank(roleReqDTO.getId());
  181 + if (update) {
  182 + // do update
  183 + role =
  184 + baseMapper.selectOne(
  185 + new QueryWrapper<SysRoleEntity>()
  186 + .lambda()
  187 + .eq(SysRoleEntity::getId, roleReqDTO.getId())
  188 + .eq(!isSysadmin, SysRoleEntity::getTenantId, tenantId));
  189 + if (role == null) {
  190 + return null;
  191 + } else {
  192 + role.setRemark(roleReqDTO.getRemark());
  193 + role.setName(roleReqDTO.getName());
  194 + role.setEnabled(roleReqDTO.getStatus() == 1);
  195 + baseMapper.updateById(role);
  196 + }
  197 + } else {
  198 + // do save
  199 + role = new SysRoleEntity();
  200 + role.setRoleType(roleType);
  201 + role.setCode(RandomStringUtils.randomAlphabetic(10));
  202 + role.setRemark(roleReqDTO.getRemark());
  203 + role.setName(roleReqDTO.getName());
  204 + role.setEnabled(roleReqDTO.getStatus() == 1);
  205 + role.setTenantId(tenantId);
  206 + baseMapper.insert(role);
  207 + }
  208 + Set<String> oldMenus = menuMapper.selectRoleMenuIds(role.getId());
  209 + // do update or save menu associate with this roleId
  210 + menuService.assignMenuToRole(
  211 + roleReqDTO.getMenu().toArray(new String[roleReqDTO.getMenu().size()]), role.getId());
  212 + // 如果是租户管理员角色并且是更新，则需要更新租户菜单表
  213 + if (role.getRoleType().equals(RoleEnum.TENANT_ADMIN.name()) && update) {
  214 + List<String> newMenus = roleReqDTO.getMenu();
  215 + Set<String> removeMenus = new HashSet<>();
  216 + for (String menu : oldMenus) {
  217 + if (newMenus.contains(menu)) {
  218 + newMenus.remove(menu);
172 219 } else {
173   - // do save
174   - role = new SysRoleEntity();
175   - role.setRoleType(roleType);
176   - role.setCode(RandomStringUtils.randomAlphabetic(10));
177   - role.setRemark(roleReqDTO.getRemark());
178   - role.setName(roleReqDTO.getName());
179   - role.setEnabled(roleReqDTO.getStatus() == 1);
180   - role.setTenantId(tenantId);
181   - baseMapper.insert(role);
  220 + removeMenus.add(menu);
182 221 }
183   - Set<String> oldMenus = menuMapper.selectRoleMenuIds(role.getId());
184   - // do update or save menu associate with this roleId
185   - menuService.assignMenuToRole(
186   - roleReqDTO.getMenu().toArray(new String[roleReqDTO.getMenu().size()]), role.getId());
187   - // 如果是租户管理员角色并且是更新，则需要更新租户菜单表
188   - if (role.getRoleType().equals(RoleEnum.TENANT_ADMIN.name()) && update) {
189   - List<String> newMenus = roleReqDTO.getMenu();
190   - Set<String> removeMenus = new HashSet<>();
191   - for(String menu: oldMenus){
192   - if(newMenus.contains(menu)){
193   - newMenus.remove(menu);
194   - }else{
195   - removeMenus.add(menu);
196   - }
197   - }
198   - // 先删除以前的租户菜单，再更新新的租户菜单
199   - // 1、查询这个角色有几个租户用户
200   - // 2、删除并更新对应租户的信息
201   - // 3、超级管理员删除租户角色菜单时，同步删除租户内客户角色的权限，租户ID+菜单ID
202   - List<SysTenantRoleEntity> tenantRoles =
203   - tenantRoleMapper.selectList(
204   - new QueryWrapper<SysTenantRoleEntity>().lambda().eq(SysTenantRoleEntity::getRoleId, role.getId()));
205   - tenantRoles.forEach(
206   - tenantRole -> {
207   - String updateTenantId = tenantRole.getTenantId();
208   -
209   - if(!removeMenus.isEmpty()){
210   - //刷新租户的菜单
211   - tenantMenuMapper.delete(
212   - new QueryWrapper<SysTenantMenuEntity>()
213   - .lambda()
214   - .eq(SysTenantMenuEntity::getTenantId, updateTenantId)
215   - .in(SysTenantMenuEntity::getMenuId,removeMenus));
216   - //刷新客户的菜单
217   - List<SysRoleEntity> customerRoles = baseMapper.selectList(
218   - new QueryWrapper<SysRoleEntity>()
219   - .lambda()
220   - .eq(SysRoleEntity::getTenantId, updateTenantId)
221   - .eq(SysRoleEntity::getRoleType,RoleEnum.CUSTOMER_USER.name()));
222   - customerRoles.forEach(cr -> menuMapper.removeMenuFromRole(cr.getId(),removeMenus));
223   - }
224   - newMenus.forEach(
225   - menu -> {
226   - SysTenantMenuEntity tenantMenu = new SysTenantMenuEntity();
227   - tenantMenu.setMenuId(menu);
228   - tenantMenu.setTenantId(updateTenantId);
229   - tenantMenuMapper.insert(tenantMenu);
230   - });
  222 + }
  223 + // 先删除以前的租户菜单，再更新新的租户菜单
  224 + // 1、查询这个角色有几个租户用户
  225 + // 2、删除并更新对应租户的信息
  226 + // 3、超级管理员删除租户角色菜单时，同步删除租户内客户角色的权限，租户ID+菜单ID
  227 + List<SysTenantRoleEntity> tenantRoles =
  228 + tenantRoleMapper.selectList(
  229 + new QueryWrapper<SysTenantRoleEntity>()
  230 + .lambda()
  231 + .eq(SysTenantRoleEntity::getRoleId, role.getId()));
  232 + tenantRoles.forEach(
  233 + tenantRole -> {
  234 + String updateTenantId = tenantRole.getTenantId();
231 235
232   - });
233   - }
234   - cacheUtils.invalidateCacheName(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY);
235   - return role.getDTO(RoleDTO.class);
  236 + if (!removeMenus.isEmpty()) {
  237 + // 刷新租户的菜单
  238 + tenantMenuMapper.delete(
  239 + new QueryWrapper<SysTenantMenuEntity>()
  240 + .lambda()
  241 + .eq(SysTenantMenuEntity::getTenantId, updateTenantId)
  242 + .in(SysTenantMenuEntity::getMenuId, removeMenus));
  243 + // 刷新客户的菜单
  244 + List<SysRoleEntity> customerRoles =
  245 + baseMapper.selectList(
  246 + new QueryWrapper<SysRoleEntity>()
  247 + .lambda()
  248 + .eq(SysRoleEntity::getTenantId, updateTenantId)
  249 + .eq(SysRoleEntity::getRoleType, RoleEnum.CUSTOMER_USER.name()));
  250 + customerRoles.forEach(cr -> menuMapper.removeMenuFromRole(cr.getId(), removeMenus));
  251 + }
  252 + newMenus.forEach(
  253 + menu -> {
  254 + SysTenantMenuEntity tenantMenu = new SysTenantMenuEntity();
  255 + tenantMenu.setMenuId(menu);
  256 + tenantMenu.setTenantId(updateTenantId);
  257 + tenantMenuMapper.insert(tenantMenu);
  258 + });
  259 + });
236 260 }
  261 + cacheUtils.invalidateCacheName(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY);
  262 + return role.getDTO(RoleDTO.class);
  263 + }
237 264
238   - @Override
239   - public List<RoleDTO> findRoleInfo(
240   - boolean isTenantAdmin, String tenantId, String userId, RoleDTO roleDTO) {
241   - if (StringUtils.isEmpty(roleDTO.getTenantId())) {
242   - roleDTO.setTenantId(tenantId);
243   - }
244   - if (isTenantAdmin) {
245   - // 租户管理员既要查询自己拥有的角色，也要查询自己创建的角色
246   - List<String> roleIds =
247   - userRoleMapper
248   - .selectList(new QueryWrapper<SysUserRoleEntity>().lambda().eq(SysUserRoleEntity::getUserId, userId))
249   - .stream()
250   - .map(SysUserRoleEntity::getRoleId)
251   - .collect(Collectors.toList());
252   - roleDTO.setRoleIds(roleIds.toArray(new String[roleIds.size()]));
253   - }
254   - return baseMapper.findRoleInfo(roleDTO);
  265 + @Override
  266 + public List<RoleDTO> findRoleInfo(
  267 + boolean isTenantAdmin, String tenantId, String userId, RoleDTO roleDTO) {
  268 + if (StringUtils.isEmpty(roleDTO.getTenantId())) {
  269 + roleDTO.setTenantId(tenantId);
  270 + }
  271 + if (isTenantAdmin) {
  272 + // 租户管理员既要查询自己拥有的角色，也要查询自己创建的角色
  273 + List<String> roleIds =
  274 + userRoleMapper
  275 + .selectList(
  276 + new QueryWrapper<SysUserRoleEntity>()
  277 + .lambda()
  278 + .eq(SysUserRoleEntity::getUserId, userId))
  279 + .stream()
  280 + .map(SysUserRoleEntity::getRoleId)
  281 + .collect(Collectors.toList());
  282 + roleDTO.setRoleIds(roleIds.toArray(new String[roleIds.size()]));
255 283 }
  284 + return baseMapper.findRoleInfo(roleDTO);
  285 + }
256 286 }
... ...