Export/import API refactoring

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

@@ -17,11 +17,13 @@ package org.thingsboard.server.controller;
 
 import io.swagger.annotations.ApiParam;
 import lombok.RequiredArgsConstructor;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
@@ -29,14 +31,18 @@ import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.export.ExportableEntity;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
+import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.expimp.EntitiesExportImportService;
+import org.thingsboard.server.service.expimp.exp.EntityExportSettings;
 import org.thingsboard.server.service.expimp.imp.EntityImportResult;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 import org.thingsboard.server.service.security.model.SecurityUser;
 import org.thingsboard.server.service.security.permission.Operation;
 import org.thingsboard.server.service.security.permission.Resource;
 
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 @RestController
 @RequestMapping("/api/entities")
@@ -49,66 +55,60 @@ public class EntitiesExportImportController extends BaseController {
 
     @PostMapping("/export/{entityType}/{entityId}")
     @PreAuthorize("hasAuthority('TENANT_ADMIN')")
-    public EntityExportData<?> exportEntity(@ApiParam(allowableValues = "DEVICE, DEVICE_PROFILE, ASSET, RULE_CHAIN, DASHBOARD, CUSTOMER") @PathVariable EntityType entityType,
+    public EntityExportData<?> exportEntity(@ApiParam(allowableValues = "DEVICE, DEVICE_PROFILE, ASSET, RULE_CHAIN, DASHBOARD, CUSTOMER")
-                                            @PathVariable("entityId") UUID entityUuid) throws ThingsboardException {
+                                            @PathVariable EntityType entityType,
+                                            @PathVariable("entityId") UUID entityUuid,
+                                            @RequestParam(defaultValue = "false") boolean exportInboundRelations) throws ThingsboardException {
         EntityId entityId = EntityIdFactory.getByTypeAndUuid(entityType, entityUuid);
+        EntityExportSettings exportSettings = EntityExportSettings.builder()
+                .exportInboundRelations(exportInboundRelations)
+                .build();
         try {
-            return exportEntity(getCurrentUser(), entityId);
+            return exportEntity(getCurrentUser(), entityId, exportSettings);
         } catch (Exception e) {
             throw handleException(e);
         }
     }
 
 
-//    @PostMapping("/export/batch")
-//    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
-//    public EntitiesExportResponse exportEntities(@RequestBody EntitiesExportRequest exportRequest) throws ThingsboardException {
-//        TenantId tenantId = getTenantId();
-//
-//        EntitiesExportResponse exportResponse = new EntitiesExportResponse();
-//
-//        Map<EntityType, List<EntityExportData<HasId<EntityId>>>> result = new HashMap<>();
-//        exportRequest.getEntities().forEach((entityType, entityIds) -> {
-//            List<EntityExportData<HasId<EntityId>>> exportDataForEntityType = new LinkedList<>();
-//            entityIds.forEach(entityId -> {
-//                EntityExportData<HasId<EntityId>> exportData = exportImportService.exportEntity(tenantId, entityId);
-//                exportDataForEntityType.add(exportData);
-//            });
-//            result.put(entityType, exportDataForEntityType);
-//        });
-//
-//        exportResponse.setExportData(result);
-//        return exportResponse;
-//    }
-    // TODO: export and import of batches
-    // TODO: api to export and import whole customer, whole tenant
-
-
     @PostMapping("/import")
     @PreAuthorize("hasAuthority('TENANT_ADMIN')")
-    public EntityImportResult<ExportableEntity<EntityId>> importEntity(@RequestBody EntityExportData<ExportableEntity<EntityId>> exportData) throws ThingsboardException {
+    public EntityImportResult<ExportableEntity<EntityId>> importEntity(@RequestBody EntityExportData<ExportableEntity<EntityId>> exportData,
+                                                                       @RequestParam(defaultValue = "false") boolean importInboundRelations) throws ThingsboardException {
+        EntityImportSettings importSettings = EntityImportSettings.builder()
+                .importInboundRelations(importInboundRelations)
+                .build();
         try {
-            return importEntity(getCurrentUser(), exportData);
+            return importEntity(getCurrentUser(), exportData, importSettings);
         } catch (Exception e) {
             throw handleException(e);
         }
     }
 
 
-    private EntityExportData<ExportableEntity<EntityId>> exportEntity(SecurityUser user, EntityId entityId) throws ThingsboardException {
+    // TODO [viacheslav]: export and import of batches
+    // TODO [viacheslav]: api to export and import whole customer, whole tenant
+
+    private EntityExportData<ExportableEntity<EntityId>> exportEntity(SecurityUser user, EntityId entityId, EntityExportSettings exportSettings) throws ThingsboardException {
         checkEntityId(entityId, Operation.READ);
-        return exportImportService.exportEntity(getTenantId(), entityId);
+        return exportImportService.exportEntity(user.getTenantId(), entityId, exportSettings);
     }
 
-    private EntityImportResult<ExportableEntity<EntityId>> importEntity(SecurityUser user, EntityExportData<ExportableEntity<EntityId>> exportData) throws ThingsboardException {
+    private EntityImportResult<ExportableEntity<EntityId>> importEntity(SecurityUser user, EntityExportData<ExportableEntity<EntityId>> exportData, EntityImportSettings importSettings) throws ThingsboardException {
         ExportableEntity<?> existingEntity = exportImportService.findEntityByExternalId(user.getTenantId(), exportData.getMainEntity().getId());
-        if (existingEntity != null) {
+        if (existingEntity != null) {// todo [viacheslav] maybe need to extract permission check to BaseController and put there permission checks from other controllers
-            checkEntityId(existingEntity.getId(), Operation.WRITE); // todo maybe need to extract permission check to BaseController and put there permission checks from other controllers
+            checkEntityId(existingEntity.getId(), Operation.WRITE);
+            if (importSettings.isImportInboundRelations() && CollectionUtils.isNotEmpty(exportData.getInboundRelations())) {
+                for (EntityId fromId : exportData.getInboundRelations().stream().map(EntityRelation::getFrom).collect(Collectors.toSet())) {
+                    // FIXME [viacheslav]: fromId is external
+//                    checkEntityId(fromId, Operation.WRITE);
+                }
+            }
         } else {
             checkEntity(null, exportData.getMainEntity(), Resource.of(exportData.getEntityType()));
         }
 
-        EntityImportResult<ExportableEntity<EntityId>> importResult = exportImportService.importEntity(getTenantId(), exportData);
+        EntityImportResult<ExportableEntity<EntityId>> importResult = exportImportService.importEntity(getTenantId(), exportData, importSettings);
         onEntityUpdatedOrCreated(user, importResult.getSavedEntity(), importResult.getOldEntity(), importResult.getOldEntity() == null);
 
         return importResult;

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

@@ -25,56 +25,63 @@ import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.ExportableEntityDao;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.expimp.exp.EntityExportService;
+import org.thingsboard.server.service.expimp.exp.EntityExportSettings;
 import org.thingsboard.server.service.expimp.imp.EntityImportResult;
 import org.thingsboard.server.service.expimp.imp.EntityImportService;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
 
-// FIXME: review packages and classes naming
+// FIXME [viacheslav]: review packages and classes naming
 @Service
 @TbCoreComponent
 public class DefaultEntitiesExportImportService implements EntitiesExportImportService {
 
-    private final Map<EntityType, EntityExportService<?, ?>> exportServices = new HashMap<>();
+    private final Map<EntityType, EntityExportService<?, ?, ?>> exportServices = new HashMap<>();
     private final Map<EntityType, EntityImportService<?, ?, ?>> importServices = new HashMap<>();
     private final Map<EntityType, ExportableEntityDao<?>> daos = new HashMap<>();
 
 
-    // TODO: export and import of the whole tenant
+    // TODO [viacheslav]: export and import of the whole tenant
-    // TODO: export and import of the whole customer ?
+    // TODO [viacheslav]: export and import of the whole customer ?
-    // TODO: relations export and import
     @Override
-    public <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(TenantId tenantId, I entityId) {
+    public <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(TenantId tenantId, I entityId, EntityExportSettings exportSettings) {
         EntityType entityType = entityId.getEntityType();
-        EntityExportService<I, E> exportService = getExportService(entityType);
+        EntityExportService<I, E, EntityExportData<E>> exportService = getExportService(entityType);
 
-        return exportService.getExportData(tenantId, entityId);
+        return exportService.getExportData(tenantId, entityId, exportSettings);
     }
 
-    // FIXME: somehow validate export data
+    // FIXME [viacheslav]: somehow validate export data
     @Override
-    public <E extends ExportableEntity<I>, I extends EntityId> EntityImportResult<E> importEntity(TenantId tenantId, EntityExportData<E> exportData) {
+    public <E extends ExportableEntity<I>, I extends EntityId> EntityImportResult<E> importEntity(TenantId tenantId, EntityExportData<E> exportData, EntityImportSettings importSettings) {
         EntityType entityType = exportData.getEntityType();
         EntityImportService<I, E, EntityExportData<E>> importService = getImportService(entityType);
 
-        return importService.importEntity(tenantId, exportData);
+        return importService.importEntity(tenantId, exportData, importSettings);
     }
 
 
+    @Override
+    public <E extends ExportableEntity<I>, I extends EntityId> E findEntityById(TenantId tenantId, I id) {
+        ExportableEntityDao<E> dao = getDao(id.getEntityType());
+        return dao.findByTenantIdAndId(tenantId.getId(), id.getId());
+    }
+
     @Override
     public <E extends ExportableEntity<I>, I extends EntityId> E findEntityByExternalId(TenantId tenantId, I externalId) {
         ExportableEntityDao<E> dao = getDao(externalId.getEntityType());
         return Optional.ofNullable(dao.findByTenantIdAndExternalId(tenantId.getId(), externalId.getId()))
-                .orElseGet(() -> dao.findByTenantIdAndId(tenantId.getId(), externalId.getId()));
+                .orElseGet(() -> findEntityById(tenantId, externalId));
     }
 
 
     @SuppressWarnings("unchecked")
-    private <I extends EntityId, E extends ExportableEntity<I>> EntityExportService<I, E> getExportService(EntityType entityType) {
+    private <I extends EntityId, E extends ExportableEntity<I>, D extends EntityExportData<E>> EntityExportService<I, E, D> getExportService(EntityType entityType) {
-        return (EntityExportService<I, E>) exportServices.get(entityType);
+        return (EntityExportService<I, E, D>) exportServices.get(entityType);
     }
 
     @SuppressWarnings("unchecked")
@@ -88,7 +95,7 @@ public class DefaultEntitiesExportImportService implements EntitiesExportImportS
     }
 
     @Autowired
-    private void setServices(Collection<EntityExportService<?, ?>> exportServices,
+    private void setServices(Collection<EntityExportService<?, ?, ?>> exportServices,
                              Collection<EntityImportService<?, ?, ?>> importServices,
                              Collection<ExportableEntityDao<?>> daos) {
         exportServices.forEach(entityExportService -> {

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

@@ -19,12 +19,14 @@ import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.export.ExportableEntity;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.service.expimp.exp.EntityExportSettings;
 import org.thingsboard.server.service.expimp.imp.EntityImportResult;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 
 public interface EntitiesExportImportService extends ExportableEntitiesService {
 
-    <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(TenantId tenantId, I entityId);
+    <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(TenantId tenantId, I entityId, EntityExportSettings exportSettings);
 
-    <E extends ExportableEntity<I>, I extends EntityId> EntityImportResult<E> importEntity(TenantId tenantId, EntityExportData<E> exportData);
+    <E extends ExportableEntity<I>, I extends EntityId> EntityImportResult<E> importEntity(TenantId tenantId, EntityExportData<E> exportData, EntityImportSettings importSettings);
 
 }

application/src/main/java/org/thingsboard/server/service/expimp/ExportableEntitiesService.java

@@ -21,6 +21,8 @@ import org.thingsboard.server.common.data.id.TenantId;
 
 public interface ExportableEntitiesService {
 
+    <E extends ExportableEntity<I>, I extends EntityId> E findEntityById(TenantId tenantId, I id);
+
     <E extends ExportableEntity<I>, I extends EntityId> E findEntityByExternalId(TenantId tenantId, I externalId);
 
 }

application/src/main/java/org/thingsboard/server/service/expimp/exp/EntityExportService.java

@@ -21,11 +21,9 @@ import org.thingsboard.server.common.data.export.ExportableEntity;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 
-public interface EntityExportService<I extends EntityId, E extends ExportableEntity<I>> {
+public interface EntityExportService<I extends EntityId, E extends ExportableEntity<I>, D extends EntityExportData<E>> {
 
-    // FIXME: export relations
+    D getExportData(TenantId tenantId, I entityId, EntityExportSettings exportSettings);
-    // FIXME: get rid of boilerplate
-    EntityExportData<E> getExportData(TenantId tenantId, I entityId);
 
     EntityType getEntityType();
 

common/data/src/main/java/org/thingsboard/server/common/data/export/EntitiesExportResponse.java → application/src/main/java/org/thingsboard/server/service/expimp/exp/EntityExportSettings.java

@@ -13,16 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.common.data.export;
+package org.thingsboard.server.service.expimp.exp;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
-import org.thingsboard.server.common.data.EntityType;
+import lombok.NoArgsConstructor;
-import org.thingsboard.server.common.data.id.EntityId;
-
-import java.util.List;
-import java.util.Map;
 
 @Data
-public class EntitiesExportResponse {
+@AllArgsConstructor
-    private Map<EntityType, List<EntityExportData<ExportableEntity<EntityId>>>> exportData;
+@NoArgsConstructor
+@Builder
+public class EntityExportSettings {
+    private boolean exportInboundRelations;
 }

application/src/main/java/org/thingsboard/server/service/expimp/exp/impl/AbstractEntityExportService.java

@@ -0,0 +1,63 @@
+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.expimp.exp.impl;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.thingsboard.server.common.data.export.EntityExportData;
+import org.thingsboard.server.common.data.export.ExportableEntity;
+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.expimp.ExportableEntitiesService;
+import org.thingsboard.server.service.expimp.exp.EntityExportService;
+import org.thingsboard.server.service.expimp.exp.EntityExportSettings;
+
+import java.util.List;
+
+public abstract class AbstractEntityExportService<I extends EntityId, E extends ExportableEntity<I>, D extends EntityExportData<E>> implements EntityExportService<I, E, D> {
+
+    @Autowired @Lazy
+    private ExportableEntitiesService exportableEntitiesService;
+    @Autowired
+    private RelationService relationService;
+
+
+    @Override
+    public final D getExportData(TenantId tenantId, I entityId, EntityExportSettings exportSettings) {
+        D exportData = newExportData();
+
+        E mainEntity = exportableEntitiesService.findEntityById(tenantId, entityId);
+        exportData.setMainEntity(mainEntity);
+        setRelatedEntities(tenantId, mainEntity, exportData);
+        if (exportSettings.isExportInboundRelations()) {
+            exportData.setInboundRelations(getInboundRelations(tenantId, entityId));
+        }
+
+        return exportData;
+    }
+
+    protected List<EntityRelation> getInboundRelations(TenantId tenantId, I entityId) {
+        return relationService.findByTo(tenantId, entityId, RelationTypeGroup.COMMON); // FIXME [viacheslav]: RelationTypeGroup
+    }
+
+    protected void setRelatedEntities(TenantId tenantId, E mainEntity, D exportData) {}
+
+    protected abstract D newExportData();
+
+}

application/src/main/java/org/thingsboard/server/service/expimp/exp/impl/AssetExportService.java

@@ -15,31 +15,20 @@
  */
 package org.thingsboard.server.service.expimp.exp.impl;
 
-import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.asset.Asset;
-import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.export.impl.AssetExportData;
 import org.thingsboard.server.common.data.id.AssetId;
-import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.dao.asset.AssetService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
-import org.thingsboard.server.service.expimp.exp.EntityExportService;
 
 @Service
 @TbCoreComponent
-@RequiredArgsConstructor
+public class AssetExportService extends AbstractEntityExportService<AssetId, Asset, AssetExportData> {
-public class AssetExportService implements EntityExportService<AssetId, Asset> {
-
-    private final AssetService assetService;
-
 
     @Override
-    public EntityExportData<Asset> getExportData(TenantId tenantId, AssetId assetId) {
+    protected AssetExportData newExportData() {
-        AssetExportData exportData = new AssetExportData();
+        return new AssetExportData();
-        exportData.setAsset(assetService.findAssetById(tenantId, assetId));
-        return exportData;
     }
 
     @Override

application/src/main/java/org/thingsboard/server/service/expimp/exp/impl/CustomerExportService.java

@@ -15,31 +15,20 @@
  */
 package org.thingsboard.server.service.expimp.exp.impl;
 
-import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.Customer;
 import org.thingsboard.server.common.data.EntityType;
-import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.export.impl.CustomerExportData;
 import org.thingsboard.server.common.data.id.CustomerId;
-import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
-import org.thingsboard.server.service.expimp.exp.EntityExportService;
 
 @Service
 @TbCoreComponent
-@RequiredArgsConstructor
+public class CustomerExportService extends AbstractEntityExportService<CustomerId, Customer, CustomerExportData> {
-public class CustomerExportService implements EntityExportService<CustomerId, Customer> {
-
-    private final CustomerService customerService;
-
 
     @Override
-    public EntityExportData<Customer> getExportData(TenantId tenantId, CustomerId customerId) {
+    protected CustomerExportData newExportData() {
-        CustomerExportData exportData = new CustomerExportData();
+        return new CustomerExportData();
-        exportData.setCustomer(customerService.findCustomerById(tenantId, customerId));
-        return exportData;
     }
 
     @Override

application/src/main/java/org/thingsboard/server/service/expimp/exp/impl/DashboardExportService.java

@@ -15,31 +15,20 @@
  */
 package org.thingsboard.server.service.expimp.exp.impl;
 
-import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.Dashboard;
 import org.thingsboard.server.common.data.EntityType;
-import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.export.impl.DashboardExportData;
 import org.thingsboard.server.common.data.id.DashboardId;
-import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
-import org.thingsboard.server.service.expimp.exp.EntityExportService;
 
 @Service
 @TbCoreComponent
-@RequiredArgsConstructor
+public class DashboardExportService extends AbstractEntityExportService<DashboardId, Dashboard, DashboardExportData> {
-public class DashboardExportService implements EntityExportService<DashboardId, Dashboard> {
-
-    private final DashboardService dashboardService;
-
 
     @Override
-    public EntityExportData<Dashboard> getExportData(TenantId tenantId, DashboardId dashboardId) {
+    protected DashboardExportData newExportData() {
-        DashboardExportData exportData = new DashboardExportData();
+        return new DashboardExportData();
-        exportData.setDashboard(dashboardService.findDashboardById(tenantId, dashboardId));
-        return exportData;
     }
 
     @Override

application/src/main/java/org/thingsboard/server/service/expimp/exp/impl/DeviceExportService.java

@@ -19,30 +19,28 @@ import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.EntityType;
-import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.export.impl.DeviceExportData;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
-import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
-import org.thingsboard.server.service.expimp.exp.EntityExportService;
 
 @Service
 @TbCoreComponent
 @RequiredArgsConstructor
-public class DeviceExportService implements EntityExportService<DeviceId, Device> {
+public class DeviceExportService extends AbstractEntityExportService<DeviceId, Device, DeviceExportData> {
 
-    private final DeviceService deviceService;
     private final DeviceCredentialsService deviceCredentialsService;
 
 
     @Override
-    public EntityExportData<Device> getExportData(TenantId tenantId, DeviceId deviceId) {
+    protected void setRelatedEntities(TenantId tenantId, Device device, DeviceExportData exportData) {
-        DeviceExportData exportData = new DeviceExportData();
+        exportData.setCredentials(deviceCredentialsService.findDeviceCredentialsByDeviceId(TenantId.SYS_TENANT_ID, device.getId()));
-        exportData.setDevice(deviceService.findDeviceById(tenantId, deviceId));
+    }
-        exportData.setCredentials(deviceCredentialsService.findDeviceCredentialsByDeviceId(TenantId.SYS_TENANT_ID, deviceId));
+
-        return exportData;
+    @Override
+    protected DeviceExportData newExportData() {
+        return new DeviceExportData();
     }
 
     @Override

application/src/main/java/org/thingsboard/server/service/expimp/exp/impl/DeviceProfileExportService.java

@@ -15,31 +15,20 @@
  */
 package org.thingsboard.server.service.expimp.exp.impl;
 
-import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.EntityType;
-import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.export.impl.DeviceProfileExportData;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
-import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.dao.device.DeviceProfileService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
-import org.thingsboard.server.service.expimp.exp.EntityExportService;
 
 @Service
 @TbCoreComponent
-@RequiredArgsConstructor
+public class DeviceProfileExportService extends AbstractEntityExportService<DeviceProfileId, DeviceProfile, DeviceProfileExportData> {
-public class DeviceProfileExportService implements EntityExportService<DeviceProfileId, DeviceProfile> {
-
-    private final DeviceProfileService deviceProfileService;
-
 
     @Override
-    public EntityExportData<DeviceProfile> getExportData(TenantId tenantId, DeviceProfileId deviceProfileId) {
+    protected DeviceProfileExportData newExportData() {
-        DeviceProfileExportData exportData = new DeviceProfileExportData();
+        return new DeviceProfileExportData();
-        exportData.setDeviceProfile(deviceProfileService.findDeviceProfileById(tenantId, deviceProfileId));
-        return exportData;
     }
 
     @Override

application/src/main/java/org/thingsboard/server/service/expimp/exp/impl/RuleChainExportService.java

@@ -18,29 +18,29 @@ package org.thingsboard.server.service.expimp.exp.impl;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.EntityType;
-import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.export.impl.RuleChainExportData;
 import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
-import org.thingsboard.server.service.expimp.exp.EntityExportService;
 
 @Service
 @TbCoreComponent
 @RequiredArgsConstructor
-public class RuleChainExportService implements EntityExportService<RuleChainId, RuleChain> {
+public class RuleChainExportService extends AbstractEntityExportService<RuleChainId, RuleChain, RuleChainExportData> {
 
     private final RuleChainService ruleChainService;
 
 
     @Override
-    public EntityExportData<RuleChain> getExportData(TenantId tenantId, RuleChainId ruleChainId) {
+    protected void setRelatedEntities(TenantId tenantId, RuleChain ruleChain, RuleChainExportData exportData) {
-        RuleChainExportData exportData = new RuleChainExportData();
+        exportData.setMetaData(ruleChainService.loadRuleChainMetaData(tenantId, ruleChain.getId()));
-        exportData.setRuleChain(ruleChainService.findRuleChainById(tenantId, ruleChainId));
+    }
-        exportData.setMetaData(ruleChainService.loadRuleChainMetaData(tenantId, ruleChainId));
+
-        return exportData;
+    @Override
+    protected RuleChainExportData newExportData() {
+        return new RuleChainExportData();
     }
 
     @Override

application/src/main/java/org/thingsboard/server/service/expimp/imp/EntityImportService.java

@@ -23,7 +23,13 @@ import org.thingsboard.server.common.data.id.TenantId;
 
 public interface EntityImportService<I extends EntityId, E extends ExportableEntity<I>, D extends EntityExportData<E>> {
 
-    EntityImportResult<E> importEntity(TenantId tenantId, D exportData);
+    /*
+     * TODO [viacheslav]: should be as options:
+     *  to update related entities e.g. firmware or device profile if entity already exists
+     *  to delete current relations when importing new
+     *  to ignore when cannot find linked entity by external id
+     * */
+    EntityImportResult<E> importEntity(TenantId tenantId, D exportData, EntityImportSettings importSettings);
 
     EntityType getEntityType();
 

common/data/src/main/java/org/thingsboard/server/common/data/export/EntitiesExportRequest.java → application/src/main/java/org/thingsboard/server/service/expimp/imp/EntityImportSettings.java

@@ -13,17 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.common.data.export;
+package org.thingsboard.server.service.expimp.imp;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
-import org.thingsboard.server.common.data.EntityType;
+import lombok.NoArgsConstructor;
-import org.thingsboard.server.common.data.id.EntityId;
-
-import java.util.List;
-import java.util.Map;
 
 @Data
-public class EntitiesExportRequest {
+@AllArgsConstructor
-    // todo: should be processed in a specific order, e.g. device profiles, then devices, then relations, etc.
+@NoArgsConstructor
-    private Map<EntityType, List<EntityId>> entities;
+@Builder
+public class EntityImportSettings {
+    private boolean importInboundRelations;
 }

application/src/main/java/org/thingsboard/server/service/expimp/imp/impl/AbstractEntityImportService.java

@@ -15,6 +15,7 @@
  */
 package org.thingsboard.server.service.expimp.imp.impl;
 
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.thingsboard.server.common.data.export.EntityExportData;
@@ -22,23 +23,22 @@ import org.thingsboard.server.common.data.export.ExportableEntity;
 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.relation.RelationService;
 import org.thingsboard.server.service.expimp.ExportableEntitiesService;
 import org.thingsboard.server.service.expimp.imp.EntityImportResult;
 import org.thingsboard.server.service.expimp.imp.EntityImportService;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 
 public abstract class AbstractEntityImportService<I extends EntityId, E extends ExportableEntity<I>, D extends EntityExportData<E>> implements EntityImportService<I, E, D> {
 
     @Autowired @Lazy
     private ExportableEntitiesService exportableEntitiesService;
+    @Autowired
+    private RelationService relationService;
+
 
-    // FIXME what if exporting and importing back already exported entity ? (save version and then load it back)
-    /*
-     * export entity -> id from env1 -> import this entity -> ...
-     *
-     * maybe find not only by external id but by internal too ? but then what if we will try
-     * */
     @Override
-    public final EntityImportResult<E> importEntity(TenantId tenantId, D exportData) {
+    public final EntityImportResult<E> importEntity(TenantId tenantId, D exportData, EntityImportSettings importSettings) {
         E entity = exportData.getMainEntity();
         E existingEntity = findByExternalId(tenantId, entity.getId());
 
@@ -51,7 +51,18 @@ public abstract class AbstractEntityImportService<I extends EntityId, E extends
             entity.setId(existingEntity.getId());
         }
 
-        E savedEntity = prepareAndSaveEntity(tenantId, entity, existingEntity, exportData);
+        E savedEntity = prepareAndSaveEntity(tenantId, entity, existingEntity, exportData, importSettings);
+
+        if (importSettings.isImportInboundRelations() && CollectionUtils.isNotEmpty(exportData.getInboundRelations())) {
+            if (existingEntity != null) {
+                relationService.deleteEntityRelations(tenantId, savedEntity.getId());
+            }
+            exportData.getInboundRelations().forEach(relation -> {
+                relation.setTo(savedEntity.getId());
+                relation.setFrom(getInternalId(tenantId, relation.getFrom()));
+                relationService.saveRelation(tenantId, relation);
+            });
+        }
 
         EntityImportResult<E> importResult = new EntityImportResult<>();
         importResult.setSavedEntity(savedEntity);
@@ -59,17 +70,14 @@ public abstract class AbstractEntityImportService<I extends EntityId, E extends
         return importResult;
     }
 
-    protected abstract E prepareAndSaveEntity(TenantId tenantId, E entity, E existingEntity, D exportData);
+    protected abstract E prepareAndSaveEntity(TenantId tenantId, E entity, E existingEntity, D exportData, EntityImportSettings importSettings);
 
 
     private E findByExternalId(TenantId tenantId, I externalId) {
         return exportableEntitiesService.findEntityByExternalId(tenantId, externalId);
     }
 
-    // TODO or maybe set as additional config whether to update related entities when device already exists ?
+    // FIXME [viacheslav]: review use cases for version controlling: in the same tenant, between tenants, between environments and different tenants
-    // TODO: or also whether to ignore not found internal ids
-
-    // FIXME: review use cases for version controlling: in the same tenant, between tenants, between environments and different tenants
     protected final <ID extends EntityId> ID getInternalId(TenantId tenantId, ID externalId) {
         if (externalId == null) {
             return null;

application/src/main/java/org/thingsboard/server/service/expimp/imp/impl/AssetImportService.java

@@ -24,6 +24,7 @@ import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.asset.AssetService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 
 @Service
 @TbCoreComponent
@@ -34,7 +35,7 @@ public class AssetImportService extends AbstractEntityImportService<AssetId, Ass
 
 
     @Override
-    protected Asset prepareAndSaveEntity(TenantId tenantId, Asset asset, Asset existingAsset, AssetExportData exportData) {
+    protected Asset prepareAndSaveEntity(TenantId tenantId, Asset asset, Asset existingAsset, AssetExportData exportData, EntityImportSettings importSettings) {
         asset.setCustomerId(getInternalId(tenantId, asset.getCustomerId()));
 
         return assetService.saveAsset(asset);

application/src/main/java/org/thingsboard/server/service/expimp/imp/impl/CustomerImportService.java

@@ -24,6 +24,7 @@ import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 
 @Service
 @TbCoreComponent
@@ -34,7 +35,7 @@ public class CustomerImportService extends AbstractEntityImportService<CustomerI
 
 
     @Override
-    protected Customer prepareAndSaveEntity(TenantId tenantId, Customer customer, Customer existingCustomer, CustomerExportData exportData) {
+    protected Customer prepareAndSaveEntity(TenantId tenantId, Customer customer, Customer existingCustomer, CustomerExportData exportData, EntityImportSettings importSettings) {
         return customerService.saveCustomer(customer);
     }
 

application/src/main/java/org/thingsboard/server/service/expimp/imp/impl/DashboardImportService.java

@@ -24,6 +24,7 @@ import org.thingsboard.server.common.data.id.DashboardId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 
 @Service
 @TbCoreComponent
@@ -34,9 +35,9 @@ public class DashboardImportService extends AbstractEntityImportService<Dashboar
 
 
     @Override
-    protected Dashboard prepareAndSaveEntity(TenantId tenantId, Dashboard dashboard, Dashboard existingDashboard, DashboardExportData exportData) {
+    protected Dashboard prepareAndSaveEntity(TenantId tenantId, Dashboard dashboard, Dashboard existingDashboard, DashboardExportData exportData, EntityImportSettings importSettings) {
         if (existingDashboard == null) {
-            dashboard.setAssignedCustomers(null); // FIXME: need to assign dashboard to customers ?
+            dashboard.setAssignedCustomers(null); // FIXME [viacheslav]: need to assign dashboard to customers ?
         } else {
             dashboard.setAssignedCustomers(existingDashboard.getAssignedCustomers());
         }

application/src/main/java/org/thingsboard/server/service/expimp/imp/impl/DeviceImportService.java

@@ -24,6 +24,7 @@ import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 
 @Service
 @TbCoreComponent
@@ -34,7 +35,7 @@ public class DeviceImportService extends AbstractEntityImportService<DeviceId, D
 
 
     @Override
-    protected Device prepareAndSaveEntity(TenantId tenantId, Device device, Device existingDevice, DeviceExportData exportData) {
+    protected Device prepareAndSaveEntity(TenantId tenantId, Device device, Device existingDevice, DeviceExportData exportData, EntityImportSettings importSettings) {
         device.setCustomerId(getInternalId(tenantId, device.getCustomerId()));
         device.setDeviceProfileId(getInternalId(tenantId, device.getDeviceProfileId()));
         device.setFirmwareId(getInternalId(tenantId, device.getFirmwareId()));

application/src/main/java/org/thingsboard/server/service/expimp/imp/impl/DeviceProfileImportService.java

@@ -24,6 +24,7 @@ import org.thingsboard.server.common.data.id.DeviceProfileId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.device.DeviceProfileService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 
 @Service
 @TbCoreComponent
@@ -34,7 +35,7 @@ public class DeviceProfileImportService extends AbstractEntityImportService<Devi
 
 
     @Override
-    protected DeviceProfile prepareAndSaveEntity(TenantId tenantId, DeviceProfile deviceProfile, DeviceProfile existingDeviceProfile, DeviceProfileExportData exportData) {
+    protected DeviceProfile prepareAndSaveEntity(TenantId tenantId, DeviceProfile deviceProfile, DeviceProfile existingDeviceProfile, DeviceProfileExportData exportData, EntityImportSettings importSettings) {
         deviceProfile.setDefaultRuleChainId(getInternalId(tenantId, deviceProfile.getDefaultRuleChainId()));
         deviceProfile.setDefaultDashboardId(getInternalId(tenantId, deviceProfile.getDefaultDashboardId()));
         deviceProfile.setFirmwareId(getInternalId(tenantId, deviceProfile.getFirmwareId()));

application/src/main/java/org/thingsboard/server/service/expimp/imp/impl/RuleChainImportService.java

@@ -26,6 +26,7 @@ import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.rule.RuleChainMetaData;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.expimp.imp.EntityImportSettings;
 
 @Service
 @TbCoreComponent
@@ -37,7 +38,7 @@ public class RuleChainImportService extends AbstractEntityImportService<RuleChai
 
     @Transactional
     @Override
-    protected RuleChain prepareAndSaveEntity(TenantId tenantId, RuleChain ruleChain, RuleChain existingRuleChain, RuleChainExportData exportData) {
+    protected RuleChain prepareAndSaveEntity(TenantId tenantId, RuleChain ruleChain, RuleChain existingRuleChain, RuleChainExportData exportData, EntityImportSettings importSettings) {
         ruleChain.setFirstRuleNodeId(null); // will be set during metadata persisting
         if (existingRuleChain != null) {
             ruleChainService.deleteRuleNodes(tenantId, existingRuleChain.getId());
@@ -53,8 +54,8 @@ public class RuleChainImportService extends AbstractEntityImportService<RuleChai
         });
         metaData.getRuleChainConnections().forEach(ruleChainConnectionInfo -> {
 //            ruleChainConnectionInfo.setTargetRuleChainId();
-            // TODO: check if this thing is needed for "Other Rule Chain Node"
+            // TODO [viacheslav]: check if this thing is needed for "Other Rule Chain Node"
-            // TODO: and check import of tenant rule chains
+            // TODO [viacheslav]: and check import of tenant rule chains
         });
         ruleChainService.saveRuleChainMetaData(tenantId, metaData);
 

common/data/src/main/java/org/thingsboard/server/common/data/Customer.java

@@ -40,7 +40,7 @@ public class Customer extends ContactBased<CustomerId> implements HasTenantId, E
     private TenantId tenantId;
 
     @Getter @Setter
-    private CustomerId externalId; // FIXME: add to hashcode, equals, etc
+    private CustomerId externalId; // FIXME [viacheslav]: add to hashcode, equals, etc
 
     public Customer() {
         super();

common/data/src/main/java/org/thingsboard/server/common/data/export/EntityExportData.java

@@ -20,6 +20,7 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonSubTypes.Type;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import lombok.Data;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.export.impl.AssetExportData;
 import org.thingsboard.server.common.data.export.impl.CustomerExportData;
@@ -28,6 +29,9 @@ import org.thingsboard.server.common.data.export.impl.DeviceExportData;
 import org.thingsboard.server.common.data.export.impl.DeviceProfileExportData;
 import org.thingsboard.server.common.data.export.impl.RuleChainExportData;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.relation.EntityRelation;
+
+import java.util.List;
 
 @JsonIgnoreProperties(ignoreUnknown = true)
 @JsonTypeInfo(property = "entityType", use = JsonTypeInfo.Id.NAME)
@@ -39,12 +43,13 @@ import org.thingsboard.server.common.data.id.EntityId;
         @Type(name = "DASHBOARD", value = DashboardExportData.class),
         @Type(name = "CUSTOMER", value = CustomerExportData.class)
 })
-public interface EntityExportData<E extends ExportableEntity<? extends EntityId>> {
+@Data
+public abstract class EntityExportData<E extends ExportableEntity<? extends EntityId>> {
 
-    @JsonIgnore
+    private E mainEntity;
-    E getMainEntity();
+    private List<EntityRelation> inboundRelations;
 
     @JsonIgnore
-    EntityType getEntityType(); // fixme: maybe remove if not needed
+    public abstract EntityType getEntityType();
 
 }

common/data/src/main/java/org/thingsboard/server/common/data/export/ExportableEntity.java

@@ -15,8 +15,6 @@
  */
 package org.thingsboard.server.common.data.export;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import org.springframework.data.annotation.Transient;
 import org.thingsboard.server.common.data.HasName;
 import org.thingsboard.server.common.data.HasTenantId;
 import org.thingsboard.server.common.data.id.EntityId;
@@ -25,9 +23,7 @@ import org.thingsboard.server.common.data.id.TenantId;
 
 public interface ExportableEntity<I extends EntityId> extends HasId<I>, HasTenantId, HasName {
 
-    @Transient @JsonIgnore
     I getId();
-    @Transient @JsonIgnore
     void setId(I id);
 
     I getExternalId();

common/data/src/main/java/org/thingsboard/server/common/data/export/impl/AssetExportData.java

@@ -16,19 +16,14 @@
 package org.thingsboard.server.common.data.export.impl;
 
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.export.EntityExportData;
 
+@EqualsAndHashCode(callSuper = true)
 @Data
-public class AssetExportData implements EntityExportData<Asset> {
+public class AssetExportData extends EntityExportData<Asset> {
-
-    private Asset asset;
-
-    @Override
-    public Asset getMainEntity() {
-        return asset;
-    }
 
     @Override
     public EntityType getEntityType() {

common/data/src/main/java/org/thingsboard/server/common/data/export/impl/CustomerExportData.java

@@ -16,19 +16,14 @@
 package org.thingsboard.server.common.data.export.impl;
 
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.Customer;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.export.EntityExportData;
 
+@EqualsAndHashCode(callSuper = true)
 @Data
-public class CustomerExportData implements EntityExportData<Customer> {
+public class CustomerExportData extends EntityExportData<Customer> {
-
-    private Customer customer;
-
-    @Override
-    public Customer getMainEntity() {
-        return customer;
-    }
 
     @Override
     public EntityType getEntityType() {

common/data/src/main/java/org/thingsboard/server/common/data/export/impl/DashboardExportData.java

@@ -16,19 +16,14 @@
 package org.thingsboard.server.common.data.export.impl;
 
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.Dashboard;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.export.EntityExportData;
 
+@EqualsAndHashCode(callSuper = true)
 @Data
-public class DashboardExportData implements EntityExportData<Dashboard> {
+public class DashboardExportData extends EntityExportData<Dashboard> {
-
-    private Dashboard dashboard;
-
-    @Override
-    public Dashboard getMainEntity() {
-        return dashboard;
-    }
 
     @Override
     public EntityType getEntityType() {

common/data/src/main/java/org/thingsboard/server/common/data/export/impl/DeviceExportData.java

@@ -16,22 +16,18 @@
 package org.thingsboard.server.common.data.export.impl;
 
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 
+@EqualsAndHashCode(callSuper = true)
 @Data
-public class DeviceExportData implements EntityExportData<Device> {
+public class DeviceExportData extends EntityExportData<Device> {
 
-    private Device device;
     private DeviceCredentials credentials;
 
-    @Override
-    public Device getMainEntity() {
-        return device;
-    }
-
     @Override
     public EntityType getEntityType() {
         return EntityType.DEVICE;

common/data/src/main/java/org/thingsboard/server/common/data/export/impl/DeviceProfileExportData.java

@@ -16,19 +16,14 @@
 package org.thingsboard.server.common.data.export.impl;
 
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.export.EntityExportData;
 
+@EqualsAndHashCode(callSuper = true)
 @Data
-public class DeviceProfileExportData implements EntityExportData<DeviceProfile> {
+public class DeviceProfileExportData extends EntityExportData<DeviceProfile> {
-
-    private DeviceProfile deviceProfile;
-
-    @Override
-    public DeviceProfile getMainEntity() {
-        return deviceProfile;
-    }
 
     @Override
     public EntityType getEntityType() {

common/data/src/main/java/org/thingsboard/server/common/data/export/impl/RuleChainExportData.java

@@ -16,22 +16,18 @@
 package org.thingsboard.server.common.data.export.impl;
 
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.export.EntityExportData;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.rule.RuleChainMetaData;
 
+@EqualsAndHashCode(callSuper = true)
 @Data
-public class RuleChainExportData implements EntityExportData<RuleChain> {
+public class RuleChainExportData extends EntityExportData<RuleChain> {
 
-    private RuleChain ruleChain;
     private RuleChainMetaData metaData;
 
-    @Override
-    public RuleChain getMainEntity() {
-        return ruleChain;
-    }
-
     @Override
     public EntityType getEntityType() {
         return EntityType.RULE_CHAIN;

common/data/src/main/java/org/thingsboard/server/common/data/id/IdBased.java

@@ -16,33 +16,34 @@
 package org.thingsboard.server.common.data.id;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonSetter;
 
-import java.io.Serializable;
 import java.util.UUID;
 
 public abstract class IdBased<I extends UUIDBased> implements HasId<I> {
 	
 	protected I id;
-	
-	public IdBased() {
-		super();
-	}
-	
-	public IdBased(I id) {
-		super();
-		this.id = id;
-	}
 
-	public void setId(I id) {
+    public IdBased() {
-		this.id = id;
+        super();
-	}
+    }
 
-	public I getId() {
+    public IdBased(I id) {
-		return id;
+        super();
-	}
+        this.id = id;
+    }
+
+    @JsonSetter
+    public void setId(I id) {
+        this.id = id;
+    }
+
+    public I getId() {
+        return id;
+    }
 
-	@JsonIgnore
+    @JsonIgnore
-	public UUID getUuidId() {
+    public UUID getUuidId() {
 		if (id != null) {
 			return id.getId();
 		}

dao/src/main/java/org/thingsboard/server/dao/ExportableEntityDao.java

@@ -24,7 +24,7 @@ public interface ExportableEntityDao<T> {
     T findByTenantIdAndExternalId(UUID tenantId, UUID externalId);
 
     T findByTenantIdAndId(UUID tenantId, UUID id);
-    // fixme: get rid of boilerplate ?
+    // fixme [viacheslav]: get rid of boilerplate ?
 
     EntityType getEntityType();