简柏林 / 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 3 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
4 4 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
5 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 9 import lombok.RequiredArgsConstructor;
7 10 import org.apache.commons.lang3.StringUtils;
8 11 import org.springframework.beans.BeanUtils;
... ... @@ -30,331 +33,349 @@ import java.util.stream.Collectors;
30 33 @Service
31 34 @RequiredArgsConstructor
32 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 131 roleMapper.deleteBatchIds(allRoleIds);
126 132 roleMapper.deleteRoleMenuMappingByRoleIds(allRoleIds);
127 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 138 menuMapper.deleteBatchIds(allMenuIds);
133 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 3 import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
4 4 import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
5 5 import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
  6 +import org.thingsboard.server.dao.yunteng.entities.TkDeviceProfileEntity;
6 7
7 8 import java.util.List;
8 9 import java.util.Optional;
9 10 import java.util.Set;
10 11
11   -public interface TkDeviceProfileService {
  12 +public interface TkDeviceProfileService extends BaseService<TkDeviceProfileEntity>{
12 13
13 14 DeviceProfileDTO insertOrUpdate(DeviceProfileDTO deviceDTO);
14 15
... ...
... ... @@ -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 6 import org.thingsboard.server.common.data.query.TsValue;
6 7 import org.thingsboard.server.common.data.yunteng.dto.HomePageLeftBottomDTO;
7 8 import org.thingsboard.server.common.data.yunteng.dto.TenantDTO;
... ... @@ -19,7 +20,7 @@ public interface TkTenantService {
19 20
20 21 TenantDTO updateTenant(TenantDTO tenantDTO);
21 22
22   - boolean deleteTenants(String[] ids);
  23 + ListenableFuture<Boolean> deleteTenants(String[] ids);
23 24
24 25 Optional<TenantDTO> findById(String id);
25 26
... ...