简柏林 / 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,6 +101,7 @@ public enum ErrorMessage {
101 NAME_OR_IDENTIFIER_IS_EMPTY(400077,"【%s】的名称或标识符不能为空或空字符串"), 101 NAME_OR_IDENTIFIER_IS_EMPTY(400077,"【%s】的名称或标识符不能为空或空字符串"),
102 IDENTIFIER_ALREADY_EXISTS(400078,"标识符【%s】已经存在"), 102 IDENTIFIER_ALREADY_EXISTS(400078,"标识符【%s】已经存在"),
103 DEVICE_IDENTIFIER_REPEATED(400079,"设备地址码或标识码【%s】与设备【%s】重复"), 103 DEVICE_IDENTIFIER_REPEATED(400079,"设备地址码或标识码【%s】与设备【%s】重复"),
  104 + CURRENT_ROLE_IN_USE(400080,"当前角色正在被【%s】使用,不能被禁用"),
104 HAVE_NO_PERMISSION(500002,"没有修改权限"); 105 HAVE_NO_PERMISSION(500002,"没有修改权限");
105 private final int code; 106 private final int code;
106 private String message; 107 private String message;
1 package org.thingsboard.server.dao.yunteng.impl; 1 package org.thingsboard.server.dao.yunteng.impl;
2 2
  3 +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
3 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; 4 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
4 import com.baomidou.mybatisplus.core.metadata.IPage; 5 import com.baomidou.mybatisplus.core.metadata.IPage;
5 import com.google.common.collect.Sets; 6 import com.google.common.collect.Sets;
@@ -17,11 +18,9 @@ import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage; @@ -17,11 +18,9 @@ import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
17 import org.thingsboard.server.common.data.yunteng.dto.RoleDTO; 18 import org.thingsboard.server.common.data.yunteng.dto.RoleDTO;
18 import org.thingsboard.server.common.data.yunteng.dto.request.RoleReqDTO; 19 import org.thingsboard.server.common.data.yunteng.dto.request.RoleReqDTO;
19 import org.thingsboard.server.common.data.yunteng.enums.RoleEnum; 20 import org.thingsboard.server.common.data.yunteng.enums.RoleEnum;
  21 +import org.thingsboard.server.common.data.yunteng.enums.StatusEnum;
20 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData; 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 import org.thingsboard.server.dao.yunteng.mapper.*; 24 import org.thingsboard.server.dao.yunteng.mapper.*;
26 import org.thingsboard.server.dao.yunteng.service.AbstractBaseService; 25 import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
27 import org.thingsboard.server.dao.yunteng.service.MenuService; 26 import org.thingsboard.server.dao.yunteng.service.MenuService;
@@ -33,224 +32,255 @@ import java.util.stream.Collectors; @@ -33,224 +32,255 @@ import java.util.stream.Collectors;
33 @Service 32 @Service
34 @Slf4j 33 @Slf4j
35 @RequiredArgsConstructor 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 } else { 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 }