Impl

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

@@ -57,6 +57,7 @@ import org.thingsboard.server.dao.plugin.PluginService;
 import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.dao.rule.RuleService;
+import org.thingsboard.server.dao.tenant.TenantService;
 import org.thingsboard.server.dao.user.UserService;
 import org.thingsboard.server.dao.widget.WidgetTypeService;
 import org.thingsboard.server.dao.widget.WidgetsBundleService;
@@ -85,6 +86,9 @@ public abstract class BaseController {
     @Autowired
     private ThingsboardErrorResponseHandler errorResponseHandler;
 
+    @Autowired
+    protected TenantService tenantService;
+
     @Autowired
     protected CustomerService customerService;
 
@@ -602,5 +606,8 @@ public abstract class BaseController {
         auditLogService.logEntityAction(user.getTenantId(), customerId, user.getId(), user.getName(), entityId, entity, actionType, e, additionalInfo);
     }
 
+    protected static Exception toException(Throwable error) {
+        return Exception.class.isInstance(error) ? (Exception) error : new Exception(error);
+    }
 
 }

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

@@ -9,33 +9,49 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.util.StringUtils;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.context.request.async.DeferredResult;
 import org.thingsboard.server.actors.plugin.ValidationResult;
+import org.thingsboard.server.common.data.Customer;
 import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.Tenant;
+import org.thingsboard.server.common.data.asset.Asset;
+import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.id.AssetId;
+import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
+import org.thingsboard.server.common.data.id.RuleChainId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.id.UUIDBased;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.KvEntry;
+import org.thingsboard.server.common.data.kv.TsKvEntry;
+import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.dao.attributes.AttributesService;
 import org.thingsboard.server.dao.timeseries.TimeseriesService;
 import org.thingsboard.server.exception.ThingsboardException;
 import org.thingsboard.server.extensions.api.exception.ToErrorResponseEntity;
 import org.thingsboard.server.extensions.api.plugins.PluginConstants;
+import org.thingsboard.server.extensions.core.plugin.telemetry.AttributeData;
 import org.thingsboard.server.service.security.model.SecurityUser;
 
 import javax.annotation.Nullable;
 import javax.annotation.PreDestroy;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.function.BiConsumer;
 import java.util.stream.Collectors;
 
 /**
@@ -74,61 +90,169 @@ public class TelemetryController extends BaseController {
     @ResponseStatus(value = HttpStatus.OK)
     public DeferredResult<ResponseEntity> getAttributeKeys(
             @PathVariable("entityType") String entityType, @PathVariable("entityId") String entityIdStr) throws ThingsboardException {
-        DeferredResult<ResponseEntity> response = new DeferredResult<ResponseEntity>();
+        return validateEntityAndCallback(entityType, entityIdStr,
+                this::getAttributeKeysCallback,
+                (result, t) -> handleError(t, result, HttpStatus.INTERNAL_SERVER_ERROR));
+    }
+
+    @PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/{entityType}/{entityId}/keys/ATTRIBUTES/{scope}", method = RequestMethod.GET)
+    @ResponseStatus(value = HttpStatus.OK)
+    public DeferredResult<ResponseEntity> getAttributeKeysByScope(
+            @PathVariable("entityType") String entityType, @PathVariable("entityId") String entityIdStr
+            , @PathVariable("scope") String scope) throws ThingsboardException {
+        return validateEntityAndCallback(entityType, entityIdStr,
+                (result, entityId) -> getAttributeKeysCallback(result, entityId, scope),
+                (result, t) -> handleError(t, result, HttpStatus.INTERNAL_SERVER_ERROR));
+    }
+
+    @PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/{entityType}/{entityId}/values/ATTRIBUTES", method = RequestMethod.GET)
+    @ResponseStatus(value = HttpStatus.OK)
+    public DeferredResult<ResponseEntity> getAttributes(
+            @PathVariable("entityType") String entityType, @PathVariable("entityId") String entityIdStr,
+            @RequestParam(name = "keys", required = false) String keysStr) throws ThingsboardException {
+        SecurityUser user = getCurrentUser();
+        return validateEntityAndCallback(entityType, entityIdStr,
+                (result, entityId) -> getAttributeValuesCallback(result, user, entityId, null, keysStr),
+                (result, t) -> handleError(t, result, HttpStatus.INTERNAL_SERVER_ERROR));
+    }
+
+    @PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/{entityType}/{entityId}/values/ATTRIBUTES/{scope}", method = RequestMethod.GET)
+    @ResponseStatus(value = HttpStatus.OK)
+    public DeferredResult<ResponseEntity> getAttributesByScope(
+            @PathVariable("entityType") String entityType, @PathVariable("entityId") String entityIdStr,
+            @PathVariable("scope") String scope,
+            @RequestParam(name = "keys", required = false) String keysStr) throws ThingsboardException {
+        SecurityUser user = getCurrentUser();
+        return validateEntityAndCallback(entityType, entityIdStr,
+                (result, entityId) -> getAttributeValuesCallback(result, user, entityId, scope, keysStr),
+                (result, t) -> handleError(t, result, HttpStatus.INTERNAL_SERVER_ERROR));
+    }
+
+    @PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/{entityType}/{entityId}/keys/TIMESERIES", method = RequestMethod.GET)
+    @ResponseStatus(value = HttpStatus.OK)
+    public DeferredResult<ResponseEntity> getTimeseriesKeys(
+            @PathVariable("entityType") String entityType, @PathVariable("entityId") String entityIdStr) throws ThingsboardException {
+        return validateEntityAndCallback(entityType, entityIdStr,
+                (result, entityId) -> {
+                    Futures.addCallback(tsService.findAllLatest(entityId), getTsKeysToResponseCallback(result));
+                },
+                (result, t) -> handleError(t, result, HttpStatus.INTERNAL_SERVER_ERROR));
+    }
+
+    @PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/{entityType}/{entityId}/values/TIMESERIES", method = RequestMethod.GET)
+    @ResponseStatus(value = HttpStatus.OK)
+    public DeferredResult<ResponseEntity> getLatestTimeseries(
+            @PathVariable("entityType") String entityType, @PathVariable("entityId") String entityIdStr,
+            @PathVariable("scope") String scope,
+            @RequestParam(name = "keys", required = false) String keysStr) throws ThingsboardException {
+        SecurityUser user = getCurrentUser();
+
+        return validateEntityAndCallback(entityType, entityIdStr,
+                (result, entityId) -> getAttributeValuesCallback(result, user, entityId, scope, keysStr),
+                (result, t) -> handleError(t, result, HttpStatus.INTERNAL_SERVER_ERROR));
+    }
+
+
+    @PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/{entityType}/{entityId}/values/TIMESERIES", method = RequestMethod.GET)
+    @ResponseStatus(value = HttpStatus.OK)
+    public DeferredResult<ResponseEntity> getLatestTimeseries(
+            @PathVariable("entityType") String entityType, @PathVariable("entityId") String entityIdStr,
+            @PathVariable("scope") String scope,
+            @RequestParam(name = "keys", required = false) String keysStr) throws ThingsboardException {
+        SecurityUser user = getCurrentUser();
+
+        return validateEntityAndCallback(entityType, entityIdStr,
+                (result, entityId) -> getAttributeValuesCallback(result, user, entityId, scope, keysStr),
+                (result, t) -> handleError(t, result, HttpStatus.INTERNAL_SERVER_ERROR));
+    }
+
+    private DeferredResult<ResponseEntity> validateEntityAndCallback(String entityType, String entityIdStr,
+                                                                     BiConsumer<DeferredResult<ResponseEntity>, EntityId> onSuccess, BiConsumer<DeferredResult<ResponseEntity>, Throwable> onFailure) throws ThingsboardException {
+        final DeferredResult<ResponseEntity> response = new DeferredResult<>();
         EntityId entityId = EntityIdFactory.getByTypeAndId(entityType, entityIdStr);
 
         validate(getCurrentUser(), entityId, new ValidationCallback(response,
                 new FutureCallback<DeferredResult<ResponseEntity>>() {
                     @Override
                     public void onSuccess(@Nullable DeferredResult<ResponseEntity> result) {
-                        List<ListenableFuture<List<AttributeKvEntry>>> futures = new ArrayList<>();
+                        onSuccess.accept(response, entityId);
-                        for (String scope : DataConstants.allScopes()) {
-                            futures.add(attributesService.findAll(entityId, scope));
-                        }
-
-                        ListenableFuture<List<AttributeKvEntry>> future = Futures.transform(Futures.successfulAsList(futures),
-                                (Function<? super List<List<AttributeKvEntry>>, ? extends List<AttributeKvEntry>>) input -> {
-                                    List<AttributeKvEntry> tmp = new ArrayList<>();
-                                    if (input != null) {
-                                        input.forEach(tmp::addAll);
-                                    }
-                                    return tmp;
-                                }, executor);
-
-                        Futures.addCallback(future, getAttributeKeysPluginCallback(result));
                     }
 
                     @Override
                     public void onFailure(Throwable t) {
-                        handleError(t, response, HttpStatus.INTERNAL_SERVER_ERROR);
+                        onFailure.accept(response, t);
                     }
                 }));
 
         return response;
     }
 
-    @PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
+    private void getAttributeValuesCallback(@Nullable DeferredResult<ResponseEntity> result, SecurityUser user, EntityId entityId, String scope, String keys) {
-    @RequestMapping(value = "/{entityType}/{entityId}/keys/ATTRIBUTES/{scope}", method = RequestMethod.GET)
+        List<String> keyList = null;
-    @ResponseStatus(value = HttpStatus.OK)
+        if (!StringUtils.isEmpty(keys)) {
-    public DeferredResult<ResponseEntity> getAttributeKeysByScope() {
+            keyList = Arrays.asList(keys.split(","));
-        return null;
+        }
+        FutureCallback<List<AttributeKvEntry>> callback = getAttributeValuesToResponseCallback(result, user, scope, entityId, keyList);
+        if (!StringUtils.isEmpty(scope)) {
+            if (keyList != null && !keyList.isEmpty()) {
+                Futures.addCallback(attributesService.find(entityId, scope, keyList), callback);
+            } else {
+                Futures.addCallback(attributesService.findAll(entityId, scope), callback);
+            }
+        } else {
+            List<ListenableFuture<List<AttributeKvEntry>>> futures = new ArrayList<>();
+            for (String tmpScope : DataConstants.allScopes()) {
+                if (keyList != null && !keyList.isEmpty()) {
+                    futures.add(attributesService.find(entityId, tmpScope, keyList));
+                } else {
+                    futures.add(attributesService.findAll(entityId, tmpScope));
+                }
+            }
+
+            ListenableFuture<List<AttributeKvEntry>> future = mergeAllAttributesFutures(futures);
+
+            Futures.addCallback(future, callback);
+        }
     }
 
-    @PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
+    private void getAttributeKeysCallback(@Nullable DeferredResult<ResponseEntity> result, EntityId entityId, String scope) {
-    @RequestMapping(value = "/{entityType}/{entityId}/values/ATTRIBUTES", method = RequestMethod.GET)
+        Futures.addCallback(attributesService.findAll(entityId, scope), getAttributeKeysToResponseCallback(result));
-    @ResponseStatus(value = HttpStatus.OK)
-    public DeferredResult<ResponseEntity> getAttributeValues() {
-        return null;
     }
 
-    @PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
+    private void getAttributeKeysCallback(@Nullable DeferredResult<ResponseEntity> result, EntityId entityId) {
-    @RequestMapping(value = "/{entityType}/{entityId}/values/ATTRIBUTES", method = RequestMethod.GET)
+        List<ListenableFuture<List<AttributeKvEntry>>> futures = new ArrayList<>();
-    @ResponseStatus(value = HttpStatus.OK)
+        for (String scope : DataConstants.allScopes()) {
-    public DeferredResult<ResponseEntity> getAttributeValuesByScope() {
+            futures.add(attributesService.findAll(entityId, scope));
-        return null;
+        }
+
+        ListenableFuture<List<AttributeKvEntry>> future = mergeAllAttributesFutures(futures);
+
+        Futures.addCallback(future, getAttributeKeysToResponseCallback(result));
     }
 
-    private FutureCallback<List<AttributeKvEntry>> getAttributeKeysPluginCallback(final DeferredResult<ResponseEntity> response) {
+    private FutureCallback<List<TsKvEntry>> getTsKeysToResponseCallback(final DeferredResult<ResponseEntity> response) {
+        return new FutureCallback<List<TsKvEntry>>() {
+            @Override
+            public void onSuccess(List<TsKvEntry> values) {
+                List<String> keys = values.stream().map(KvEntry::getKey).collect(Collectors.toList());
+                response.setResult(new ResponseEntity<>(keys, HttpStatus.OK));
+            }
+
+            @Override
+            public void onFailure(Throwable e) {
+                log.error("Failed to fetch attributes", e);
+                handleError(e, response, HttpStatus.INTERNAL_SERVER_ERROR);
+            }
+        };
+    }
+
+    private FutureCallback<List<AttributeKvEntry>> getAttributeKeysToResponseCallback(final DeferredResult<ResponseEntity> response) {
         return new FutureCallback<List<AttributeKvEntry>>() {
 
             @Override
@@ -145,6 +269,40 @@ public class TelemetryController extends BaseController {
         };
     }
 
+    private FutureCallback<List<AttributeKvEntry>> getAttributeValuesToResponseCallback(final DeferredResult<ResponseEntity> response, final SecurityUser user, final String scope,
+                                                                                        final EntityId entityId, final List<String> keyList) {
+        return new FutureCallback<List<AttributeKvEntry>>() {
+            @Override
+            public void onSuccess(List<AttributeKvEntry> attributes) {
+                List<AttributeData> values = attributes.stream().map(attribute -> new AttributeData(attribute.getLastUpdateTs(),
+                        attribute.getKey(), attribute.getValue())).collect(Collectors.toList());
+                logAttributesRead(user, entityId, scope, keyList, null);
+                response.setResult(new ResponseEntity<>(values, HttpStatus.OK));
+            }
+
+            @Override
+            public void onFailure(Throwable e) {
+                log.error("Failed to fetch attributes", e);
+                logAttributesRead(user, entityId, scope, keyList, e);
+                handleError(e, response, HttpStatus.INTERNAL_SERVER_ERROR);
+            }
+        };
+    }
+
+    private void logAttributesRead(SecurityUser user, EntityId entityId, String scope, List<String> keys, Throwable e) {
+        auditLogService.logEntityAction(
+                user.getTenantId(),
+                user.getCustomerId(),
+                user.getId(),
+                user.getName(),
+                (UUIDBased & EntityId) entityId,
+                null,
+                ActionType.ATTRIBUTES_READ,
+                toException(e),
+                scope,
+                keys);
+    }
+
     private void handleError(Throwable e, final DeferredResult<ResponseEntity> response, HttpStatus defaultErrorStatus) {
         ResponseEntity responseEntity;
         if (e != null && e instanceof ToErrorResponseEntity) {
@@ -162,24 +320,18 @@ public class TelemetryController extends BaseController {
             case DEVICE:
                 validateDevice(currentUser, entityId, callback);
                 return;
-//            case ASSET:
+            case ASSET:
-//                validateAsset(ctx, entityId, callback);
+                validateAsset(currentUser, entityId, callback);
-//                return;
+                return;
-//            case RULE:
+            case RULE_CHAIN:
-//                validateRule(ctx, entityId, callback);
+                validateRuleChain(currentUser, entityId, callback);
-//                return;
+                return;
-//            case RULE_CHAIN:
+            case CUSTOMER:
-//                validateRuleChain(ctx, entityId, callback);
+                validateCustomer(currentUser, entityId, callback);
-//                return;
+                return;
-//            case PLUGIN:
+            case TENANT:
-//                validatePlugin(ctx, entityId, callback);
+                validateTenant(currentUser, entityId, callback);
-//                return;
+                return;
-//            case CUSTOMER:
-//                validateCustomer(ctx, entityId, callback);
-//                return;
-//            case TENANT:
-//                validateTenant(ctx, entityId, callback);
-//                return;
             default:
                 //TODO: add support of other entities
                 throw new IllegalStateException("Not Implemented!");
@@ -207,6 +359,89 @@ public class TelemetryController extends BaseController {
         }
     }
 
+    private void validateAsset(final SecurityUser currentUser, EntityId entityId, ValidationCallback callback) {
+        if (currentUser.isSystemAdmin()) {
+            callback.onSuccess(ValidationResult.accessDenied(SYSTEM_ADMINISTRATOR_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
+        } else {
+            ListenableFuture<Asset> assetFuture = assetService.findAssetByIdAsync(new AssetId(entityId.getId()));
+            Futures.addCallback(assetFuture, getCallback(callback, asset -> {
+                if (asset == null) {
+                    return ValidationResult.entityNotFound("Asset with requested id wasn't found!");
+                } else {
+                    if (!asset.getTenantId().equals(currentUser.getTenantId())) {
+                        return ValidationResult.accessDenied("Asset doesn't belong to the current Tenant!");
+                    } else if (currentUser.isCustomerUser() && !asset.getCustomerId().equals(currentUser.getCustomerId())) {
+                        return ValidationResult.accessDenied("Asset doesn't belong to the current Customer!");
+                    } else {
+                        return ValidationResult.ok();
+                    }
+                }
+            }));
+        }
+    }
+
+
+    private void validateRuleChain(final SecurityUser currentUser, EntityId entityId, ValidationCallback callback) {
+        if (currentUser.isCustomerUser()) {
+            callback.onSuccess(ValidationResult.accessDenied(CUSTOMER_USER_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
+        } else {
+            ListenableFuture<RuleChain> ruleChainFuture = ruleChainService.findRuleChainByIdAsync(new RuleChainId(entityId.getId()));
+            Futures.addCallback(ruleChainFuture, getCallback(callback, ruleChain -> {
+                if (ruleChain == null) {
+                    return ValidationResult.entityNotFound("Rule chain with requested id wasn't found!");
+                } else {
+                    if (currentUser.isTenantAdmin() && !ruleChain.getTenantId().equals(currentUser.getTenantId())) {
+                        return ValidationResult.accessDenied("Rule chain doesn't belong to the current Tenant!");
+                    } else if (currentUser.isSystemAdmin() && !ruleChain.getTenantId().isNullUid()) {
+                        return ValidationResult.accessDenied("Rule chain is not in system scope!");
+                    } else {
+                        return ValidationResult.ok();
+                    }
+                }
+            }));
+        }
+    }
+
+    private void validateCustomer(final SecurityUser currentUser, EntityId entityId, ValidationCallback callback) {
+        if (currentUser.isSystemAdmin()) {
+            callback.onSuccess(ValidationResult.accessDenied(SYSTEM_ADMINISTRATOR_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
+        } else {
+            ListenableFuture<Customer> customerFuture = customerService.findCustomerByIdAsync(new CustomerId(entityId.getId()));
+            Futures.addCallback(customerFuture, getCallback(callback, customer -> {
+                if (customer == null) {
+                    return ValidationResult.entityNotFound("Customer with requested id wasn't found!");
+                } else {
+                    if (!customer.getTenantId().equals(currentUser.getTenantId())) {
+                        return ValidationResult.accessDenied("Customer doesn't belong to the current Tenant!");
+                    } else if (currentUser.isCustomerUser() && !customer.getId().equals(currentUser.getCustomerId())) {
+                        return ValidationResult.accessDenied("Customer doesn't relate to the currently authorized customer user!");
+                    } else {
+                        return ValidationResult.ok();
+                    }
+                }
+            }));
+        }
+    }
+
+    private void validateTenant(final SecurityUser currentUser, EntityId entityId, ValidationCallback callback) {
+        if (currentUser.isCustomerUser()) {
+            callback.onSuccess(ValidationResult.accessDenied(CUSTOMER_USER_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
+        } else if (currentUser.isSystemAdmin()) {
+            callback.onSuccess(ValidationResult.ok());
+        } else {
+            ListenableFuture<Tenant> tenantFuture = tenantService.findTenantByIdAsync(new TenantId(entityId.getId()));
+            Futures.addCallback(tenantFuture, getCallback(callback, tenant -> {
+                if (tenant == null) {
+                    return ValidationResult.entityNotFound("Tenant with requested id wasn't found!");
+                } else if (!tenant.getId().equals(currentUser.getTenantId())) {
+                    return ValidationResult.accessDenied("Tenant doesn't relate to the currently authorized user!");
+                } else {
+                    return ValidationResult.ok();
+                }
+            }));
+        }
+    }
+
     private <T> FutureCallback<T> getCallback(ValidationCallback callback, Function<T, ValidationResult> transformer) {
         return new FutureCallback<T>() {
             @Override
@@ -220,131 +455,16 @@ public class TelemetryController extends BaseController {
             }
         };
     }
-//
-//    private void validateAsset(final PluginApiCallSecurityContext ctx, EntityId entityId, ValidationCallback callback) {
-//        if (ctx.isSystemAdmin()) {
-//            callback.onSuccess(this, ValidationResult.accessDenied(SYSTEM_ADMINISTRATOR_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
-//        } else {
-//            ListenableFuture<Asset> assetFuture = pluginCtx.assetService.findAssetByIdAsync(new AssetId(entityId.getId()));
-//            Futures.addCallback(assetFuture, getCallback(callback, asset -> {
-//                if (asset == null) {
-//                    return ValidationResult.entityNotFound("Asset with requested id wasn't found!");
-//                } else {
-//                    if (!asset.getTenantId().equals(ctx.getTenantId())) {
-//                        return ValidationResult.accessDenied("Asset doesn't belong to the current Tenant!");
-//                    } else if (ctx.isCustomerUser() && !asset.getCustomerId().equals(ctx.getCustomerId())) {
-//                        return ValidationResult.accessDenied("Asset doesn't belong to the current Customer!");
-//                    } else {
-//                        return ValidationResult.ok();
-//                    }
-//                }
-//            }));
-//        }
-//    }
-//
-//    private void validateRule(final PluginApiCallSecurityContext ctx, EntityId entityId, ValidationCallback callback) {
-//        if (ctx.isCustomerUser()) {
-//            callback.onSuccess(this, ValidationResult.accessDenied(CUSTOMER_USER_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
-//        } else {
-//            ListenableFuture<RuleMetaData> ruleFuture = pluginCtx.ruleService.findRuleByIdAsync(new RuleId(entityId.getId()));
-//            Futures.addCallback(ruleFuture, getCallback(callback, rule -> {
-//                if (rule == null) {
-//                    return ValidationResult.entityNotFound("Rule with requested id wasn't found!");
-//                } else {
-//                    if (ctx.isTenantAdmin() && !rule.getTenantId().equals(ctx.getTenantId())) {
-//                        return ValidationResult.accessDenied("Rule doesn't belong to the current Tenant!");
-//                    } else if (ctx.isSystemAdmin() && !rule.getTenantId().isNullUid()) {
-//                        return ValidationResult.accessDenied("Rule is not in system scope!");
-//                    } else {
-//                        return ValidationResult.ok();
-//                    }
-//                }
-//            }));
-//        }
-//    }
-//
-//    private void validateRuleChain(final PluginApiCallSecurityContext ctx, EntityId entityId, ValidationCallback callback) {
-//        if (ctx.isCustomerUser()) {
-//            callback.onSuccess(this, ValidationResult.accessDenied(CUSTOMER_USER_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
-//        } else {
-//            ListenableFuture<RuleChain> ruleChainFuture = pluginCtx.ruleChainService.findRuleChainByIdAsync(new RuleChainId(entityId.getId()));
-//            Futures.addCallback(ruleChainFuture, getCallback(callback, ruleChain -> {
-//                if (ruleChain == null) {
-//                    return ValidationResult.entityNotFound("Rule chain with requested id wasn't found!");
-//                } else {
-//                    if (ctx.isTenantAdmin() && !ruleChain.getTenantId().equals(ctx.getTenantId())) {
-//                        return ValidationResult.accessDenied("Rule chain doesn't belong to the current Tenant!");
-//                    } else if (ctx.isSystemAdmin() && !ruleChain.getTenantId().isNullUid()) {
-//                        return ValidationResult.accessDenied("Rule chain is not in system scope!");
-//                    } else {
-//                        return ValidationResult.ok();
-//                    }
-//                }
-//            }));
-//        }
-//    }
-//
-//
-//    private void validatePlugin(final PluginApiCallSecurityContext ctx, EntityId entityId, ValidationCallback callback) {
-//        if (ctx.isCustomerUser()) {
-//            callback.onSuccess(this, ValidationResult.accessDenied(CUSTOMER_USER_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
-//        } else {
-//            ListenableFuture<PluginMetaData> pluginFuture = pluginCtx.pluginService.findPluginByIdAsync(new PluginId(entityId.getId()));
-//            Futures.addCallback(pluginFuture, getCallback(callback, plugin -> {
-//                if (plugin == null) {
-//                    return ValidationResult.entityNotFound("Plugin with requested id wasn't found!");
-//                } else {
-//                    if (ctx.isTenantAdmin() && !plugin.getTenantId().equals(ctx.getTenantId())) {
-//                        return ValidationResult.accessDenied("Plugin doesn't belong to the current Tenant!");
-//                    } else if (ctx.isSystemAdmin() && !plugin.getTenantId().isNullUid()) {
-//                        return ValidationResult.accessDenied("Plugin is not in system scope!");
-//                    } else {
-//                        return ValidationResult.ok();
-//                    }
-//                }
-//            }));
-//        }
-//    }
-//
-//    private void validateCustomer(final PluginApiCallSecurityContext ctx, EntityId entityId, ValidationCallback callback) {
-//        if (ctx.isSystemAdmin()) {
-//            callback.onSuccess(this, ValidationResult.accessDenied(SYSTEM_ADMINISTRATOR_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
-//        } else {
-//            ListenableFuture<Customer> customerFuture = pluginCtx.customerService.findCustomerByIdAsync(new CustomerId(entityId.getId()));
-//            Futures.addCallback(customerFuture, getCallback(callback, customer -> {
-//                if (customer == null) {
-//                    return ValidationResult.entityNotFound("Customer with requested id wasn't found!");
-//                } else {
-//                    if (!customer.getTenantId().equals(ctx.getTenantId())) {
-//                        return ValidationResult.accessDenied("Customer doesn't belong to the current Tenant!");
-//                    } else if (ctx.isCustomerUser() && !customer.getId().equals(ctx.getCustomerId())) {
-//                        return ValidationResult.accessDenied("Customer doesn't relate to the currently authorized customer user!");
-//                    } else {
-//                        return ValidationResult.ok();
-//                    }
-//                }
-//            }));
-//        }
-//    }
-//
-//    private void validateTenant(final PluginApiCallSecurityContext ctx, EntityId entityId, ValidationCallback callback) {
-//        if (ctx.isCustomerUser()) {
-//            callback.onSuccess(this, ValidationResult.accessDenied(CUSTOMER_USER_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
-//        } else if (ctx.isSystemAdmin()) {
-//            callback.onSuccess(this, ValidationResult.ok());
-//        } else {
-//            ListenableFuture<Tenant> tenantFuture = pluginCtx.tenantService.findTenantByIdAsync(new TenantId(entityId.getId()));
-//            Futures.addCallback(tenantFuture, getCallback(callback, tenant -> {
-//                if (tenant == null) {
-//                    return ValidationResult.entityNotFound("Tenant with requested id wasn't found!");
-//                } else if (!tenant.getId().equals(ctx.getTenantId())) {
-//                    return ValidationResult.accessDenied("Tenant doesn't relate to the currently authorized user!");
-//                } else {
-//                    return ValidationResult.ok();
-//                }
-//            }));
-//        }
-//    }
 
+    private ListenableFuture<List<AttributeKvEntry>> mergeAllAttributesFutures(List<ListenableFuture<List<AttributeKvEntry>>> futures) {
+        return Futures.transform(Futures.successfulAsList(futures),
+                (Function<? super List<List<AttributeKvEntry>>, ? extends List<AttributeKvEntry>>) input -> {
+                    List<AttributeKvEntry> tmp = new ArrayList<>();
+                    if (input != null) {
+                        input.forEach(tmp::addAll);
+                    }
+                    return tmp;
+                }, executor);
+    }
 
 }