Fix permission checks for export/import api

application/src/main/java/org/thingsboard/server/controller/EntitiesExportImportController.java

@@ -39,7 +39,6 @@ import org.thingsboard.server.common.data.query.EntityKey;
 import org.thingsboard.server.common.data.query.EntityKeyType;
 import org.thingsboard.server.common.data.query.EntityTypeFilter;
 import org.thingsboard.server.common.data.relation.EntityRelation;
-import org.thingsboard.server.common.data.relation.RelationTypeGroup;
 import org.thingsboard.server.dao.entity.EntityService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.sync.EntitiesExportImportService;
@@ -81,9 +80,10 @@ public class EntitiesExportImportController extends BaseController {
     public EntityExportData<ExportableEntity<EntityId>> exportSingleEntity(@PathVariable EntityType entityType,
                                                                            @PathVariable UUID id,
                                                                            @RequestParam Map<String, String> exportSettingsParams) throws ThingsboardException {
+        SecurityUser user = getCurrentUser();
         EntityId entityId = EntityIdFactory.getByTypeAndUuid(entityType, id);
         try {
-            return exportEntity(getTenantId(), entityId, toExportSettings(exportSettingsParams));
+            return exportEntity(user, entityId, toExportSettings(exportSettingsParams));
         } catch (Exception e) {
             throw handleException(e);
         }
@@ -93,11 +93,12 @@ public class EntitiesExportImportController extends BaseController {
     public List<EntityExportData<ExportableEntity<EntityId>>> exportEntitiesByIds(@PathVariable EntityType entityType,
                                                                                   @RequestParam UUID[] ids,
                                                                                   @RequestParam Map<String, String> exportSettingsParams) throws ThingsboardException {
+        SecurityUser user = getCurrentUser();
         List<EntityId> entitiesIds = Arrays.stream(ids)
                 .map(id -> EntityIdFactory.getByTypeAndUuid(entityType, id))
                 .collect(Collectors.toList());
         try {
-            return exportEntitiesByIds(getTenantId(), entitiesIds, toExportSettings(exportSettingsParams));
+            return exportEntitiesByIds(user, entitiesIds, toExportSettings(exportSettingsParams));
         } catch (Exception e) {
             throw handleException(e);
         }
@@ -109,13 +110,13 @@ public class EntitiesExportImportController extends BaseController {
                                                                                          @RequestParam(defaultValue = "0") int page,
                                                                                          @RequestParam(defaultValue = "2147483647") int pageSize,
                                                                                          @RequestParam(name = "customerId", required = false) UUID customerUuid) throws ThingsboardException {
-        TenantId tenantId = getTenantId();
+        SecurityUser user = getCurrentUser();
         CustomerId customerId = toCustomerId(customerUuid);
 
         EntityTypeFilter entityTypeFilter = new EntityTypeFilter();
         entityTypeFilter.setEntityType(entityType);
         try {
-            return exportEntitiesByFilter(tenantId, customerId, entityTypeFilter, page, pageSize, toExportSettings(exportSettingsParams));
+            return exportEntitiesByFilter(user, customerId, entityTypeFilter, page, pageSize, toExportSettings(exportSettingsParams));
         } catch (Exception e) {
             throw handleException(e);
         }
@@ -127,10 +128,10 @@ public class EntitiesExportImportController extends BaseController {
                                                                                      @RequestParam(defaultValue = "0") int page,
                                                                                      @RequestParam(defaultValue = "2147483647") int pageSize,
                                                                                      @RequestParam(name = "customerId", required = false) UUID customerUuid) throws ThingsboardException {
-        TenantId tenantId = getTenantId();
+        SecurityUser user = getCurrentUser();
         CustomerId customerId = toCustomerId(customerUuid);
         try {
-            return exportEntitiesByFilter(tenantId, customerId, filter, page, pageSize, toExportSettings(exportSettingsParams));
+            return exportEntitiesByFilter(user, customerId, filter, page, pageSize, toExportSettings(exportSettingsParams));
         } catch (Exception e) {
             throw handleException(e);
         }
@@ -141,12 +142,12 @@ public class EntitiesExportImportController extends BaseController {
     public List<EntityExportData<ExportableEntity<EntityId>>> exportAllEntitiesByFilters(@RequestBody List<EntityFilter> filters,
                                                                                          @RequestParam Map<String, String> exportSettingsParams,
                                                                                          @RequestParam(name = "customerId", required = false) UUID customerUuid) throws ThingsboardException {
-        TenantId tenantId = getTenantId();
+        SecurityUser user = getCurrentUser();
         CustomerId customerId = toCustomerId(customerUuid);
         try {
             List<EntityExportData<ExportableEntity<EntityId>>> exportDataList = new ArrayList<>();
             for (EntityFilter filter : filters) {
-                exportDataList.addAll(exportEntitiesByFilter(tenantId, customerId, filter, 0, Integer.MAX_VALUE, toExportSettings(exportSettingsParams)));
+                exportDataList.addAll(exportEntitiesByFilter(user, customerId, filter, 0, Integer.MAX_VALUE, toExportSettings(exportSettingsParams)));
             }
             return exportDataList;
         } catch (Exception e) {
@@ -158,17 +159,17 @@ public class EntitiesExportImportController extends BaseController {
     public List<EntityExportData<ExportableEntity<EntityId>>> exportEntitiesByQuery(@RequestBody EntityDataQuery entitiesQuery,
                                                                                     @RequestParam Map<String, String> exportSettingsParams,
                                                                                     @RequestParam(name = "customerId", required = false) UUID customerUuid) throws ThingsboardException {
-        TenantId tenantId = getTenantId();
+        SecurityUser user = getCurrentUser();
         CustomerId customerId = toCustomerId(customerUuid);
         try {
-            return exportEntitiesByQuery(tenantId, customerId, entitiesQuery, toExportSettings(exportSettingsParams));
+            return exportEntitiesByQuery(user, customerId, entitiesQuery, toExportSettings(exportSettingsParams));
         } catch (Exception e) {
             throw handleException(e);
         }
     }
 
 
-    private List<EntityExportData<ExportableEntity<EntityId>>> exportEntitiesByFilter(TenantId tenantId, CustomerId customerId, EntityFilter filter, int page, int pageSize, EntityExportSettings exportSettings) throws ThingsboardException {
+    private List<EntityExportData<ExportableEntity<EntityId>>> exportEntitiesByFilter(SecurityUser user, CustomerId customerId, EntityFilter filter, int page, int pageSize, EntityExportSettings exportSettings) throws ThingsboardException {
         EntityDataPageLink pageLink = new EntityDataPageLink();
         pageLink.setPage(page);
         pageLink.setPageSize(pageSize);
@@ -176,43 +177,26 @@ public class EntitiesExportImportController extends BaseController {
         pageLink.setSortOrder(new EntityDataSortOrder(sortProperty, EntityDataSortOrder.Direction.DESC));
 
         EntityDataQuery query = new EntityDataQuery(filter, pageLink, List.of(sortProperty), Collections.emptyList(), Collections.emptyList());
-        return exportEntitiesByQuery(tenantId, customerId, query, exportSettings);
+        return exportEntitiesByQuery(user, customerId, query, exportSettings);
     }
 
-    private List<EntityExportData<ExportableEntity<EntityId>>> exportEntitiesByQuery(TenantId tenantId, CustomerId customerId, EntityDataQuery query, EntityExportSettings exportSettings) throws ThingsboardException {
-        List<EntityId> entitiesIds = entityService.findEntityDataByQuery(tenantId, customerId, query).getData().stream()
+    private List<EntityExportData<ExportableEntity<EntityId>>> exportEntitiesByQuery(SecurityUser user, CustomerId customerId, EntityDataQuery query, EntityExportSettings exportSettings) throws ThingsboardException {
+        List<EntityId> entitiesIds = entityService.findEntityDataByQuery(user.getTenantId(), customerId, query).getData().stream()
                 .map(EntityData::getEntityId)
                 .collect(Collectors.toList());
-        return exportEntitiesByIds(tenantId, entitiesIds, exportSettings);
+        return exportEntitiesByIds(user, entitiesIds, exportSettings);
     }
 
-    private List<EntityExportData<ExportableEntity<EntityId>>> exportEntitiesByIds(TenantId tenantId, List<EntityId> entitiesIds, EntityExportSettings exportSettings) throws ThingsboardException {
+    private List<EntityExportData<ExportableEntity<EntityId>>> exportEntitiesByIds(SecurityUser user, List<EntityId> entitiesIds, EntityExportSettings exportSettings) throws ThingsboardException {
         List<EntityExportData<ExportableEntity<EntityId>>> exportDataList = new ArrayList<>();
         for (EntityId entityId : entitiesIds) {
-            exportDataList.add(exportEntity(tenantId, entityId, exportSettings));
+            exportDataList.add(exportEntity(user, entityId, exportSettings));
         }
         return exportDataList;
     }
 
-    private <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(TenantId tenantId, I entityId, EntityExportSettings exportSettings) throws ThingsboardException {
-        checkEntityId(entityId, Operation.READ);
-
-        List<EntityRelation> relations = new LinkedList<>();
-        if (exportSettings.isExportInboundRelations()) {
-            relations.addAll(relationService.findByTo(tenantId, entityId, RelationTypeGroup.COMMON));
-        }
-        if (exportSettings.isExportOutboundRelations()) {
-            relations.addAll(relationService.findByFrom(tenantId, entityId, RelationTypeGroup.COMMON));
-        }
-        for (EntityRelation relation : relations) {
-            if (!relation.getFrom().equals(entityId)) {
-                checkEntityId(relation.getFrom(), Operation.READ);
-            } else if (!relation.getTo().equals(entityId)) {
-                checkEntityId(relation.getTo(), Operation.READ);
-            }
-        }
-
-        return exportImportService.exportEntity(tenantId, entityId, exportSettings);
+    private <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(SecurityUser user, I entityId, EntityExportSettings exportSettings) throws ThingsboardException {
+        return exportImportService.exportEntity(user, entityId, exportSettings);
     }
 
 
@@ -235,41 +219,7 @@ public class EntitiesExportImportController extends BaseController {
 
 
     public List<EntityImportResult<ExportableEntity<EntityId>>> importEntities(SecurityUser user, List<EntityExportData<ExportableEntity<EntityId>>> exportDataList, EntityImportSettings importSettings) throws ThingsboardException {
-        for (EntityExportData<ExportableEntity<EntityId>> exportData : exportDataList) {
-            ExportableEntity<EntityId> existingEntity = exportableEntitiesService.findEntityByExternalId(user.getTenantId(), exportData.getEntity().getId());
-            if (existingEntity != null) {
-                accessControlService.checkPermission(user, Resource.of(exportData.getEntityType()), Operation.WRITE, existingEntity.getId(), existingEntity);
-            } else {
-                exportData.getEntity().setTenantId(user.getTenantId());
-                accessControlService.checkPermission(user, Resource.of(exportData.getEntityType()), Operation.CREATE, null, exportData.getEntity());
-            }
-
-            List<EntityRelation> relations = new LinkedList<>();
-            if (importSettings.isImportInboundRelations() && exportData.getInboundRelations() != null) {
-                relations.addAll(exportData.getInboundRelations());
-            }
-            if (importSettings.isImportOutboundRelations() && exportData.getOutboundRelations() != null) {
-                relations.addAll(exportData.getOutboundRelations());
-            }
-            for (EntityRelation relation : relations) {
-                EntityId otherEntityId = null;
-                if (!relation.getFrom().equals(exportData.getEntity().getId())) {
-                    otherEntityId = relation.getFrom();
-                } else if (!relation.getTo().equals(exportData.getEntity().getId())) {
-                    otherEntityId = relation.getTo();
-                }
-                if (otherEntityId != null) {
-                    ExportableEntity<EntityId> otherEntity = exportableEntitiesService.findEntityByExternalId(user.getTenantId(), otherEntityId);
-                    if (otherEntity != null) {
-                        checkEntityId(otherEntity.getId(), Operation.WRITE);
-                    } else {
-                        throw new IllegalArgumentException("Relation is referencing non-existing entity");
-                    }
-                }
-            }
-        }
-
-        return exportImportService.importEntities(user.getTenantId(), exportDataList, importSettings);
+        return exportImportService.importEntities(user, exportDataList, importSettings);
     }
 
 

application/src/main/java/org/thingsboard/server/service/sync/DefaultEntitiesExportImportService.java

@@ -15,19 +15,23 @@
  */
 package org.thingsboard.server.service.sync;
 
+import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.ExportableEntity;
 import org.thingsboard.server.common.data.HasTenantId;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.HasId;
-import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.ExportableEntityDao;
-import org.thingsboard.server.dao.TenantEntityDao;
 import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.security.model.SecurityUser;
+import org.thingsboard.server.service.security.permission.AccessControlService;
+import org.thingsboard.server.service.security.permission.Operation;
+import org.thingsboard.server.service.security.permission.Resource;
 import org.thingsboard.server.service.sync.exporting.EntityExportService;
 import org.thingsboard.server.service.sync.exporting.EntityExportSettings;
 import org.thingsboard.server.service.sync.exporting.ExportableEntitiesService;
@@ -36,7 +40,10 @@ import org.thingsboard.server.service.sync.importing.EntityImportResult;
 import org.thingsboard.server.service.sync.importing.EntityImportService;
 import org.thingsboard.server.service.sync.importing.EntityImportSettings;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
@@ -45,12 +52,15 @@ import java.util.stream.Collectors;
 
 @Service
 @TbCoreComponent
+@RequiredArgsConstructor
 public class DefaultEntitiesExportImportService implements EntitiesExportImportService, ExportableEntitiesService {
 
     private final Map<EntityType, EntityExportService<?, ?, ?>> exportServices = new HashMap<>();
     private final Map<EntityType, EntityImportService<?, ?, ?>> importServices = new HashMap<>();
     private final Map<EntityType, Dao<?>> daos = new HashMap<>();
 
+    private final AccessControlService accessControlService;
+
     protected static final List<EntityType> SUPPORTED_ENTITY_TYPES = List.of(
             EntityType.CUSTOMER, EntityType.ASSET, EntityType.RULE_CHAIN,
             EntityType.DEVICE_PROFILE, EntityType.DEVICE, EntityType.DASHBOARD
@@ -58,52 +68,67 @@ public class DefaultEntitiesExportImportService implements EntitiesExportImportS
 
 
     @Override
-    public <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(TenantId tenantId, I entityId, EntityExportSettings exportSettings) {
+    public <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(SecurityUser user, I entityId, EntityExportSettings exportSettings) throws ThingsboardException {
         EntityType entityType = entityId.getEntityType();
         EntityExportService<I, E, EntityExportData<E>> exportService = getExportService(entityType);
 
-        return exportService.getExportData(tenantId, entityId, exportSettings);
+        return exportService.getExportData(user, entityId, exportSettings);
     }
 
 
     // TODO [viacheslav]: validate export data
-    @Transactional
+    @Transactional(rollbackFor = Exception.class)
     @Override
-    public <E extends ExportableEntity<I>, I extends EntityId> EntityImportResult<E> importEntity(TenantId tenantId, EntityExportData<E> exportData, EntityImportSettings importSettings) {
+    public <E extends ExportableEntity<I>, I extends EntityId> EntityImportResult<E> importEntity(SecurityUser user, EntityExportData<E> exportData, EntityImportSettings importSettings) throws ThingsboardException {
         EntityType entityType = exportData.getEntityType();
         EntityImportService<I, E, EntityExportData<E>> importService = getImportService(entityType);
 
-        return importService.importEntity(tenantId, exportData, importSettings);
+        return importService.importEntity(user, exportData, importSettings);
     }
 
-    @Transactional
+    @Transactional(rollbackFor = Exception.class)
     @Override
-    public <E extends ExportableEntity<I>, I extends EntityId> List<EntityImportResult<E>> importEntities(TenantId tenantId, List<EntityExportData<E>> exportDataList, EntityImportSettings importSettings) {
-        return exportDataList.stream()
-                .sorted(Comparator.comparing(exportData -> SUPPORTED_ENTITY_TYPES.indexOf(exportData.getEntityType())))
-                // TODO [viacheslav]: order for rule chains (depending on references)
-                .map(exportData -> importEntity(tenantId, exportData, importSettings))
-                .collect(Collectors.toList());
+    public List<EntityImportResult<ExportableEntity<EntityId>>> importEntities(SecurityUser user, List<EntityExportData<ExportableEntity<EntityId>>> exportDataList, EntityImportSettings importSettings) throws ThingsboardException {
+        exportDataList.sort(Comparator.comparing(exportData -> SUPPORTED_ENTITY_TYPES.indexOf(exportData.getEntityType())));
+
+        List<EntityImportResult<ExportableEntity<EntityId>>> importResults = new ArrayList<>();
+        for (EntityExportData<ExportableEntity<EntityId>> exportData : exportDataList) {
+            importResults.add(importEntity(user, exportData, importSettings));
+        }
+        return importResults;
     }
 
 
     @Override
-    public <E extends ExportableEntity<I>, I extends EntityId> E findEntityByExternalId(TenantId tenantId, I externalId) {
+    public <E extends ExportableEntity<I>, I extends EntityId> E findEntityByExternalId(SecurityUser user, I externalId) {
         EntityType entityType = externalId.getEntityType();
         if (SUPPORTED_ENTITY_TYPES.contains(entityType)) {
             ExportableEntityDao<E> dao = (ExportableEntityDao<E>) getDao(entityType);
-            E entity = dao.findByTenantIdAndExternalId(tenantId.getId(), externalId.getId());
-            if (entity != null) {
-                return entity;
-            }
+            return dao.findByTenantIdAndExternalId(user.getTenantId().getId(), externalId.getId());
         }
-        return findEntityById(tenantId, externalId);
+        return findEntityById(user, externalId);
     }
 
     @Override
-    public <E extends HasId<I>, I extends EntityId> E findEntityById(TenantId tenantId, I id) {
+    public <E extends HasId<I>, I extends EntityId> E findEntityById(SecurityUser user, I id) {
         Dao<E> dao = (Dao<E>) getDao(id.getEntityType());
-        return dao.findById(tenantId, id.getId());
+        return dao.findById(user.getTenantId(), id.getId());
+    }
+
+
+    @Override
+    public void checkPermission(SecurityUser user, HasId<? extends EntityId> entity, Operation operation) throws ThingsboardException {
+        if (entity instanceof HasTenantId) {
+            accessControlService.checkPermission(user, Resource.of(entity.getId().getEntityType()), operation, entity.getId(), (HasTenantId) entity);
+        } else if (entity != null) {
+            accessControlService.checkPermission(user, Resource.of(entity.getId().getEntityType()), operation);
+        }
+    }
+
+    @Override
+    public void checkPermission(SecurityUser user, EntityId entityId, Operation operation) throws ThingsboardException {
+        HasId<EntityId> entity = findEntityById(user, entityId);
+        checkPermission(user, entity, operation);
     }
 
 

application/src/main/java/org/thingsboard/server/service/sync/EntitiesExportImportService.java

@@ -16,8 +16,9 @@
 package org.thingsboard.server.service.sync;
 
 import org.thingsboard.server.common.data.ExportableEntity;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
-import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.service.security.model.SecurityUser;
 import org.thingsboard.server.service.sync.exporting.EntityExportSettings;
 import org.thingsboard.server.service.sync.exporting.data.EntityExportData;
 import org.thingsboard.server.service.sync.importing.EntityImportResult;
@@ -27,10 +28,10 @@ import java.util.List;
 
 public interface EntitiesExportImportService {
 
-    <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(TenantId tenantId, I entityId, EntityExportSettings exportSettings);
+    <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(SecurityUser user, I entityId, EntityExportSettings exportSettings) throws ThingsboardException;
 
-    <E extends ExportableEntity<I>, I extends EntityId> EntityImportResult<E> importEntity(TenantId tenantId, EntityExportData<E> exportData, EntityImportSettings importSettings);
+    <E extends ExportableEntity<I>, I extends EntityId> EntityImportResult<E> importEntity(SecurityUser user, EntityExportData<E> exportData, EntityImportSettings importSettings) throws ThingsboardException;
 
-    <E extends ExportableEntity<I>, I extends EntityId> List<EntityImportResult<E>> importEntities(TenantId tenantId, List<EntityExportData<E>> exportDataList, EntityImportSettings importSettings);
+    List<EntityImportResult<ExportableEntity<EntityId>>> importEntities(SecurityUser user, List<EntityExportData<ExportableEntity<EntityId>>> exportDataList, EntityImportSettings importSettings) throws ThingsboardException;
 
 }

application/src/main/java/org/thingsboard/server/service/sync/exporting/EntityExportService.java

@@ -17,13 +17,14 @@ package org.thingsboard.server.service.sync.exporting;
 
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.ExportableEntity;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
-import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.service.security.model.SecurityUser;
 import org.thingsboard.server.service.sync.exporting.data.EntityExportData;
 
 public interface EntityExportService<I extends EntityId, E extends ExportableEntity<I>, D extends EntityExportData<E>> {
 
-    D getExportData(TenantId tenantId, I entityId, EntityExportSettings exportSettings);
+    D getExportData(SecurityUser user, I entityId, EntityExportSettings exportSettings) throws ThingsboardException;
 
     EntityType getEntityType();
 

application/src/main/java/org/thingsboard/server/service/sync/exporting/ExportableEntitiesService.java

@@ -16,14 +16,22 @@
 package org.thingsboard.server.service.sync.exporting;
 
 import org.thingsboard.server.common.data.ExportableEntity;
+import org.thingsboard.server.common.data.HasTenantId;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.HasId;
-import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.service.security.model.SecurityUser;
+import org.thingsboard.server.service.security.permission.Operation;
 
 public interface ExportableEntitiesService {
 
-    <E extends ExportableEntity<I>, I extends EntityId> E findEntityByExternalId(TenantId tenantId, I externalId);
+    <E extends ExportableEntity<I>, I extends EntityId> E findEntityByExternalId(SecurityUser user, I externalId);
 
-    <E extends HasId<I>, I extends EntityId> E findEntityById(TenantId tenantId, I id);
+    <E extends HasId<I>, I extends EntityId> E findEntityById(SecurityUser user, I id);
+
+
+    void checkPermission(SecurityUser user, HasId<? extends EntityId> entity, Operation operation) throws ThingsboardException;
+
+    void checkPermission(SecurityUser user, EntityId entityId, Operation operation) throws ThingsboardException;
 
 }

application/src/main/java/org/thingsboard/server/service/sync/exporting/impl/BaseEntityExportService.java

@@ -18,14 +18,17 @@ package org.thingsboard.server.service.sync.exporting.impl;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.thingsboard.server.common.data.ExportableEntity;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.RelationTypeGroup;
 import org.thingsboard.server.dao.relation.RelationService;
-import org.thingsboard.server.service.sync.exporting.ExportableEntitiesService;
+import org.thingsboard.server.service.security.model.SecurityUser;
+import org.thingsboard.server.service.security.permission.Operation;
 import org.thingsboard.server.service.sync.exporting.EntityExportService;
 import org.thingsboard.server.service.sync.exporting.EntityExportSettings;
+import org.thingsboard.server.service.sync.exporting.ExportableEntitiesService;
 import org.thingsboard.server.service.sync.exporting.data.EntityExportData;
 
 import java.util.List;
@@ -38,19 +41,31 @@ public abstract class BaseEntityExportService<I extends EntityId, E extends Expo
     private RelationService relationService;
 
     @Override
-    public final D getExportData(TenantId tenantId, I entityId, EntityExportSettings exportSettings) {
+    public final D getExportData(SecurityUser user, I entityId, EntityExportSettings exportSettings) throws ThingsboardException {
         D exportData = newExportData();
 
-        E entity = exportableEntitiesService.findEntityById(tenantId, entityId);
+        E entity = exportableEntitiesService.findEntityById(user, entityId);
+        exportableEntitiesService.checkPermission(user, entity, Operation.READ);
+
         exportData.setEntity(entity);
-        setRelatedEntities(tenantId, entity, exportData);
+        setRelatedEntities(user.getTenantId(), entity, exportData);
 
         if (exportSettings.isExportInboundRelations()) {
-            List<EntityRelation> inboundRelations = relationService.findByTo(tenantId, entityId, RelationTypeGroup.COMMON);
+            List<EntityRelation> inboundRelations = relationService.findByTo(user.getTenantId(), entityId, RelationTypeGroup.COMMON);
+            if (inboundRelations != null) {
+                for (EntityRelation relation : inboundRelations) {
+                    exportableEntitiesService.checkPermission(user, relation.getFrom(), Operation.READ);
+                }
+            }
             exportData.setInboundRelations(inboundRelations);
         }
         if (exportSettings.isExportOutboundRelations()) {
-            List<EntityRelation> outboundRelations = relationService.findByFrom(tenantId, entityId, RelationTypeGroup.COMMON);
+            List<EntityRelation> outboundRelations = relationService.findByFrom(user.getTenantId(), entityId, RelationTypeGroup.COMMON);
+            if (outboundRelations != null) {
+                for (EntityRelation relation : outboundRelations) {
+                    exportableEntitiesService.checkPermission(user, relation.getTo(), Operation.READ);
+                }
+            }
             exportData.setOutboundRelations(outboundRelations);
         }
 

application/src/main/java/org/thingsboard/server/service/sync/importing/EntityImportService.java

@@ -17,13 +17,14 @@ package org.thingsboard.server.service.sync.importing;
 
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.ExportableEntity;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
-import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.service.security.model.SecurityUser;
 import org.thingsboard.server.service.sync.exporting.data.EntityExportData;
 
 public interface EntityImportService<I extends EntityId, E extends ExportableEntity<I>, D extends EntityExportData<E>> {
 
-    EntityImportResult<E> importEntity(TenantId tenantId, D exportData, EntityImportSettings importSettings);
+    EntityImportResult<E> importEntity(SecurityUser user, D exportData, EntityImportSettings importSettings) throws ThingsboardException;
 
     EntityType getEntityType();
 

application/src/main/java/org/thingsboard/server/service/sync/importing/impl/AssetImportService.java

@@ -33,9 +33,13 @@ public class AssetImportService extends BaseEntityImportService<AssetId, Asset,
     private final AssetService assetService;
 
     @Override
-    protected Asset prepareAndSave(TenantId tenantId, Asset asset, AssetExportData exportData, NewIdProvider idProvider) {
+    protected void setOwner(TenantId tenantId, Asset asset, NewIdProvider idProvider) {
         asset.setTenantId(tenantId);
-        asset.setCustomerId(idProvider.get(tenantId, Asset::getCustomerId));
+        asset.setCustomerId(idProvider.get(Asset::getCustomerId));
+    }
+
+    @Override
+    protected Asset prepareAndSave(TenantId tenantId, Asset asset, AssetExportData exportData, NewIdProvider idProvider) {
         return assetService.saveAsset(asset);
     }
 

application/src/main/java/org/thingsboard/server/service/sync/importing/impl/BaseEntityImportService.java

@@ -22,12 +22,15 @@ import org.springframework.context.annotation.Lazy;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.ExportableEntity;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.HasId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.RelationTypeGroup;
 import org.thingsboard.server.dao.relation.RelationService;
+import org.thingsboard.server.service.security.model.SecurityUser;
+import org.thingsboard.server.service.security.permission.Operation;
 import org.thingsboard.server.service.sync.exporting.ExportableEntitiesService;
 import org.thingsboard.server.service.sync.exporting.data.EntityExportData;
 import org.thingsboard.server.service.sync.importing.EntityImportResult;
@@ -50,22 +53,26 @@ public abstract class BaseEntityImportService<I extends EntityId, E extends Expo
     @Autowired
     private RelationService relationService;
 
-    @Transactional
+    @Transactional(rollbackFor = Exception.class)
     @Override
-    public EntityImportResult<E> importEntity(TenantId tenantId, D exportData, EntityImportSettings importSettings) {
+    public EntityImportResult<E> importEntity(SecurityUser user, D exportData, EntityImportSettings importSettings) throws ThingsboardException {
         E entity = exportData.getEntity();
-        E existingEntity = exportableEntitiesService.findEntityByExternalId(tenantId, entity.getId());
+        E existingEntity = exportableEntitiesService.findEntityByExternalId(user, entity.getId());
 
         entity.setExternalId(entity.getId());
 
+        NewIdProvider idProvider = new NewIdProvider(user, entity, existingEntity, importSettings);
+        setOwner(user.getTenantId(), entity, idProvider);
         if (existingEntity == null) {
             entity.setId(null);
+            exportableEntitiesService.checkPermission(user, entity, Operation.CREATE);
         } else {
             entity.setId(existingEntity.getId());
+            exportableEntitiesService.checkPermission(user, existingEntity, Operation.WRITE);
         }
 
-        E savedEntity = prepareAndSave(tenantId, entity, exportData, new NewIdProvider(entity, existingEntity, importSettings));
-        importRelations(tenantId, savedEntity, existingEntity, exportData, importSettings);
+        E savedEntity = prepareAndSave(user.getTenantId(), entity, exportData, idProvider);
+        importRelations(user, savedEntity, existingEntity, exportData, importSettings);
 
         EntityImportResult<E> importResult = new EntityImportResult<>();
         importResult.setSavedEntity(savedEntity);
@@ -73,57 +80,71 @@ public abstract class BaseEntityImportService<I extends EntityId, E extends Expo
         return importResult;
     }
 
+    protected abstract void setOwner(TenantId tenantId, E entity, NewIdProvider idProvider);
+
     protected abstract E prepareAndSave(TenantId tenantId, E entity, D exportData, NewIdProvider idProvider);
 
 
-    private void importRelations(TenantId tenantId, E savedEntity, E existingEntity, D exportData, EntityImportSettings importSettings) {
+    private void importRelations(SecurityUser user, E savedEntity, E existingEntity, D exportData, EntityImportSettings importSettings) throws ThingsboardException {
         List<EntityRelation> newRelations = new LinkedList<>();
 
         if (importSettings.isImportInboundRelations() && CollectionUtils.isNotEmpty(exportData.getInboundRelations())) {
             newRelations.addAll(exportData.getInboundRelations().stream()
-                    .peek(relation -> {
-                        relation.setTo(savedEntity.getId());
-                        relation.setFrom(getInternalId(tenantId, relation.getFrom()));
-                    })
+                    .peek(relation -> relation.setTo(savedEntity.getId()))
                     .collect(Collectors.toList()));
+
             if (importSettings.isRemoveExistingRelations() && existingEntity != null) {
-                relationService.findByTo(tenantId, savedEntity.getId(), RelationTypeGroup.COMMON).forEach(existingRelation -> {
-                    relationService.deleteRelation(tenantId, existingRelation);
-                });
+                for (EntityRelation existingRelation : relationService.findByTo(user.getTenantId(), savedEntity.getId(), RelationTypeGroup.COMMON)) {
+                    exportableEntitiesService.checkPermission(user, existingRelation.getFrom(), Operation.WRITE);
+                    relationService.deleteRelation(user.getTenantId(), existingRelation);
+                }
             }
         }
         if (importSettings.isImportOutboundRelations() && CollectionUtils.isNotEmpty(exportData.getOutboundRelations())) {
             newRelations.addAll(exportData.getOutboundRelations().stream()
-                    .peek(relation -> {
-                        relation.setTo(getInternalId(tenantId, relation.getTo()));
-                        relation.setFrom(savedEntity.getId());
-                    })
+                    .peek(relation -> relation.setFrom(savedEntity.getId()))
                     .collect(Collectors.toList()));
+
             if (importSettings.isRemoveExistingRelations() && existingEntity != null) {
-                relationService.findByFrom(tenantId, savedEntity.getId(), RelationTypeGroup.COMMON).forEach(existingRelation -> {
-                    relationService.deleteRelation(tenantId, existingRelation);
-                });
+                for (EntityRelation existingRelation : relationService.findByFrom(user.getTenantId(), savedEntity.getId(), RelationTypeGroup.COMMON)) {
+                    exportableEntitiesService.checkPermission(user, existingRelation.getTo(), Operation.WRITE);
+                    relationService.deleteRelation(user.getTenantId(), existingRelation);
+                }
             }
         }
 
-        newRelations.forEach(relation -> {
-            relationService.saveRelation(tenantId, relation);
-        });
+        for (EntityRelation relation : newRelations) {
+            HasId<EntityId> otherEntity = null;
+            if (!relation.getTo().equals(savedEntity.getId())) {
+                otherEntity = findInternalEntity(user, relation.getTo());
+                relation.setTo(otherEntity.getId());
+            }
+            if (!relation.getFrom().equals(savedEntity.getId())) {
+                otherEntity = findInternalEntity(user, relation.getFrom());
+                relation.setFrom(otherEntity.getId());
+            }
+            if (otherEntity != null) {
+                exportableEntitiesService.checkPermission(user, otherEntity, Operation.WRITE);
+            }
+
+            relationService.saveRelation(user.getTenantId(), relation);
+        }
     }
 
-    private <ID extends EntityId> ID getInternalId(TenantId tenantId, ID externalId) {
+    private <IE extends HasId<ID>, ID extends EntityId> IE findInternalEntity(SecurityUser user, ID externalId) {
         if (externalId == null || externalId.isNullUid()) {
             return null;
         }
-        HasId<ID> entity = exportableEntitiesService.findEntityByExternalId(tenantId, externalId);
+        IE entity = exportableEntitiesService.findEntityByExternalId(user, externalId);
         if (entity == null) {
             throw new IllegalArgumentException("Cannot find " + externalId.getEntityType() + " by external id " + externalId);
         }
-        return entity.getId();
+        return entity;
     }
 
     @RequiredArgsConstructor
     protected class NewIdProvider {
+        private final SecurityUser user;
         private final E entity;
         private final E existingEntity;
         private final EntityImportSettings importSettings;
@@ -132,26 +153,37 @@ public abstract class BaseEntityImportService<I extends EntityId, E extends Expo
                 EntityType.RULE_CHAIN
         );
 
-        public <ID extends EntityId> ID get(TenantId tenantId, Function<E, ID> idExtractor) {
+        public <ID extends EntityId> ID get(Function<E, ID> idExtractor) {
             if (existingEntity == null || importSettings.isUpdateReferencesToOtherEntities()
                     || ALWAYS_UPDATE_REFERENCED_IDS.contains(getEntityType())) {
-                return getInternalId(tenantId, idExtractor.apply(entity));
+                return getInternalId(idExtractor.apply(this.entity));
             } else {
                 return idExtractor.apply(existingEntity);
             }
         }
 
-        public <ID extends EntityId, T> Set<T> get(TenantId tenantId, Function<E, Set<T>> listExtractor, Function<T, ID> idGetter, BiConsumer<T, ID> idSetter) {
+        public <ID extends EntityId, T> Set<T> get(Function<E, Set<T>> listExtractor, Function<T, ID> idGetter, BiConsumer<T, ID> idSetter) {
             if (existingEntity == null || importSettings.isUpdateReferencesToOtherEntities()) {
                 return Optional.ofNullable(listExtractor.apply(entity)).orElse(Collections.emptySet()).stream()
                         .peek(t -> {
-                            idSetter.accept(t, getInternalId(tenantId, idGetter.apply(t)));
+                            idSetter.accept(t, getInternalId(idGetter.apply(t)));
                         })
                         .collect(Collectors.toSet());
             } else {
                 return listExtractor.apply(existingEntity);
             }
         }
+
+        private <ID extends EntityId> ID getInternalId(ID externalId) {
+            try {
+                HasId<ID> entity = findInternalEntity(user, externalId);
+                exportableEntitiesService.checkPermission(user, entity, Operation.READ);
+                return entity.getId();
+            } catch (ThingsboardException e) {
+                throw new IllegalArgumentException(e.getMessage(), e);
+            }
+        }
+
     }
 
 }

application/src/main/java/org/thingsboard/server/service/sync/importing/impl/CustomerImportService.java

@@ -33,8 +33,12 @@ public class CustomerImportService extends BaseEntityImportService<CustomerId, C
     private final CustomerService customerService;
 
     @Override
-    protected Customer prepareAndSave(TenantId tenantId, Customer customer, CustomerExportData exportData, NewIdProvider idProvider) {
+    protected void setOwner(TenantId tenantId, Customer customer, NewIdProvider idProvider) {
         customer.setTenantId(tenantId);
+    }
+
+    @Override
+    protected Customer prepareAndSave(TenantId tenantId, Customer customer, CustomerExportData exportData, NewIdProvider idProvider) {
         return customerService.saveCustomer(customer);
     }
 

application/src/main/java/org/thingsboard/server/service/sync/importing/impl/DashboardImportService.java

@@ -40,12 +40,16 @@ public class DashboardImportService extends BaseEntityImportService<DashboardId,
 
     private final DashboardService dashboardService;
 
+    @Override
+    protected void setOwner(TenantId tenantId, Dashboard dashboard, NewIdProvider idProvider) {
+        dashboard.setTenantId(tenantId);
+    }
+
     // TODO [viacheslav]: improve the code
     @Override
     protected Dashboard prepareAndSave(TenantId tenantId, Dashboard dashboard, DashboardExportData exportData, NewIdProvider idProvider) {
-        dashboard.setTenantId(tenantId);
         if (dashboard.getId() == null) {
-            Set<ShortCustomerInfo> assignedCustomers = idProvider.get(tenantId, Dashboard::getAssignedCustomers, ShortCustomerInfo::getCustomerId, ShortCustomerInfo::setCustomerId);
+            Set<ShortCustomerInfo> assignedCustomers = idProvider.get(Dashboard::getAssignedCustomers, ShortCustomerInfo::getCustomerId, ShortCustomerInfo::setCustomerId);
             dashboard.setAssignedCustomers(null);
             dashboard = dashboardService.saveDashboard(dashboard);
             for (ShortCustomerInfo customerInfo : assignedCustomers) {
@@ -54,7 +58,7 @@ public class DashboardImportService extends BaseEntityImportService<DashboardId,
         } else {
             Set<CustomerId> existingAssignedCustomers = Optional.ofNullable(dashboardService.findDashboardById(tenantId, dashboard.getId()).getAssignedCustomers())
                     .orElse(Collections.emptySet()).stream().map(ShortCustomerInfo::getCustomerId).collect(Collectors.toSet());
-            Set<CustomerId> newAssignedCustomers = idProvider.get(tenantId, Dashboard::getAssignedCustomers, ShortCustomerInfo::getCustomerId, ShortCustomerInfo::setCustomerId).stream()
+            Set<CustomerId> newAssignedCustomers = idProvider.get(Dashboard::getAssignedCustomers, ShortCustomerInfo::getCustomerId, ShortCustomerInfo::setCustomerId).stream()
                     .map(ShortCustomerInfo::getCustomerId).collect(Collectors.toSet());
 
             Set<CustomerId> toUnassign = new HashSet<>(existingAssignedCustomers);

application/src/main/java/org/thingsboard/server/service/sync/importing/impl/DeviceImportService.java

@@ -33,12 +33,16 @@ public class DeviceImportService extends BaseEntityImportService<DeviceId, Devic
     private final DeviceService deviceService;
 
     @Override
-    protected Device prepareAndSave(TenantId tenantId, Device device, DeviceExportData exportData, NewIdProvider idProvider) {
+    protected void setOwner(TenantId tenantId, Device device, NewIdProvider idProvider) {
         device.setTenantId(tenantId);
-        device.setCustomerId(idProvider.get(tenantId, Device::getCustomerId));
-        device.setDeviceProfileId(idProvider.get(tenantId, Device::getDeviceProfileId));
-        device.setFirmwareId(idProvider.get(tenantId, Device::getFirmwareId));
-        device.setSoftwareId(idProvider.get(tenantId, Device::getSoftwareId));
+        device.setCustomerId(idProvider.get(Device::getCustomerId));
+    }
+
+    @Override
+    protected Device prepareAndSave(TenantId tenantId, Device device, DeviceExportData exportData, NewIdProvider idProvider) {
+        device.setDeviceProfileId(idProvider.get(Device::getDeviceProfileId));
+        device.setFirmwareId(idProvider.get(Device::getFirmwareId));
+        device.setSoftwareId(idProvider.get(Device::getSoftwareId));
         if (exportData.getCredentials() != null) {
             exportData.getCredentials().setId(null);
             exportData.getCredentials().setDeviceId(null);

application/src/main/java/org/thingsboard/server/service/sync/importing/impl/DeviceProfileImportService.java

@@ -33,12 +33,16 @@ public class DeviceProfileImportService extends BaseEntityImportService<DevicePr
     private final DeviceProfileService deviceProfileService;
 
     @Override
-    protected DeviceProfile prepareAndSave(TenantId tenantId, DeviceProfile deviceProfile, DeviceProfileExportData exportData, NewIdProvider idProvider) {
+    protected void setOwner(TenantId tenantId, DeviceProfile deviceProfile, NewIdProvider idProvider) {
         deviceProfile.setTenantId(tenantId);
-        deviceProfile.setDefaultRuleChainId(idProvider.get(tenantId, DeviceProfile::getDefaultRuleChainId));
-        deviceProfile.setDefaultDashboardId(idProvider.get(tenantId, DeviceProfile::getDefaultDashboardId));
-        deviceProfile.setFirmwareId(idProvider.get(tenantId, DeviceProfile::getFirmwareId));
-        deviceProfile.setSoftwareId(idProvider.get(tenantId, DeviceProfile::getSoftwareId));
+    }
+
+    @Override
+    protected DeviceProfile prepareAndSave(TenantId tenantId, DeviceProfile deviceProfile, DeviceProfileExportData exportData, NewIdProvider idProvider) {
+        deviceProfile.setDefaultRuleChainId(idProvider.get(DeviceProfile::getDefaultRuleChainId));
+        deviceProfile.setDefaultDashboardId(idProvider.get(DeviceProfile::getDefaultDashboardId));
+        deviceProfile.setFirmwareId(idProvider.get(DeviceProfile::getFirmwareId));
+        deviceProfile.setSoftwareId(idProvider.get(DeviceProfile::getSoftwareId));
         return deviceProfileService.saveDeviceProfile(deviceProfile);
     }
 

application/src/main/java/org/thingsboard/server/service/sync/importing/impl/RuleChainImportService.java

@@ -41,8 +41,12 @@ public class RuleChainImportService extends BaseEntityImportService<RuleChainId,
     private final RuleChainService ruleChainService;
 
     @Override
-    protected RuleChain prepareAndSave(TenantId tenantId, RuleChain ruleChain, RuleChainExportData exportData, NewIdProvider idProvider) {
+    protected void setOwner(TenantId tenantId, RuleChain ruleChain, NewIdProvider idProvider) {
         ruleChain.setTenantId(tenantId);
+    }
+
+    @Override
+    protected RuleChain prepareAndSave(TenantId tenantId, RuleChain ruleChain, RuleChainExportData exportData, NewIdProvider idProvider) {
         RuleChainMetaData metaData = exportData.getMetaData();
         Optional.ofNullable(metaData.getNodes()).orElse(Collections.emptyList())
                 .forEach(ruleNode -> {
@@ -54,18 +58,19 @@ public class RuleChainImportService extends BaseEntityImportService<RuleChainId,
                             .map(JsonNode::asText).map(UUID::fromString)
                             .ifPresent(otherRuleChainUuid -> {
                                 ((ObjectNode) ruleNodeConfig).set("ruleChainId", new TextNode(
-                                        idProvider.get(tenantId, rc -> new RuleChainId(otherRuleChainUuid)).toString()
+                                        idProvider.get(rc -> new RuleChainId(otherRuleChainUuid)).toString()
                                 ));
                                 ruleNode.setConfiguration(ruleNodeConfig);
                             });
                 });
         Optional.ofNullable(metaData.getRuleChainConnections()).orElse(Collections.emptyList())
                 .forEach(ruleChainConnectionInfo -> {
-                    ruleChainConnectionInfo.setTargetRuleChainId(idProvider.get(tenantId, rc -> ruleChainConnectionInfo.getTargetRuleChainId()));
+                    ruleChainConnectionInfo.setTargetRuleChainId(idProvider.get(rc -> ruleChainConnectionInfo.getTargetRuleChainId()));
                 });
         ruleChain.setFirstRuleNodeId(null);
 
         if (ruleChain.getId() != null) {
+            // FIXME [viacheslav]: maybe no need to delete
             ruleChainService.deleteRuleNodes(tenantId, ruleChain.getId());
         }
         ruleChain = ruleChainService.saveRuleChain(ruleChain);

dao/src/main/java/org/thingsboard/server/dao/sql/alarm/JpaAlarmDao.java

@@ -21,6 +21,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.alarm.Alarm;
 import org.thingsboard.server.common.data.alarm.AlarmInfo;
 import org.thingsboard.server.common.data.alarm.AlarmQuery;
@@ -188,4 +189,10 @@ public class JpaAlarmDao extends JpaAbstractDao<AlarmEntity, Alarm> implements A
         log.trace("[{}] Try to delete entity alarm records using [{}]", tenantId, entityId);
         entityAlarmRepository.deleteByEntityId(entityId.getId());
     }
+
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.ALARM;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/edge/JpaEdgeDao.java

@@ -193,4 +193,9 @@ public class JpaEdgeDao extends JpaAbstractSearchTextDao<EdgeEntity, Edge> imple
         return list;
     }
 
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.EDGE;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/entityview/JpaEntityViewDao.java

@@ -200,4 +200,10 @@ public class JpaEntityViewDao extends JpaAbstractSearchTextDao<EntityViewEntity,
                         Objects.toString(pageLink.getTextSearch(), ""),
                         DaoUtil.toPageable(pageLink)));
     }
+
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.ENTITY_VIEW;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/resource/JpaTbResourceDao.java

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.sql.resource;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.ResourceType;
 import org.thingsboard.server.common.data.TbResource;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -96,4 +97,10 @@ public class JpaTbResourceDao extends JpaAbstractSearchTextDao<TbResourceEntity,
     public Long sumDataSizeByTenantId(TenantId tenantId) {
         return resourceRepository.sumDataSizeByTenantId(tenantId.getId());
     }
+
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.TB_RESOURCE;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/rpc/JpaRpcDao.java

@@ -19,6 +19,7 @@ import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
@@ -68,4 +69,10 @@ public class JpaRpcDao extends JpaAbstractDao<RpcEntity, Rpc> implements RpcDao
     public Long deleteOutdatedRpcByTenantId(TenantId tenantId, Long expirationTime) {
         return rpcRepository.deleteOutdatedRpcByTenantId(tenantId.getId(), expirationTime);
     }
+
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.RPC;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/rule/JpaRuleNodeDao.java

@@ -19,6 +19,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.rule.RuleNode;
 import org.thingsboard.server.dao.DaoUtil;
@@ -50,4 +51,10 @@ public class JpaRuleNodeDao extends JpaAbstractSearchTextDao<RuleNodeEntity, Rul
     public List<RuleNode> findRuleNodesByTenantIdAndType(TenantId tenantId, String type, String search) {
         return DaoUtil.convertDataList(ruleNodeRepository.findRuleNodesByTenantIdAndType(tenantId.getId(), type, search));
     }
+
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.RULE_NODE;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/tenant/JpaTenantDao.java

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.sql.tenant;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.TenantInfo;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -78,4 +79,9 @@ public class JpaTenantDao extends JpaAbstractSearchTextDao<TenantEntity, Tenant>
         return DaoUtil.pageToPageData(tenantRepository.findTenantsIds(DaoUtil.toPageable(pageLink))).mapData(TenantId::fromUUID);
     }
 
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.TENANT;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/usagerecord/JpaApiUsageStateDao.java

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.sql.usagerecord;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.ApiUsageState;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.DaoUtil;
@@ -68,4 +69,10 @@ public class JpaApiUsageStateDao extends JpaAbstractDao<ApiUsageStateEntity, Api
     public void deleteApiUsageStateByEntityId(EntityId entityId) {
         apiUsageStateRepository.deleteByEntityIdAndEntityType(entityId.getId(), entityId.getEntityType().name());
     }
+
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.API_USAGE_STATE;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/user/JpaUserDao.java

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.sql.user;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.User;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
@@ -96,4 +97,10 @@ public class JpaUserDao extends JpaAbstractSearchTextDao<UserEntity, User> imple
     public Long countByTenantId(TenantId tenantId) {
         return userRepository.countByTenantId(tenantId.getId());
     }
+
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.USER;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/widget/JpaWidgetTypeDao.java

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.sql.widget;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.widget.WidgetType;
 import org.thingsboard.server.common.data.widget.WidgetTypeDetails;
@@ -73,4 +74,10 @@ public class JpaWidgetTypeDao extends JpaAbstractDao<WidgetTypeDetailsEntity, Wi
     public WidgetType findByTenantIdBundleAliasAndAlias(UUID tenantId, String bundleAlias, String alias) {
         return DaoUtil.getData(widgetTypeRepository.findWidgetTypeByTenantIdAndBundleAliasAndAlias(tenantId, bundleAlias, alias));
     }
+
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.WIDGET_TYPE;
+    }
+
 }

dao/src/main/java/org/thingsboard/server/dao/sql/widget/JpaWidgetsBundleDao.java

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.sql.widget;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -86,4 +87,10 @@ public class JpaWidgetsBundleDao extends JpaAbstractSearchTextDao<WidgetsBundleE
                                 Objects.toString(pageLink.getTextSearch(), ""),
                                 DaoUtil.toPageable(pageLink)));
     }
+
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.WIDGETS_BUNDLE;
+    }
+
 }