简柏林 / 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 38 @RequiredArgsConstructor
39 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 25 import java.time.LocalDateTime;
26 26 import java.util.*;
27 27 import java.util.concurrent.CompletableFuture;
  28 +import java.util.concurrent.atomic.AtomicBoolean;
  29 +import java.util.stream.Collectors;
28 30
29 31 @Service
30 32 @RequiredArgsConstructor
31 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 }
... ...