简柏林 / thingskit · Commits

Commit 11c7f4a95946480b7572405c501fba5832973ff3

Authored by 黄 x
1 parent fc67baa3

fix: delete tenant and delete device profile

Inline Side-by-side
Showing 3 changed files with 320 additions and 297 deletions
@@ -3,6 +3,9 @@ package org.thingsboard.server.dao.yunteng.impl; @@ -3,6 +3,9 @@ package org.thingsboard.server.dao.yunteng.impl;
3 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; 3 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
4 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; 4 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
5 import com.baomidou.mybatisplus.core.metadata.IPage; 5 import com.baomidou.mybatisplus.core.metadata.IPage;
  6 +import com.google.common.util.concurrent.Futures;
  7 +import com.google.common.util.concurrent.ListenableFuture;
  8 +import com.google.common.util.concurrent.MoreExecutors;
6 import lombok.RequiredArgsConstructor; 9 import lombok.RequiredArgsConstructor;
7 import org.apache.commons.lang3.StringUtils; 10 import org.apache.commons.lang3.StringUtils;
8 import org.springframework.beans.BeanUtils; 11 import org.springframework.beans.BeanUtils;
@@ -30,331 +33,349 @@ import java.util.stream.Collectors; @@ -30,331 +33,349 @@ import java.util.stream.Collectors;
30 @Service 33 @Service
31 @RequiredArgsConstructor 34 @RequiredArgsConstructor
32 public class TkTenantServiceImpl extends AbstractBaseService<TenantMapper, SysTenantEntity> 35 public class TkTenantServiceImpl extends AbstractBaseService<TenantMapper, SysTenantEntity>
33 - implements TkTenantService { 36 + implements TkTenantService {
34 37
35 - private final MenuMapper menuMapper;  
36 - private final RoleMapper roleMapper;  
37 - private final UserMapper userMapper;  
38 - private final TenantMenuMapper tenantMenuMapper;  
39 - private final TenantRoleMapper tenantRoleMapper;  
40 - private final TkOrganizationService tkOrganizationService;  
41 - private final TkDeviceService ytDeviceService;  
42 - private final TkMessageTemplateService tkMessageTemplateService;  
43 - private final TkMessageConfigService ytMessageConfigService;  
44 - private final TkMailLogService ytMailLogService;  
45 - private final SmsLogService smsLogService;  
46 - private final TkAlarmContactService ytAlarmContactService;  
47 - private final AlarmProfileMapper alarmProfileMapper;  
48 - private final SysNoticeService sysNoticeService;  
49 - private final SysNoticeUserService sysNoticeUserService;  
50 - private final SceneLinkageService sceneLinkageService;  
51 - private final DoActionService doActionService;  
52 - private final DoConditionService doConditionService;  
53 - private final TriggerService triggerService;  
54 - private final ConvertConfigService convertConfigService;  
55 - private final SysAppDesignService sysAppDesignService;  
56 - private final SysPlatformDesignService sysPlatformDesignService;  
57 - private final SysEnterpriseService sysEnterpriseService;  
58 - private final UserRoleMapper userRoleMapper; 38 + private final MenuMapper menuMapper;
  39 + private final RoleMapper roleMapper;
  40 + private final UserMapper userMapper;
  41 + private final TenantMenuMapper tenantMenuMapper;
  42 + private final TenantRoleMapper tenantRoleMapper;
  43 + private final TkOrganizationService tkOrganizationService;
  44 + private final TkDeviceService ytDeviceService;
  45 + private final TkMessageTemplateService tkMessageTemplateService;
  46 + private final TkMessageConfigService ytMessageConfigService;
  47 + private final TkMailLogService ytMailLogService;
  48 + private final SmsLogService smsLogService;
  49 + private final TkAlarmContactService ytAlarmContactService;
  50 + private final AlarmProfileMapper alarmProfileMapper;
  51 + private final SysNoticeService sysNoticeService;
  52 + private final SysNoticeUserService sysNoticeUserService;
  53 + private final SceneLinkageService sceneLinkageService;
  54 + private final DoActionService doActionService;
  55 + private final DoConditionService doConditionService;
  56 + private final TriggerService triggerService;
  57 + private final ConvertConfigService convertConfigService;
  58 + private final SysAppDesignService sysAppDesignService;
  59 + private final SysPlatformDesignService sysPlatformDesignService;
  60 + private final SysEnterpriseService sysEnterpriseService;
  61 + private final UserRoleMapper userRoleMapper;
  62 + private final TkDeviceProfileService tkDeviceProfileService;
59 63
60 - @Override  
61 - @Transactional  
62 - public TenantDTO createNewTenant(TenantReqDTO tenantReqDTO) {  
63 - TenantDTO tenantDTO = new TenantDTO();  
64 - BeanUtils.copyProperties(tenantReqDTO, tenantDTO);  
65 - SysTenantEntity tenant = tenantDTO.getEntity(SysTenantEntity.class);  
66 - tenant.setTenantProfileId(tenantReqDTO.getTenantProfileId().getId().toString());  
67 - baseMapper.insert(tenant);  
68 - tenant.copyToDTO(tenantDTO);  
69 - saveTenantMapping(tenantDTO.getTenantId(), tenantReqDTO.getRoleIds());  
70 - return tenantDTO;  
71 - } 64 + @Override
  65 + @Transactional
  66 + public TenantDTO createNewTenant(TenantReqDTO tenantReqDTO) {
  67 + TenantDTO tenantDTO = new TenantDTO();
  68 + BeanUtils.copyProperties(tenantReqDTO, tenantDTO);
  69 + SysTenantEntity tenant = tenantDTO.getEntity(SysTenantEntity.class);
  70 + tenant.setTenantProfileId(tenantReqDTO.getTenantProfileId().getId().toString());
  71 + baseMapper.insert(tenant);
  72 + tenant.copyToDTO(tenantDTO);
  73 + saveTenantMapping(tenantDTO.getTenantId(), tenantReqDTO.getRoleIds());
  74 + return tenantDTO;
  75 + }
72 76
73 - @Override  
74 - public YtPageData<TenantDTO> page(Map<String, Object> queryMap) {  
75 - IPage<SysTenantEntity> tenantIPage = getPage(queryMap, "create_time", false);  
76 - IPage<TenantDTO> userPage =  
77 - baseMapper.getTenantPage(  
78 - tenantIPage, (String) queryMap.get("tenantName"), EntityId.NULL_UUID.toString());  
79 - YtPageData<TenantDTO> ytPageData = getPageData(userPage, TenantDTO.class);  
80 - determineTenantStatus(ytPageData.getItems());  
81 - return ytPageData;  
82 - } 77 + @Override
  78 + public YtPageData<TenantDTO> page(Map<String, Object> queryMap) {
  79 + IPage<SysTenantEntity> tenantIPage = getPage(queryMap, "create_time", false);
  80 + IPage<TenantDTO> userPage =
  81 + baseMapper.getTenantPage(
  82 + tenantIPage, (String) queryMap.get("tenantName"), EntityId.NULL_UUID.toString());
  83 + YtPageData<TenantDTO> ytPageData = getPageData(userPage, TenantDTO.class);
  84 + determineTenantStatus(ytPageData.getItems());
  85 + return ytPageData;
  86 + }
83 87
84 - private void determineTenantStatus(Collection<TenantDTO> tenantDTOList) {  
85 - tenantDTOList.forEach(  
86 - tenantDTO -> {  
87 - if (!tenantDTO.isEnabled()) {  
88 - tenantDTO.setTenantStatus(TenantStatusEnum.DISABLED);  
89 - } else {  
90 - tenantDTO.setTenantStatus(TenantStatusEnum.NORMAL);  
91 - if (tenantDTO.getTenantExpireTime() != null  
92 - && LocalDateTime.now().isAfter(tenantDTO.getTenantExpireTime())) {  
93 - tenantDTO.setTenantStatus(TenantStatusEnum.EXPIRED);  
94 - }  
95 - }  
96 - });  
97 - } 88 + private void determineTenantStatus(Collection<TenantDTO> tenantDTOList) {
  89 + tenantDTOList.forEach(
  90 + tenantDTO -> {
  91 + if (!tenantDTO.isEnabled()) {
  92 + tenantDTO.setTenantStatus(TenantStatusEnum.DISABLED);
  93 + } else {
  94 + tenantDTO.setTenantStatus(TenantStatusEnum.NORMAL);
  95 + if (tenantDTO.getTenantExpireTime() != null
  96 + && LocalDateTime.now().isAfter(tenantDTO.getTenantExpireTime())) {
  97 + tenantDTO.setTenantStatus(TenantStatusEnum.EXPIRED);
  98 + }
  99 + }
  100 + });
  101 + }
98 102
99 - @Override  
100 - @Transactional  
101 - public TenantDTO updateTenant(TenantDTO tenantDTO) {  
102 - SysTenantEntity tenant = baseMapper.selectById(tenantDTO.getId());  
103 - if (tenant == null) {  
104 - throw new YtDataValidationException("tenant does not exist");  
105 - }  
106 - String existTenantId = tenant.getTenantId();  
107 - tenantDTO.copyToEntity(tenant);  
108 - // tenantCode is immutable  
109 - tenant.setTenantId(existTenantId);  
110 - baseMapper.updateById(tenant);  
111 - tenant.copyToDTO(tenantDTO);  
112 - return tenantDTO; 103 + @Override
  104 + @Transactional
  105 + public TenantDTO updateTenant(TenantDTO tenantDTO) {
  106 + SysTenantEntity tenant = baseMapper.selectById(tenantDTO.getId());
  107 + if (tenant == null) {
  108 + throw new YtDataValidationException("tenant does not exist");
113 } 109 }
  110 + String existTenantId = tenant.getTenantId();
  111 + tenantDTO.copyToEntity(tenant);
  112 + // tenantCode is immutable
  113 + tenant.setTenantId(existTenantId);
  114 + baseMapper.updateById(tenant);
  115 + tenant.copyToDTO(tenantDTO);
  116 + return tenantDTO;
  117 + }
114 118
115 - @Override  
116 - @Transactional  
117 - public boolean deleteTenants(String[] idArr) {  
118 - Set<String> ids = Set.of(idArr);  
119 -  
120 - Set<String> tenantIds = baseMapper.getTenantIdsByTenantIds(ids);  
121 - // 1. GET ALL ROLE_ID  
122 - Set<String> allRoleIds = roleMapper.getAllIdsByTenantId(tenantIds);  
123 - // 2. DELETE SYS_ROLE SYS_ROLE_MENU SYS_USER_ROLE  
124 - if (!allRoleIds.isEmpty()) { 119 + @Override
  120 + @Transactional
  121 + public ListenableFuture<Boolean> deleteTenants(String[] idArr) {
  122 + Set<String> deleteIds = Set.of(idArr);
  123 + return Futures.transformAsync(
  124 + Futures.immediateFuture(deleteIds),
  125 + ids -> {
  126 + Set<String> tenantIds = baseMapper.getTenantIdsByTenantIds(ids);
  127 + // 1. GET ALL ROLE_ID
  128 + Set<String> allRoleIds = roleMapper.getAllIdsByTenantId(tenantIds);
  129 + // 2. DELETE SYS_ROLE SYS_ROLE_MENU SYS_USER_ROLE
  130 + if (!allRoleIds.isEmpty()) {
125 roleMapper.deleteBatchIds(allRoleIds); 131 roleMapper.deleteBatchIds(allRoleIds);
126 roleMapper.deleteRoleMenuMappingByRoleIds(allRoleIds); 132 roleMapper.deleteRoleMenuMappingByRoleIds(allRoleIds);
127 roleMapper.deleteRoleUserMappingByRoleIds(allRoleIds); 133 roleMapper.deleteRoleUserMappingByRoleIds(allRoleIds);
128 - }  
129 - // 3. DELETE SYS_MENU SYS_TENANT_MENU  
130 - Set<String> allMenuIds = menuMapper.getAllIdsByTenantId(tenantIds);  
131 - if (!allMenuIds.isEmpty()) { 134 + }
  135 + // 3. DELETE SYS_MENU SYS_TENANT_MENU
  136 + Set<String> allMenuIds = menuMapper.getAllIdsByTenantId(tenantIds);
  137 + if (!allMenuIds.isEmpty()) {
132 menuMapper.deleteBatchIds(allMenuIds); 138 menuMapper.deleteBatchIds(allMenuIds);
133 menuMapper.deleteTenantMenuMappingByMenuIds(allMenuIds); 139 menuMapper.deleteTenantMenuMappingByMenuIds(allMenuIds);
134 - }  
135 - // 4. DELETE USER  
136 - userMapper.delete(new QueryWrapper<SysUserEntity>().lambda().in(SysUserEntity::getTenantId, tenantIds));  
137 - // 5. TELL RULE ENGINE TO STOP TENANT  
138 - // 6. DELETE OTHER RESOURCES IF ANY  
139 - // 7. DELETE ORGANIZATION  
140 - tkOrganizationService.deleteDataByTenantIds(tenantIds);  
141 - // 8. DELETE DEVICE  
142 - ytDeviceService.deleteDataByTenantIds(tenantIds);  
143 - // 9. DELETE MESSAGE_TEMPLATE MESSAGE_CONFIG SEND_RECORDS  
144 - tkMessageTemplateService.deleteDataByTenantIds(tenantIds);  
145 - ytMessageConfigService.deleteDataByTenantIds(tenantIds);  
146 - ytMailLogService.deleteDataByTenantIds(tenantIds);  
147 - smsLogService.deleteDataByTenantIds(tenantIds);  
148 - // 10.DELETE ALARM CONTACT  
149 - ytAlarmContactService.deleteDataByTenantIds(tenantIds);  
150 - if (!tenantIds.isEmpty()) {  
151 - alarmProfileMapper.delete(new LambdaQueryWrapper<TkAlarmProfileEntity>().in(TkAlarmProfileEntity::getTenantId, tenantIds));  
152 - }  
153 - // 11.DELETE NOTICE NOTICE_RECORDS  
154 - sysNoticeService.deleteDataByTenantIds(tenantIds);  
155 - sysNoticeUserService.deleteDataByTenantIds(tenantIds);  
156 - // 12.DELETE SCENES  
157 - sceneLinkageService.deleteDataByTenantIds(tenantIds);  
158 - doActionService.deleteDataByTenantIds(tenantIds);  
159 - doConditionService.deleteDataByTenantIds(tenantIds);  
160 - triggerService.deleteDataByTenantIds(tenantIds);  
161 - // 13.DELETE CONVERT_CONFIG  
162 - convertConfigService.deleteDataByTenantIds(tenantIds);  
163 - // 14.DELETE APP_DESIGN PLATFORM_DESIGN ENTERPRISE  
164 - sysAppDesignService.deleteDataByTenantIds(tenantIds);  
165 - sysPlatformDesignService.deleteDataByTenantIds(tenantIds);  
166 - sysEnterpriseService.deleteDataByTenantIds(tenantIds);  
167 - // 15.DELETE TENANT_ROLE、TENANT_MENU  
168 - freshTenantAdminRole(tenantIds, null);  
169 - deleteTenantRolesByTenantId(tenantIds);  
170 - deleteTenantMenusByTenantId(tenantIds);  
171 - // 16. DELETE TENANT  
172 - baseMapper.deleteBatchIds(ids); 140 + }
  141 + // 4. DELETE USER
  142 + userMapper.delete(
  143 + new QueryWrapper<SysUserEntity>().lambda().in(SysUserEntity::getTenantId, tenantIds));
  144 + // 5. TELL RULE ENGINE TO STOP TENANT
  145 + // 6. DELETE OTHER RESOURCES IF ANY
  146 + // 7. DELETE ORGANIZATION
  147 + tkOrganizationService.deleteDataByTenantIds(tenantIds);
  148 + // 8. DELETE DEVICE
  149 + ytDeviceService.deleteDataByTenantIds(tenantIds);
  150 + // 9. DELETE MESSAGE_TEMPLATE MESSAGE_CONFIG SEND_RECORDS
  151 + tkMessageTemplateService.deleteDataByTenantIds(tenantIds);
  152 + ytMessageConfigService.deleteDataByTenantIds(tenantIds);
  153 + ytMailLogService.deleteDataByTenantIds(tenantIds);
  154 + smsLogService.deleteDataByTenantIds(tenantIds);
  155 + // 10.DELETE ALARM CONTACT
  156 + ytAlarmContactService.deleteDataByTenantIds(tenantIds);
  157 + if (!tenantIds.isEmpty()) {
  158 + alarmProfileMapper.delete(
  159 + new LambdaQueryWrapper<TkAlarmProfileEntity>()
  160 + .in(TkAlarmProfileEntity::getTenantId, tenantIds));
  161 + }
  162 + // 11.DELETE NOTICE NOTICE_RECORDS
  163 + sysNoticeService.deleteDataByTenantIds(tenantIds);
  164 + sysNoticeUserService.deleteDataByTenantIds(tenantIds);
  165 + // 12.DELETE SCENES
  166 + sceneLinkageService.deleteDataByTenantIds(tenantIds);
  167 + doActionService.deleteDataByTenantIds(tenantIds);
  168 + doConditionService.deleteDataByTenantIds(tenantIds);
  169 + triggerService.deleteDataByTenantIds(tenantIds);
  170 + // 13.DELETE CONVERT_CONFIG
  171 + convertConfigService.deleteDataByTenantIds(tenantIds);
  172 + // 14.DELETE APP_DESIGN PLATFORM_DESIGN ENTERPRISE
  173 + sysAppDesignService.deleteDataByTenantIds(tenantIds);
  174 + sysPlatformDesignService.deleteDataByTenantIds(tenantIds);
  175 + sysEnterpriseService.deleteDataByTenantIds(tenantIds);
  176 + // 15.DELETE TENANT_ROLE、TENANT_MENU
  177 + freshTenantAdminRole(tenantIds, null);
  178 + deleteTenantRolesByTenantId(tenantIds);
  179 + deleteTenantMenusByTenantId(tenantIds);
  180 + // 16. DELETE TENANT
  181 + baseMapper.deleteBatchIds(ids);
  182 + // 17. DELETE DEVICE_PROFILE
  183 + tkDeviceProfileService.deleteDataByTenantIds(tenantIds);
  184 + return Futures.immediateFuture(true);
  185 + },
  186 + MoreExecutors.directExecutor());
  187 + }
173 188
  189 + /**
  190 + * 通过租户Code删除租户角色关系
  191 + *
  192 + * @param tenantIds 租户Code
  193 + */
  194 + private void deleteTenantRolesByTenantId(Set<String> tenantIds) {
  195 + tenantRoleMapper.delete(
  196 + new QueryWrapper<SysTenantRoleEntity>()
  197 + .lambda()
  198 + .in(SysTenantRoleEntity::getTenantId, tenantIds));
  199 + }
174 200
175 - return true;  
176 - } 201 + /**
  202 + * 通过租户Code删除租户角色关系
  203 + *
  204 + * @param tenantIds 租户Code
  205 + */
  206 + private void deleteTenantMenusByTenantId(Set<String> tenantIds) {
  207 + tenantMenuMapper.delete(
  208 + new QueryWrapper<SysTenantMenuEntity>()
  209 + .lambda()
  210 + .in(SysTenantMenuEntity::getTenantId, tenantIds));
  211 + }
177 212
178 - /**  
179 - * 通过租户Code删除租户角色关系  
180 - *  
181 - * @param tenantIds 租户Code  
182 - */  
183 - private void deleteTenantRolesByTenantId(Set<String> tenantIds) {  
184 - tenantRoleMapper.delete(  
185 - new QueryWrapper<SysTenantRoleEntity>().lambda().in(SysTenantRoleEntity::getTenantId, tenantIds));  
186 - } 213 + /**
  214 + * 刷新租户管理员与角色关系 1、1个租户1个角色；1个角色多个租户 2、1个角色多个用户(租户管理员)
  215 + *
  216 + * @param tenantIds 租户ID
  217 + * @param newRoles 新增的角色ID
  218 + */
  219 + private void freshTenantAdminRole(Set<String> tenantIds, List<String> newRoles) {
  220 + LambdaQueryWrapper<SysTenantRoleEntity> roleFilter =
  221 + new QueryWrapper<SysTenantRoleEntity>()
  222 + .lambda()
  223 + .in(SysTenantRoleEntity::getTenantId, tenantIds);
  224 + List<String> deleteIds =
  225 + tenantRoleMapper.selectList(roleFilter).stream()
  226 + .map(i -> i.getRoleId())
  227 + .collect(Collectors.toList());
187 228
188 - /**  
189 - * 通过租户Code删除租户角色关系  
190 - *  
191 - * @param tenantIds 租户Code  
192 - */  
193 - private void deleteTenantMenusByTenantId(Set<String> tenantIds) {  
194 - tenantMenuMapper.delete(  
195 - new QueryWrapper<SysTenantMenuEntity>().lambda().in(SysTenantMenuEntity::getTenantId, tenantIds));  
196 - }  
197 -  
198 - /**  
199 - * 刷新租户管理员与角色关系  
200 - * 1、1个租户1个角色；1个角色多个租户  
201 - * 2、1个角色多个用户(租户管理员)  
202 - *  
203 - * @param tenantIds 租户ID  
204 - * @param newRoles 新增的角色ID  
205 - */  
206 - private void freshTenantAdminRole(Set<String> tenantIds, List<String> newRoles) {  
207 - LambdaQueryWrapper<SysTenantRoleEntity> roleFilter = new QueryWrapper<SysTenantRoleEntity>().lambda()  
208 - .in(SysTenantRoleEntity::getTenantId, tenantIds);  
209 - List<String> deleteIds = tenantRoleMapper.selectList(roleFilter).stream()  
210 - .map(i -> i.getRoleId())  
211 - .collect(Collectors.toList()); 229 + LambdaQueryWrapper<SysUserEntity> userFilter =
  230 + new QueryWrapper<SysUserEntity>()
  231 + .lambda()
  232 + .eq(SysUserEntity::getLevel, 2)
  233 + .in(SysUserEntity::getTenantId, tenantIds);
  234 + List<String> userIds =
  235 + userMapper.selectList(userFilter).stream().map(m -> m.getId()).collect(Collectors.toList());
212 236
213 - LambdaQueryWrapper<SysUserEntity> userFilter = new QueryWrapper<SysUserEntity>().lambda()  
214 - .eq(SysUserEntity::getLevel,2)  
215 - .in(SysUserEntity::getTenantId, tenantIds);  
216 - List<String> userIds = userMapper.selectList(userFilter).stream()  
217 - .map(m -> m.getId())  
218 - .collect(Collectors.toList());  
219 -  
220 - if(!deleteIds.isEmpty() && !userIds.isEmpty()){  
221 - LambdaQueryWrapper<SysUserRoleEntity> filter = new QueryWrapper<SysUserRoleEntity>().lambda()  
222 - .in(SysUserRoleEntity::getRoleId, deleteIds)  
223 - .in(SysUserRoleEntity::getUserId,userIds);  
224 - userRoleMapper.delete(filter);  
225 - }  
226 -  
227 - if (newRoles == null || newRoles.isEmpty()  
228 - || userIds == null || userIds.isEmpty()) {  
229 - return;  
230 - }  
231 - userIds.forEach(item -> {  
232 - for (String roleId : newRoles) {  
233 - SysUserRoleEntity role = new SysUserRoleEntity();  
234 - role.setRoleId(roleId);  
235 - role.setUserId(item);  
236 - userRoleMapper.insert(role);  
237 - }  
238 - }); 237 + if (!deleteIds.isEmpty() && !userIds.isEmpty()) {
  238 + LambdaQueryWrapper<SysUserRoleEntity> filter =
  239 + new QueryWrapper<SysUserRoleEntity>()
  240 + .lambda()
  241 + .in(SysUserRoleEntity::getRoleId, deleteIds)
  242 + .in(SysUserRoleEntity::getUserId, userIds);
  243 + userRoleMapper.delete(filter);
239 } 244 }
240 245
241 - @Override  
242 - public Optional<TenantDTO> findById(String id) {  
243 - return Optional.ofNullable(baseMapper.selectById(id))  
244 - .map(tenant -> tenant.getDTO(TenantDTO.class)); 246 + if (newRoles == null || newRoles.isEmpty() || userIds == null || userIds.isEmpty()) {
  247 + return;
245 } 248 }
  249 + userIds.forEach(
  250 + item -> {
  251 + for (String roleId : newRoles) {
  252 + SysUserRoleEntity role = new SysUserRoleEntity();
  253 + role.setRoleId(roleId);
  254 + role.setUserId(item);
  255 + userRoleMapper.insert(role);
  256 + }
  257 + });
  258 + }
246 259
247 - @Override  
248 - @Transactional  
249 - public TenantDTO updateOrCreateTenant(TenantReqDTO tenantReqDTO) {  
250 - if (StringUtils.isNotBlank(tenantReqDTO.getId())) {  
251 - SysTenantEntity tenant;  
252 - tenant = baseMapper.selectById(tenantReqDTO.getId());  
253 - if (tenant != null) {  
254 - BeanUtils.copyProperties(tenantReqDTO, tenant);  
255 - if (!tenantReqDTO.getTenantProfileId().isNullUid()) {  
256 - tenant.setTenantProfileId(tenantReqDTO.getTenantProfileId().getId().toString());  
257 - }  
258 - //update tenant role  
259 - //delete  
260 - Set<String> tenantIds = new HashSet<>();  
261 - tenantIds.add(tenantReqDTO.getTenantId());  
262 - freshTenantAdminRole(tenantIds, Arrays.asList(tenantReqDTO.getRoleIds()));  
263 - deleteTenantRolesByTenantId(tenantIds);  
264 - deleteTenantMenusByTenantId(tenantIds);  
265 - //add  
266 - saveTenantMapping(tenantReqDTO.getTenantId(), tenantReqDTO.getRoleIds());  
267 - baseMapper.updateById(tenant);  
268 - }  
269 - return tenant.getDTO(TenantDTO.class);  
270 - } else {  
271 - return createNewTenant(tenantReqDTO);  
272 - }  
273 - } 260 + @Override
  261 + public Optional<TenantDTO> findById(String id) {
  262 + return Optional.ofNullable(baseMapper.selectById(id))
  263 + .map(tenant -> tenant.getDTO(TenantDTO.class));
  264 + }
274 265
275 - @Override  
276 - public List<String> getTenantRolesByTenantId(String tenantId) {  
277 - if (StringUtils.isEmpty(tenantId)) {  
278 - throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage()); 266 + @Override
  267 + @Transactional
  268 + public TenantDTO updateOrCreateTenant(TenantReqDTO tenantReqDTO) {
  269 + if (StringUtils.isNotBlank(tenantReqDTO.getId())) {
  270 + SysTenantEntity tenant;
  271 + tenant = baseMapper.selectById(tenantReqDTO.getId());
  272 + if (tenant != null) {
  273 + BeanUtils.copyProperties(tenantReqDTO, tenant);
  274 + if (!tenantReqDTO.getTenantProfileId().isNullUid()) {
  275 + tenant.setTenantProfileId(tenantReqDTO.getTenantProfileId().getId().toString());
279 } 276 }
280 - List<String> roles = new ArrayList<>();  
281 - List<SysTenantRoleEntity> tenantRoleList =  
282 - tenantRoleMapper.selectList(  
283 - new QueryWrapper<SysTenantRoleEntity>().lambda().eq(SysTenantRoleEntity::getTenantId, tenantId));  
284 - tenantRoleList.forEach(role -> roles.add(role.getRoleId()));  
285 - return roles; 277 + // update tenant role
  278 + // delete
  279 + Set<String> tenantIds = new HashSet<>();
  280 + tenantIds.add(tenantReqDTO.getTenantId());
  281 + freshTenantAdminRole(tenantIds, Arrays.asList(tenantReqDTO.getRoleIds()));
  282 + deleteTenantRolesByTenantId(tenantIds);
  283 + deleteTenantMenusByTenantId(tenantIds);
  284 + // add
  285 + saveTenantMapping(tenantReqDTO.getTenantId(), tenantReqDTO.getRoleIds());
  286 + baseMapper.updateById(tenant);
  287 + }
  288 + return tenant.getDTO(TenantDTO.class);
  289 + } else {
  290 + return createNewTenant(tenantReqDTO);
286 } 291 }
  292 + }
287 293
288 - @Override  
289 - public YtPageData<TenantDTO> getCurrentMonthExpireTenantPage(Map<String, Object> queryMap) {  
290 - IPage<SysTenantEntity> tenantIPage = getPage(queryMap, "create_time", true);  
291 - IPage<TenantDTO> tenantDTOIPage = baseMapper.getCurrentMonthExpireTenantPage(tenantIPage);  
292 - return getPageData(tenantDTOIPage, TenantDTO.class); 294 + @Override
  295 + public List<String> getTenantRolesByTenantId(String tenantId) {
  296 + if (StringUtils.isEmpty(tenantId)) {
  297 + throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
293 } 298 }
  299 + List<String> roles = new ArrayList<>();
  300 + List<SysTenantRoleEntity> tenantRoleList =
  301 + tenantRoleMapper.selectList(
  302 + new QueryWrapper<SysTenantRoleEntity>()
  303 + .lambda()
  304 + .eq(SysTenantRoleEntity::getTenantId, tenantId));
  305 + tenantRoleList.forEach(role -> roles.add(role.getRoleId()));
  306 + return roles;
  307 + }
294 308
295 - @Override  
296 - public List<TenantDTO> getAllTenant() {  
297 - List<SysTenantEntity> tenants =  
298 - baseMapper.selectList(  
299 - new LambdaQueryWrapper<SysTenantEntity>()  
300 - .ne(SysTenantEntity::getTenantId, EntityId.NULL_UUID.toString()));  
301 - return ReflectUtils.sourceToTarget(tenants, TenantDTO.class);  
302 - } 309 + @Override
  310 + public YtPageData<TenantDTO> getCurrentMonthExpireTenantPage(Map<String, Object> queryMap) {
  311 + IPage<SysTenantEntity> tenantIPage = getPage(queryMap, "create_time", true);
  312 + IPage<TenantDTO> tenantDTOIPage = baseMapper.getCurrentMonthExpireTenantPage(tenantIPage);
  313 + return getPageData(tenantDTOIPage, TenantDTO.class);
  314 + }
303 315
304 - @Override  
305 - @Async  
306 - public CompletableFuture<TsValue> findTenantsByTs(  
307 - LocalDateTime startTs, LocalDateTime endTs, long ts) {  
308 - List<SysTenantEntity> tenants =  
309 - baseMapper.selectList(  
310 - new LambdaQueryWrapper<SysTenantEntity>()  
311 - .ge(SysTenantEntity::getCreateTime, startTs).lt(SysTenantEntity::getCreateTime, endTs));  
312 - return CompletableFuture.supplyAsync(  
313 - () -> new TsValue(ts, String.valueOf(tenants.size())));  
314 - } 316 + @Override
  317 + public List<TenantDTO> getAllTenant() {
  318 + List<SysTenantEntity> tenants =
  319 + baseMapper.selectList(
  320 + new LambdaQueryWrapper<SysTenantEntity>()
  321 + .ne(SysTenantEntity::getTenantId, EntityId.NULL_UUID.toString()));
  322 + return ReflectUtils.sourceToTarget(tenants, TenantDTO.class);
  323 + }
315 324
316 - /**  
317 - * 保存租户与菜单、角色的映射关系  
318 - *  
319 - * @param tenantId 租户Code  
320 - * @param roleIds 角色IDS  
321 - */  
322 - private void saveTenantMapping(String tenantId, String[] roleIds) {  
323 - // 添加租户角色关系  
324 - for (String roleId : roleIds) {  
325 - saveTenantRoleMapping(roleId, tenantId);  
326 - // 查询roleId有多少菜单  
327 - Set<String> menuIds = roleMapper.getMenuIdsByRoleId(roleId);  
328 - // 添加租户菜单关系  
329 - for (String menuId : menuIds) {  
330 - saveTenantMenuMapping(menuId, tenantId);  
331 - }  
332 - }  
333 - } 325 + @Override
  326 + @Async
  327 + public CompletableFuture<TsValue> findTenantsByTs(
  328 + LocalDateTime startTs, LocalDateTime endTs, long ts) {
  329 + List<SysTenantEntity> tenants =
  330 + baseMapper.selectList(
  331 + new LambdaQueryWrapper<SysTenantEntity>()
  332 + .ge(SysTenantEntity::getCreateTime, startTs)
  333 + .lt(SysTenantEntity::getCreateTime, endTs));
  334 + return CompletableFuture.supplyAsync(() -> new TsValue(ts, String.valueOf(tenants.size())));
  335 + }
334 336
335 - /**  
336 - * 保存租户与菜单的关系  
337 - *  
338 - * @param menuId 菜单ID  
339 - * @param tenantId 租户Code  
340 - */  
341 - private void saveTenantMenuMapping(String menuId, String tenantId) {  
342 - SysTenantMenuEntity tenantMenu = new SysTenantMenuEntity();  
343 - tenantMenu.setMenuId(menuId);  
344 - tenantMenu.setTenantId(tenantId);  
345 - tenantMenuMapper.insert(tenantMenu); 337 + /**
  338 + * 保存租户与菜单、角色的映射关系
  339 + *
  340 + * @param tenantId 租户Code
  341 + * @param roleIds 角色IDS
  342 + */
  343 + private void saveTenantMapping(String tenantId, String[] roleIds) {
  344 + // 添加租户角色关系
  345 + for (String roleId : roleIds) {
  346 + saveTenantRoleMapping(roleId, tenantId);
  347 + // 查询roleId有多少菜单
  348 + Set<String> menuIds = roleMapper.getMenuIdsByRoleId(roleId);
  349 + // 添加租户菜单关系
  350 + for (String menuId : menuIds) {
  351 + saveTenantMenuMapping(menuId, tenantId);
  352 + }
346 } 353 }
  354 + }
347 355
348 - /**  
349 - * 保存租户与角色的关系  
350 - *  
351 - * @param roleId 角色ID  
352 - * @param tenantId 租户Code  
353 - */  
354 - private void saveTenantRoleMapping(String roleId, String tenantId) {  
355 - SysTenantRoleEntity tenantRole = new SysTenantRoleEntity();  
356 - tenantRole.setTenantId(tenantId);  
357 - tenantRole.setRoleId(roleId);  
358 - tenantRoleMapper.insert(tenantRole);  
359 - } 356 + /**
  357 + * 保存租户与菜单的关系
  358 + *
  359 + * @param menuId 菜单ID
  360 + * @param tenantId 租户Code
  361 + */
  362 + private void saveTenantMenuMapping(String menuId, String tenantId) {
  363 + SysTenantMenuEntity tenantMenu = new SysTenantMenuEntity();
  364 + tenantMenu.setMenuId(menuId);
  365 + tenantMenu.setTenantId(tenantId);
  366 + tenantMenuMapper.insert(tenantMenu);
  367 + }
  368 +
  369 + /**
  370 + * 保存租户与角色的关系
  371 + *
  372 + * @param roleId 角色ID
  373 + * @param tenantId 租户Code
  374 + */
  375 + private void saveTenantRoleMapping(String roleId, String tenantId) {
  376 + SysTenantRoleEntity tenantRole = new SysTenantRoleEntity();
  377 + tenantRole.setTenantId(tenantId);
  378 + tenantRole.setRoleId(roleId);
  379 + tenantRoleMapper.insert(tenantRole);
  380 + }
360 } 381 }
@@ -3,12 +3,13 @@ package org.thingsboard.server.dao.yunteng.service; @@ -3,12 +3,13 @@ package org.thingsboard.server.dao.yunteng.service;
3 import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO; 3 import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
4 import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum; 4 import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
5 import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData; 5 import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
  6 +import org.thingsboard.server.dao.yunteng.entities.TkDeviceProfileEntity;
6 7
7 import java.util.List; 8 import java.util.List;
8 import java.util.Optional; 9 import java.util.Optional;
9 import java.util.Set; 10 import java.util.Set;
10 11
11 -public interface TkDeviceProfileService { 12 +public interface TkDeviceProfileService extends BaseService<TkDeviceProfileEntity>{
12 13
13 DeviceProfileDTO insertOrUpdate(DeviceProfileDTO deviceDTO); 14 DeviceProfileDTO insertOrUpdate(DeviceProfileDTO deviceDTO);
14 15
@@ -2,6 +2,7 @@ package org.thingsboard.server.dao.yunteng.service; @@ -2,6 +2,7 @@ package org.thingsboard.server.dao.yunteng.service;
2 2
3 3
4 4
  5 +import com.google.common.util.concurrent.ListenableFuture;
5 import org.thingsboard.server.common.data.query.TsValue; 6 import org.thingsboard.server.common.data.query.TsValue;
6 import org.thingsboard.server.common.data.yunteng.dto.HomePageLeftBottomDTO; 7 import org.thingsboard.server.common.data.yunteng.dto.HomePageLeftBottomDTO;
7 import org.thingsboard.server.common.data.yunteng.dto.TenantDTO; 8 import org.thingsboard.server.common.data.yunteng.dto.TenantDTO;
@@ -19,7 +20,7 @@ public interface TkTenantService { @@ -19,7 +20,7 @@ public interface TkTenantService {
19 20
20 TenantDTO updateTenant(TenantDTO tenantDTO); 21 TenantDTO updateTenant(TenantDTO tenantDTO);
21 22
22 - boolean deleteTenants(String[] ids); 23 + ListenableFuture<Boolean> deleteTenants(String[] ids);
23 24
24 Optional<TenantDTO> findById(String id); 25 Optional<TenantDTO> findById(String id);
25 26