简柏林 / thingskit · Commits

Commit 9cbc658cec37aae27e08381343a8aad42da693e1

Authored by xp.Huang
2 parents d4b5685c 058cb274

Merge branch '20220510' into 'master' 

20220510

See merge request huang/thingsboard3.3.2!95
Inline Side-by-side
Showing 2 changed files with 496 additions and 439 deletions
@@ -38,198 +38,199 @@ import java.util.stream.Collectors; @@ -38,198 +38,199 @@ import java.util.stream.Collectors;
38 @RequiredArgsConstructor 38 @RequiredArgsConstructor
39 public class RoleServiceImpl extends AbstractBaseService<RoleMapper, Role> implements RoleService { 39 public class RoleServiceImpl extends AbstractBaseService<RoleMapper, Role> implements RoleService {
40 40
41 - private final MenuMapper menuMapper;  
42 - private final CacheUtils cacheUtils;  
43 - private final MenuService menuService;  
44 - private final TenantMenuMapper tenantMenuMapper;  
45 - private final TenantRoleMapper tenantRoleMapper;  
46 - private final UserRoleMapper userRoleMapper; 41 + private final MenuMapper menuMapper;
  42 + private final CacheUtils cacheUtils;
  43 + private final MenuService menuService;
  44 + private final TenantMenuMapper tenantMenuMapper;
  45 + private final TenantRoleMapper tenantRoleMapper;
  46 + private final UserRoleMapper userRoleMapper;
47 47
48 - @Override  
49 - public YtPageData<RoleDTO> page(String tenantId, Map<String, Object> queryMap) {  
50 - IPage<Role> roleIPage =  
51 - baseMapper.selectPage(  
52 - getPage(queryMap, "create_time", false),  
53 - new QueryWrapper<Role>()  
54 - .lambda()  
55 - .eq(queryMap.get("status") != null, Role::isEnabled, queryMap.get("status"))  
56 - .eq(queryMap.get("roleType") != null, Role::getRoleType, queryMap.get("roleType"))  
57 - .ne(queryMap.get("roleType") == null, Role::getRoleType, RoleEnum.TENANT_ADMIN.name())  
58 - .eq(Role::getTenantId, tenantId)  
59 - .like(  
60 - queryMap.get("roleName") != null,  
61 - Role::getName,  
62 - String.valueOf(queryMap.get("roleName"))));  
63 - return getPageData(roleIPage, RoleDTO.class);  
64 - }  
65 -  
66 - @Override  
67 - @Transactional  
68 - public boolean deleteRole(String[] roleIds, String tenantId) {  
69 - Set<String> ids = Set.of(roleIds);  
70 - int notTenantMenuCount =  
71 - baseMapper.selectCount(  
72 - new QueryWrapper<Role>().lambda().ne(Role::getTenantId, tenantId).in(Role::getId, ids));  
73 - if (notTenantMenuCount > 0) {  
74 - throw new AccessDeniedException("cannot delete role that not create by you");  
75 - }  
76 - // 判断该角色下面是否有用户  
77 - Set<String> userIds = baseMapper.checkRoleUserMappingByRoleIds(ids);  
78 - if (null != userIds && userIds.size() > 0) {  
79 - throw new YtDataValidationException(ErrorMessage.ROLE_IN_USE.getMessage()); 48 + @Override
  49 + public YtPageData<RoleDTO> page(String tenantId, Map<String, Object> queryMap) {
  50 + IPage<Role> roleIPage =
  51 + baseMapper.selectPage(
  52 + getPage(queryMap, "create_time", false),
  53 + new QueryWrapper<Role>()
  54 + .lambda()
  55 + .eq(queryMap.get("status") != null, Role::isEnabled, queryMap.get("status"))
  56 + .eq(queryMap.get("roleType") != null, Role::getRoleType, queryMap.get("roleType"))
  57 + .ne(queryMap.get("roleType") == null, Role::getRoleType, RoleEnum.TENANT_ADMIN.name())
  58 + .eq(Role::getTenantId, tenantId)
  59 + .like(
  60 + queryMap.get("roleName") != null,
  61 + Role::getName,
  62 + String.valueOf(queryMap.get("roleName"))));
  63 + return getPageData(roleIPage, RoleDTO.class);
80 } 64 }
81 - // delete sys_role_menu mapping  
82 - baseMapper.deleteRoleMenuMappingByRoleIds(ids);  
83 - // delete role  
84 - baseMapper.deleteBatchIds(ids);  
85 - // FIXME 频繁删除role造成缓存效果不大  
86 - cacheUtils.invalidateCacheName(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY);  
87 - return true;  
88 - }  
89 65
90 - @Override  
91 - public Set<String> getPermissions(  
92 - boolean isSysadmin, boolean isTenantAdmin, String tenantId, String useerId) {  
93 - Set<String> permissions = Sets.newHashSet();  
94 - Set<String> allPermission;  
95 - String cacheKey;  
96 - boolean cachePresent;  
97 - if (isSysadmin) {  
98 - cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + RoleEnum.SYS_ADMIN.name();  
99 - Optional<Set<String>> optionalPermission =  
100 - cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);  
101 - cachePresent = optionalPermission.isPresent();  
102 - allPermission = optionalPermission.orElseGet(menuMapper::getAllPermission);  
103 - } else if (isTenantAdmin) {  
104 - cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + tenantId;  
105 - Optional<Set<String>> optionalPermission =  
106 - cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);  
107 - cachePresent = optionalPermission.isPresent();  
108 - allPermission =  
109 - optionalPermission.orElseGet(() -> menuMapper.getAllPermissionsByTenantId(tenantId));  
110 - } else {  
111 - cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + useerId;  
112 - Optional<Set<String>> optionalPermission =  
113 - cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);  
114 - cachePresent = optionalPermission.isPresent();  
115 - allPermission =  
116 - optionalPermission.orElseGet(() -> menuMapper.getAllPermissionsByUserId(useerId)); 66 + @Override
  67 + @Transactional
  68 + public boolean deleteRole(String[] roleIds, String tenantId) {
  69 + Set<String> ids = Set.of(roleIds);
  70 + int notTenantMenuCount =
  71 + baseMapper.selectCount(
  72 + new QueryWrapper<Role>().lambda().ne(Role::getTenantId, tenantId).in(Role::getId, ids));
  73 + if (notTenantMenuCount > 0) {
  74 + throw new AccessDeniedException("cannot delete role that not create by you");
  75 + }
  76 + // 判断该角色下面是否有用户
  77 + Set<String> userIds = baseMapper.checkRoleUserMappingByRoleIds(ids);
  78 + if (null != userIds && userIds.size() > 0) {
  79 + throw new YtDataValidationException(ErrorMessage.ROLE_IN_USE.getMessage());
  80 + }
  81 + // delete sys_role_menu mapping
  82 + baseMapper.deleteRoleMenuMappingByRoleIds(ids);
  83 + // delete role
  84 + baseMapper.deleteBatchIds(ids);
  85 + // FIXME 频繁删除role造成缓存效果不大
  86 + cacheUtils.invalidateCacheName(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY);
  87 + return true;
117 } 88 }
118 - if (cachePresent) {  
119 - return allPermission;  
120 - } else {  
121 - allPermission.forEach(  
122 - permission -> permissions.addAll(Sets.newHashSet(permission.split(","))));  
123 - cacheUtils.put(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey, permissions);  
124 - }  
125 - return permissions;  
126 - }  
127 -  
128 - @Override  
129 - @Transactional  
130 - public void updateRoleStatus(String roleId, int status, boolean isSysadmin, String tenantId) {  
131 - Optional.ofNullable(  
132 - baseMapper.selectOne(  
133 - new QueryWrapper<Role>()  
134 - .lambda()  
135 - .eq(Role::getId, roleId)  
136 - .eq(!isSysadmin, Role::getTenantId, tenantId)))  
137 - .ifPresent(  
138 - role -> {  
139 - role.setEnabled(status == 1);  
140 - baseMapper.updateById(role);  
141 - });  
142 - }  
143 89
144 - @Override  
145 - @Transactional  
146 - public RoleDTO saveOrUpdateRoleInfoWithMenu(  
147 - RoleReqDTO roleReqDTO, boolean isSysadmin, boolean isPlatformAdmin, String tenantId) {  
148 - Role role;  
149 - // 默认普通管理员角色,即租户管理员添加的角色  
150 - var roleType = RoleEnum.CUSTOMER_USER.name();  
151 - if (null != roleReqDTO.getRoleType()) {  
152 - roleType = roleReqDTO.getRoleType().name();  
153 - } else {  
154 - if (isSysadmin || isPlatformAdmin) {  
155 - roleType = RoleEnum.PLATFORM_ADMIN.name();  
156 - } 90 + @Override
  91 + public Set<String> getPermissions(
  92 + boolean isSysadmin, boolean isTenantAdmin, String tenantId, String useerId) {
  93 + Set<String> permissions = Sets.newHashSet();
  94 + Set<String> allPermission;
  95 + String cacheKey;
  96 + boolean cachePresent;
  97 + if (isSysadmin) {
  98 + cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + RoleEnum.SYS_ADMIN.name();
  99 + Optional<Set<String>> optionalPermission =
  100 + cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);
  101 + cachePresent = optionalPermission.isPresent();
  102 + allPermission = optionalPermission.orElseGet(menuMapper::getAllPermission);
  103 + } else if (isTenantAdmin) {
  104 + cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + tenantId;
  105 + Optional<Set<String>> optionalPermission =
  106 + cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);
  107 + cachePresent = optionalPermission.isPresent();
  108 + allPermission =
  109 + optionalPermission.orElseGet(() -> menuMapper.getAllPermissionsByTenantId(tenantId));
  110 + } else {
  111 + cacheKey = FastIotConstants.CacheConfigKey.USER_PERMISSION_PREFIX + useerId;
  112 + Optional<Set<String>> optionalPermission =
  113 + cacheUtils.get(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey);
  114 + cachePresent = optionalPermission.isPresent();
  115 + allPermission =
  116 + optionalPermission.orElseGet(() -> menuMapper.getAllPermissionsByUserId(useerId));
  117 + }
  118 + if (cachePresent) {
  119 + return allPermission;
  120 + } else {
  121 + allPermission.forEach(
  122 + permission -> permissions.addAll(Sets.newHashSet(permission.split(","))));
  123 + cacheUtils.put(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY, cacheKey, permissions);
  124 + }
  125 + return permissions;
157 } 126 }
158 - boolean update = StringUtils.isNotBlank(roleReqDTO.getId());  
159 - if (update) {  
160 - // do update  
161 - role =  
162 - baseMapper.selectOne(  
163 - new QueryWrapper<Role>()  
164 - .lambda()  
165 - .eq(Role::getId, roleReqDTO.getId())  
166 - .eq(!isSysadmin, Role::getTenantId, tenantId));  
167 - if (role == null) {  
168 - return null;  
169 - } else {  
170 - role.setRemark(roleReqDTO.getRemark());  
171 - role.setName(roleReqDTO.getName());  
172 - role.setEnabled(roleReqDTO.getStatus() == 1);  
173 - baseMapper.updateById(role);  
174 - }  
175 - } else {  
176 - // do save  
177 - role = new Role();  
178 - role.setRoleType(roleType);  
179 - role.setCode(RandomStringUtils.randomAlphabetic(10));  
180 - role.setRemark(roleReqDTO.getRemark());  
181 - role.setName(roleReqDTO.getName());  
182 - role.setEnabled(roleReqDTO.getStatus() == 1);  
183 - role.setTenantId(tenantId);  
184 - baseMapper.insert(role);  
185 - }  
186 - // do update or save menu associate with this roleId  
187 - menuService.assignMenuToRole(  
188 - roleReqDTO.getMenu().toArray(new String[roleReqDTO.getMenu().size()]), role.getId());  
189 - // 如果是租户管理员角色并且是更新，则需要更新租户菜单表  
190 - if (role.getRoleType().equals(RoleEnum.TENANT_ADMIN.name()) && update) {  
191 - List<String> menus = roleReqDTO.getMenu();  
192 - // 先删除以前的租户菜单，再更新新的租户菜单  
193 - // 1、查询这个角色有几个租户用户  
194 - // 2、删除并更新对应租户的信息  
195 - List<TenantRole> tenantRoles =  
196 - tenantRoleMapper.selectList(  
197 - new QueryWrapper<TenantRole>().lambda().eq(TenantRole::getRoleId, role.getId()));  
198 - tenantRoles.forEach(  
199 - tenantRole -> {  
200 - String updateTenantId = tenantRole.getTenantId();  
201 - tenantMenuMapper.delete(  
202 - new QueryWrapper<TenantMenu>()  
203 - .lambda()  
204 - .eq(TenantMenu::getTenantId, updateTenantId));  
205 - menus.forEach(  
206 - menu -> {  
207 - TenantMenu tenantMenu = new TenantMenu();  
208 - tenantMenu.setMenuId(menu);  
209 - tenantMenu.setTenantId(updateTenantId);  
210 - tenantMenuMapper.insert(tenantMenu);  
211 - });  
212 - }); 127 +
  128 + @Override
  129 + @Transactional
  130 + public void updateRoleStatus(String roleId, int status, boolean isSysadmin, String tenantId) {
  131 + Optional.ofNullable(
  132 + baseMapper.selectOne(
  133 + new QueryWrapper<Role>()
  134 + .lambda()
  135 + .eq(Role::getId, roleId)
  136 + .eq(!isSysadmin, Role::getTenantId, tenantId)))
  137 + .ifPresent(
  138 + role -> {
  139 + role.setEnabled(status == 1);
  140 + baseMapper.updateById(role);
  141 + });
213 } 142 }
214 - return role.getDTO(RoleDTO.class);  
215 - }  
216 143
217 - @Override  
218 - public List<RoleDTO> findRoleInfo(  
219 - boolean isTenantAdmin, String tenantId, String userId, RoleDTO roleDTO) {  
220 - if (StringUtils.isEmpty(roleDTO.getTenantId())) {  
221 - roleDTO.setTenantId(tenantId); 144 + @Override
  145 + @Transactional
  146 + public RoleDTO saveOrUpdateRoleInfoWithMenu(
  147 + RoleReqDTO roleReqDTO, boolean isSysadmin, boolean isPlatformAdmin, String tenantId) {
  148 + Role role;
  149 + // 默认普通管理员角色,即租户管理员添加的角色
  150 + var roleType = RoleEnum.CUSTOMER_USER.name();
  151 + if (null != roleReqDTO.getRoleType()) {
  152 + roleType = roleReqDTO.getRoleType().name();
  153 + } else {
  154 + if (isSysadmin || isPlatformAdmin) {
  155 + roleType = RoleEnum.PLATFORM_ADMIN.name();
  156 + }
  157 + }
  158 + boolean update = StringUtils.isNotBlank(roleReqDTO.getId());
  159 + if (update) {
  160 + // do update
  161 + role =
  162 + baseMapper.selectOne(
  163 + new QueryWrapper<Role>()
  164 + .lambda()
  165 + .eq(Role::getId, roleReqDTO.getId())
  166 + .eq(!isSysadmin, Role::getTenantId, tenantId));
  167 + if (role == null) {
  168 + return null;
  169 + } else {
  170 + role.setRemark(roleReqDTO.getRemark());
  171 + role.setName(roleReqDTO.getName());
  172 + role.setEnabled(roleReqDTO.getStatus() == 1);
  173 + baseMapper.updateById(role);
  174 + }
  175 + } else {
  176 + // do save
  177 + role = new Role();
  178 + role.setRoleType(roleType);
  179 + role.setCode(RandomStringUtils.randomAlphabetic(10));
  180 + role.setRemark(roleReqDTO.getRemark());
  181 + role.setName(roleReqDTO.getName());
  182 + role.setEnabled(roleReqDTO.getStatus() == 1);
  183 + role.setTenantId(tenantId);
  184 + baseMapper.insert(role);
  185 + }
  186 + // do update or save menu associate with this roleId
  187 + menuService.assignMenuToRole(
  188 + roleReqDTO.getMenu().toArray(new String[roleReqDTO.getMenu().size()]), role.getId());
  189 + // 如果是租户管理员角色并且是更新，则需要更新租户菜单表
  190 + if (role.getRoleType().equals(RoleEnum.TENANT_ADMIN.name()) && update) {
  191 + List<String> menus = roleReqDTO.getMenu();
  192 + // 先删除以前的租户菜单，再更新新的租户菜单
  193 + // 1、查询这个角色有几个租户用户
  194 + // 2、删除并更新对应租户的信息
  195 + List<TenantRole> tenantRoles =
  196 + tenantRoleMapper.selectList(
  197 + new QueryWrapper<TenantRole>().lambda().eq(TenantRole::getRoleId, role.getId()));
  198 + tenantRoles.forEach(
  199 + tenantRole -> {
  200 + String updateTenantId = tenantRole.getTenantId();
  201 + tenantMenuMapper.delete(
  202 + new QueryWrapper<TenantMenu>()
  203 + .lambda()
  204 + .eq(TenantMenu::getTenantId, updateTenantId));
  205 + menus.forEach(
  206 + menu -> {
  207 + TenantMenu tenantMenu = new TenantMenu();
  208 + tenantMenu.setMenuId(menu);
  209 + tenantMenu.setTenantId(updateTenantId);
  210 + tenantMenuMapper.insert(tenantMenu);
  211 + });
  212 + });
  213 + }
  214 + cacheUtils.invalidateCacheName(FastIotConstants.CacheConfigKey.CACHE_CONFIG_KEY);
  215 + return role.getDTO(RoleDTO.class);
222 } 216 }
223 - if (isTenantAdmin) {  
224 - // 租户管理员既要查询自己拥有的角色，也要查询自己创建的角色  
225 - List<String> roleIds =  
226 - userRoleMapper  
227 - .selectList(new QueryWrapper<UserRole>().lambda().eq(UserRole::getUserId, userId))  
228 - .stream()  
229 - .map(UserRole::getRoleId)  
230 - .collect(Collectors.toList());  
231 - roleDTO.setRoleIds(roleIds.toArray(new String[roleIds.size()])); 217 +
  218 + @Override
  219 + public List<RoleDTO> findRoleInfo(
  220 + boolean isTenantAdmin, String tenantId, String userId, RoleDTO roleDTO) {
  221 + if (StringUtils.isEmpty(roleDTO.getTenantId())) {
  222 + roleDTO.setTenantId(tenantId);
  223 + }
  224 + if (isTenantAdmin) {
  225 + // 租户管理员既要查询自己拥有的角色，也要查询自己创建的角色
  226 + List<String> roleIds =
  227 + userRoleMapper
  228 + .selectList(new QueryWrapper<UserRole>().lambda().eq(UserRole::getUserId, userId))
  229 + .stream()
  230 + .map(UserRole::getRoleId)
  231 + .collect(Collectors.toList());
  232 + roleDTO.setRoleIds(roleIds.toArray(new String[roleIds.size()]));
  233 + }
  234 + return baseMapper.findRoleInfo(roleDTO);
232 } 235 }
233 - return baseMapper.findRoleInfo(roleDTO);  
234 - }  
235 } 236 }
@@ -25,288 +25,344 @@ import org.thingsboard.server.dao.yunteng.service.*; @@ -25,288 +25,344 @@ import org.thingsboard.server.dao.yunteng.service.*;
25 import java.time.LocalDateTime; 25 import java.time.LocalDateTime;
26 import java.util.*; 26 import java.util.*;
27 import java.util.concurrent.CompletableFuture; 27 import java.util.concurrent.CompletableFuture;
  28 +import java.util.concurrent.atomic.AtomicBoolean;
  29 +import java.util.stream.Collectors;
28 30
29 @Service 31 @Service
30 @RequiredArgsConstructor 32 @RequiredArgsConstructor
31 public class YtTenantServiceImpl extends AbstractBaseService<TenantMapper, Tenant> 33 public class YtTenantServiceImpl extends AbstractBaseService<TenantMapper, Tenant>
32 - implements YtTenantService { 34 + implements YtTenantService {
33 35
34 - private final MenuMapper menuMapper;  
35 - private final RoleMapper roleMapper;  
36 - private final UserMapper userMapper;  
37 - private final TenantMenuMapper tenantMenuMapper;  
38 - private final TenantRoleMapper tenantRoleMapper;  
39 - private final YtOrganizationService ytOrganizationService;  
40 - private final YtDeviceService ytDeviceService;  
41 - private final YtMessageTemplateService ytMessageTemplateService;  
42 - private final YtMessageConfigService ytMessageConfigService;  
43 - private final YtMailLogService ytMailLogService;  
44 - private final SmsLogService smsLogService;  
45 - private final YtAlarmContactService ytAlarmContactService;  
46 - private final AlarmProfileMapper alarmProfileMapper;  
47 - private final SysNoticeService sysNoticeService;  
48 - private final SysNoticeUserService sysNoticeUserService;  
49 - private final SceneLinkageService sceneLinkageService;  
50 - private final DoActionService doActionService;  
51 - private final DoConditionService doConditionService;  
52 - private final TriggerService triggerService;  
53 - private final ConvertConfigService convertConfigService;  
54 - private final SysAppDesignService sysAppDesignService;  
55 - private final SysPlatformDesignService sysPlatformDesignService;  
56 - private final SysEnterpriseService sysEnterpriseService;  
57 - @Override  
58 - @Transactional  
59 - public TenantDTO createNewTenant(TenantReqDTO tenantReqDTO) {  
60 - TenantDTO tenantDTO = new TenantDTO();  
61 - BeanUtils.copyProperties(tenantReqDTO, tenantDTO);  
62 - Tenant tenant = tenantDTO.getEntity(Tenant.class);  
63 - tenant.setTenantProfileId(tenantReqDTO.getTenantProfileId().getId().toString());  
64 - baseMapper.insert(tenant);  
65 - tenant.copyToDTO(tenantDTO);  
66 - saveTenantMapping(tenantDTO.getTenantId(), tenantReqDTO.getRoleIds());  
67 - return tenantDTO;  
68 - } 36 + private final MenuMapper menuMapper;
  37 + private final RoleMapper roleMapper;
  38 + private final UserMapper userMapper;
  39 + private final TenantMenuMapper tenantMenuMapper;
  40 + private final TenantRoleMapper tenantRoleMapper;
  41 + private final YtOrganizationService ytOrganizationService;
  42 + private final YtDeviceService ytDeviceService;
  43 + private final YtMessageTemplateService ytMessageTemplateService;
  44 + private final YtMessageConfigService ytMessageConfigService;
  45 + private final YtMailLogService ytMailLogService;
  46 + private final SmsLogService smsLogService;
  47 + private final YtAlarmContactService ytAlarmContactService;
  48 + private final AlarmProfileMapper alarmProfileMapper;
  49 + private final SysNoticeService sysNoticeService;
  50 + private final SysNoticeUserService sysNoticeUserService;
  51 + private final SceneLinkageService sceneLinkageService;
  52 + private final DoActionService doActionService;
  53 + private final DoConditionService doConditionService;
  54 + private final TriggerService triggerService;
  55 + private final ConvertConfigService convertConfigService;
  56 + private final SysAppDesignService sysAppDesignService;
  57 + private final SysPlatformDesignService sysPlatformDesignService;
  58 + private final SysEnterpriseService sysEnterpriseService;
  59 + private final UserRoleMapper userRoleMapper;
69 60
70 - @Override  
71 - public YtPageData<TenantDTO> page(Map<String, Object> queryMap) {  
72 - IPage<Tenant> tenantIPage = getPage(queryMap, "create_time", false);  
73 - IPage<TenantDTO> userPage =  
74 - baseMapper.getTenantPage(  
75 - tenantIPage, (String) queryMap.get("tenantName"), EntityId.NULL_UUID.toString());  
76 - YtPageData<TenantDTO> ytPageData = getPageData(userPage, TenantDTO.class);  
77 - determineTenantStatus(ytPageData.getItems());  
78 - return ytPageData;  
79 - }  
80 -  
81 - private void determineTenantStatus(Collection<TenantDTO> tenantDTOList) {  
82 - tenantDTOList.forEach(  
83 - tenantDTO -> {  
84 - if (!tenantDTO.isEnabled()) {  
85 - tenantDTO.setTenantStatus(TenantStatusEnum.DISABLED);  
86 - } else {  
87 - tenantDTO.setTenantStatus(TenantStatusEnum.NORMAL);  
88 - if (tenantDTO.getTenantExpireTime() != null  
89 - && LocalDateTime.now().isAfter(tenantDTO.getTenantExpireTime())) {  
90 - tenantDTO.setTenantStatus(TenantStatusEnum.EXPIRED);  
91 - }  
92 - }  
93 - });  
94 - }  
95 -  
96 - @Override  
97 - @Transactional  
98 - public TenantDTO updateTenant(TenantDTO tenantDTO) {  
99 - Tenant tenant = baseMapper.selectById(tenantDTO.getId());  
100 - if (tenant == null) {  
101 - throw new YtDataValidationException("tenant does not exist"); 61 + @Override
  62 + @Transactional
  63 + public TenantDTO createNewTenant(TenantReqDTO tenantReqDTO) {
  64 + TenantDTO tenantDTO = new TenantDTO();
  65 + BeanUtils.copyProperties(tenantReqDTO, tenantDTO);
  66 + Tenant tenant = tenantDTO.getEntity(Tenant.class);
  67 + tenant.setTenantProfileId(tenantReqDTO.getTenantProfileId().getId().toString());
  68 + baseMapper.insert(tenant);
  69 + tenant.copyToDTO(tenantDTO);
  70 + saveTenantMapping(tenantDTO.getTenantId(), tenantReqDTO.getRoleIds());
  71 + return tenantDTO;
102 } 72 }
103 - String existTenantId = tenant.getTenantId();  
104 - tenantDTO.copyToEntity(tenant);  
105 - // tenantCode is immutable  
106 - tenant.setTenantId(existTenantId);  
107 - baseMapper.updateById(tenant);  
108 - tenant.copyToDTO(tenantDTO);  
109 - return tenantDTO;  
110 - }  
111 73
112 - @Override  
113 - @Transactional  
114 - public boolean deleteTenants(String[] idArr) {  
115 - Set<String> ids = Set.of(idArr); 74 + @Override
  75 + public YtPageData<TenantDTO> page(Map<String, Object> queryMap) {
  76 + IPage<Tenant> tenantIPage = getPage(queryMap, "create_time", false);
  77 + IPage<TenantDTO> userPage =
  78 + baseMapper.getTenantPage(
  79 + tenantIPage, (String) queryMap.get("tenantName"), EntityId.NULL_UUID.toString());
  80 + YtPageData<TenantDTO> ytPageData = getPageData(userPage, TenantDTO.class);
  81 + determineTenantStatus(ytPageData.getItems());
  82 + return ytPageData;
  83 + }
116 84
117 - Set<String> tenantIds = baseMapper.getTenantIdsByTenantIds(ids);  
118 - // 1. GET ALL ROLE_ID  
119 - Set<String> allRoleIds = roleMapper.getAllIdsByTenantId(tenantIds);  
120 - // 2. DELETE SYS_ROLE SYS_ROLE_MENU SYS_USER_ROLE  
121 - if (!allRoleIds.isEmpty()) {  
122 - roleMapper.deleteBatchIds(allRoleIds);  
123 - roleMapper.deleteRoleMenuMappingByRoleIds(allRoleIds);  
124 - roleMapper.deleteRoleUserMappingByRoleIds(allRoleIds); 85 + private void determineTenantStatus(Collection<TenantDTO> tenantDTOList) {
  86 + tenantDTOList.forEach(
  87 + tenantDTO -> {
  88 + if (!tenantDTO.isEnabled()) {
  89 + tenantDTO.setTenantStatus(TenantStatusEnum.DISABLED);
  90 + } else {
  91 + tenantDTO.setTenantStatus(TenantStatusEnum.NORMAL);
  92 + if (tenantDTO.getTenantExpireTime() != null
  93 + && LocalDateTime.now().isAfter(tenantDTO.getTenantExpireTime())) {
  94 + tenantDTO.setTenantStatus(TenantStatusEnum.EXPIRED);
  95 + }
  96 + }
  97 + });
125 } 98 }
126 - // 3. DELETE SYS_MENU SYS_TENANT_MENU  
127 - Set<String> allMenuIds = menuMapper.getAllIdsByTenantId(tenantIds);  
128 - if (!allMenuIds.isEmpty()) {  
129 - menuMapper.deleteBatchIds(allMenuIds);  
130 - menuMapper.deleteTenantMenuMappingByMenuIds(allMenuIds); 99 +
  100 + @Override
  101 + @Transactional
  102 + public TenantDTO updateTenant(TenantDTO tenantDTO) {
  103 + Tenant tenant = baseMapper.selectById(tenantDTO.getId());
  104 + if (tenant == null) {
  105 + throw new YtDataValidationException("tenant does not exist");
  106 + }
  107 + String existTenantId = tenant.getTenantId();
  108 + tenantDTO.copyToEntity(tenant);
  109 + // tenantCode is immutable
  110 + tenant.setTenantId(existTenantId);
  111 + baseMapper.updateById(tenant);
  112 + tenant.copyToDTO(tenantDTO);
  113 + return tenantDTO;
131 } 114 }
132 - // 4. DELETE USER  
133 - userMapper.delete(new QueryWrapper<User>().lambda().in(User::getTenantId, tenantIds));  
134 - // 5. TELL RULE ENGINE TO STOP TENANT  
135 - // 6. DELETE OTHER RESOURCES IF ANY  
136 - // 7. DELETE ORGANIZATION  
137 - ytOrganizationService.deleteDataByTenantIds(tenantIds);  
138 - // 8. DELETE DEVICE  
139 - ytDeviceService.deleteDataByTenantIds(tenantIds);  
140 - // 9. DELETE MESSAGE_TEMPLATE MESSAGE_CONFIG SEND_RECORDS  
141 - ytMessageTemplateService.deleteDataByTenantIds(tenantIds);  
142 - ytMessageConfigService.deleteDataByTenantIds(tenantIds);  
143 - ytMailLogService.deleteDataByTenantIds(tenantIds);  
144 - smsLogService.deleteDataByTenantIds(tenantIds);  
145 - // 10.DELETE ALARM CONTACT  
146 - ytAlarmContactService.deleteDataByTenantIds(tenantIds);  
147 - if(!tenantIds.isEmpty()){  
148 - alarmProfileMapper.delete(new LambdaQueryWrapper<AlarmProfile>().in(AlarmProfile::getTenantId,tenantIds)); 115 +
  116 + @Override
  117 + @Transactional
  118 + public boolean deleteTenants(String[] idArr) {
  119 + Set<String> ids = Set.of(idArr);
  120 +
  121 + Set<String> tenantIds = baseMapper.getTenantIdsByTenantIds(ids);
  122 + // 1. GET ALL ROLE_ID
  123 + Set<String> allRoleIds = roleMapper.getAllIdsByTenantId(tenantIds);
  124 + // 2. DELETE SYS_ROLE SYS_ROLE_MENU SYS_USER_ROLE
  125 + if (!allRoleIds.isEmpty()) {
  126 + roleMapper.deleteBatchIds(allRoleIds);
  127 + roleMapper.deleteRoleMenuMappingByRoleIds(allRoleIds);
  128 + roleMapper.deleteRoleUserMappingByRoleIds(allRoleIds);
  129 + }
  130 + // 3. DELETE SYS_MENU SYS_TENANT_MENU
  131 + Set<String> allMenuIds = menuMapper.getAllIdsByTenantId(tenantIds);
  132 + if (!allMenuIds.isEmpty()) {
  133 + menuMapper.deleteBatchIds(allMenuIds);
  134 + menuMapper.deleteTenantMenuMappingByMenuIds(allMenuIds);
  135 + }
  136 + // 4. DELETE USER
  137 + userMapper.delete(new QueryWrapper<User>().lambda().in(User::getTenantId, tenantIds));
  138 + // 5. TELL RULE ENGINE TO STOP TENANT
  139 + // 6. DELETE OTHER RESOURCES IF ANY
  140 + // 7. DELETE ORGANIZATION
  141 + ytOrganizationService.deleteDataByTenantIds(tenantIds);
  142 + // 8. DELETE DEVICE
  143 + ytDeviceService.deleteDataByTenantIds(tenantIds);
  144 + // 9. DELETE MESSAGE_TEMPLATE MESSAGE_CONFIG SEND_RECORDS
  145 + ytMessageTemplateService.deleteDataByTenantIds(tenantIds);
  146 + ytMessageConfigService.deleteDataByTenantIds(tenantIds);
  147 + ytMailLogService.deleteDataByTenantIds(tenantIds);
  148 + smsLogService.deleteDataByTenantIds(tenantIds);
  149 + // 10.DELETE ALARM CONTACT
  150 + ytAlarmContactService.deleteDataByTenantIds(tenantIds);
  151 + if (!tenantIds.isEmpty()) {
  152 + alarmProfileMapper.delete(new LambdaQueryWrapper<AlarmProfile>().in(AlarmProfile::getTenantId, tenantIds));
  153 + }
  154 + // 11.DELETE NOTICE NOTICE_RECORDS
  155 + sysNoticeService.deleteDataByTenantIds(tenantIds);
  156 + sysNoticeUserService.deleteDataByTenantIds(tenantIds);
  157 + // 12.DELETE SCENES
  158 + sceneLinkageService.deleteDataByTenantIds(tenantIds);
  159 + doActionService.deleteDataByTenantIds(tenantIds);
  160 + doConditionService.deleteDataByTenantIds(tenantIds);
  161 + triggerService.deleteDataByTenantIds(tenantIds);
  162 + // 13.DELETE CONVERT_CONFIG
  163 + convertConfigService.deleteDataByTenantIds(tenantIds);
  164 + // 14.DELETE APP_DESIGN PLATFORM_DESIGN ENTERPRISE
  165 + sysAppDesignService.deleteDataByTenantIds(tenantIds);
  166 + sysPlatformDesignService.deleteDataByTenantIds(tenantIds);
  167 + sysEnterpriseService.deleteDataByTenantIds(tenantIds);
  168 + // 15.DELETE TENANT_ROLE、TENANT_MENU
  169 + freshTenantAdminRole(tenantIds, null);
  170 + deleteTenantRolesByTenantId(tenantIds);
  171 + deleteTenantMenusByTenantId(tenantIds);
  172 + // 16. DELETE TENANT
  173 + baseMapper.deleteBatchIds(ids);
  174 +
  175 +
  176 + return true;
149 } 177 }
150 - // 11.DELETE NOTICE NOTICE_RECORDS  
151 - sysNoticeService.deleteDataByTenantIds(tenantIds);  
152 - sysNoticeUserService.deleteDataByTenantIds(tenantIds);  
153 - // 12.DELETE SCENES  
154 - sceneLinkageService.deleteDataByTenantIds(tenantIds);  
155 - doActionService.deleteDataByTenantIds(tenantIds);  
156 - doConditionService.deleteDataByTenantIds(tenantIds);  
157 - triggerService.deleteDataByTenantIds(tenantIds);  
158 - // 13.DELETE CONVERT_CONFIG  
159 - convertConfigService.deleteDataByTenantIds(tenantIds);  
160 - // 14.DELETE APP_DESIGN PLATFORM_DESIGN ENTERPRISE  
161 - sysAppDesignService.deleteDataByTenantIds(tenantIds);  
162 - sysPlatformDesignService.deleteDataByTenantIds(tenantIds);  
163 - sysEnterpriseService.deleteDataByTenantIds(tenantIds);  
164 - // 15.DELETE TENANT_ROLE、TENANT_MENU  
165 - deleteTenantRolesByTenantId(tenantIds);  
166 - deleteTenantMenusByTenantId(tenantIds);  
167 - // 16. DELETE TENANT  
168 - baseMapper.deleteBatchIds(ids);  
169 178
  179 + /**
  180 + * 通过租户Code删除租户角色关系
  181 + *
  182 + * @param tenantIds 租户Code
  183 + */
  184 + private void deleteTenantRolesByTenantId(Set<String> tenantIds) {
  185 + tenantRoleMapper.delete(
  186 + new QueryWrapper<TenantRole>().lambda().in(TenantRole::getTenantId, tenantIds));
  187 + }
170 188
171 - return true;  
172 - } 189 + /**
  190 + * 通过租户Code删除租户角色关系
  191 + *
  192 + * @param tenantIds 租户Code
  193 + */
  194 + private void deleteTenantMenusByTenantId(Set<String> tenantIds) {
  195 + tenantMenuMapper.delete(
  196 + new QueryWrapper<TenantMenu>().lambda().in(TenantMenu::getTenantId, tenantIds));
  197 + }
173 198
174 - /**  
175 - * 通过租户Code删除租户角色关系  
176 - *  
177 - * @param tenantIds 租户Code  
178 - */  
179 - private void deleteTenantRolesByTenantId(Set<String> tenantIds) {  
180 - tenantRoleMapper.delete(  
181 - new QueryWrapper<TenantRole>().lambda().in(TenantRole::getTenantId, tenantIds));  
182 - } 199 + /**
  200 + * 刷新租户管理员与角色关系
  201 + *
  202 + * @param tenantIds 租户ID
  203 + * @param newRoles 新增的角色ID
  204 + */
  205 + private void freshTenantAdminRole(Set<String> tenantIds, List<String> newRoles) {
  206 + AtomicBoolean notChanged = new AtomicBoolean(false);
  207 + LambdaQueryWrapper<TenantRole> roleFilter = new QueryWrapper<TenantRole>().lambda()
  208 + .in(TenantRole::getTenantId, tenantIds);
  209 + List<String> oldRoleIds = tenantRoleMapper.selectList(roleFilter).stream()
  210 + .map(i -> i.getRoleId())
  211 + .collect(Collectors.toList());
  212 + List<String> deleteIds = oldRoleIds.stream()
  213 + .filter(f -> {
  214 + if(newRoles == null || newRoles.isEmpty()){
  215 + return true;
  216 + }
  217 + if(newRoles.contains(f)){
  218 + notChanged.set(true);
  219 + return false;
  220 + }
  221 + return true;
  222 + })
  223 + .collect(Collectors.toList());
  224 + if(!deleteIds.isEmpty()){
  225 + LambdaQueryWrapper<UserRole> filter = new QueryWrapper<UserRole>().lambda()
  226 + .in(UserRole::getRoleId, deleteIds);
  227 + userRoleMapper.delete(filter);
  228 + }
183 229
184 - /**  
185 - * 通过租户Code删除租户角色关系  
186 - *  
187 - * @param tenantIds 租户Code  
188 - */  
189 - private void deleteTenantMenusByTenantId(Set<String> tenantIds) {  
190 - tenantMenuMapper.delete(  
191 - new QueryWrapper<TenantMenu>().lambda().in(TenantMenu::getTenantId, tenantIds));  
192 - } 230 + if (notChanged.get() || newRoles == null || newRoles.isEmpty()) {
  231 + return;
  232 + }
  233 + LambdaQueryWrapper<User> userFilter = new QueryWrapper<User>().lambda()
  234 + .eq(User::getLevel,2)
  235 + .in(User::getTenantId, tenantIds);
  236 + List<String> userIds = userMapper.selectList(userFilter).stream()
  237 + .map(m -> m.getId())
  238 + .collect(Collectors.toList());
  239 + userIds.forEach(item -> {
  240 + for (String roleId : newRoles) {
  241 + UserRole role = new UserRole();
  242 + role.setRoleId(roleId);
  243 + role.setUserId(item);
  244 + userRoleMapper.insert(role);
  245 + }
  246 + });
  247 + }
193 248
194 - @Override  
195 - public Optional<TenantDTO> findById(String id) {  
196 - return Optional.ofNullable(baseMapper.selectById(id))  
197 - .map(tenant -> tenant.getDTO(TenantDTO.class));  
198 - } 249 + @Override
  250 + public Optional<TenantDTO> findById(String id) {
  251 + return Optional.ofNullable(baseMapper.selectById(id))
  252 + .map(tenant -> tenant.getDTO(TenantDTO.class));
  253 + }
199 254
200 - @Override  
201 - @Transactional  
202 - public TenantDTO updateOrCreateTenant(TenantReqDTO tenantReqDTO) {  
203 - if (StringUtils.isNotBlank(tenantReqDTO.getId())) {  
204 - Tenant tenant;  
205 - tenant = baseMapper.selectById(tenantReqDTO.getId());  
206 - if (tenant != null) {  
207 - BeanUtils.copyProperties(tenantReqDTO, tenant);  
208 - if(!tenantReqDTO.getTenantProfileId().isNullUid()){  
209 - tenant.setTenantProfileId(tenantReqDTO.getTenantProfileId().getId().toString()); 255 + @Override
  256 + @Transactional
  257 + public TenantDTO updateOrCreateTenant(TenantReqDTO tenantReqDTO) {
  258 + if (StringUtils.isNotBlank(tenantReqDTO.getId())) {
  259 + Tenant tenant;
  260 + tenant = baseMapper.selectById(tenantReqDTO.getId());
  261 + if (tenant != null) {
  262 + BeanUtils.copyProperties(tenantReqDTO, tenant);
  263 + if (!tenantReqDTO.getTenantProfileId().isNullUid()) {
  264 + tenant.setTenantProfileId(tenantReqDTO.getTenantProfileId().getId().toString());
  265 + }
  266 + //update tenant role
  267 + //delete
  268 + Set<String> tenantIds = new HashSet<>();
  269 + tenantIds.add(tenantReqDTO.getTenantId());
  270 + freshTenantAdminRole(tenantIds, Arrays.asList(tenantReqDTO.getRoleIds()));
  271 + deleteTenantRolesByTenantId(tenantIds);
  272 + deleteTenantMenusByTenantId(tenantIds);
  273 + //add
  274 + saveTenantMapping(tenantReqDTO.getTenantId(), tenantReqDTO.getRoleIds());
  275 + baseMapper.updateById(tenant);
  276 + }
  277 + return tenant.getDTO(TenantDTO.class);
  278 + } else {
  279 + return createNewTenant(tenantReqDTO);
210 } 280 }
211 - //update tenant role  
212 - //delete  
213 - Set<String> tenantIds = new HashSet<>();  
214 - tenantIds.add(tenantReqDTO.getTenantId());  
215 - deleteTenantRolesByTenantId(tenantIds);  
216 - deleteTenantMenusByTenantId(tenantIds);  
217 - //add  
218 - saveTenantMapping(tenantReqDTO.getTenantId(), tenantReqDTO.getRoleIds());  
219 - baseMapper.updateById(tenant);  
220 - }  
221 - return tenant.getDTO(TenantDTO.class);  
222 - } else {  
223 - return createNewTenant(tenantReqDTO);  
224 } 281 }
225 - }  
226 282
227 - @Override  
228 - public List<String> getTenantRolesByTenantId(String tenantId) {  
229 - if (StringUtils.isEmpty(tenantId)) {  
230 - throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage()); 283 + @Override
  284 + public List<String> getTenantRolesByTenantId(String tenantId) {
  285 + if (StringUtils.isEmpty(tenantId)) {
  286 + throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
  287 + }
  288 + List<String> roles = new ArrayList<>();
  289 + List<TenantRole> tenantRoleList =
  290 + tenantRoleMapper.selectList(
  291 + new QueryWrapper<TenantRole>().lambda().eq(TenantRole::getTenantId, tenantId));
  292 + tenantRoleList.forEach(role -> roles.add(role.getRoleId()));
  293 + return roles;
231 } 294 }
232 - List<String> roles = new ArrayList<>();  
233 - List<TenantRole> tenantRoleList =  
234 - tenantRoleMapper.selectList(  
235 - new QueryWrapper<TenantRole>().lambda().eq(TenantRole::getTenantId, tenantId));  
236 - tenantRoleList.forEach(role -> roles.add(role.getRoleId()));  
237 - return roles;  
238 - }  
239 295
240 - @Override  
241 - public YtPageData<TenantDTO> getCurrentMonthExpireTenantPage(Map<String, Object> queryMap) {  
242 - IPage<Tenant> tenantIPage = getPage(queryMap, "create_time", true);  
243 - IPage<TenantDTO> tenantDTOIPage = baseMapper.getCurrentMonthExpireTenantPage(tenantIPage);  
244 - return getPageData(tenantDTOIPage, TenantDTO.class);  
245 - } 296 + @Override
  297 + public YtPageData<TenantDTO> getCurrentMonthExpireTenantPage(Map<String, Object> queryMap) {
  298 + IPage<Tenant> tenantIPage = getPage(queryMap, "create_time", true);
  299 + IPage<TenantDTO> tenantDTOIPage = baseMapper.getCurrentMonthExpireTenantPage(tenantIPage);
  300 + return getPageData(tenantDTOIPage, TenantDTO.class);
  301 + }
246 302
247 - @Override  
248 - public List<TenantDTO> getAllTenant() {  
249 - List<Tenant> tenants =  
250 - baseMapper.selectList(  
251 - new LambdaQueryWrapper<Tenant>()  
252 - .ne(Tenant::getTenantId, EntityId.NULL_UUID.toString()));  
253 - return ReflectUtils.sourceToTarget(tenants, TenantDTO.class);  
254 - } 303 + @Override
  304 + public List<TenantDTO> getAllTenant() {
  305 + List<Tenant> tenants =
  306 + baseMapper.selectList(
  307 + new LambdaQueryWrapper<Tenant>()
  308 + .ne(Tenant::getTenantId, EntityId.NULL_UUID.toString()));
  309 + return ReflectUtils.sourceToTarget(tenants, TenantDTO.class);
  310 + }
255 311
256 - @Override  
257 - @Async  
258 - public CompletableFuture<TsValue> findTenantsByTs(  
259 - LocalDateTime startTs, LocalDateTime endTs,long ts) {  
260 - List<Tenant> tenants =  
261 - baseMapper.selectList(  
262 - new LambdaQueryWrapper<Tenant>()  
263 - .ge(Tenant::getCreateTime, startTs).lt(Tenant::getCreateTime,endTs));  
264 - return CompletableFuture.supplyAsync(  
265 - () -> new TsValue(ts,String.valueOf(tenants.size())));  
266 - } 312 + @Override
  313 + @Async
  314 + public CompletableFuture<TsValue> findTenantsByTs(
  315 + LocalDateTime startTs, LocalDateTime endTs, long ts) {
  316 + List<Tenant> tenants =
  317 + baseMapper.selectList(
  318 + new LambdaQueryWrapper<Tenant>()
  319 + .ge(Tenant::getCreateTime, startTs).lt(Tenant::getCreateTime, endTs));
  320 + return CompletableFuture.supplyAsync(
  321 + () -> new TsValue(ts, String.valueOf(tenants.size())));
  322 + }
267 323
268 - /**  
269 - * 保存租户与菜单、角色的映射关系  
270 - *  
271 - * @param tenantId 租户Code  
272 - * @param roleIds 角色IDS  
273 - */  
274 - private void saveTenantMapping(String tenantId, String[] roleIds) {  
275 - // 添加租户角色关系  
276 - for (String roleId : roleIds) {  
277 - saveTenantRoleMapping(roleId, tenantId);  
278 - // 查询roleId有多少菜单  
279 - Set<String> menuIds = roleMapper.getMenuIdsByRoleId(roleId);  
280 - // 添加租户菜单关系  
281 - for (String menuId : menuIds) {  
282 - saveTenantMenuMapping(menuId, tenantId);  
283 - } 324 + /**
  325 + * 保存租户与菜单、角色的映射关系
  326 + *
  327 + * @param tenantId 租户Code
  328 + * @param roleIds 角色IDS
  329 + */
  330 + private void saveTenantMapping(String tenantId, String[] roleIds) {
  331 + // 添加租户角色关系
  332 + for (String roleId : roleIds) {
  333 + saveTenantRoleMapping(roleId, tenantId);
  334 + // 查询roleId有多少菜单
  335 + Set<String> menuIds = roleMapper.getMenuIdsByRoleId(roleId);
  336 + // 添加租户菜单关系
  337 + for (String menuId : menuIds) {
  338 + saveTenantMenuMapping(menuId, tenantId);
  339 + }
  340 + }
284 } 341 }
285 - }  
286 342
287 - /**  
288 - * 保存租户与菜单的关系  
289 - *  
290 - * @param menuId 菜单ID  
291 - * @param tenantId 租户Code  
292 - */  
293 - private void saveTenantMenuMapping(String menuId, String tenantId) {  
294 - TenantMenu tenantMenu = new TenantMenu();  
295 - tenantMenu.setMenuId(menuId);  
296 - tenantMenu.setTenantId(tenantId);  
297 - tenantMenuMapper.insert(tenantMenu);  
298 - } 343 + /**
  344 + * 保存租户与菜单的关系
  345 + *
  346 + * @param menuId 菜单ID
  347 + * @param tenantId 租户Code
  348 + */
  349 + private void saveTenantMenuMapping(String menuId, String tenantId) {
  350 + TenantMenu tenantMenu = new TenantMenu();
  351 + tenantMenu.setMenuId(menuId);
  352 + tenantMenu.setTenantId(tenantId);
  353 + tenantMenuMapper.insert(tenantMenu);
  354 + }
299 355
300 - /**  
301 - * 保存租户与角色的关系  
302 - *  
303 - * @param roleId 角色ID  
304 - * @param tenantId 租户Code  
305 - */  
306 - private void saveTenantRoleMapping(String roleId, String tenantId) {  
307 - TenantRole tenantRole = new TenantRole();  
308 - tenantRole.setTenantId(tenantId);  
309 - tenantRole.setRoleId(roleId);  
310 - tenantRoleMapper.insert(tenantRole);  
311 - } 356 + /**
  357 + * 保存租户与角色的关系
  358 + *
  359 + * @param roleId 角色ID
  360 + * @param tenantId 租户Code
  361 + */
  362 + private void saveTenantRoleMapping(String roleId, String tenantId) {
  363 + TenantRole tenantRole = new TenantRole();
  364 + tenantRole.setTenantId(tenantId);
  365 + tenantRole.setRoleId(roleId);
  366 + tenantRoleMapper.insert(tenantRole);
  367 + }
312 } 368 }