Browse Source

Merge pull request #152 from thingsboard/dao-refactoring-vs

Dao refactoring to support PostgreSQL
pull/191/head
Andrew Shvayka 9 years ago
committed by GitHub
parent
commit
65e4739320
  1. 15
      application/pom.xml
  2. 6
      application/src/main/java/org/thingsboard/server/ThingsboardServerApplication.java
  3. 55
      application/src/main/java/org/thingsboard/server/actors/plugin/PluginProcessingContext.java
  4. 2
      application/src/main/java/org/thingsboard/server/controller/BaseController.java
  5. 14
      application/src/main/java/org/thingsboard/server/controller/CustomerController.java
  6. 1
      application/src/main/java/org/thingsboard/server/controller/PluginController.java
  7. 41
      application/src/main/java/org/thingsboard/server/service/mail/DefaultMailService.java
  8. 24
      application/src/main/resources/thingsboard.yml
  9. 49
      application/src/test/java/org/thingsboard/server/ThingsboardApplicationTests.java
  10. 35
      application/src/test/java/org/thingsboard/server/controller/AbstractControllerTest.java
  11. 1
      application/src/test/java/org/thingsboard/server/controller/AssetControllerTest.java
  12. 14
      application/src/test/java/org/thingsboard/server/controller/ControllerTestSuite.java
  13. 4
      application/src/test/java/org/thingsboard/server/controller/DashboardControllerTest.java
  14. 4
      application/src/test/java/org/thingsboard/server/controller/DeviceControllerTest.java
  15. 73
      application/src/test/java/org/thingsboard/server/mqtt/AbstractFeatureIntegrationTest.java
  16. 15
      application/src/test/java/org/thingsboard/server/mqtt/MqttTestSuite.java
  17. 98
      application/src/test/java/org/thingsboard/server/mqtt/rpc/MqttServerSideRpcIntegrationTest.java
  18. 31
      application/src/test/java/org/thingsboard/server/mqtt/telemetry/MqttTelemetryIntegrationTest.java
  19. 2
      application/src/test/java/org/thingsboard/server/system/BaseHttpDeviceApiTest.java
  20. 11
      application/src/test/java/org/thingsboard/server/system/SystemNoSqlTestSuite.java
  21. 38
      application/src/test/java/org/thingsboard/server/system/SystemSqlTestSuite.java
  22. 27
      application/src/test/java/org/thingsboard/server/system/nosql/DeviceApiNoSqlTest.java
  23. 26
      application/src/test/java/org/thingsboard/server/system/sql/DeviceApiSqlTest.java
  24. 1
      application/src/test/resources/thingsboard-test.properties
  25. 7
      common/data/src/main/java/org/thingsboard/server/common/data/asset/TenantAssetType.java
  26. 2
      common/data/src/main/java/org/thingsboard/server/common/data/kv/TsKvQuery.java
  27. 2
      common/data/src/main/java/org/thingsboard/server/common/data/relation/EntityRelation.java
  28. 5
      common/data/src/main/java/org/thingsboard/server/common/data/rule/RuleMetaData.java
  29. 28
      dao/pom.xml
  30. 3
      dao/src/main/java/org/thingsboard/server/dao/Dao.java
  31. 12
      dao/src/main/java/org/thingsboard/server/dao/DaoUtil.java
  32. 1
      dao/src/main/java/org/thingsboard/server/dao/EncryptionUtil.java
  33. 38
      dao/src/main/java/org/thingsboard/server/dao/JpaDaoConfig.java
  34. 33
      dao/src/main/java/org/thingsboard/server/dao/NoSqlDaoConfig.java
  35. 5
      dao/src/main/java/org/thingsboard/server/dao/alarm/AlarmDao.java
  36. 18
      dao/src/main/java/org/thingsboard/server/dao/alarm/BaseAlarmService.java
  37. 37
      dao/src/main/java/org/thingsboard/server/dao/alarm/CassandraAlarmDao.java
  38. 22
      dao/src/main/java/org/thingsboard/server/dao/asset/AssetDao.java
  39. 1
      dao/src/main/java/org/thingsboard/server/dao/asset/AssetSearchQuery.java
  40. 84
      dao/src/main/java/org/thingsboard/server/dao/asset/BaseAssetService.java
  41. 59
      dao/src/main/java/org/thingsboard/server/dao/asset/CassandraAssetDao.java
  42. 6
      dao/src/main/java/org/thingsboard/server/dao/attributes/AttributesDao.java
  43. 8
      dao/src/main/java/org/thingsboard/server/dao/attributes/AttributesService.java
  44. 10
      dao/src/main/java/org/thingsboard/server/dao/attributes/BaseAttributesService.java
  45. 32
      dao/src/main/java/org/thingsboard/server/dao/attributes/CassandraBaseAttributesDao.java
  46. 29
      dao/src/main/java/org/thingsboard/server/dao/cache/ServiceCacheConfiguration.java
  47. 14
      dao/src/main/java/org/thingsboard/server/dao/cassandra/CassandraCluster.java
  48. 5
      dao/src/main/java/org/thingsboard/server/dao/cassandra/CassandraQueryOptions.java
  49. 5
      dao/src/main/java/org/thingsboard/server/dao/cassandra/CassandraSocketOptions.java
  50. 20
      dao/src/main/java/org/thingsboard/server/dao/component/BaseComponentDescriptorService.java
  51. 51
      dao/src/main/java/org/thingsboard/server/dao/component/CassandraBaseComponentDescriptorDao.java
  52. 13
      dao/src/main/java/org/thingsboard/server/dao/component/ComponentDescriptorDao.java
  53. 48
      dao/src/main/java/org/thingsboard/server/dao/customer/CassandraCustomerDao.java
  54. 16
      dao/src/main/java/org/thingsboard/server/dao/customer/CustomerDao.java
  55. 4
      dao/src/main/java/org/thingsboard/server/dao/customer/CustomerService.java
  56. 81
      dao/src/main/java/org/thingsboard/server/dao/customer/CustomerServiceImpl.java
  57. 39
      dao/src/main/java/org/thingsboard/server/dao/dashboard/CassandraDashboardDao.java
  58. 18
      dao/src/main/java/org/thingsboard/server/dao/dashboard/CassandraDashboardInfoDao.java
  59. 12
      dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardDao.java
  60. 60
      dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardDaoImpl.java
  61. 18
      dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardInfoDao.java
  62. 32
      dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardService.java
  63. 75
      dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardServiceImpl.java
  64. 40
      dao/src/main/java/org/thingsboard/server/dao/device/CassandraDeviceCredentialsDao.java
  65. 78
      dao/src/main/java/org/thingsboard/server/dao/device/CassandraDeviceDao.java
  66. 15
      dao/src/main/java/org/thingsboard/server/dao/device/DeviceCredentialsDao.java
  67. 7
      dao/src/main/java/org/thingsboard/server/dao/device/DeviceCredentialsService.java
  68. 26
      dao/src/main/java/org/thingsboard/server/dao/device/DeviceCredentialsServiceImpl.java
  69. 30
      dao/src/main/java/org/thingsboard/server/dao/device/DeviceDao.java
  70. 2
      dao/src/main/java/org/thingsboard/server/dao/device/DeviceSearchQuery.java
  71. 97
      dao/src/main/java/org/thingsboard/server/dao/device/DeviceServiceImpl.java
  72. 46
      dao/src/main/java/org/thingsboard/server/dao/event/BaseEventService.java
  73. 57
      dao/src/main/java/org/thingsboard/server/dao/event/CassandraBaseEventDao.java
  74. 15
      dao/src/main/java/org/thingsboard/server/dao/event/EventDao.java
  75. 1
      dao/src/main/java/org/thingsboard/server/dao/event/EventService.java
  76. 26
      dao/src/main/java/org/thingsboard/server/dao/exception/DatabaseException.java
  77. 4
      dao/src/main/java/org/thingsboard/server/dao/exception/IncorrectParameterException.java
  78. 25
      dao/src/main/java/org/thingsboard/server/dao/model/ModelConstants.java
  79. 3
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/AdminSettingsEntity.java
  80. 3
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/AlarmEntity.java
  81. 3
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/AssetEntity.java
  82. 23
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/ComponentDescriptorEntity.java
  83. 20
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/CustomerEntity.java
  84. 19
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/DashboardEntity.java
  85. 20
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/DashboardInfoEntity.java
  86. 17
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/DeviceCredentialsEntity.java
  87. 7
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/DeviceEntity.java
  88. 13
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/EventEntity.java
  89. 36
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/PluginMetaDataEntity.java
  90. 12
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/RuleMetaDataEntity.java
  91. 19
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/TenantEntity.java
  92. 12
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/UserCredentialsEntity.java
  93. 15
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/UserEntity.java
  94. 20
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/WidgetTypeEntity.java
  95. 18
      dao/src/main/java/org/thingsboard/server/dao/model/nosql/WidgetsBundleEntity.java
  96. 84
      dao/src/main/java/org/thingsboard/server/dao/model/sql/AdminSettingsEntity.java
  97. 136
      dao/src/main/java/org/thingsboard/server/dao/model/sql/AlarmEntity.java
  98. 117
      dao/src/main/java/org/thingsboard/server/dao/model/sql/AssetEntity.java
  99. 34
      dao/src/main/java/org/thingsboard/server/dao/model/sql/AttributeKvCompositeKey.java
  100. 81
      dao/src/main/java/org/thingsboard/server/dao/model/sql/AttributeKvEntity.java

15
application/pom.xml

@ -241,6 +241,21 @@
<artifactId>mockito-all</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.dbunit</groupId>
<artifactId>dbunit</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.github.springtestdbunit</groupId>
<artifactId>spring-test-dbunit</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>ru.yandex.qatools.embed</groupId>
<artifactId>postgresql-embedded</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>

6
application/src/main/java/org/thingsboard/server/ThingsboardServerApplication.java

@ -16,15 +16,13 @@
package org.thingsboard.server;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.ComponentScan;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
import java.util.Arrays;
@EnableAutoConfiguration
@SpringBootApplication
@SpringBootConfiguration
@EnableSwagger2
@ComponentScan({"org.thingsboard.server"})
public class ThingsboardServerApplication {

55
application/src/main/java/org/thingsboard/server/actors/plugin/PluginProcessingContext.java

@ -15,15 +15,7 @@
*/
package org.thingsboard.server.actors.plugin;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.ResultSetFuture;
import com.datastax.driver.core.Row;
import akka.actor.ActorRef;
import com.google.common.base.Function;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
@ -45,8 +37,8 @@ import org.thingsboard.server.common.data.rule.RuleMetaData;
import org.thingsboard.server.common.msg.cluster.ServerAddress;
import org.thingsboard.server.extensions.api.device.DeviceAttributesEventNotificationMsg;
import org.thingsboard.server.extensions.api.plugins.PluginApiCallSecurityContext;
import org.thingsboard.server.extensions.api.plugins.PluginContext;
import org.thingsboard.server.extensions.api.plugins.PluginCallback;
import org.thingsboard.server.extensions.api.plugins.PluginContext;
import org.thingsboard.server.extensions.api.plugins.msg.PluginToRuleMsg;
import org.thingsboard.server.extensions.api.plugins.msg.TimeoutMsg;
import org.thingsboard.server.extensions.api.plugins.msg.ToDeviceRpcRequest;
@ -55,9 +47,12 @@ import org.thingsboard.server.extensions.api.plugins.rpc.RpcMsg;
import org.thingsboard.server.extensions.api.plugins.ws.PluginWebsocketSessionRef;
import org.thingsboard.server.extensions.api.plugins.ws.msg.PluginWebsocketMsg;
import akka.actor.ActorRef;
import javax.annotation.Nullable;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;
@Slf4j
public final class PluginProcessingContext implements PluginContext {
@ -95,8 +90,8 @@ public final class PluginProcessingContext implements PluginContext {
@Override
public void saveAttributes(final TenantId tenantId, final EntityId entityId, final String scope, final List<AttributeKvEntry> attributes, final PluginCallback<Void> callback) {
validate(entityId, new ValidationCallback(callback, ctx -> {
ListenableFuture<List<ResultSet>> rsListFuture = pluginCtx.attributesService.save(entityId, scope, attributes);
Futures.addCallback(rsListFuture, getListCallback(callback, v -> {
ListenableFuture<List<Void>> futures = pluginCtx.attributesService.save(entityId, scope, attributes);
Futures.addCallback(futures, getListCallback(callback, v -> {
if (entityId.getEntityType() == EntityType.DEVICE) {
onDeviceAttributesChanged(tenantId, new DeviceId(entityId.getId()), scope, attributes);
}
@ -108,8 +103,8 @@ public final class PluginProcessingContext implements PluginContext {
@Override
public void removeAttributes(final TenantId tenantId, final EntityId entityId, final String scope, final List<String> keys, final PluginCallback<Void> callback) {
validate(entityId, new ValidationCallback(callback, ctx -> {
ListenableFuture<List<ResultSet>> future = pluginCtx.attributesService.removeAll(entityId, scope, keys);
Futures.addCallback(future, getCallback(callback, v -> null), executor);
ListenableFuture<List<Void>> futures = pluginCtx.attributesService.removeAll(entityId, scope, keys);
Futures.addCallback(futures, getCallback(callback, v -> null), executor);
if (entityId.getEntityType() == EntityType.DEVICE) {
onDeviceAttributesDeleted(tenantId, new DeviceId(entityId.getId()), keys.stream().map(key -> new AttributeKey(scope, key)).collect(Collectors.toSet()));
}
@ -161,7 +156,7 @@ public final class PluginProcessingContext implements PluginContext {
@Override
public void saveTsData(final EntityId entityId, final TsKvEntry entry, final PluginCallback<Void> callback) {
validate(entityId, new ValidationCallback(callback, ctx -> {
ListenableFuture<List<ResultSet>> rsListFuture = pluginCtx.tsService.save(entityId, entry);
ListenableFuture<List<Void>> rsListFuture = pluginCtx.tsService.save(entityId, entry);
Futures.addCallback(rsListFuture, getListCallback(callback, v -> null), executor);
}));
}
@ -174,7 +169,7 @@ public final class PluginProcessingContext implements PluginContext {
@Override
public void saveTsData(final EntityId entityId, final List<TsKvEntry> entries, long ttl, final PluginCallback<Void> callback) {
validate(entityId, new ValidationCallback(callback, ctx -> {
ListenableFuture<List<ResultSet>> rsListFuture = pluginCtx.tsService.save(entityId, entries, ttl);
ListenableFuture<List<Void>> rsListFuture = pluginCtx.tsService.save(entityId, entries, ttl);
Futures.addCallback(rsListFuture, getListCallback(callback, v -> null), executor);
}));
}
@ -191,26 +186,16 @@ public final class PluginProcessingContext implements PluginContext {
@Override
public void loadLatestTimeseries(final EntityId entityId, final PluginCallback<List<TsKvEntry>> callback) {
validate(entityId, new ValidationCallback(callback, ctx -> {
ResultSetFuture future = pluginCtx.tsService.findAllLatest(entityId);
Futures.addCallback(future, getCallback(callback, pluginCtx.tsService::convertResultSetToTsKvEntryList), executor);
ListenableFuture<List<TsKvEntry>> future = pluginCtx.tsService.findAllLatest(entityId);
Futures.addCallback(future, getCallback(callback, v -> v), executor);
}));
}
@Override
public void loadLatestTimeseries(final EntityId entityId, final Collection<String> keys, final PluginCallback<List<TsKvEntry>> callback) {
validate(entityId, new ValidationCallback(callback, ctx -> {
ListenableFuture<List<ResultSet>> rsListFuture = pluginCtx.tsService.findLatest(entityId, keys);
Futures.addCallback(rsListFuture, getListCallback(callback, rsList ->
{
List<TsKvEntry> result = new ArrayList<>();
for (ResultSet rs : rsList) {
Row row = rs.one();
if (row != null) {
result.add(pluginCtx.tsService.convertResultToTsKvEntry(row));
}
}
return result;
}), executor);
ListenableFuture<List<TsKvEntry>> rsListFuture = pluginCtx.tsService.findLatest(entityId, keys);
Futures.addCallback(rsListFuture, getCallback(callback, v -> v), executor);
}));
}
@ -237,10 +222,10 @@ public final class PluginProcessingContext implements PluginContext {
pluginCtx.toDeviceActor(DeviceAttributesEventNotificationMsg.onUpdate(tenantId, deviceId, scope, values));
}
private <T> FutureCallback<List<ResultSet>> getListCallback(final PluginCallback<T> callback, Function<List<ResultSet>, T> transformer) {
return new FutureCallback<List<ResultSet>>() {
private <T, R> FutureCallback<List<T>> getListCallback(final PluginCallback<R> callback, Function<List<T>, R> transformer) {
return new FutureCallback<List<T>>() {
@Override
public void onSuccess(@Nullable List<ResultSet> result) {
public void onSuccess(@Nullable List<T> result) {
pluginCtx.self().tell(PluginCallbackMessage.onSuccess(callback, transformer.apply(result)), ActorRef.noSender());
}

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

@ -15,8 +15,6 @@
*/
package org.thingsboard.server.controller;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;

14
application/src/main/java/org/thingsboard/server/controller/CustomerController.java

@ -67,6 +67,20 @@ public class CustomerController extends BaseController {
}
}
@PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
@RequestMapping(value = "/customer/{customerId}/title", method = RequestMethod.GET, produces = "application/text")
@ResponseBody
public String getCustomerTitleById(@PathVariable("customerId") String strCustomerId) throws ThingsboardException {
checkParameter("customerId", strCustomerId);
try {
CustomerId customerId = new CustomerId(toUUID(strCustomerId));
Customer customer = checkCustomerId(customerId);
return customer.getTitle();
} catch (Exception e) {
throw handleException(e);
}
}
@PreAuthorize("hasAuthority('TENANT_ADMIN')")
@RequestMapping(value = "/customer", method = RequestMethod.POST)
@ResponseBody

1
application/src/main/java/org/thingsboard/server/controller/PluginController.java

@ -25,7 +25,6 @@ import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
import org.thingsboard.server.common.data.plugin.PluginMetaData;
import org.thingsboard.server.common.data.security.Authority;
import org.thingsboard.server.common.data.widget.WidgetsBundle;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.exception.ThingsboardException;

41
application/src/main/java/org/thingsboard/server/service/mail/DefaultMailService.java

@ -15,34 +15,31 @@
*/
package org.thingsboard.server.service.mail;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import javax.annotation.PostConstruct;
import javax.mail.internet.MimeMessage;
import com.fasterxml.jackson.databind.JsonNode;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.velocity.app.VelocityEngine;
import org.springframework.beans.factory.annotation.Qualifier;
import org.thingsboard.server.exception.ThingsboardErrorCode;
import org.thingsboard.server.exception.ThingsboardException;
import org.thingsboard.server.common.data.AdminSettings;
import org.thingsboard.server.dao.settings.AdminSettingsService;
import org.thingsboard.server.dao.exception.IncorrectParameterException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.MessageSource;
import org.springframework.core.NestedRuntimeException;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;
import org.springframework.ui.velocity.VelocityEngineUtils;
import org.thingsboard.server.common.data.AdminSettings;
import org.thingsboard.server.dao.exception.IncorrectParameterException;
import org.thingsboard.server.dao.settings.AdminSettingsService;
import org.thingsboard.server.exception.ThingsboardErrorCode;
import org.thingsboard.server.exception.ThingsboardException;
import javax.annotation.PostConstruct;
import javax.mail.internet.MimeMessage;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import com.fasterxml.jackson.databind.JsonNode;
@Service
@Slf4j
public class DefaultMailService implements MailService {
@ -69,9 +66,13 @@ public class DefaultMailService implements MailService {
@Override
public void updateMailConfiguration() {
AdminSettings settings = adminSettingsService.findAdminSettingsByKey("mail");
JsonNode jsonConfig = settings.getJsonValue();
mailSender = createMailSender(jsonConfig);
mailFrom = jsonConfig.get("mailFrom").asText();
if (settings != null) {
JsonNode jsonConfig = settings.getJsonValue();
mailSender = createMailSender(jsonConfig);
mailFrom = jsonConfig.get("mailFrom").asText();
} else {
throw new IncorrectParameterException("Failed to date mail configuration. Settings not found!");
}
}
private JavaMailSenderImpl createMailSender(JsonNode jsonConfig) {

24
application/src/main/resources/thingsboard.yml

@ -107,6 +107,7 @@ coap:
# Cassandra driver configuration parameters
cassandra:
enabled: "${CASSANDRA_ENABLED:false}"
# Thingsboard cluster name
cluster_name: "${CASSANDRA_CLUSTER_NAME:Thingsboard Cluster}"
# Thingsboard keyspace name
@ -152,7 +153,7 @@ cassandra:
# Specify partitioning size for timestamp key-value storage. Example MINUTES, HOURS, DAYS, MONTHS
ts_key_value_partitioning: "${TS_KV_PARTITIONING:MONTHS}"
# Specify max data points per request
min_aggregation_step_ms: "${TS_KV_MIN_AGGREGATION_STEP_MS:100}"
min_aggregation_step_ms: "${TS_KV_MIN_AGGREGATION_STEP_MS:1000}"
# Actor system parameters
actors:
@ -222,3 +223,24 @@ spring.mvc.cors:
allowed-headers: "*"
max-age: "1800"
allow-credentials: "true"
# SQL DAO Configuration
sql:
enabled: "${SQL_ENABLED:true}"
spring:
data:
jpa:
repositories:
enabled: "true"
jpa:
show-sql: "false"
generate-ddl: "true"
database-platform: "org.hibernate.dialect.PostgreSQLDialect"
hibernate:
ddl-auto: "validate"
datasource:
driverClassName: "${SPRING_DRIVER_CLASS_NAME:org.postgresql.Driver}"
url: "${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/thingsboard}"
username: "${SPRING_DATASOURCE_USERNAME:postgres}"
password: "${SPRING_DATASOURCE_PASSWORD:postgres}"

49
application/src/test/java/org/thingsboard/server/ThingsboardApplicationTests.java

@ -1,49 +0,0 @@
/**
* Copyright © 2016-2017 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;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.boot.test.IntegrationTest;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = ThingsboardServerApplication.class)
@WebAppConfiguration
@IntegrationTest("server.port:0")
public class ThingsboardApplicationTests {
@Test
public void contextLoads() {
String test = "[ \n" +
" {\n" +
" \"key\": \"name\",\n" +
"\t\"type\": \"text\" \n" +
" },\n" +
" {\n" +
"\t\"key\": \"name2\",\n" +
"\t\"type\": \"color\"\n" +
" },\n" +
" {\n" +
"\t\"key\": \"name3\",\n" +
"\t\"type\": \"javascript\"\n" +
" } \n" +
"]";
}
}

35
application/src/test/java/org/thingsboard/server/controller/AbstractControllerTest.java

@ -28,14 +28,9 @@ import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.IntegrationTest;
import org.springframework.boot.test.SpringApplicationContextLoader;
import org.springframework.context.annotation.Bean;
import org.springframework.boot.test.context.SpringBootContextLoader;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
@ -48,7 +43,7 @@ import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
@ -66,11 +61,9 @@ import org.thingsboard.server.common.data.id.UUIDBased;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.common.data.security.Authority;
import org.thingsboard.server.config.ThingsboardSecurityConfiguration;
import org.thingsboard.server.exception.ThingsboardException;
import org.thingsboard.server.service.mail.MailService;
import org.thingsboard.server.service.mail.TestMailService;
import org.thingsboard.server.service.security.auth.rest.LoginRequest;
import org.thingsboard.server.service.security.auth.jwt.RefreshTokenRequest;
import org.thingsboard.server.service.security.auth.rest.LoginRequest;
import java.io.IOException;
import java.nio.charset.Charset;
@ -81,21 +74,18 @@ import java.util.List;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.webAppContextSetup;
@ActiveProfiles("test")
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=AbstractControllerTest.class, loader=SpringApplicationContextLoader.class)
@TestPropertySource(locations = {"classpath:cassandra-test.properties", "classpath:thingsboard-test.properties"})
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = AbstractControllerTest.class, loader = SpringBootContextLoader.class)
@TestPropertySource(locations = {"classpath:cassandra-test.properties", "classpath:application-test.properties", "classpath:nosql-test.properties"})
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
@Configuration
@EnableAutoConfiguration
@ComponentScan({"org.thingsboard.server"})
@WebAppConfiguration
@IntegrationTest("server.port:0")
@SpringBootTest
public abstract class AbstractControllerTest {
protected static final String TEST_TENANT_NAME = "TEST TENANT";
@ -113,7 +103,6 @@ public abstract class AbstractControllerTest {
MediaType.APPLICATION_JSON.getSubtype(),
Charset.forName("utf8"));
protected MockMvc mockMvc;
protected String token;
@ -305,7 +294,7 @@ public abstract class AbstractControllerTest {
protected <T> T doPost(String urlTemplate, T content, Class<T> responseClass, String... params) throws Exception {
return readResponse(doPost(urlTemplate, content, params).andExpect(status().isOk()), responseClass);
}
protected <T> T doDelete(String urlTemplate, Class<T> responseClass, String... params) throws Exception {
return readResponse(doDelete(urlTemplate, params).andExpect(status().isOk()), responseClass);
}
@ -364,8 +353,8 @@ public abstract class AbstractControllerTest {
ObjectMapper mapper = new ObjectMapper();
return mapper.readerFor(type).readValue(content);
}
class IdComparator<D extends BaseData<? extends UUIDBased>> implements Comparator<D> {
public class IdComparator<D extends BaseData<? extends UUIDBased>> implements Comparator<D> {
@Override
public int compare(D o1, D o2) {
return o1.getId().getId().compareTo(o2.getId().getId());

1
application/src/test/java/org/thingsboard/server/controller/AssetControllerTest.java

@ -28,7 +28,6 @@ import org.thingsboard.server.common.data.*;
import org.thingsboard.server.common.data.asset.Asset;
import org.thingsboard.server.common.data.asset.TenantAssetType;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.AssetId;
import org.thingsboard.server.common.data.page.TextPageData;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.common.data.security.Authority;

14
application/src/test/java/org/thingsboard/server/controller/ControllerTestSuite.java

@ -18,22 +18,22 @@ package org.thingsboard.server.controller;
import org.cassandraunit.dataset.cql.ClassPathCQLDataSet;
import org.junit.ClassRule;
import org.junit.extensions.cpsuite.ClasspathSuite;
import org.junit.extensions.cpsuite.ClasspathSuite.ClassnameFilters;
import org.junit.runner.RunWith;
import org.thingsboard.server.dao.CustomCassandraCQLUnit;
import java.util.Arrays;
@RunWith(ClasspathSuite.class)
@ClassnameFilters({"org.thingsboard.server.controller.*Test"})
@ClasspathSuite.ClassnameFilters({
"org.thingsboard.server.controller.*Test"})
public class ControllerTestSuite {
@ClassRule
public static CustomCassandraCQLUnit cassandraUnit =
new CustomCassandraCQLUnit(Arrays.asList(
new ClassPathCQLDataSet("schema.cql", false, false),
new ClassPathCQLDataSet("system-data.cql", false, false),
new ClassPathCQLDataSet("system-test.cql", false, false)),
new CustomCassandraCQLUnit(
Arrays.asList(
new ClassPathCQLDataSet("cassandra/schema.cql", false, false),
new ClassPathCQLDataSet("cassandra/system-data.cql", false, false),
new ClassPathCQLDataSet("system-test.cql", false, false)),
"cassandra-test.yaml", 30000l);
}

4
application/src/test/java/org/thingsboard/server/controller/DashboardControllerTest.java

@ -23,6 +23,7 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.datastax.driver.core.utils.UUIDs;
import org.apache.commons.lang3.RandomStringUtils;
import org.thingsboard.server.common.data.*;
import org.thingsboard.server.common.data.id.CustomerId;
@ -35,7 +36,6 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import com.datastax.driver.core.utils.UUIDs;
import com.fasterxml.jackson.core.type.TypeReference;
public class DashboardControllerTest extends AbstractControllerTest {
@ -155,7 +155,7 @@ public class DashboardControllerTest extends AbstractControllerTest {
dashboard.setTitle("My dashboard");
Dashboard savedDashboard = doPost("/api/dashboard", dashboard, Dashboard.class);
doPost("/api/customer/" + UUIDs.timeBased().toString()
doPost("/api/customer/" + UUIDs.timeBased().toString()
+ "/dashboard/" + savedDashboard.getId().getId().toString())
.andExpect(status().isNotFound());
}

4
application/src/test/java/org/thingsboard/server/controller/DeviceControllerTest.java

@ -23,6 +23,7 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.datastax.driver.core.utils.UUIDs;
import org.apache.commons.lang3.RandomStringUtils;
import org.thingsboard.server.common.data.*;
import org.thingsboard.server.common.data.id.CustomerId;
@ -39,7 +40,6 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import com.datastax.driver.core.utils.UUIDs;
import com.fasterxml.jackson.core.type.TypeReference;
public class DeviceControllerTest extends AbstractControllerTest {
@ -215,7 +215,7 @@ public class DeviceControllerTest extends AbstractControllerTest {
device.setType("default");
Device savedDevice = doPost("/api/device", device, Device.class);
doPost("/api/customer/" + UUIDs.timeBased().toString()
doPost("/api/customer/" + UUIDs.timeBased().toString()
+ "/device/" + savedDevice.getId().getId().toString())
.andExpect(status().isNotFound());
}

73
application/src/test/java/org/thingsboard/server/mqtt/AbstractFeatureIntegrationTest.java

@ -1,73 +0,0 @@
/**
* Copyright © 2016-2017 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.mqtt;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.IntegrationTest;
import org.springframework.boot.test.SpringApplicationContextLoader;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.web.context.WebApplicationContext;
import org.thingsboard.server.mqtt.telemetry.MqttTelemetryIntergrationTest;
import java.util.Arrays;
import static org.junit.Assert.assertNotNull;
/**
* @author Valerii Sosliuk
*/
@ActiveProfiles("default")
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes= MqttTelemetryIntergrationTest.class, loader=SpringApplicationContextLoader.class)
@TestPropertySource(locations = {"classpath:cassandra-test.properties", "classpath:thingsboard-test.properties"})
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
@Configuration
@EnableAutoConfiguration
@ComponentScan({"org.thingsboard.server"})
@WebAppConfiguration
@IntegrationTest("server.port:8080")
public class AbstractFeatureIntegrationTest {
@SuppressWarnings("rawtypes")
private HttpMessageConverter mappingJackson2HttpMessageConverter;
@Autowired
private WebApplicationContext webApplicationContext;
@Autowired
void setConverters(HttpMessageConverter<?>[] converters) {
this.mappingJackson2HttpMessageConverter = Arrays.stream(converters)
.filter(hmc -> hmc instanceof MappingJackson2HttpMessageConverter)
.findAny()
.get();
assertNotNull("the JSON message converter must not be null",
this.mappingJackson2HttpMessageConverter);
}
}

15
application/src/test/java/org/thingsboard/server/mqtt/MqttSuite.java → application/src/test/java/org/thingsboard/server/mqtt/MqttTestSuite.java

@ -23,19 +23,16 @@ import org.thingsboard.server.dao.CustomCassandraCQLUnit;
import java.util.Arrays;
/**
* @author Valerii Sosliuk
*/
@RunWith(ClasspathSuite.class)
@ClasspathSuite.ClassnameFilters({"org.thingsboard.server.mqtt.*.*Test"})
public class MqttSuite {
@ClasspathSuite.ClassnameFilters({
"org.thingsboard.server.mqtt.*.*Test"})
public class MqttTestSuite {
@ClassRule
public static CustomCassandraCQLUnit cassandraUnit =
new CustomCassandraCQLUnit(
Arrays.asList(new ClassPathCQLDataSet("schema.cql", false, false),
new ClassPathCQLDataSet("system-data.cql", false, false),
new ClassPathCQLDataSet("demo-data.cql", false, false)),
Arrays.asList(
new ClassPathCQLDataSet("cassandra/schema.cql", false, false),
new ClassPathCQLDataSet("cassandra/system-data.cql", false, false)),
"cassandra-test.yaml", 30000l);
}

98
application/src/test/java/org/thingsboard/server/mqtt/rpc/MqttServerSideRpcIntegrationTest.java

@ -17,47 +17,67 @@ package org.thingsboard.server.mqtt.rpc;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.*;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.*;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.HttpClientErrorException;
import org.thingsboard.client.tools.RestClient;
import org.thingsboard.server.common.data.Device;
import org.thingsboard.server.common.data.Tenant;
import org.thingsboard.server.common.data.User;
import org.thingsboard.server.common.data.security.Authority;
import org.thingsboard.server.common.data.security.DeviceCredentials;
import org.thingsboard.server.mqtt.AbstractFeatureIntegrationTest;
import org.thingsboard.server.controller.AbstractControllerTest;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
/**
* @author Valerii Sosliuk
*/
@Slf4j
public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegrationTest {
public class MqttServerSideRpcIntegrationTest extends AbstractControllerTest {
private static final String MQTT_URL = "tcp://localhost:1883";
private static final String BASE_URL = "http://localhost:8080";
private static final String FAIL_MSG_IF_HTTP_CLIENT_ERROR_NOT_ENCOUNTERED = "HttpClientErrorException expected, but not encountered";
private static final String USERNAME = "tenant@thingsboard.org";
private static final String PASSWORD = "tenant";
private RestClient restClient;
private Tenant savedTenant;
private User tenantAdmin;
@Before
public void beforeTest() throws Exception {
restClient = new RestClient(BASE_URL);
restClient.login(USERNAME, PASSWORD);
loginSysAdmin();
Tenant tenant = new Tenant();
tenant.setTitle("My tenant");
savedTenant = doPost("/api/tenant", tenant, Tenant.class);
Assert.assertNotNull(savedTenant);
tenantAdmin = new User();
tenantAdmin.setAuthority(Authority.TENANT_ADMIN);
tenantAdmin.setTenantId(savedTenant.getId());
tenantAdmin.setEmail("tenant2@thingsboard.org");
tenantAdmin.setFirstName("Joe");
tenantAdmin.setLastName("Downs");
createUserAndLogin(tenantAdmin, "testPassword1");
}
@After
public void afterTest() throws Exception {
loginSysAdmin();
doDelete("/api/tenant/" + savedTenant.getId().getId().toString())
.andExpect(status().isOk());
}
@Test
@Ignore
public void testServerMqttOneWayRpc() throws Exception {
Device device = new Device();
device.setName("Test One-Way Server-Side RPC");
device.setType("default");
Device savedDevice = getSavedDevice(device);
DeviceCredentials deviceCredentials = getDeviceCredentials(savedDevice);
assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
@ -69,22 +89,22 @@ public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegration
MqttConnectOptions options = new MqttConnectOptions();
options.setUserName(accessToken);
client.connect(options);
Thread.sleep(3000);
client.connect(options).waitForCompletion();
client.subscribe("v1/devices/me/rpc/request/+", 1);
client.setCallback(new TestMqttCallback(client));
String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"23\",\"value\": 1}}";
String deviceId = savedDevice.getId().getId().toString();
ResponseEntity result = restClient.getRestTemplate().postForEntity(BASE_URL + "api/plugins/rpc/oneway/" + deviceId, setGpioRequest, String.class);
Assert.assertEquals(HttpStatus.OK, result.getStatusCode());
Assert.assertNull(result.getBody());
String result = doPost("api/plugins/rpc/oneway/" + deviceId, setGpioRequest, String.class);
Assert.assertNull(result);
}
@Test
@Ignore
public void testServerMqttOneWayRpcDeviceOffline() throws Exception {
Device device = new Device();
device.setName("Test One-Way Server-Side RPC Device Offline");
device.setType("default");
Device savedDevice = getSavedDevice(device);
DeviceCredentials deviceCredentials = getDeviceCredentials(savedDevice);
assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
@ -94,8 +114,8 @@ public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegration
String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"23\",\"value\": 1}}";
String deviceId = savedDevice.getId().getId().toString();
try {
restClient.getRestTemplate().postForEntity(BASE_URL + "api/plugins/rpc/oneway/" + deviceId, setGpioRequest, String.class);
Assert.fail("HttpClientErrorException expected, but not encountered");
doPost("api/plugins/rpc/oneway/" + deviceId, setGpioRequest, String.class);
Assert.fail(FAIL_MSG_IF_HTTP_CLIENT_ERROR_NOT_ENCOUNTERED);
} catch (HttpClientErrorException e) {
log.error(e.getMessage(), e);
Assert.assertEquals(HttpStatus.REQUEST_TIMEOUT, e.getStatusCode());
@ -104,12 +124,13 @@ public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegration
}
@Test
@Ignore
public void testServerMqttOneWayRpcDeviceDoesNotExist() throws Exception {
String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"23\",\"value\": 1}}";
String nonExistentDeviceId = UUID.randomUUID().toString();
try {
restClient.getRestTemplate().postForEntity(BASE_URL + "api/plugins/rpc/oneway/" + nonExistentDeviceId, setGpioRequest, String.class);
Assert.fail("HttpClientErrorException expected, but not encountered");
doPost("api/plugins/rpc/oneway/" + nonExistentDeviceId, setGpioRequest, String.class);
Assert.fail(FAIL_MSG_IF_HTTP_CLIENT_ERROR_NOT_ENCOUNTERED);
} catch (HttpClientErrorException e) {
log.error(e.getMessage(), e);
Assert.assertEquals(HttpStatus.BAD_REQUEST, e.getStatusCode());
@ -118,10 +139,11 @@ public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegration
}
@Test
@Ignore
public void testServerMqttTwoWayRpc() throws Exception {
Device device = new Device();
device.setName("Test Two-Way Server-Side RPC");
device.setType("default");
Device savedDevice = getSavedDevice(device);
DeviceCredentials deviceCredentials = getDeviceCredentials(savedDevice);
assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
@ -133,8 +155,7 @@ public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegration
MqttConnectOptions options = new MqttConnectOptions();
options.setUserName(accessToken);
client.connect(options);
Thread.sleep(3000);
client.connect(options).waitForCompletion();
client.subscribe("v1/devices/me/rpc/request/+", 1);
client.setCallback(new TestMqttCallback(client));
@ -145,9 +166,11 @@ public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegration
}
@Test
@Ignore
public void testServerMqttTwoWayRpcDeviceOffline() throws Exception {
Device device = new Device();
device.setName("Test Two-Way Server-Side RPC Device Offline");
device.setType("default");
Device savedDevice = getSavedDevice(device);
DeviceCredentials deviceCredentials = getDeviceCredentials(savedDevice);
assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
@ -157,8 +180,8 @@ public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegration
String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"23\",\"value\": 1}}";
String deviceId = savedDevice.getId().getId().toString();
try {
restClient.getRestTemplate().postForEntity(BASE_URL + "api/plugins/rpc/twoway/" + deviceId, setGpioRequest, String.class);
Assert.fail("HttpClientErrorException expected, but not encountered");
doPost("api/plugins/rpc/twoway/" + deviceId, setGpioRequest, String.class);
Assert.fail(FAIL_MSG_IF_HTTP_CLIENT_ERROR_NOT_ENCOUNTERED);
} catch (HttpClientErrorException e) {
log.error(e.getMessage(), e);
Assert.assertEquals(HttpStatus.REQUEST_TIMEOUT, e.getStatusCode());
@ -167,12 +190,13 @@ public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegration
}
@Test
@Ignore
public void testServerMqttTwoWayRpcDeviceDoesNotExist() throws Exception {
String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"23\",\"value\": 1}}";
String nonExistentDeviceId = UUID.randomUUID().toString();
try {
restClient.getRestTemplate().postForEntity(BASE_URL + "api/plugins/rpc/oneway/" + nonExistentDeviceId, setGpioRequest, String.class);
Assert.fail("HttpClientErrorException expected, but not encountered");
doPost("api/plugins/rpc/oneway/" + nonExistentDeviceId, setGpioRequest, String.class);
Assert.fail(FAIL_MSG_IF_HTTP_CLIENT_ERROR_NOT_ENCOUNTERED);
} catch (HttpClientErrorException e) {
log.error(e.getMessage(), e);
Assert.assertEquals(HttpStatus.BAD_REQUEST, e.getStatusCode());
@ -180,16 +204,16 @@ public class MqttServerSideRpcIntegrationTest extends AbstractFeatureIntegration
}
}
private Device getSavedDevice(Device device) {
return restClient.getRestTemplate().postForEntity(BASE_URL + "/api/device", device, Device.class).getBody();
private Device getSavedDevice(Device device) throws Exception {
return doPost("/api/device", device, Device.class);
}
private DeviceCredentials getDeviceCredentials(Device savedDevice) {
return restClient.getRestTemplate().getForEntity(BASE_URL + "/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class).getBody();
private DeviceCredentials getDeviceCredentials(Device savedDevice) throws Exception {
return doGet("/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class);
}
private String getStringResult(String requestData, String callType, String deviceId) {
return restClient.getRestTemplate().postForEntity(BASE_URL + "api/plugins/rpc/" + callType + "/" + deviceId, requestData, String.class).getBody();
private String getStringResult(String requestData, String callType, String deviceId) throws Exception {
return doPost("api/plugins/rpc/" + callType + "/" + deviceId, requestData, String.class);
}
private static class TestMqttCallback implements MqttCallback {

31
application/src/test/java/org/thingsboard/server/mqtt/telemetry/MqttTelemetryIntergrationTest.java → application/src/test/java/org/thingsboard/server/mqtt/telemetry/MqttTelemetryIntegrationTest.java

@ -20,12 +20,12 @@ import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.springframework.web.util.UriComponentsBuilder;
import org.thingsboard.client.tools.RestClient;
import org.thingsboard.server.common.data.Device;
import org.thingsboard.server.common.data.security.DeviceCredentials;
import org.thingsboard.server.mqtt.AbstractFeatureIntegrationTest;
import org.thingsboard.server.controller.AbstractControllerTest;
import java.net.URI;
import java.util.Arrays;
@ -39,35 +39,32 @@ import static org.junit.Assert.assertNotNull;
* @author Valerii Sosliuk
*/
@Slf4j
public class MqttTelemetryIntergrationTest extends AbstractFeatureIntegrationTest {
public class MqttTelemetryIntegrationTest extends AbstractControllerTest {
private static final String MQTT_URL = "tcp://localhost:1883";
private static final String BASE_URL = "http://localhost:8080";
private static final String USERNAME = "tenant@thingsboard.org";
private static final String PASSWORD = "tenant";
private Device savedDevice;
private String accessToken;
private RestClient restClient;
@Before
public void beforeTest() throws Exception {
restClient = new RestClient(BASE_URL);
restClient.login(USERNAME, PASSWORD);
loginTenantAdmin();
Device device = new Device();
device.setName("Test device");
savedDevice = restClient.getRestTemplate().postForEntity(BASE_URL + "/api/device", device, Device.class).getBody();
device.setType("default");
savedDevice = doPost("/api/device", device, Device.class);
DeviceCredentials deviceCredentials =
restClient.getRestTemplate().getForEntity(BASE_URL + "/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class).getBody();
doGet("/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class);
assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
accessToken = deviceCredentials.getCredentialsId();
assertNotNull(accessToken);
}
@Test
@Ignore
public void testPushMqttRpcData() throws Exception {
String clientId = MqttAsyncClient.generateClientId();
MqttAsyncClient client = new MqttAsyncClient(MQTT_URL, clientId);
@ -83,13 +80,13 @@ public class MqttTelemetryIntergrationTest extends AbstractFeatureIntegrationTes
String deviceId = savedDevice.getId().getId().toString();
Thread.sleep(1000);
List keys = restClient.getRestTemplate().getForEntity(BASE_URL + "/api/plugins/telemetry/" + deviceId + "/keys/timeseries", List.class).getBody();
Object keys = doGet("/api/plugins/telemetry/" + deviceId + "/keys/timeseries", Object.class);
assertEquals(Arrays.asList("key1", "key2", "key3", "key4"), keys);
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(BASE_URL + "/api/plugins/telemetry/" + deviceId + "/values/timeseries")
.queryParam("keys", String.join(",", keys));
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl("/api/plugins/telemetry/" + deviceId + "/values/timeseries")
.queryParam("keys", String.join(",", (CharSequence[]) keys));
URI uri = builder.build().encode().toUri();
Map<String, List<Map<String, String>>> values = restClient.getRestTemplate().getForEntity(uri, Map.class).getBody();
Map<String, List<Map<String, String>>> values = doGet(uri.getPath(), Map.class);
assertEquals("value1", values.get("key1").get(0).get("value"));
assertEquals("true", values.get("key2").get(0).get("value"));

2
application/src/test/java/org/thingsboard/server/system/HttpDeviceApiTest.java → application/src/test/java/org/thingsboard/server/system/BaseHttpDeviceApiTest.java

@ -35,7 +35,7 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
/**
* @author Andrew Shvayka
*/
public class HttpDeviceApiTest extends AbstractControllerTest {
public abstract class BaseHttpDeviceApiTest extends AbstractControllerTest {
private static final AtomicInteger idSeq = new AtomicInteger(new Random(System.currentTimeMillis()).nextInt());

11
application/src/test/java/org/thingsboard/server/system/SystemTestSuite.java → application/src/test/java/org/thingsboard/server/system/SystemNoSqlTestSuite.java

@ -27,13 +27,14 @@ import java.util.Arrays;
* @author Andrew Shvayka
*/
@RunWith(ClasspathSuite.class)
@ClasspathSuite.ClassnameFilters({"org.thingsboard.server.system.*Test"})
public class SystemTestSuite {
@ClasspathSuite.ClassnameFilters({"org.thingsboard.server.system.*NoSqlTest"})
public class SystemNoSqlTestSuite {
@ClassRule
public static CustomCassandraCQLUnit cassandraUnit =
new CustomCassandraCQLUnit(Arrays.asList(
new ClassPathCQLDataSet("schema.cql", false, false),
new ClassPathCQLDataSet("system-data.cql", false, false)),
new CustomCassandraCQLUnit(
Arrays.asList(
new ClassPathCQLDataSet("cassandra/schema.cql", false, false),
new ClassPathCQLDataSet("cassandra/system-data.cql", false, false)),
"cassandra-test.yaml", 30000l);
}

38
application/src/test/java/org/thingsboard/server/system/SystemSqlTestSuite.java

@ -0,0 +1,38 @@
/**
* Copyright © 2016-2017 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.system;
import org.junit.ClassRule;
import org.junit.extensions.cpsuite.ClasspathSuite;
import org.junit.runner.RunWith;
import org.thingsboard.server.dao.CustomPostgresUnit;
import java.util.Arrays;
/**
* Created by Valerii Sosliuk on 6/27/2017.
*/
@RunWith(ClasspathSuite.class)
@ClasspathSuite.ClassnameFilters({"org.thingsboard.server.system.sql.*SqlTest"})
public class SystemSqlTestSuite {
@ClassRule
public static CustomPostgresUnit postgresUnit = new CustomPostgresUnit(
Arrays.asList("postgres/schema.sql", "postgres/system-data.sql"),
"postgres-embedded-test.properties");
}

27
application/src/test/java/org/thingsboard/server/system/nosql/DeviceApiNoSqlTest.java

@ -0,0 +1,27 @@
/**
* Copyright © 2016-2017 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.system.nosql;
import org.thingsboard.server.dao.service.DaoNoSqlTest;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.system.BaseHttpDeviceApiTest;
/**
* Created by Valerii Sosliuk on 6/27/2017.
*/
@DaoNoSqlTest
public class DeviceApiNoSqlTest extends BaseHttpDeviceApiTest {
}

26
application/src/test/java/org/thingsboard/server/system/sql/DeviceApiSqlTest.java

@ -0,0 +1,26 @@
/**
* Copyright © 2016-2017 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.system.sql;
import org.thingsboard.server.dao.service.DaoSqlTest;
import org.thingsboard.server.system.BaseHttpDeviceApiTest;
/**
* Created by Valerii Sosliuk on 6/27/2017.
*/
@DaoSqlTest
public class DeviceApiSqlTest extends BaseHttpDeviceApiTest{
}

1
application/src/test/resources/thingsboard-test.properties

@ -1 +0,0 @@
updates.enabled=false

7
common/data/src/main/java/org/thingsboard/server/common/data/asset/TenantAssetType.java

@ -17,6 +17,8 @@ package org.thingsboard.server.common.data.asset;
import org.thingsboard.server.common.data.id.TenantId;
import java.util.UUID;
public class TenantAssetType {
private static final long serialVersionUID = 8057290243855622101L;
@ -33,6 +35,11 @@ public class TenantAssetType {
this.tenantId = tenantId;
}
public TenantAssetType(String type, UUID tenantId) {
this.type = type;
this.tenantId = new TenantId(tenantId);
}
public String getType() {
return type;
}

2
common/data/src/main/java/org/thingsboard/server/common/data/kv/TsKvQuery.java

@ -15,8 +15,6 @@
*/
package org.thingsboard.server.common.data.kv;
import java.util.Optional;
public interface TsKvQuery {
String getKey();

2
common/data/src/main/java/org/thingsboard/server/common/data/relation/EntityRelation.java

@ -18,8 +18,6 @@ package org.thingsboard.server.common.data.relation;
import com.fasterxml.jackson.databind.JsonNode;
import org.thingsboard.server.common.data.id.EntityId;
import java.util.Objects;
public class EntityRelation {
private static final long serialVersionUID = 2807343040519543363L;

5
common/data/src/main/java/org/thingsboard/server/common/data/rule/RuleMetaData.java

@ -15,15 +15,12 @@
*/
package org.thingsboard.server.common.data.rule;
import com.fasterxml.jackson.databind.JsonNode;
import lombok.Data;
import lombok.ToString;
import org.thingsboard.server.common.data.HasName;
import org.thingsboard.server.common.data.SearchTextBased;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.RuleId;
import org.thingsboard.server.common.data.id.TenantId;
import com.fasterxml.jackson.databind.JsonNode;
import org.thingsboard.server.common.data.plugin.ComponentLifecycleState;
@Data

28
dao/pom.xml

@ -57,14 +57,24 @@
<artifactId>logback-classic</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.dbunit</groupId>
<artifactId>dbunit</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.github.springtestdbunit</groupId>
<artifactId>spring-test-dbunit</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
@ -150,6 +160,20 @@
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>ru.yandex.qatools.embed</groupId>
<artifactId>postgresql-embedded</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>

3
dao/src/main/java/org/thingsboard/server/dao/Dao.java

@ -15,7 +15,6 @@
*/
package org.thingsboard.server.dao;
import com.datastax.driver.core.ResultSet;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
@ -31,6 +30,6 @@ public interface Dao<T> {
T save(T t);
ResultSet removeById(UUID id);
boolean removeById(UUID id);
}

12
dao/src/main/java/org/thingsboard/server/dao/DaoUtil.java

@ -15,15 +15,11 @@
*/
package org.thingsboard.server.dao;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import org.thingsboard.server.common.data.id.UUIDBased;
import org.thingsboard.server.dao.model.ToData;
import java.util.*;
public abstract class DaoUtil {
private DaoUtil() {
@ -34,7 +30,9 @@ public abstract class DaoUtil {
if (toDataList != null && !toDataList.isEmpty()) {
list = new ArrayList<>();
for (ToData<T> object : toDataList) {
list.add(object.toData());
if (object != null) {
list.add(object.toData());
}
}
}
return list;

1
dao/src/main/java/org/thingsboard/server/dao/EncryptionUtil.java

@ -15,7 +15,6 @@
*/
package org.thingsboard.server.dao;
import com.google.common.base.CharMatcher;
import lombok.extern.slf4j.Slf4j;
import org.bouncycastle.crypto.digests.SHA3Digest;
import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;

38
dao/src/main/java/org/thingsboard/server/dao/JpaDaoConfig.java

@ -0,0 +1,38 @@
/**
* Copyright © 2016-2017 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.dao;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.thingsboard.server.dao.util.SqlDao;
/**
* @author Valerii Sosliuk
*/
@Configuration
@EnableAutoConfiguration
@ComponentScan("org.thingsboard.server.dao.sql")
@EnableJpaRepositories("org.thingsboard.server.dao.sql")
@EntityScan("org.thingsboard.server.dao.model.sql")
@EnableTransactionManagement
@SqlDao
public class JpaDaoConfig {
}

33
dao/src/main/java/org/thingsboard/server/dao/NoSqlDaoConfig.java

@ -0,0 +1,33 @@
/**
* Copyright © 2016-2017 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.dao;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.context.annotation.Configuration;
import org.thingsboard.server.dao.util.NoSqlDao;
@Configuration
@EnableAutoConfiguration(
exclude = {
DataSourceAutoConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class,
HibernateJpaAutoConfiguration.class})
@NoSqlDao
public class NoSqlDaoConfig {
}

5
dao/src/main/java/org/thingsboard/server/dao/alarm/AlarmDao.java

@ -22,7 +22,6 @@ import org.thingsboard.server.common.data.alarm.AlarmQuery;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.Dao;
import org.thingsboard.server.dao.model.AlarmEntity;
import java.util.List;
import java.util.UUID;
@ -30,13 +29,13 @@ import java.util.UUID;
/**
* Created by ashvayka on 11.05.17.
*/
public interface AlarmDao extends Dao<AlarmEntity> {
public interface AlarmDao extends Dao<Alarm> {
ListenableFuture<Alarm> findLatestByOriginatorAndType(TenantId tenantId, EntityId originator, String type);
ListenableFuture<Alarm> findAlarmByIdAsync(UUID key);
AlarmEntity save(Alarm alarm);
Alarm save(Alarm alarm);
ListenableFuture<List<AlarmInfo>> findAlarms(AlarmQuery query);
}

18
dao/src/main/java/org/thingsboard/server/dao/alarm/BaseAlarmService.java

@ -24,6 +24,7 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.thingsboard.server.common.data.Tenant;
import org.thingsboard.server.common.data.alarm.*;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.page.TimePageData;
@ -31,10 +32,8 @@ import org.thingsboard.server.common.data.page.TimePageLink;
import org.thingsboard.server.common.data.relation.EntityRelation;
import org.thingsboard.server.common.data.relation.RelationTypeGroup;
import org.thingsboard.server.dao.entity.AbstractEntityService;
import org.thingsboard.server.dao.entity.BaseEntityService;
import org.thingsboard.server.dao.entity.EntityService;
import org.thingsboard.server.dao.exception.DataValidationException;
import org.thingsboard.server.dao.model.*;
import org.thingsboard.server.dao.relation.EntityRelationsQuery;
import org.thingsboard.server.dao.relation.EntitySearchDirection;
import org.thingsboard.server.dao.relation.RelationService;
@ -53,8 +52,7 @@ import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;
import static org.thingsboard.server.dao.DaoUtil.*;
import static org.thingsboard.server.dao.service.Validator.*;
import static org.thingsboard.server.dao.service.Validator.validateId;
@Service
@Slf4j
@ -115,7 +113,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
private Alarm createAlarm(Alarm alarm) throws InterruptedException, ExecutionException {
log.debug("New Alarm : {}", alarm);
Alarm saved = getData(alarmDao.save(new AlarmEntity(alarm)));
Alarm saved = alarmDao.save(alarm);
EntityRelationsQuery query = new EntityRelationsQuery();
query.setParameters(new RelationsSearchParameters(saved.getOriginator(), EntitySearchDirection.TO, Integer.MAX_VALUE));
List<EntityId> parentEntities = relationService.findByQuery(query).get().stream().map(r -> r.getFrom()).collect(Collectors.toList());
@ -144,11 +142,11 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
private Alarm updateAlarm(Alarm oldAlarm, Alarm newAlarm) {
AlarmStatus oldStatus = oldAlarm.getStatus();
AlarmStatus newStatus = newAlarm.getStatus();
AlarmEntity result = alarmDao.save(new AlarmEntity(merge(oldAlarm, newAlarm)));
Alarm result = alarmDao.save(merge(oldAlarm, newAlarm));
if (oldStatus != newStatus) {
updateRelations(oldAlarm, oldStatus, newStatus);
}
return result.toData();
return result;
}
@Override
@ -164,7 +162,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
AlarmStatus newStatus = oldStatus.isCleared() ? AlarmStatus.CLEARED_ACK : AlarmStatus.ACTIVE_ACK;
alarm.setStatus(newStatus);
alarm.setAckTs(ackTime);
alarmDao.save(new AlarmEntity(alarm));
alarmDao.save(alarm);
updateRelations(alarm, oldStatus, newStatus);
return true;
}
@ -185,7 +183,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
AlarmStatus newStatus = oldStatus.isAck() ? AlarmStatus.CLEARED_ACK : AlarmStatus.CLEARED_UNACK;
alarm.setStatus(newStatus);
alarm.setClearTs(clearTime);
alarmDao.save(new AlarmEntity(alarm));
alarmDao.save(alarm);
updateRelations(alarm, oldStatus, newStatus);
return true;
}
@ -387,7 +385,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
if (alarm.getTenantId() == null) {
throw new DataValidationException("Alarm should be assigned to tenant!");
} else {
TenantEntity tenant = tenantDao.findById(alarm.getTenantId().getId());
Tenant tenant = tenantDao.findById(alarm.getTenantId().getId());
if (tenant == null) {
throw new DataValidationException("Alarm is referencing to non-existent tenant!");
}

37
dao/src/main/java/org/thingsboard/server/dao/alarm/AlarmDaoImpl.java → dao/src/main/java/org/thingsboard/server/dao/alarm/CassandraAlarmDao.java

@ -33,10 +33,10 @@ 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.AbstractModelDao;
import org.thingsboard.server.dao.AbstractSearchTimeDao;
import org.thingsboard.server.dao.model.AlarmEntity;
import org.thingsboard.server.dao.nosql.CassandraAbstractModelDao;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.dao.model.nosql.AlarmEntity;
import org.thingsboard.server.dao.relation.RelationDao;
import java.util.ArrayList;
@ -49,7 +49,8 @@ import static org.thingsboard.server.dao.model.ModelConstants.*;
@Component
@Slf4j
public class AlarmDaoImpl extends AbstractModelDao<AlarmEntity> implements AlarmDao {
@NoSqlDao
public class CassandraAlarmDao extends CassandraAbstractModelDao<AlarmEntity, Alarm> implements AlarmDao {
@Autowired
private RelationDao relationDao;
@ -69,9 +70,9 @@ public class AlarmDaoImpl extends AbstractModelDao<AlarmEntity> implements Alarm
}
@Override
public AlarmEntity save(Alarm alarm) {
public Alarm save(Alarm alarm) {
log.debug("Save asset [{}] ", alarm);
return save(new AlarmEntity(alarm));
return super.save(alarm);
}
@Override
@ -84,16 +85,7 @@ public class AlarmDaoImpl extends AbstractModelDao<AlarmEntity> implements Alarm
query.and(eq(ALARM_TYPE_PROPERTY, type));
query.limit(1);
query.orderBy(QueryBuilder.asc(ModelConstants.ALARM_TYPE_PROPERTY), QueryBuilder.desc(ModelConstants.ID_PROPERTY));
return Futures.transform(findOneByStatementAsync(query), toDataFunction());
}
@Override
public ListenableFuture<Alarm> findAlarmByIdAsync(UUID key) {
log.debug("Get alarm by id {}", key);
Select.Where query = select().from(ALARM_BY_ID_VIEW_NAME).where(eq(ModelConstants.ID_PROPERTY, key));
query.limit(1);
log.trace("Execute query {}", query);
return Futures.transform(findOneByStatementAsync(query), toDataFunction());
return findOneByStatementAsync(query);
}
@Override
@ -114,10 +106,19 @@ public class AlarmDaoImpl extends AbstractModelDao<AlarmEntity> implements Alarm
List<ListenableFuture<AlarmInfo>> alarmFutures = new ArrayList<>(input.size());
for (EntityRelation relation : input) {
alarmFutures.add(Futures.transform(
findAlarmByIdAsync(relation.getTo().getId()), (Function<Alarm, AlarmInfo>)
alarm1 -> new AlarmInfo(alarm1)));
findAlarmByIdAsync(relation.getTo().getId()),
(Function<Alarm, AlarmInfo>) AlarmInfo::new));
}
return Futures.successfulAsList(alarmFutures);
});
}
@Override
public ListenableFuture<Alarm> findAlarmByIdAsync(UUID key) {
log.debug("Get alarm by id {}", key);
Select.Where query = select().from(ALARM_BY_ID_VIEW_NAME).where(eq(ModelConstants.ID_PROPERTY, key));
query.limit(1);
log.trace("Execute query {}", query);
return findOneByStatementAsync(query);
}
}

22
dao/src/main/java/org/thingsboard/server/dao/asset/AssetDao.java

@ -17,9 +17,9 @@ package org.thingsboard.server.dao.asset;
import com.google.common.util.concurrent.ListenableFuture;
import org.thingsboard.server.common.data.asset.Asset;
import org.thingsboard.server.common.data.asset.TenantAssetType;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.Dao;
import org.thingsboard.server.dao.model.AssetEntity;
import org.thingsboard.server.dao.model.TenantAssetTypeEntity;
import java.util.List;
@ -30,7 +30,7 @@ import java.util.UUID;
* The Interface AssetDao.
*
*/
public interface AssetDao extends Dao<AssetEntity> {
public interface AssetDao extends Dao<Asset> {
/**
* Save or update asset object
@ -38,7 +38,7 @@ public interface AssetDao extends Dao<AssetEntity> {
* @param asset the asset object
* @return saved asset object
*/
AssetEntity save(Asset asset);
Asset save(Asset asset);
/**
* Find assets by tenantId and page link.
@ -47,7 +47,7 @@ public interface AssetDao extends Dao<AssetEntity> {
* @param pageLink the page link
* @return the list of asset objects
*/
List<AssetEntity> findAssetsByTenantId(UUID tenantId, TextPageLink pageLink);
List<Asset> findAssetsByTenantId(UUID tenantId, TextPageLink pageLink);
/**
* Find assets by tenantId, type and page link.
@ -57,7 +57,7 @@ public interface AssetDao extends Dao<AssetEntity> {
* @param pageLink the page link
* @return the list of asset objects
*/
List<AssetEntity> findAssetsByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink);
List<Asset> findAssetsByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink);
/**
* Find assets by tenantId and assets Ids.
@ -66,7 +66,7 @@ public interface AssetDao extends Dao<AssetEntity> {
* @param assetIds the asset Ids
* @return the list of asset objects
*/
ListenableFuture<List<AssetEntity>> findAssetsByTenantIdAndIdsAsync(UUID tenantId, List<UUID> assetIds);
ListenableFuture<List<Asset>> findAssetsByTenantIdAndIdsAsync(UUID tenantId, List<UUID> assetIds);
/**
* Find assets by tenantId, customerId and page link.
@ -76,7 +76,7 @@ public interface AssetDao extends Dao<AssetEntity> {
* @param pageLink the page link
* @return the list of asset objects
*/
List<AssetEntity> findAssetsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink);
List<Asset> findAssetsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink);
/**
* Find assets by tenantId, customerId, type and page link.
@ -87,7 +87,7 @@ public interface AssetDao extends Dao<AssetEntity> {
* @param pageLink the page link
* @return the list of asset objects
*/
List<AssetEntity> findAssetsByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink);
List<Asset> findAssetsByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink);
/**
* Find assets by tenantId, customerId and assets Ids.
@ -97,7 +97,7 @@ public interface AssetDao extends Dao<AssetEntity> {
* @param assetIds the asset Ids
* @return the list of asset objects
*/
ListenableFuture<List<AssetEntity>> findAssetsByTenantIdCustomerIdAndIdsAsync(UUID tenantId, UUID customerId, List<UUID> assetIds);
ListenableFuture<List<Asset>> findAssetsByTenantIdAndCustomerIdAndIdsAsync(UUID tenantId, UUID customerId, List<UUID> assetIds);
/**
* Find assets by tenantId and asset name.
@ -106,13 +106,13 @@ public interface AssetDao extends Dao<AssetEntity> {
* @param name the asset name
* @return the optional asset object
*/
Optional<AssetEntity> findAssetsByTenantIdAndName(UUID tenantId, String name);
Optional<Asset> findAssetsByTenantIdAndName(UUID tenantId, String name);
/**
* Find tenants asset types.
*
* @return the list of tenant asset type objects
*/
ListenableFuture<List<TenantAssetTypeEntity>> findTenantAssetTypesAsync();
ListenableFuture<List<TenantAssetType>> findTenantAssetTypesAsync();
}

1
dao/src/main/java/org/thingsboard/server/dao/asset/AssetSearchQuery.java

@ -23,7 +23,6 @@ import org.thingsboard.server.dao.relation.EntityRelationsQuery;
import org.thingsboard.server.dao.relation.EntityTypeFilter;
import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

84
dao/src/main/java/org/thingsboard/server/dao/asset/BaseAssetService.java

@ -24,7 +24,9 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.thingsboard.server.common.data.Customer;
import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.Tenant;
import org.thingsboard.server.common.data.asset.Asset;
import org.thingsboard.server.common.data.asset.TenantAssetType;
import org.thingsboard.server.common.data.id.AssetId;
@ -37,7 +39,6 @@ import org.thingsboard.server.common.data.relation.EntityRelation;
import org.thingsboard.server.dao.customer.CustomerDao;
import org.thingsboard.server.dao.entity.AbstractEntityService;
import org.thingsboard.server.dao.exception.DataValidationException;
import org.thingsboard.server.dao.model.*;
import org.thingsboard.server.dao.relation.EntitySearchDirection;
import org.thingsboard.server.dao.service.DataValidator;
import org.thingsboard.server.dao.service.PaginatedRemover;
@ -45,6 +46,7 @@ import org.thingsboard.server.dao.tenant.TenantDao;
import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
@ -70,35 +72,28 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
public Asset findAssetById(AssetId assetId) {
log.trace("Executing findAssetById [{}]", assetId);
validateId(assetId, "Incorrect assetId " + assetId);
AssetEntity assetEntity = assetDao.findById(assetId.getId());
return getData(assetEntity);
return assetDao.findById(assetId.getId());
}
@Override
public ListenableFuture<Asset> findAssetByIdAsync(AssetId assetId) {
log.trace("Executing findAssetById [{}]", assetId);
validateId(assetId, "Incorrect assetId " + assetId);
ListenableFuture<AssetEntity> assetEntity = assetDao.findByIdAsync(assetId.getId());
return Futures.transform(assetEntity, (Function<? super AssetEntity, ? extends Asset>) input -> getData(input));
return assetDao.findByIdAsync(assetId.getId());
}
@Override
public Optional<Asset> findAssetByTenantIdAndName(TenantId tenantId, String name) {
log.trace("Executing findAssetByTenantIdAndName [{}][{}]", tenantId, name);
validateId(tenantId, "Incorrect tenantId " + tenantId);
Optional<AssetEntity> assetEntityOpt = assetDao.findAssetsByTenantIdAndName(tenantId.getId(), name);
if (assetEntityOpt.isPresent()) {
return Optional.of(getData(assetEntityOpt.get()));
} else {
return Optional.empty();
}
return assetDao.findAssetsByTenantIdAndName(tenantId.getId(), name);
}
@Override
public Asset saveAsset(Asset asset) {
log.trace("Executing saveAsset [{}]", asset);
assetValidator.validate(asset);
return getData(assetDao.save(asset));
return assetDao.save(asset);
}
@Override
@ -128,8 +123,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
log.trace("Executing findAssetsByTenantId, tenantId [{}], pageLink [{}]", tenantId, pageLink);
validateId(tenantId, "Incorrect tenantId " + tenantId);
validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<AssetEntity> assetEntities = assetDao.findAssetsByTenantId(tenantId.getId(), pageLink);
List<Asset> assets = convertDataList(assetEntities);
List<Asset> assets = assetDao.findAssetsByTenantId(tenantId.getId(), pageLink);
return new TextPageData<>(assets, pageLink);
}
@ -139,8 +133,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateString(type, "Incorrect type " + type);
validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<AssetEntity> assetEntities = assetDao.findAssetsByTenantIdAndType(tenantId.getId(), type, pageLink);
List<Asset> assets = convertDataList(assetEntities);
List<Asset> assets = assetDao.findAssetsByTenantIdAndType(tenantId.getId(), type, pageLink);
return new TextPageData<>(assets, pageLink);
}
@ -149,15 +142,14 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
log.trace("Executing findAssetsByTenantIdAndIdsAsync, tenantId [{}], assetIds [{}]", tenantId, assetIds);
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateIds(assetIds, "Incorrect assetIds " + assetIds);
ListenableFuture<List<AssetEntity>> assetEntities = assetDao.findAssetsByTenantIdAndIdsAsync(tenantId.getId(), toUUIDs(assetIds));
return Futures.transform(assetEntities, (Function<List<AssetEntity>, List<Asset>>) input -> convertDataList(input));
return assetDao.findAssetsByTenantIdAndIdsAsync(tenantId.getId(), toUUIDs(assetIds));
}
@Override
public void deleteAssetsByTenantId(TenantId tenantId) {
log.trace("Executing deleteAssetsByTenantId, tenantId [{}]", tenantId);
validateId(tenantId, "Incorrect tenantId " + tenantId);
tenantAssetsRemover.removeEntitites(tenantId);
tenantAssetsRemover.removeEntities(tenantId);
}
@Override
@ -166,9 +158,8 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateId(customerId, "Incorrect customerId " + customerId);
validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<AssetEntity> assetEntities = assetDao.findAssetsByTenantIdAndCustomerId(tenantId.getId(), customerId.getId(), pageLink);
List<Asset> assets = convertDataList(assetEntities);
return new TextPageData<>(assets, pageLink);
List<Asset> assets = assetDao.findAssetsByTenantIdAndCustomerId(tenantId.getId(), customerId.getId(), pageLink);
return new TextPageData<Asset>(assets, pageLink);
}
@Override
@ -178,20 +169,17 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
validateId(customerId, "Incorrect customerId " + customerId);
validateString(type, "Incorrect type " + type);
validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<AssetEntity> assetEntities = assetDao.findAssetsByTenantIdAndCustomerIdAndType(tenantId.getId(), customerId.getId(), type, pageLink);
List<Asset> assets = convertDataList(assetEntities);
List<Asset> assets = assetDao.findAssetsByTenantIdAndCustomerIdAndType(tenantId.getId(), customerId.getId(), type, pageLink);
return new TextPageData<>(assets, pageLink);
}
@Override
public ListenableFuture<List<Asset>> findAssetsByTenantIdCustomerIdAndIdsAsync(TenantId tenantId, CustomerId customerId, List<AssetId> assetIds) {
log.trace("Executing findAssetsByTenantIdCustomerIdAndIdsAsync, tenantId [{}], customerId [{}], assetIds [{}]", tenantId, customerId, assetIds);
log.trace("Executing findAssetsByTenantIdAndCustomerIdAndIdsAsync, tenantId [{}], customerId [{}], assetIds [{}]", tenantId, customerId, assetIds);
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateId(customerId, "Incorrect customerId " + customerId);
validateIds(assetIds, "Incorrect assetIds " + assetIds);
ListenableFuture<List<AssetEntity>> assetEntities = assetDao.findAssetsByTenantIdCustomerIdAndIdsAsync(tenantId.getId(),
customerId.getId(), toUUIDs(assetIds));
return Futures.transform(assetEntities, (Function<List<AssetEntity>, List<Asset>>) input -> convertDataList(input));
return assetDao.findAssetsByTenantIdAndCustomerIdAndIdsAsync(tenantId.getId(), customerId.getId(), toUUIDs(assetIds));
}
@Override
@ -199,7 +187,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
log.trace("Executing unassignCustomerAssets, tenantId [{}], customerId [{}]", tenantId, customerId);
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateId(customerId, "Incorrect customerId " + customerId);
new CustomerAssetsUnassigner(tenantId).removeEntitites(customerId);
new CustomerAssetsUnassigner(tenantId).removeEntities(customerId);
}
@Override
@ -232,16 +220,16 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
public ListenableFuture<List<TenantAssetType>> findAssetTypesByTenantId(TenantId tenantId) {
log.trace("Executing findAssetTypesByTenantId, tenantId [{}]", tenantId);
validateId(tenantId, "Incorrect tenantId " + tenantId);
ListenableFuture<List<TenantAssetTypeEntity>> tenantAssetTypeEntities = assetDao.findTenantAssetTypesAsync();
ListenableFuture<List<TenantAssetType>> tenantAssetTypeEntities = assetDao.findTenantAssetTypesAsync();
ListenableFuture<List<TenantAssetType>> tenantAssetTypes = Futures.transform(tenantAssetTypeEntities,
(Function<List<TenantAssetTypeEntity>, List<TenantAssetType>>) assetTypeEntities -> {
(Function<List<TenantAssetType>, List<TenantAssetType>>) assetTypeEntities -> {
List<TenantAssetType> assetTypes = new ArrayList<>();
for (TenantAssetTypeEntity assetTypeEntity : assetTypeEntities) {
if (assetTypeEntity.getTenantId().equals(tenantId.getId())) {
assetTypes.add(assetTypeEntity.toTenantAssetType());
for (TenantAssetType assetType : assetTypeEntities) {
if (assetType.getTenantId().equals(tenantId)) {
assetTypes.add(assetType);
}
}
assetTypes.sort((TenantAssetType o1, TenantAssetType o2) -> o1.getType().compareTo(o2.getType()));
assetTypes.sort(Comparator.comparing(TenantAssetType::getType));
return assetTypes;
});
return tenantAssetTypes;
@ -263,7 +251,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
protected void validateUpdate(Asset asset) {
assetDao.findAssetsByTenantIdAndName(asset.getTenantId().getId(), asset.getName()).ifPresent(
d -> {
if (!d.getId().equals(asset.getUuidId())) {
if (!d.getId().equals(asset.getId())) {
throw new DataValidationException("Asset with such name already exists!");
}
}
@ -281,7 +269,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
if (asset.getTenantId() == null) {
throw new DataValidationException("Asset should be assigned to tenant!");
} else {
TenantEntity tenant = tenantDao.findById(asset.getTenantId().getId());
Tenant tenant = tenantDao.findById(asset.getTenantId().getId());
if (tenant == null) {
throw new DataValidationException("Asset is referencing to non-existent tenant!");
}
@ -289,32 +277,32 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
if (asset.getCustomerId() == null) {
asset.setCustomerId(new CustomerId(NULL_UUID));
} else if (!asset.getCustomerId().getId().equals(NULL_UUID)) {
CustomerEntity customer = customerDao.findById(asset.getCustomerId().getId());
Customer customer = customerDao.findById(asset.getCustomerId().getId());
if (customer == null) {
throw new DataValidationException("Can't assign asset to non-existent customer!");
}
if (!customer.getTenantId().equals(asset.getTenantId().getId())) {
if (!customer.getTenantId().equals(asset.getTenantId())) {
throw new DataValidationException("Can't assign asset to customer from different tenant!");
}
}
}
};
private PaginatedRemover<TenantId, AssetEntity> tenantAssetsRemover =
new PaginatedRemover<TenantId, AssetEntity>() {
private PaginatedRemover<TenantId, Asset> tenantAssetsRemover =
new PaginatedRemover<TenantId, Asset>() {
@Override
protected List<AssetEntity> findEntities(TenantId id, TextPageLink pageLink) {
protected List<Asset> findEntities(TenantId id, TextPageLink pageLink) {
return assetDao.findAssetsByTenantId(id.getId(), pageLink);
}
@Override
protected void removeEntity(AssetEntity entity) {
deleteAsset(new AssetId(entity.getId()));
protected void removeEntity(Asset entity) {
deleteAsset(new AssetId(entity.getId().getId()));
}
};
class CustomerAssetsUnassigner extends PaginatedRemover<CustomerId, AssetEntity> {
class CustomerAssetsUnassigner extends PaginatedRemover<CustomerId, Asset> {
private TenantId tenantId;
@ -323,13 +311,13 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
}
@Override
protected List<AssetEntity> findEntities(CustomerId id, TextPageLink pageLink) {
protected List<Asset> findEntities(CustomerId id, TextPageLink pageLink) {
return assetDao.findAssetsByTenantIdAndCustomerId(tenantId.getId(), id.getId(), pageLink);
}
@Override
protected void removeEntity(AssetEntity entity) {
unassignAssetFromCustomer(new AssetId(entity.getId()));
protected void removeEntity(Asset entity) {
unassignAssetFromCustomer(new AssetId(entity.getId().getId()));
}
}
}

59
dao/src/main/java/org/thingsboard/server/dao/asset/AssetDaoImpl.java → dao/src/main/java/org/thingsboard/server/dao/asset/CassandraAssetDao.java

@ -25,10 +25,13 @@ import com.google.common.util.concurrent.ListenableFuture;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.thingsboard.server.common.data.asset.Asset;
import org.thingsboard.server.common.data.asset.TenantAssetType;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.AbstractSearchTextDao;
import org.thingsboard.server.dao.model.AssetEntity;
import org.thingsboard.server.dao.nosql.CassandraAbstractSearchTextDao;
import org.thingsboard.server.dao.DaoUtil;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.TenantAssetTypeEntity;
import org.thingsboard.server.dao.model.nosql.AssetEntity;
import javax.annotation.Nullable;
import java.util.*;
@ -38,7 +41,8 @@ import static org.thingsboard.server.dao.model.ModelConstants.*;
@Component
@Slf4j
public class AssetDaoImpl extends AbstractSearchTextDao<AssetEntity> implements AssetDao {
@NoSqlDao
public class CassandraAssetDao extends CassandraAbstractSearchTextDao<AssetEntity, Asset> implements AssetDao {
@Override
protected Class<AssetEntity> getColumnFamilyClass() {
@ -51,33 +55,26 @@ public class AssetDaoImpl extends AbstractSearchTextDao<AssetEntity> implements
}
@Override
public AssetEntity save(Asset asset) {
log.debug("Save asset [{}] ", asset);
return save(new AssetEntity(asset));
}
@Override
public List<AssetEntity> findAssetsByTenantId(UUID tenantId, TextPageLink pageLink) {
public List<Asset> findAssetsByTenantId(UUID tenantId, TextPageLink pageLink) {
log.debug("Try to find assets by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
List<AssetEntity> assetEntities = findPageWithTextSearch(ASSET_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Collections.singletonList(eq(ASSET_TENANT_ID_PROPERTY, tenantId)), pageLink);
log.trace("Found assets [{}] by tenantId [{}] and pageLink [{}]", assetEntities, tenantId, pageLink);
return assetEntities;
return DaoUtil.convertDataList(assetEntities);
}
@Override
public List<AssetEntity> findAssetsByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
public List<Asset> findAssetsByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
log.debug("Try to find assets by tenantId [{}], type [{}] and pageLink [{}]", tenantId, type, pageLink);
List<AssetEntity> assetEntities = findPageWithTextSearch(ASSET_BY_TENANT_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(ASSET_TYPE_PROPERTY, type),
eq(ASSET_TENANT_ID_PROPERTY, tenantId)), pageLink);
log.trace("Found assets [{}] by tenantId [{}], type [{}] and pageLink [{}]", assetEntities, tenantId, type, pageLink);
return assetEntities;
return DaoUtil.convertDataList(assetEntities);
}
@Override
public ListenableFuture<List<AssetEntity>> findAssetsByTenantIdAndIdsAsync(UUID tenantId, List<UUID> assetIds) {
public ListenableFuture<List<Asset>> findAssetsByTenantIdAndIdsAsync(UUID tenantId, List<UUID> assetIds) {
log.debug("Try to find assets by tenantId [{}] and asset Ids [{}]", tenantId, assetIds);
Select select = select().from(getColumnFamilyName());
Select.Where query = select.where();
@ -87,7 +84,7 @@ public class AssetDaoImpl extends AbstractSearchTextDao<AssetEntity> implements
}
@Override
public List<AssetEntity> findAssetsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
public List<Asset> findAssetsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
log.debug("Try to find assets by tenantId [{}], customerId[{}] and pageLink [{}]", tenantId, customerId, pageLink);
List<AssetEntity> assetEntities = findPageWithTextSearch(ASSET_BY_CUSTOMER_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(ASSET_CUSTOMER_ID_PROPERTY, customerId),
@ -95,11 +92,11 @@ public class AssetDaoImpl extends AbstractSearchTextDao<AssetEntity> implements
pageLink);
log.trace("Found assets [{}] by tenantId [{}], customerId [{}] and pageLink [{}]", assetEntities, tenantId, customerId, pageLink);
return assetEntities;
return DaoUtil.convertDataList(assetEntities);
}
@Override
public List<AssetEntity> findAssetsByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
public List<Asset> findAssetsByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
log.debug("Try to find assets by tenantId [{}], customerId [{}], type [{}] and pageLink [{}]", tenantId, customerId, type, pageLink);
List<AssetEntity> assetEntities = findPageWithTextSearch(ASSET_BY_CUSTOMER_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(ASSET_TYPE_PROPERTY, type),
@ -108,11 +105,11 @@ public class AssetDaoImpl extends AbstractSearchTextDao<AssetEntity> implements
pageLink);
log.trace("Found assets [{}] by tenantId [{}], customerId [{}], type [{}] and pageLink [{}]", assetEntities, tenantId, customerId, type, pageLink);
return assetEntities;
return DaoUtil.convertDataList(assetEntities);
}
@Override
public ListenableFuture<List<AssetEntity>> findAssetsByTenantIdCustomerIdAndIdsAsync(UUID tenantId, UUID customerId, List<UUID> assetIds) {
public ListenableFuture<List<Asset>> findAssetsByTenantIdAndCustomerIdAndIdsAsync(UUID tenantId, UUID customerId, List<UUID> assetIds) {
log.debug("Try to find assets by tenantId [{}], customerId [{}] and asset Ids [{}]", tenantId, customerId, assetIds);
Select select = select().from(getColumnFamilyName());
Select.Where query = select.where();
@ -123,16 +120,17 @@ public class AssetDaoImpl extends AbstractSearchTextDao<AssetEntity> implements
}
@Override
public Optional<AssetEntity> findAssetsByTenantIdAndName(UUID tenantId, String assetName) {
public Optional<Asset> findAssetsByTenantIdAndName(UUID tenantId, String assetName) {
Select select = select().from(ASSET_BY_TENANT_AND_NAME_VIEW_NAME);
Select.Where query = select.where();
query.and(eq(ASSET_TENANT_ID_PROPERTY, tenantId));
query.and(eq(ASSET_NAME_PROPERTY, assetName));
return Optional.ofNullable(findOneByStatement(query));
AssetEntity assetEntity = (AssetEntity) findOneByStatement(query);
return Optional.ofNullable(DaoUtil.getData(assetEntity));
}
@Override
public ListenableFuture<List<TenantAssetTypeEntity>> findTenantAssetTypesAsync() {
public ListenableFuture<List<TenantAssetType>> findTenantAssetTypesAsync() {
Select statement = select().distinct().column(ASSET_TYPE_PROPERTY).column(ASSET_TENANT_ID_PROPERTY).from(ASSET_TYPES_BY_TENANT_VIEW_NAME);
statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
ResultSetFuture resultSetFuture = getSession().executeAsync(statement);
@ -148,7 +146,20 @@ public class AssetDaoImpl extends AbstractSearchTextDao<AssetEntity> implements
}
}
});
return result;
return Futures.transform(result, new Function<List<TenantAssetTypeEntity>, List<TenantAssetType>>() {
@Nullable
@Override
public List<TenantAssetType> apply(@Nullable List<TenantAssetTypeEntity> entityList) {
List<TenantAssetType> list = Collections.emptyList();
if (entityList != null && !entityList.isEmpty()) {
list = new ArrayList<>();
for (TenantAssetTypeEntity object : entityList) {
list.add(object.toTenantAssetType());
}
}
return list;
}
});
}
}

6
dao/src/main/java/org/thingsboard/server/dao/attributes/AttributesDao.java

@ -15,8 +15,6 @@
*/
package org.thingsboard.server.dao.attributes;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.ResultSetFuture;
import com.google.common.util.concurrent.ListenableFuture;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.kv.AttributeKvEntry;
@ -36,7 +34,7 @@ public interface AttributesDao {
ListenableFuture<List<AttributeKvEntry>> findAll(EntityId entityId, String attributeType);
ResultSetFuture save(EntityId entityId, String attributeType, AttributeKvEntry attribute);
ListenableFuture<Void> save(EntityId entityId, String attributeType, AttributeKvEntry attribute);
ListenableFuture<List<ResultSet>> removeAll(EntityId entityId, String scope, List<String> keys);
ListenableFuture<List<Void>> removeAll(EntityId entityId, String attributeType, List<String> keys);
}

8
dao/src/main/java/org/thingsboard/server/dao/attributes/AttributesService.java

@ -15,12 +15,8 @@
*/
package org.thingsboard.server.dao.attributes;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.ResultSetFuture;
import com.google.common.util.concurrent.ListenableFuture;
import org.thingsboard.server.common.data.id.DeviceId;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.id.UUIDBased;
import org.thingsboard.server.common.data.kv.AttributeKvEntry;
import java.util.Collection;
@ -38,7 +34,7 @@ public interface AttributesService {
ListenableFuture<List<AttributeKvEntry>> findAll(EntityId entityId, String scope);
ListenableFuture<List<ResultSet>> save(EntityId entityId, String scope, List<AttributeKvEntry> attributes);
ListenableFuture<List<Void>> save(EntityId entityId, String scope, List<AttributeKvEntry> attributes);
ListenableFuture<List<ResultSet>> removeAll(EntityId entityId, String scope, List<String> attributeKeys);
ListenableFuture<List<Void>> removeAll(EntityId entityId, String scope, List<String> attributeKeys);
}

10
dao/src/main/java/org/thingsboard/server/dao/attributes/BaseAttributesService.java

@ -20,11 +20,11 @@ import com.datastax.driver.core.ResultSetFuture;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.kv.AttributeKvEntry;
import org.thingsboard.server.dao.exception.IncorrectParameterException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.thingsboard.server.dao.service.Validator;
import java.util.Collection;
@ -61,10 +61,10 @@ public class BaseAttributesService implements AttributesService {
}
@Override
public ListenableFuture<List<ResultSet>> save(EntityId entityId, String scope, List<AttributeKvEntry> attributes) {
public ListenableFuture<List<Void>> save(EntityId entityId, String scope, List<AttributeKvEntry> attributes) {
validate(entityId, scope);
attributes.forEach(attribute -> validate(attribute));
List<ResultSetFuture> futures = Lists.newArrayListWithExpectedSize(attributes.size());
List<ListenableFuture<Void>> futures = Lists.newArrayListWithExpectedSize(attributes.size());
for (AttributeKvEntry attribute : attributes) {
futures.add(attributesDao.save(entityId, scope, attribute));
}
@ -72,7 +72,7 @@ public class BaseAttributesService implements AttributesService {
}
@Override
public ListenableFuture<List<ResultSet>> removeAll(EntityId entityId, String scope, List<String> keys) {
public ListenableFuture<List<Void>> removeAll(EntityId entityId, String scope, List<String> keys) {
validate(entityId, scope);
return attributesDao.removeAll(entityId, scope, keys);
}

32
dao/src/main/java/org/thingsboard/server/dao/attributes/BaseAttributesDao.java → dao/src/main/java/org/thingsboard/server/dao/attributes/CassandraBaseAttributesDao.java

@ -24,10 +24,12 @@ import com.google.common.util.concurrent.ListenableFuture;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.dao.AbstractAsyncDao;
import org.thingsboard.server.common.data.kv.AttributeKvEntry;
import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry;
import org.thingsboard.server.dao.nosql.CassandraAbstractAsyncDao;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.common.data.kv.*;
import org.thingsboard.server.dao.timeseries.BaseTimeseriesDao;
import org.thingsboard.server.dao.timeseries.CassandraBaseTimeseriesDao;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@ -37,15 +39,17 @@ import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
import static org.thingsboard.server.dao.model.ModelConstants.*;
import static com.datastax.driver.core.querybuilder.QueryBuilder.*;
/**
* @author Andrew Shvayka
*/
@Component
@Slf4j
public class BaseAttributesDao extends AbstractAsyncDao implements AttributesDao {
@NoSqlDao
public class CassandraBaseAttributesDao extends CassandraAbstractAsyncDao implements AttributesDao {
private PreparedStatement saveStmt;
@ -97,7 +101,7 @@ public class BaseAttributesDao extends AbstractAsyncDao implements AttributesDao
}
@Override
public ResultSetFuture save(EntityId entityId, String attributeType, AttributeKvEntry attribute) {
public ListenableFuture<Void> save(EntityId entityId, String attributeType, AttributeKvEntry attribute) {
BoundStatement stmt = getSaveStmt().bind();
stmt.setString(0, entityId.getEntityType().name());
stmt.setUUID(1, entityId.getId());
@ -120,23 +124,27 @@ public class BaseAttributesDao extends AbstractAsyncDao implements AttributesDao
} else {
stmt.setToNull(8);
}
return executeAsyncWrite(stmt);
log.trace("Generated save stmt [{}] for entityId {} and attributeType {} and attribute", stmt, entityId, attributeType, attribute);
return getFuture(executeAsyncWrite(stmt), rs -> null);
}
@Override
public ListenableFuture<List<ResultSet>> removeAll(EntityId entityId, String attributeType, List<String> keys) {
List<ResultSetFuture> futures = keys.stream().map(key -> delete(entityId, attributeType, key)).collect(Collectors.toList());
public ListenableFuture<List<Void>> removeAll(EntityId entityId, String attributeType, List<String> keys) {
List<ListenableFuture<Void>> futures = keys
.stream()
.map(key -> delete(entityId, attributeType, key))
.collect(Collectors.toList());
return Futures.allAsList(futures);
}
private ResultSetFuture delete(EntityId entityId, String attributeType, String key) {
private ListenableFuture<Void> delete(EntityId entityId, String attributeType, String key) {
Statement delete = QueryBuilder.delete().all().from(ModelConstants.ATTRIBUTES_KV_CF)
.where(eq(ENTITY_TYPE_COLUMN, entityId.getEntityType()))
.and(eq(ENTITY_ID_COLUMN, entityId.getId()))
.and(eq(ATTRIBUTE_TYPE_COLUMN, attributeType))
.and(eq(ATTRIBUTE_KEY_COLUMN, key));
log.debug("Remove request: {}", delete.toString());
return getSession().executeAsync(delete);
return getFuture(getSession().executeAsync(delete), rs -> null);
}
private PreparedStatement getSaveStmt() {
@ -161,7 +169,7 @@ public class BaseAttributesDao extends AbstractAsyncDao implements AttributesDao
AttributeKvEntry attributeEntry = null;
if (row != null) {
long lastUpdateTs = row.get(LAST_UPDATE_TS_COLUMN, Long.class);
attributeEntry = new BaseAttributeKvEntry(BaseTimeseriesDao.toKvEntry(row, key), lastUpdateTs);
attributeEntry = new BaseAttributeKvEntry(CassandraBaseTimeseriesDao.toKvEntry(row, key), lastUpdateTs);
}
return attributeEntry;
}

29
dao/src/main/java/org/thingsboard/server/dao/cache/ServiceCacheConfiguration.java

@ -57,16 +57,25 @@ public class ServiceCacheConfiguration {
Config config = new Config();
if (zkEnabled) {
config.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
config.setProperty(GroupProperty.DISCOVERY_SPI_ENABLED.getName(), Boolean.TRUE.toString());
DiscoveryStrategyConfig discoveryStrategyConfig = new DiscoveryStrategyConfig(new ZookeeperDiscoveryStrategyFactory());
discoveryStrategyConfig.addProperty(ZookeeperDiscoveryProperties.ZOOKEEPER_URL.key(), zkUrl);
discoveryStrategyConfig.addProperty(ZookeeperDiscoveryProperties.ZOOKEEPER_PATH.key(), zkDir);
discoveryStrategyConfig.addProperty(ZookeeperDiscoveryProperties.GROUP.key(), HAZELCAST_CLUSTER_NAME);
config.getNetworkConfig().getJoin().getDiscoveryConfig().addDiscoveryStrategyConfig(discoveryStrategyConfig);
addZkConfig(config);
}
config.addMapConfig(createDeviceCredentialsCacheConfig());
return Hazelcast.newHazelcastInstance(config);
}
private void addZkConfig(Config config) {
config.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
config.setProperty(GroupProperty.DISCOVERY_SPI_ENABLED.getName(), Boolean.TRUE.toString());
DiscoveryStrategyConfig discoveryStrategyConfig = new DiscoveryStrategyConfig(new ZookeeperDiscoveryStrategyFactory());
discoveryStrategyConfig.addProperty(ZookeeperDiscoveryProperties.ZOOKEEPER_URL.key(), zkUrl);
discoveryStrategyConfig.addProperty(ZookeeperDiscoveryProperties.ZOOKEEPER_PATH.key(), zkDir);
discoveryStrategyConfig.addProperty(ZookeeperDiscoveryProperties.GROUP.key(), HAZELCAST_CLUSTER_NAME);
config.getNetworkConfig().getJoin().getDiscoveryConfig().addDiscoveryStrategyConfig(discoveryStrategyConfig);
}
private MapConfig createDeviceCredentialsCacheConfig() {
MapConfig deviceCredentialsCacheConfig = new MapConfig(CacheConstants.DEVICE_CREDENTIALS_CACHE);
deviceCredentialsCacheConfig.setTimeToLiveSeconds(cacheDeviceCredentialsTTL);
deviceCredentialsCacheConfig.setEvictionPolicy(EvictionPolicy.LRU);
@ -75,9 +84,7 @@ public class ServiceCacheConfiguration {
cacheDeviceCredentialsMaxSizeSize,
MaxSizeConfig.MaxSizePolicy.valueOf(cacheDeviceCredentialsMaxSizePolicy))
);
config.addMapConfig(deviceCredentialsCacheConfig);
return Hazelcast.newHazelcastInstance(config);
return deviceCredentialsCacheConfig;
}
@Bean

14
dao/src/main/java/org/thingsboard/server/dao/cassandra/CassandraCluster.java

@ -16,13 +16,8 @@
package org.thingsboard.server.dao.cassandra;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.ConsistencyLevel;
import com.datastax.driver.core.HostDistance;
import com.datastax.driver.core.PoolingOptions;
import com.datastax.driver.core.*;
import com.datastax.driver.core.ProtocolOptions.Compression;
import com.datastax.driver.core.Session;
import com.datastax.driver.core.exceptions.NoHostAvailableException;
import com.datastax.driver.mapping.Mapper;
import com.datastax.driver.mapping.MappingManager;
import lombok.Data;
@ -31,20 +26,19 @@ import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.thingsboard.server.dao.exception.DatabaseException;
import org.thingsboard.server.dao.util.NoSqlDao;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.io.Closeable;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;
@Data
@Component
@Slf4j
@Data
@NoSqlDao
public class CassandraCluster {
private static final String COMMA = ",";

5
dao/src/main/java/org/thingsboard/server/dao/cassandra/CassandraQueryOptions.java

@ -21,15 +21,14 @@ import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.thingsboard.server.dao.util.NoSqlDao;
import javax.annotation.PostConstruct;
import static org.apache.commons.lang3.StringUtils.isNotBlank;
@Component
@Configuration
@Data
@NoSqlDao
public class CassandraQueryOptions {
@Value("${cassandra.query.default_fetch_size}")

5
dao/src/main/java/org/thingsboard/server/dao/cassandra/CassandraSocketOptions.java

@ -15,18 +15,19 @@
*/
package org.thingsboard.server.dao.cassandra;
import com.datastax.driver.core.SocketOptions;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import com.datastax.driver.core.SocketOptions;
import org.thingsboard.server.dao.util.NoSqlDao;
import javax.annotation.PostConstruct;
@Component
@Configuration
@Data
@NoSqlDao
public class CassandraSocketOptions {
@Value("${cassandra.socket.connect_timeout}")

20
dao/src/main/java/org/thingsboard/server/dao/component/BaseComponentDescriptorService.java

@ -32,16 +32,12 @@ import org.thingsboard.server.common.data.plugin.ComponentScope;
import org.thingsboard.server.common.data.plugin.ComponentType;
import org.thingsboard.server.dao.exception.DataValidationException;
import org.thingsboard.server.dao.exception.IncorrectParameterException;
import org.thingsboard.server.dao.model.ComponentDescriptorEntity;
import org.thingsboard.server.dao.service.DataValidator;
import org.thingsboard.server.dao.service.Validator;
import java.util.List;
import java.util.Optional;
import static org.thingsboard.server.dao.DaoUtil.convertDataList;
import static org.thingsboard.server.dao.DaoUtil.getData;
/**
* @author Andrew Shvayka
*/
@ -55,39 +51,37 @@ public class BaseComponentDescriptorService implements ComponentDescriptorServic
@Override
public ComponentDescriptor saveComponent(ComponentDescriptor component) {
componentValidator.validate(component);
Optional<ComponentDescriptorEntity> result = componentDescriptorDao.save(component);
Optional<ComponentDescriptor> result = componentDescriptorDao.saveIfNotExist(component);
if (result.isPresent()) {
return getData(result.get());
return result.get();
} else {
return getData(componentDescriptorDao.findByClazz(component.getClazz()));
return componentDescriptorDao.findByClazz(component.getClazz());
}
}
@Override
public ComponentDescriptor findById(ComponentDescriptorId componentId) {
Validator.validateId(componentId, "Incorrect component id for search request.");
return getData(componentDescriptorDao.findById(componentId));
return componentDescriptorDao.findById(componentId);
}
@Override
public ComponentDescriptor findByClazz(String clazz) {
Validator.validateString(clazz, "Incorrect clazz for search request.");
return getData(componentDescriptorDao.findByClazz(clazz));
return componentDescriptorDao.findByClazz(clazz);
}
@Override
public TextPageData<ComponentDescriptor> findByTypeAndPageLink(ComponentType type, TextPageLink pageLink) {
Validator.validatePageLink(pageLink, "Incorrect PageLink object for search plugin components request.");
List<ComponentDescriptorEntity> pluginEntities = componentDescriptorDao.findByTypeAndPageLink(type, pageLink);
List<ComponentDescriptor> components = convertDataList(pluginEntities);
List<ComponentDescriptor> components = componentDescriptorDao.findByTypeAndPageLink(type, pageLink);
return new TextPageData<>(components, pageLink);
}
@Override
public TextPageData<ComponentDescriptor> findByScopeAndTypeAndPageLink(ComponentScope scope, ComponentType type, TextPageLink pageLink) {
Validator.validatePageLink(pageLink, "Incorrect PageLink object for search plugin components request.");
List<ComponentDescriptorEntity> pluginEntities = componentDescriptorDao.findByScopeAndTypeAndPageLink(scope, type, pageLink);
List<ComponentDescriptor> components = convertDataList(pluginEntities);
List<ComponentDescriptor> components = componentDescriptorDao.findByScopeAndTypeAndPageLink(scope, type, pageLink);
return new TextPageData<>(components, pageLink);
}

51
dao/src/main/java/org/thingsboard/server/dao/component/BaseComponentDescriptorDao.java → dao/src/main/java/org/thingsboard/server/dao/component/CassandraBaseComponentDescriptorDao.java

@ -27,9 +27,11 @@ import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
import org.thingsboard.server.common.data.plugin.ComponentScope;
import org.thingsboard.server.common.data.plugin.ComponentType;
import org.thingsboard.server.dao.AbstractSearchTextDao;
import org.thingsboard.server.dao.nosql.CassandraAbstractSearchTextDao;
import org.thingsboard.server.dao.DaoUtil;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.dao.model.ComponentDescriptorEntity;
import org.thingsboard.server.dao.model.nosql.ComponentDescriptorEntity;
import java.util.Arrays;
import java.util.List;
@ -44,7 +46,8 @@ import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
*/
@Component
@Slf4j
public class BaseComponentDescriptorDao extends AbstractSearchTextDao<ComponentDescriptorEntity> implements ComponentDescriptorDao {
@NoSqlDao
public class CassandraBaseComponentDescriptorDao extends CassandraAbstractSearchTextDao<ComponentDescriptorEntity, ComponentDescriptor> implements ComponentDescriptorDao {
@Override
protected Class<ComponentDescriptorEntity> getColumnFamilyClass() {
@ -57,10 +60,10 @@ public class BaseComponentDescriptorDao extends AbstractSearchTextDao<ComponentD
}
@Override
public Optional<ComponentDescriptorEntity> save(ComponentDescriptor component) {
public Optional<ComponentDescriptor> saveIfNotExist(ComponentDescriptor component) {
ComponentDescriptorEntity entity = new ComponentDescriptorEntity(component);
log.debug("Save component entity [{}]", entity);
Optional<ComponentDescriptorEntity> result = saveIfNotExist(entity);
Optional<ComponentDescriptor> result = saveIfNotExist(entity);
if (log.isTraceEnabled()) {
log.trace("Saved result: [{}] for component entity [{}]", result.isPresent(), result.orElse(null));
} else {
@ -70,19 +73,19 @@ public class BaseComponentDescriptorDao extends AbstractSearchTextDao<ComponentD
}
@Override
public ComponentDescriptorEntity findById(ComponentDescriptorId componentId) {
public ComponentDescriptor findById(ComponentDescriptorId componentId) {
log.debug("Search component entity by id [{}]", componentId);
ComponentDescriptorEntity entity = super.findById(componentId.getId());
ComponentDescriptor componentDescriptor = super.findById(componentId.getId());
if (log.isTraceEnabled()) {
log.trace("Search result: [{}] for component entity [{}]", entity != null, entity);
log.trace("Search result: [{}] for component entity [{}]", componentDescriptor != null, componentDescriptor);
} else {
log.debug("Search result: [{}]", entity != null);
log.debug("Search result: [{}]", componentDescriptor != null);
}
return entity;
return componentDescriptor;
}
@Override
public ComponentDescriptorEntity findByClazz(String clazz) {
public ComponentDescriptor findByClazz(String clazz) {
log.debug("Search component entity by clazz [{}]", clazz);
Select.Where query = select().from(getColumnFamilyName()).where(eq(ModelConstants.COMPONENT_DESCRIPTOR_CLASS_PROPERTY, clazz));
log.trace("Execute query [{}]", query);
@ -92,47 +95,47 @@ public class BaseComponentDescriptorDao extends AbstractSearchTextDao<ComponentD
} else {
log.debug("Search result: [{}]", entity != null);
}
return entity;
return DaoUtil.getData(entity);
}
@Override
public List<ComponentDescriptorEntity> findByTypeAndPageLink(ComponentType type, TextPageLink pageLink) {
public List<ComponentDescriptor> findByTypeAndPageLink(ComponentType type, TextPageLink pageLink) {
log.debug("Try to find component by type [{}] and pageLink [{}]", type, pageLink);
List<ComponentDescriptorEntity> entities = findPageWithTextSearch(ModelConstants.COMPONENT_DESCRIPTOR_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(ModelConstants.COMPONENT_DESCRIPTOR_TYPE_PROPERTY, type.name())), pageLink);
Arrays.asList(eq(ModelConstants.COMPONENT_DESCRIPTOR_TYPE_PROPERTY, type)), pageLink);
if (log.isTraceEnabled()) {
log.trace("Search result: [{}]", Arrays.toString(entities.toArray()));
} else {
log.debug("Search result: [{}]", entities.size());
}
return entities;
return DaoUtil.convertDataList(entities);
}
@Override
public List<ComponentDescriptorEntity> findByScopeAndTypeAndPageLink(ComponentScope scope, ComponentType type, TextPageLink pageLink) {
public List<ComponentDescriptor> findByScopeAndTypeAndPageLink(ComponentScope scope, ComponentType type, TextPageLink pageLink) {
log.debug("Try to find component by scope [{}] and type [{}] and pageLink [{}]", scope, type, pageLink);
List<ComponentDescriptorEntity> entities = findPageWithTextSearch(ModelConstants.COMPONENT_DESCRIPTOR_BY_SCOPE_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(ModelConstants.COMPONENT_DESCRIPTOR_TYPE_PROPERTY, type.name()),
Arrays.asList(eq(ModelConstants.COMPONENT_DESCRIPTOR_TYPE_PROPERTY, type),
eq(ModelConstants.COMPONENT_DESCRIPTOR_SCOPE_PROPERTY, scope.name())), pageLink);
if (log.isTraceEnabled()) {
log.trace("Search result: [{}]", Arrays.toString(entities.toArray()));
} else {
log.debug("Search result: [{}]", entities.size());
}
return entities;
return DaoUtil.convertDataList(entities);
}
public ResultSet removeById(UUID key) {
public boolean removeById(UUID key) {
Statement delete = QueryBuilder.delete().all().from(ModelConstants.COMPONENT_DESCRIPTOR_BY_ID).where(eq(ModelConstants.ID_PROPERTY, key));
log.debug("Remove request: {}", delete.toString());
return getSession().execute(delete);
return getSession().execute(delete).wasApplied();
}
@Override
public void deleteById(ComponentDescriptorId id) {
log.debug("Delete plugin meta-data entity by id [{}]", id);
ResultSet resultSet = removeById(id.getId());
log.debug("Delete result: [{}]", resultSet.wasApplied());
boolean result = removeById(id.getId());
log.debug("Delete result: [{}]", result);
}
@Override
@ -144,7 +147,7 @@ public class BaseComponentDescriptorDao extends AbstractSearchTextDao<ComponentD
log.debug("Delete result: [{}]", resultSet.wasApplied());
}
private Optional<ComponentDescriptorEntity> saveIfNotExist(ComponentDescriptorEntity entity) {
private Optional<ComponentDescriptor> saveIfNotExist(ComponentDescriptorEntity entity) {
if (entity.getId() == null) {
entity.setId(UUIDs.timeBased());
}
@ -161,7 +164,7 @@ public class BaseComponentDescriptorDao extends AbstractSearchTextDao<ComponentD
.ifNotExists()
);
if (rs.wasApplied()) {
return Optional.of(entity);
return Optional.of(DaoUtil.getData(entity));
} else {
return Optional.empty();
}

13
dao/src/main/java/org/thingsboard/server/dao/component/ComponentDescriptorDao.java

@ -21,7 +21,6 @@ import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
import org.thingsboard.server.common.data.plugin.ComponentScope;
import org.thingsboard.server.common.data.plugin.ComponentType;
import org.thingsboard.server.dao.Dao;
import org.thingsboard.server.dao.model.ComponentDescriptorEntity;
import java.util.List;
import java.util.Optional;
@ -29,17 +28,17 @@ import java.util.Optional;
/**
* @author Andrew Shvayka
*/
public interface ComponentDescriptorDao extends Dao<ComponentDescriptorEntity> {
public interface ComponentDescriptorDao extends Dao<ComponentDescriptor> {
Optional<ComponentDescriptorEntity> save(ComponentDescriptor component);
Optional<ComponentDescriptor> saveIfNotExist(ComponentDescriptor component);
ComponentDescriptorEntity findById(ComponentDescriptorId componentId);
ComponentDescriptor findById(ComponentDescriptorId componentId);
ComponentDescriptorEntity findByClazz(String clazz);
ComponentDescriptor findByClazz(String clazz);
List<ComponentDescriptorEntity> findByTypeAndPageLink(ComponentType type, TextPageLink pageLink);
List<ComponentDescriptor> findByTypeAndPageLink(ComponentType type, TextPageLink pageLink);
List<ComponentDescriptorEntity> findByScopeAndTypeAndPageLink(ComponentScope scope, ComponentType type, TextPageLink pageLink);
List<ComponentDescriptor> findByScopeAndTypeAndPageLink(ComponentScope scope, ComponentType type, TextPageLink pageLink);
void deleteById(ComponentDescriptorId componentId);

48
dao/src/main/java/org/thingsboard/server/dao/customer/CustomerDaoImpl.java → dao/src/main/java/org/thingsboard/server/dao/customer/CassandraCustomerDao.java

@ -15,31 +15,29 @@
*/
package org.thingsboard.server.dao.customer;
import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_BY_TENANT_AND_TITLE_VIEW_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_TITLE_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_TENANT_ID_PROPERTY;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import com.datastax.driver.core.querybuilder.Select;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.thingsboard.server.common.data.Customer;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.AbstractSearchTextDao;
import org.thingsboard.server.dao.model.CustomerEntity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.thingsboard.server.dao.nosql.CassandraAbstractSearchTextDao;
import org.thingsboard.server.dao.DaoUtil;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.dao.model.nosql.CustomerEntity;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Component
@Slf4j
public class CustomerDaoImpl extends AbstractSearchTextDao<CustomerEntity> implements CustomerDao {
@NoSqlDao
public class CassandraCustomerDao extends CassandraAbstractSearchTextDao<CustomerEntity, Customer> implements CustomerDao {
@Override
protected Class<CustomerEntity> getColumnFamilyClass() {
@ -50,30 +48,26 @@ public class CustomerDaoImpl extends AbstractSearchTextDao<CustomerEntity> imple
protected String getColumnFamilyName() {
return ModelConstants.CUSTOMER_COLUMN_FAMILY_NAME;
}
@Override
public CustomerEntity save(Customer customer) {
log.debug("Save customer [{}] ", customer);
return save(new CustomerEntity(customer));
}
@Override
public List<CustomerEntity> findCustomersByTenantId(UUID tenantId, TextPageLink pageLink) {
public List<Customer> findCustomersByTenantId(UUID tenantId, TextPageLink pageLink) {
log.debug("Try to find customers by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
List<CustomerEntity> customerEntities = findPageWithTextSearch(ModelConstants.CUSTOMER_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(ModelConstants.CUSTOMER_TENANT_ID_PROPERTY, tenantId)),
pageLink);
log.trace("Found customers [{}] by tenantId [{}] and pageLink [{}]", customerEntities, tenantId, pageLink);
return customerEntities;
return DaoUtil.convertDataList(customerEntities);
}
@Override
public Optional<CustomerEntity> findCustomersByTenantIdAndTitle(UUID tenantId, String title) {
public Optional<Customer> findCustomersByTenantIdAndTitle(UUID tenantId, String title) {
Select select = select().from(CUSTOMER_BY_TENANT_AND_TITLE_VIEW_NAME);
Select.Where query = select.where();
query.and(eq(CUSTOMER_TENANT_ID_PROPERTY, tenantId));
query.and(eq(CUSTOMER_TITLE_PROPERTY, title));
return Optional.ofNullable(findOneByStatement(query));
CustomerEntity customerEntity = findOneByStatement(query);
Customer customer = DaoUtil.getData(customerEntity);
return Optional.ofNullable(customer);
}
}

16
dao/src/main/java/org/thingsboard/server/dao/customer/CustomerDao.java

@ -15,20 +15,18 @@
*/
package org.thingsboard.server.dao.customer;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import org.thingsboard.server.common.data.Customer;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.Dao;
import org.thingsboard.server.dao.model.CustomerEntity;
import org.thingsboard.server.dao.model.DeviceEntity;
import java.util.List;
import java.util.UUID;
/**
* The Interface CustomerDao.
*/
public interface CustomerDao extends Dao<CustomerEntity> {
public interface CustomerDao extends Dao<Customer> {
/**
* Save or update customer object
@ -36,7 +34,7 @@ public interface CustomerDao extends Dao<CustomerEntity> {
* @param customer the customer object
* @return saved customer object
*/
CustomerEntity save(Customer customer);
Customer save(Customer customer);
/**
* Find customers by tenant id and page link.
@ -45,7 +43,7 @@ public interface CustomerDao extends Dao<CustomerEntity> {
* @param pageLink the page link
* @return the list of customer objects
*/
List<CustomerEntity> findCustomersByTenantId(UUID tenantId, TextPageLink pageLink);
List<Customer> findCustomersByTenantId(UUID tenantId, TextPageLink pageLink);
/**
* Find customers by tenantId and customer title.
@ -54,6 +52,6 @@ public interface CustomerDao extends Dao<CustomerEntity> {
* @param title the customer title
* @return the optional customer object
*/
Optional<CustomerEntity> findCustomersByTenantIdAndTitle(UUID tenantId, String title);
Optional<Customer> findCustomersByTenantIdAndTitle(UUID tenantId, String title);
}

4
dao/src/main/java/org/thingsboard/server/dao/customer/CustomerService.java

@ -27,13 +27,13 @@ public interface CustomerService {
Customer findCustomerById(CustomerId customerId);
ListenableFuture<Customer> findCustomerByIdAsync(CustomerId customerId);
Customer saveCustomer(Customer customer);
void deleteCustomer(CustomerId customerId);
Customer findOrCreatePublicCustomer(TenantId tenantId);
TextPageData<Customer> findCustomersByTenantId(TenantId tenantId, TextPageLink pageLink);
void deleteCustomersByTenantId(TenantId tenantId);

81
dao/src/main/java/org/thingsboard/server/dao/customer/CustomerServiceImpl.java

@ -15,8 +15,6 @@
*/
package org.thingsboard.server.dao.customer;
import static org.thingsboard.server.dao.DaoUtil.convertDataList;
import static org.thingsboard.server.dao.DaoUtil.getData;
import static org.thingsboard.server.dao.service.Validator.validateId;
import java.io.IOException;
@ -25,12 +23,13 @@ import java.util.Optional;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.Function;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.thingsboard.server.common.data.Customer;
import org.thingsboard.server.common.data.Tenant;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.page.TextPageData;
@ -40,15 +39,12 @@ import org.thingsboard.server.dao.device.DeviceService;
import org.thingsboard.server.dao.entity.AbstractEntityService;
import org.thingsboard.server.dao.exception.DataValidationException;
import org.thingsboard.server.dao.exception.IncorrectParameterException;
import org.thingsboard.server.dao.model.CustomerEntity;
import org.thingsboard.server.dao.model.TenantEntity;
import org.thingsboard.server.dao.service.DataValidator;
import org.thingsboard.server.dao.service.PaginatedRemover;
import org.thingsboard.server.dao.service.Validator;
import org.thingsboard.server.dao.tenant.TenantDao;
import org.thingsboard.server.dao.user.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.thingsboard.server.dao.service.Validator;
@Service
@Slf4j
public class CustomerServiceImpl extends AbstractEntityService implements CustomerService {
@ -57,41 +53,38 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
@Autowired
private CustomerDao customerDao;
@Autowired
private UserService userService;
@Autowired
private TenantDao tenantDao;
@Autowired
private DeviceService deviceService;
@Autowired
private DashboardService dashboardService;
@Override
public Customer findCustomerById(CustomerId customerId) {
log.trace("Executing findCustomerById [{}]", customerId);
Validator.validateId(customerId, "Incorrect customerId " + customerId);
CustomerEntity customerEntity = customerDao.findById(customerId.getId());
return getData(customerEntity);
return customerDao.findById(customerId.getId());
}
@Override
public ListenableFuture<Customer> findCustomerByIdAsync(CustomerId customerId) {
log.trace("Executing findCustomerByIdAsync [{}]", customerId);
validateId(customerId, "Incorrect customerId " + customerId);
ListenableFuture<CustomerEntity> customerEntity = customerDao.findByIdAsync(customerId.getId());
return Futures.transform(customerEntity, (Function<? super CustomerEntity, ? extends Customer>) input -> getData(input));
return customerDao.findByIdAsync(customerId.getId());
}
@Override
public Customer saveCustomer(Customer customer) {
log.trace("Executing saveCustomer [{}]", customer);
customerValidator.validate(customer);
CustomerEntity customerEntity = customerDao.save(customer);
return getData(customerEntity);
return customerDao.save(customer);
}
@Override
@ -113,9 +106,9 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
public Customer findOrCreatePublicCustomer(TenantId tenantId) {
log.trace("Executing findOrCreatePublicCustomer, tenantId [{}]", tenantId);
Validator.validateId(tenantId, "Incorrect customerId " + tenantId);
Optional<CustomerEntity> publicCustomerEntity = customerDao.findCustomersByTenantIdAndTitle(tenantId.getId(), PUBLIC_CUSTOMER_TITLE);
if (publicCustomerEntity.isPresent()) {
return getData(publicCustomerEntity.get());
Optional<Customer> publicCustomerOpt = customerDao.findCustomersByTenantIdAndTitle(tenantId.getId(), PUBLIC_CUSTOMER_TITLE);
if (publicCustomerOpt.isPresent()) {
return publicCustomerOpt.get();
} else {
Customer publicCustomer = new Customer();
publicCustomer.setTenantId(tenantId);
@ -125,8 +118,7 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
} catch (IOException e) {
throw new IncorrectParameterException("Unable to create public customer.", e);
}
CustomerEntity customerEntity = customerDao.save(publicCustomer);
return getData(customerEntity);
return customerDao.save(publicCustomer);
}
}
@ -135,18 +127,17 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
log.trace("Executing findCustomersByTenantId, tenantId [{}], pageLink [{}]", tenantId, pageLink);
Validator.validateId(tenantId, "Incorrect tenantId " + tenantId);
Validator.validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<CustomerEntity> customerEntities = customerDao.findCustomersByTenantId(tenantId.getId(), pageLink);
List<Customer> customers = convertDataList(customerEntities);
return new TextPageData<Customer>(customers, pageLink);
List<Customer> customers = customerDao.findCustomersByTenantId(tenantId.getId(), pageLink);
return new TextPageData<>(customers, pageLink);
}
@Override
public void deleteCustomersByTenantId(TenantId tenantId) {
log.trace("Executing deleteCustomersByTenantId, tenantId [{}]", tenantId);
Validator.validateId(tenantId, "Incorrect tenantId " + tenantId);
customersByTenantRemover.removeEntitites(tenantId);
customersByTenantRemover.removeEntities(tenantId);
}
private DataValidator<Customer> customerValidator =
new DataValidator<Customer>() {
@ -184,25 +175,25 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
if (customer.getTenantId() == null) {
throw new DataValidationException("Customer should be assigned to tenant!");
} else {
TenantEntity tenant = tenantDao.findById(customer.getTenantId().getId());
Tenant tenant = tenantDao.findById(customer.getTenantId().getId());
if (tenant == null) {
throw new DataValidationException("Customer is referencing to non-existent tenant!");
}
}
}
};
private PaginatedRemover<TenantId, CustomerEntity> customersByTenantRemover =
new PaginatedRemover<TenantId, CustomerEntity>() {
@Override
protected List<CustomerEntity> findEntities(TenantId id, TextPageLink pageLink) {
return customerDao.findCustomersByTenantId(id.getId(), pageLink);
}
};
@Override
protected void removeEntity(CustomerEntity entity) {
deleteCustomer(new CustomerId(entity.getId()));
}
};
private PaginatedRemover<TenantId, Customer> customersByTenantRemover =
new PaginatedRemover<TenantId, Customer>() {
@Override
protected List<Customer> findEntities(TenantId id, TextPageLink pageLink) {
return customerDao.findCustomersByTenantId(id.getId(), pageLink);
}
@Override
protected void removeEntity(Customer entity) {
deleteCustomer(new CustomerId(entity.getUuidId()));
}
};
}

39
dao/src/main/java/org/thingsboard/server/dao/dashboard/CassandraDashboardDao.java

@ -0,0 +1,39 @@
/**
* Copyright © 2016-2017 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.dao.dashboard;
import org.springframework.stereotype.Component;
import org.thingsboard.server.common.data.Dashboard;
import org.thingsboard.server.dao.nosql.CassandraAbstractSearchTextDao;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.nosql.DashboardEntity;
import static org.thingsboard.server.dao.model.ModelConstants.DASHBOARD_COLUMN_FAMILY_NAME;
@Component
@NoSqlDao
public class CassandraDashboardDao extends CassandraAbstractSearchTextDao<DashboardEntity, Dashboard> implements DashboardDao {
@Override
protected Class<DashboardEntity> getColumnFamilyClass() {
return DashboardEntity.class;
}
@Override
protected String getColumnFamilyName() {
return DASHBOARD_COLUMN_FAMILY_NAME;
}
}

18
dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardInfoDaoImpl.java → dao/src/main/java/org/thingsboard/server/dao/dashboard/CassandraDashboardInfoDao.java

@ -17,9 +17,12 @@ package org.thingsboard.server.dao.dashboard;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.thingsboard.server.common.data.DashboardInfo;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.AbstractSearchTextDao;
import org.thingsboard.server.dao.model.DashboardInfoEntity;
import org.thingsboard.server.dao.nosql.CassandraAbstractSearchTextDao;
import org.thingsboard.server.dao.DaoUtil;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.nosql.DashboardInfoEntity;
import java.util.Arrays;
import java.util.Collections;
@ -31,7 +34,8 @@ import static org.thingsboard.server.dao.model.ModelConstants.*;
@Component
@Slf4j
public class DashboardInfoDaoImpl extends AbstractSearchTextDao<DashboardInfoEntity> implements DashboardInfoDao {
@NoSqlDao
public class CassandraDashboardInfoDao extends CassandraAbstractSearchTextDao<DashboardInfoEntity, DashboardInfo> implements DashboardInfoDao {
@Override
protected Class<DashboardInfoEntity> getColumnFamilyClass() {
@ -44,18 +48,18 @@ public class DashboardInfoDaoImpl extends AbstractSearchTextDao<DashboardInfoEnt
}
@Override
public List<DashboardInfoEntity> findDashboardsByTenantId(UUID tenantId, TextPageLink pageLink) {
public List<DashboardInfo> findDashboardsByTenantId(UUID tenantId, TextPageLink pageLink) {
log.debug("Try to find dashboards by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
List<DashboardInfoEntity> dashboardEntities = findPageWithTextSearch(DASHBOARD_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Collections.singletonList(eq(DASHBOARD_TENANT_ID_PROPERTY, tenantId)),
pageLink);
log.trace("Found dashboards [{}] by tenantId [{}] and pageLink [{}]", dashboardEntities, tenantId, pageLink);
return dashboardEntities;
return DaoUtil.convertDataList(dashboardEntities);
}
@Override
public List<DashboardInfoEntity> findDashboardsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
public List<DashboardInfo> findDashboardsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
log.debug("Try to find dashboards by tenantId [{}], customerId[{}] and pageLink [{}]", tenantId, customerId, pageLink);
List<DashboardInfoEntity> dashboardEntities = findPageWithTextSearch(DASHBOARD_BY_CUSTOMER_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(DASHBOARD_CUSTOMER_ID_PROPERTY, customerId),
@ -63,7 +67,7 @@ public class DashboardInfoDaoImpl extends AbstractSearchTextDao<DashboardInfoEnt
pageLink);
log.trace("Found dashboards [{}] by tenantId [{}], customerId [{}] and pageLink [{}]", dashboardEntities, tenantId, customerId, pageLink);
return dashboardEntities;
return DaoUtil.convertDataList(dashboardEntities);
}
}

12
dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardDao.java

@ -15,21 +15,13 @@
*/
package org.thingsboard.server.dao.dashboard;
import java.util.List;
import java.util.UUID;
import org.thingsboard.server.common.data.Dashboard;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.Dao;
import org.thingsboard.server.dao.model.DashboardEntity;
import org.thingsboard.server.dao.model.DashboardInfoEntity;
/**
* The Interface DashboardDao.
*
* @param <T> the generic type
*/
public interface DashboardDao extends Dao<DashboardEntity> {
public interface DashboardDao extends Dao<Dashboard> {
/**
* Save or update dashboard object
@ -37,6 +29,6 @@ public interface DashboardDao extends Dao<DashboardEntity> {
* @param dashboard the dashboard object
* @return saved dashboard object
*/
DashboardEntity save(Dashboard dashboard);
Dashboard save(Dashboard dashboard);
}

60
dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardDaoImpl.java

@ -1,60 +0,0 @@
/**
* Copyright © 2016-2017 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.dao.dashboard;
import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
import static org.thingsboard.server.dao.model.ModelConstants.DASHBOARD_BY_CUSTOMER_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.DASHBOARD_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.DASHBOARD_COLUMN_FAMILY_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.DASHBOARD_CUSTOMER_ID_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.DASHBOARD_TENANT_ID_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.NULL_UUID;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.thingsboard.server.common.data.Dashboard;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.AbstractSearchTextDao;
import org.thingsboard.server.dao.model.DashboardEntity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.thingsboard.server.dao.model.DashboardInfoEntity;
@Component
@Slf4j
public class DashboardDaoImpl extends AbstractSearchTextDao<DashboardEntity> implements DashboardDao {
@Override
protected Class<DashboardEntity> getColumnFamilyClass() {
return DashboardEntity.class;
}
@Override
protected String getColumnFamilyName() {
return DASHBOARD_COLUMN_FAMILY_NAME;
}
@Override
public DashboardEntity save(Dashboard dashboard) {
log.debug("Save dashboard [{}] ", dashboard);
return save(new DashboardEntity(dashboard));
}
}

18
dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardInfoDao.java

@ -15,21 +15,17 @@
*/
package org.thingsboard.server.dao.dashboard;
import java.util.List;
import java.util.UUID;
import org.thingsboard.server.common.data.Dashboard;
import org.thingsboard.server.common.data.DashboardInfo;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.Dao;
import org.thingsboard.server.dao.model.DashboardEntity;
import org.thingsboard.server.dao.model.DashboardInfoEntity;
import java.util.List;
import java.util.UUID;
/**
* The Interface DashboardInfoDao.
*
* @param <T> the generic type
*/
public interface DashboardInfoDao extends Dao<DashboardInfoEntity> {
public interface DashboardInfoDao extends Dao<DashboardInfo> {
/**
* Find dashboards by tenantId and page link.
@ -38,7 +34,7 @@ public interface DashboardInfoDao extends Dao<DashboardInfoEntity> {
* @param pageLink the page link
* @return the list of dashboard objects
*/
List<DashboardInfoEntity> findDashboardsByTenantId(UUID tenantId, TextPageLink pageLink);
List<DashboardInfo> findDashboardsByTenantId(UUID tenantId, TextPageLink pageLink);
/**
* Find dashboards by tenantId, customerId and page link.
@ -48,6 +44,6 @@ public interface DashboardInfoDao extends Dao<DashboardInfoEntity> {
* @param pageLink the page link
* @return the list of dashboard objects
*/
List<DashboardInfoEntity> findDashboardsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink);
List<DashboardInfo> findDashboardsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink);
}

32
dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardService.java

@ -26,28 +26,28 @@ import org.thingsboard.server.common.data.page.TextPageLink;
public interface DashboardService {
public Dashboard findDashboardById(DashboardId dashboardId);
Dashboard findDashboardById(DashboardId dashboardId);
public ListenableFuture<Dashboard> findDashboardByIdAsync(DashboardId dashboardId);
ListenableFuture<Dashboard> findDashboardByIdAsync(DashboardId dashboardId);
public DashboardInfo findDashboardInfoById(DashboardId dashboardId);
DashboardInfo findDashboardInfoById(DashboardId dashboardId);
public ListenableFuture<DashboardInfo> findDashboardInfoByIdAsync(DashboardId dashboardId);
ListenableFuture<DashboardInfo> findDashboardInfoByIdAsync(DashboardId dashboardId);
public Dashboard saveDashboard(Dashboard dashboard);
public Dashboard assignDashboardToCustomer(DashboardId dashboardId, CustomerId customerId);
Dashboard saveDashboard(Dashboard dashboard);
public Dashboard unassignDashboardFromCustomer(DashboardId dashboardId);
Dashboard assignDashboardToCustomer(DashboardId dashboardId, CustomerId customerId);
public void deleteDashboard(DashboardId dashboardId);
public TextPageData<DashboardInfo> findDashboardsByTenantId(TenantId tenantId, TextPageLink pageLink);
Dashboard unassignDashboardFromCustomer(DashboardId dashboardId);
public void deleteDashboardsByTenantId(TenantId tenantId);
public TextPageData<DashboardInfo> findDashboardsByTenantIdAndCustomerId(TenantId tenantId, CustomerId customerId, TextPageLink pageLink);
void deleteDashboard(DashboardId dashboardId);
TextPageData<DashboardInfo> findDashboardsByTenantId(TenantId tenantId, TextPageLink pageLink);
void deleteDashboardsByTenantId(TenantId tenantId);
TextPageData<DashboardInfo> findDashboardsByTenantIdAndCustomerId(TenantId tenantId, CustomerId customerId, TextPageLink pageLink);
void unassignCustomerDashboards(TenantId tenantId, CustomerId customerId);
public void unassignCustomerDashboards(TenantId tenantId, CustomerId customerId);
}

75
dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardServiceImpl.java

@ -15,19 +15,15 @@
*/
package org.thingsboard.server.dao.dashboard;
import static org.thingsboard.server.dao.DaoUtil.convertDataList;
import static org.thingsboard.server.dao.DaoUtil.getData;
import static org.thingsboard.server.dao.service.Validator.validateId;
import java.util.List;
import com.google.common.base.Function;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.thingsboard.server.common.data.Customer;
import org.thingsboard.server.common.data.Dashboard;
import org.thingsboard.server.common.data.DashboardInfo;
import org.thingsboard.server.common.data.Tenant;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.DashboardId;
import org.thingsboard.server.common.data.id.TenantId;
@ -36,13 +32,15 @@ import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.customer.CustomerDao;
import org.thingsboard.server.dao.entity.AbstractEntityService;
import org.thingsboard.server.dao.exception.DataValidationException;
import org.thingsboard.server.dao.model.*;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.dao.service.DataValidator;
import org.thingsboard.server.dao.service.PaginatedRemover;
import org.thingsboard.server.dao.tenant.TenantDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.thingsboard.server.dao.service.Validator;
import org.thingsboard.server.dao.tenant.TenantDao;
import java.util.List;
import static org.thingsboard.server.dao.service.Validator.validateId;
@Service
@Slf4j
@ -64,40 +62,35 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
public Dashboard findDashboardById(DashboardId dashboardId) {
log.trace("Executing findDashboardById [{}]", dashboardId);
Validator.validateId(dashboardId, "Incorrect dashboardId " + dashboardId);
DashboardEntity dashboardEntity = dashboardDao.findById(dashboardId.getId());
return getData(dashboardEntity);
return dashboardDao.findById(dashboardId.getId());
}
@Override
public ListenableFuture<Dashboard> findDashboardByIdAsync(DashboardId dashboardId) {
log.trace("Executing findDashboardByIdAsync [{}]", dashboardId);
validateId(dashboardId, "Incorrect dashboardId " + dashboardId);
ListenableFuture<DashboardEntity> dashboardEntity = dashboardDao.findByIdAsync(dashboardId.getId());
return Futures.transform(dashboardEntity, (Function<? super DashboardEntity, ? extends Dashboard>) input -> getData(input));
return dashboardDao.findByIdAsync(dashboardId.getId());
}
@Override
public DashboardInfo findDashboardInfoById(DashboardId dashboardId) {
log.trace("Executing findDashboardInfoById [{}]", dashboardId);
Validator.validateId(dashboardId, "Incorrect dashboardId " + dashboardId);
DashboardInfoEntity dashboardInfoEntity = dashboardInfoDao.findById(dashboardId.getId());
return getData(dashboardInfoEntity);
return dashboardInfoDao.findById(dashboardId.getId());
}
@Override
public ListenableFuture<DashboardInfo> findDashboardInfoByIdAsync(DashboardId dashboardId) {
log.trace("Executing findDashboardInfoByIdAsync [{}]", dashboardId);
validateId(dashboardId, "Incorrect dashboardId " + dashboardId);
ListenableFuture<DashboardInfoEntity> dashboardInfoEntity = dashboardInfoDao.findByIdAsync(dashboardId.getId());
return Futures.transform(dashboardInfoEntity, (Function<? super DashboardInfoEntity, ? extends DashboardInfo>) input -> getData(input));
return dashboardInfoDao.findByIdAsync(dashboardId.getId());
}
@Override
public Dashboard saveDashboard(Dashboard dashboard) {
log.trace("Executing saveDashboard [{}]", dashboard);
dashboardValidator.validate(dashboard);
DashboardEntity dashboardEntity = dashboardDao.save(dashboard);
return getData(dashboardEntity);
return dashboardDao.save(dashboard);
}
@Override
@ -127,16 +120,15 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
log.trace("Executing findDashboardsByTenantId, tenantId [{}], pageLink [{}]", tenantId, pageLink);
Validator.validateId(tenantId, "Incorrect tenantId " + tenantId);
Validator.validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<DashboardInfoEntity> dashboardEntities = dashboardInfoDao.findDashboardsByTenantId(tenantId.getId(), pageLink);
List<DashboardInfo> dashboards = convertDataList(dashboardEntities);
return new TextPageData<DashboardInfo>(dashboards, pageLink);
List<DashboardInfo> dashboards = dashboardInfoDao.findDashboardsByTenantId(tenantId.getId(), pageLink);
return new TextPageData<>(dashboards, pageLink);
}
@Override
public void deleteDashboardsByTenantId(TenantId tenantId) {
log.trace("Executing deleteDashboardsByTenantId, tenantId [{}]", tenantId);
Validator.validateId(tenantId, "Incorrect tenantId " + tenantId);
tenantDashboardsRemover.removeEntitites(tenantId);
tenantDashboardsRemover.removeEntities(tenantId);
}
@Override
@ -145,9 +137,8 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
Validator.validateId(tenantId, "Incorrect tenantId " + tenantId);
Validator.validateId(customerId, "Incorrect customerId " + customerId);
Validator.validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<DashboardInfoEntity> dashboardEntities = dashboardInfoDao.findDashboardsByTenantIdAndCustomerId(tenantId.getId(), customerId.getId(), pageLink);
List<DashboardInfo> dashboards = convertDataList(dashboardEntities);
return new TextPageData<DashboardInfo>(dashboards, pageLink);
List<DashboardInfo> dashboards = dashboardInfoDao.findDashboardsByTenantIdAndCustomerId(tenantId.getId(), customerId.getId(), pageLink);
return new TextPageData<>(dashboards, pageLink);
}
@Override
@ -155,7 +146,7 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
log.trace("Executing unassignCustomerDashboards, tenantId [{}], customerId [{}]", tenantId, customerId);
Validator.validateId(tenantId, "Incorrect tenantId " + tenantId);
Validator.validateId(customerId, "Incorrect customerId " + customerId);
new CustomerDashboardsUnassigner(tenantId).removeEntitites(customerId);
new CustomerDashboardsUnassigner(tenantId).removeEntities(customerId);
}
private DataValidator<Dashboard> dashboardValidator =
@ -168,7 +159,7 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
if (dashboard.getTenantId() == null) {
throw new DataValidationException("Dashboard should be assigned to tenant!");
} else {
TenantEntity tenant = tenantDao.findById(dashboard.getTenantId().getId());
Tenant tenant = tenantDao.findById(dashboard.getTenantId().getId());
if (tenant == null) {
throw new DataValidationException("Dashboard is referencing to non-existent tenant!");
}
@ -176,32 +167,32 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
if (dashboard.getCustomerId() == null) {
dashboard.setCustomerId(new CustomerId(ModelConstants.NULL_UUID));
} else if (!dashboard.getCustomerId().getId().equals(ModelConstants.NULL_UUID)) {
CustomerEntity customer = customerDao.findById(dashboard.getCustomerId().getId());
Customer customer = customerDao.findById(dashboard.getCustomerId().getId());
if (customer == null) {
throw new DataValidationException("Can't assign dashboard to non-existent customer!");
}
if (!customer.getTenantId().equals(dashboard.getTenantId().getId())) {
if (!customer.getTenantId().getId().equals(dashboard.getTenantId().getId())) {
throw new DataValidationException("Can't assign dashboard to customer from different tenant!");
}
}
}
};
private PaginatedRemover<TenantId, DashboardInfoEntity> tenantDashboardsRemover =
new PaginatedRemover<TenantId, DashboardInfoEntity>() {
private PaginatedRemover<TenantId, DashboardInfo> tenantDashboardsRemover =
new PaginatedRemover<TenantId, DashboardInfo>() {
@Override
protected List<DashboardInfoEntity> findEntities(TenantId id, TextPageLink pageLink) {
protected List<DashboardInfo> findEntities(TenantId id, TextPageLink pageLink) {
return dashboardInfoDao.findDashboardsByTenantId(id.getId(), pageLink);
}
@Override
protected void removeEntity(DashboardInfoEntity entity) {
deleteDashboard(new DashboardId(entity.getId()));
protected void removeEntity(DashboardInfo entity) {
deleteDashboard(new DashboardId(entity.getUuidId()));
}
};
class CustomerDashboardsUnassigner extends PaginatedRemover<CustomerId, DashboardInfoEntity> {
private class CustomerDashboardsUnassigner extends PaginatedRemover<CustomerId, DashboardInfo> {
private TenantId tenantId;
@ -210,13 +201,13 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
}
@Override
protected List<DashboardInfoEntity> findEntities(CustomerId id, TextPageLink pageLink) {
protected List<DashboardInfo> findEntities(CustomerId id, TextPageLink pageLink) {
return dashboardInfoDao.findDashboardsByTenantIdAndCustomerId(tenantId.getId(), id.getId(), pageLink);
}
@Override
protected void removeEntity(DashboardInfoEntity entity) {
unassignDashboardFromCustomer(new DashboardId(entity.getId()));
protected void removeEntity(DashboardInfo entity) {
unassignDashboardFromCustomer(new DashboardId(entity.getUuidId()));
}
}

40
dao/src/main/java/org/thingsboard/server/dao/device/DeviceCredentialsDaoImpl.java → dao/src/main/java/org/thingsboard/server/dao/device/CassandraDeviceCredentialsDao.java

@ -15,26 +15,25 @@
*/
package org.thingsboard.server.dao.device;
import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
import java.util.UUID;
import com.datastax.driver.core.querybuilder.Select.Where;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.thingsboard.server.common.data.security.DeviceCredentials;
import org.thingsboard.server.dao.AbstractModelDao;
import org.thingsboard.server.dao.model.DeviceCredentialsEntity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;
import com.datastax.driver.core.querybuilder.Select.Where;
import org.thingsboard.server.dao.nosql.CassandraAbstractModelDao;
import org.thingsboard.server.dao.DaoUtil;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.dao.model.nosql.DeviceCredentialsEntity;
import java.util.UUID;
import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
@Component
@Slf4j
public class DeviceCredentialsDaoImpl extends AbstractModelDao<DeviceCredentialsEntity> implements DeviceCredentialsDao {
@NoSqlDao
public class CassandraDeviceCredentialsDao extends CassandraAbstractModelDao<DeviceCredentialsEntity, DeviceCredentials> implements DeviceCredentialsDao {
@Override
protected Class<DeviceCredentialsEntity> getColumnFamilyClass() {
@ -47,31 +46,24 @@ public class DeviceCredentialsDaoImpl extends AbstractModelDao<DeviceCredentials
}
@Override
public DeviceCredentialsEntity findByDeviceId(UUID deviceId) {
public DeviceCredentials findByDeviceId(UUID deviceId) {
log.debug("Try to find device credentials by deviceId [{}] ", deviceId);
Where query = select().from(ModelConstants.DEVICE_CREDENTIALS_BY_DEVICE_COLUMN_FAMILY_NAME)
.where(eq(ModelConstants.DEVICE_CREDENTIALS_DEVICE_ID_PROPERTY, deviceId));
log.trace("Execute query {}", query);
DeviceCredentialsEntity deviceCredentialsEntity = findOneByStatement(query);
log.trace("Found device credentials [{}] by deviceId [{}]", deviceCredentialsEntity, deviceId);
return deviceCredentialsEntity;
return DaoUtil.getData(deviceCredentialsEntity);
}
@Override
public DeviceCredentialsEntity findByCredentialsId(String credentialsId) {
public DeviceCredentials findByCredentialsId(String credentialsId) {
log.debug("Try to find device credentials by credentialsId [{}] ", credentialsId);
Where query = select().from(ModelConstants.DEVICE_CREDENTIALS_BY_CREDENTIALS_ID_COLUMN_FAMILY_NAME)
.where(eq(ModelConstants.DEVICE_CREDENTIALS_CREDENTIALS_ID_PROPERTY, credentialsId));
log.trace("Execute query {}", query);
DeviceCredentialsEntity deviceCredentialsEntity = findOneByStatement(query);
log.trace("Found device credentials [{}] by credentialsId [{}]", deviceCredentialsEntity, credentialsId);
return deviceCredentialsEntity;
return DaoUtil.getData(deviceCredentialsEntity);
}
@Override
public DeviceCredentialsEntity save(DeviceCredentials deviceCredentials) {
log.debug("Save device credentials [{}] ", deviceCredentials);
return save(new DeviceCredentialsEntity(deviceCredentials));
}
}

78
dao/src/main/java/org/thingsboard/server/dao/device/DeviceDaoImpl.java → dao/src/main/java/org/thingsboard/server/dao/device/CassandraDeviceDao.java

@ -15,13 +15,6 @@
*/
package org.thingsboard.server.dao.device;
import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
import static com.datastax.driver.core.querybuilder.QueryBuilder.in;
import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
import static org.thingsboard.server.dao.model.ModelConstants.*;
import java.util.*;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.ResultSetFuture;
import com.datastax.driver.core.querybuilder.Select;
@ -32,18 +25,24 @@ import com.google.common.util.concurrent.ListenableFuture;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.thingsboard.server.common.data.Device;
import org.thingsboard.server.common.data.TenantDeviceType;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.AbstractSearchTextDao;
import org.thingsboard.server.dao.model.DeviceEntity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.thingsboard.server.dao.nosql.CassandraAbstractSearchTextDao;
import org.thingsboard.server.dao.DaoUtil;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.TenantDeviceTypeEntity;
import org.thingsboard.server.dao.model.nosql.DeviceEntity;
import javax.annotation.Nullable;
import java.util.*;
import static com.datastax.driver.core.querybuilder.QueryBuilder.*;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Component
@Slf4j
public class DeviceDaoImpl extends AbstractSearchTextDao<DeviceEntity> implements DeviceDao {
@NoSqlDao
public class CassandraDeviceDao extends CassandraAbstractSearchTextDao<DeviceEntity, Device> implements DeviceDao {
@Override
protected Class<DeviceEntity> getColumnFamilyClass() {
@ -56,33 +55,27 @@ public class DeviceDaoImpl extends AbstractSearchTextDao<DeviceEntity> implement
}
@Override
public DeviceEntity save(Device device) {
log.debug("Save device [{}] ", device);
return save(new DeviceEntity(device));
}
@Override
public List<DeviceEntity> findDevicesByTenantId(UUID tenantId, TextPageLink pageLink) {
public List<Device> findDevicesByTenantId(UUID tenantId, TextPageLink pageLink) {
log.debug("Try to find devices by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
List<DeviceEntity> deviceEntities = findPageWithTextSearch(DEVICE_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Collections.singletonList(eq(DEVICE_TENANT_ID_PROPERTY, tenantId)), pageLink);
log.trace("Found devices [{}] by tenantId [{}] and pageLink [{}]", deviceEntities, tenantId, pageLink);
return deviceEntities;
return DaoUtil.convertDataList(deviceEntities);
}
@Override
public List<DeviceEntity> findDevicesByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
public List<Device> findDevicesByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
log.debug("Try to find devices by tenantId [{}], type [{}] and pageLink [{}]", tenantId, type, pageLink);
List<DeviceEntity> deviceEntities = findPageWithTextSearch(DEVICE_BY_TENANT_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(DEVICE_TYPE_PROPERTY, type),
eq(DEVICE_TENANT_ID_PROPERTY, tenantId)), pageLink);
eq(DEVICE_TENANT_ID_PROPERTY, tenantId)), pageLink);
log.trace("Found devices [{}] by tenantId [{}], type [{}] and pageLink [{}]", deviceEntities, tenantId, type, pageLink);
return deviceEntities;
return DaoUtil.convertDataList(deviceEntities);
}
@Override
public ListenableFuture<List<DeviceEntity>> findDevicesByTenantIdAndIdsAsync(UUID tenantId, List<UUID> deviceIds) {
public ListenableFuture<List<Device>> findDevicesByTenantIdAndIdsAsync(UUID tenantId, List<UUID> deviceIds) {
log.debug("Try to find devices by tenantId [{}] and device Ids [{}]", tenantId, deviceIds);
Select select = select().from(getColumnFamilyName());
Select.Where query = select.where();
@ -92,32 +85,32 @@ public class DeviceDaoImpl extends AbstractSearchTextDao<DeviceEntity> implement
}
@Override
public List<DeviceEntity> findDevicesByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
log.debug("Try to find devices by tenantId [{}], customerId [{}] and pageLink [{}]", tenantId, customerId, pageLink);
public List<Device> findDevicesByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
log.debug("Try to find devices by tenantId [{}], customerId[{}] and pageLink [{}]", tenantId, customerId, pageLink);
List<DeviceEntity> deviceEntities = findPageWithTextSearch(DEVICE_BY_CUSTOMER_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(DEVICE_CUSTOMER_ID_PROPERTY, customerId),
eq(DEVICE_TENANT_ID_PROPERTY, tenantId)),
pageLink);
log.trace("Found devices [{}] by tenantId [{}], customerId [{}] and pageLink [{}]", deviceEntities, tenantId, customerId, pageLink);
return deviceEntities;
return DaoUtil.convertDataList(deviceEntities);
}
@Override
public List<DeviceEntity> findDevicesByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
public List<Device> findDevicesByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
log.debug("Try to find devices by tenantId [{}], customerId [{}], type [{}] and pageLink [{}]", tenantId, customerId, type, pageLink);
List<DeviceEntity> deviceEntities = findPageWithTextSearch(DEVICE_BY_CUSTOMER_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
Arrays.asList(eq(DEVICE_TYPE_PROPERTY, type),
eq(DEVICE_CUSTOMER_ID_PROPERTY, customerId),
eq(DEVICE_TENANT_ID_PROPERTY, tenantId)),
eq(DEVICE_CUSTOMER_ID_PROPERTY, customerId),
eq(DEVICE_TENANT_ID_PROPERTY, tenantId)),
pageLink);
log.trace("Found devices [{}] by tenantId [{}], customerId [{}], type [{}] and pageLink [{}]", deviceEntities, tenantId, customerId, type, pageLink);
return deviceEntities;
return DaoUtil.convertDataList(deviceEntities);
}
@Override
public ListenableFuture<List<DeviceEntity>> findDevicesByTenantIdCustomerIdAndIdsAsync(UUID tenantId, UUID customerId, List<UUID> deviceIds) {
public ListenableFuture<List<Device>> findDevicesByTenantIdCustomerIdAndIdsAsync(UUID tenantId, UUID customerId, List<UUID> deviceIds) {
log.debug("Try to find devices by tenantId [{}], customerId [{}] and device Ids [{}]", tenantId, customerId, deviceIds);
Select select = select().from(getColumnFamilyName());
Select.Where query = select.where();
@ -128,16 +121,16 @@ public class DeviceDaoImpl extends AbstractSearchTextDao<DeviceEntity> implement
}
@Override
public Optional<DeviceEntity> findDevicesByTenantIdAndName(UUID tenantId, String deviceName) {
public Optional<Device> findDeviceByTenantIdAndName(UUID tenantId, String deviceName) {
Select select = select().from(DEVICE_BY_TENANT_AND_NAME_VIEW_NAME);
Select.Where query = select.where();
query.and(eq(DEVICE_TENANT_ID_PROPERTY, tenantId));
query.and(eq(DEVICE_NAME_PROPERTY, deviceName));
return Optional.ofNullable(findOneByStatement(query));
return Optional.ofNullable(DaoUtil.getData(findOneByStatement(query)));
}
@Override
public ListenableFuture<List<TenantDeviceTypeEntity>> findTenantDeviceTypesAsync() {
public ListenableFuture<List<TenantDeviceType>> findTenantDeviceTypesAsync() {
Select statement = select().distinct().column(DEVICE_TYPE_PROPERTY).column(DEVICE_TENANT_ID_PROPERTY).from(DEVICE_TYPES_BY_TENANT_VIEW_NAME);
statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
ResultSetFuture resultSetFuture = getSession().executeAsync(statement);
@ -153,7 +146,20 @@ public class DeviceDaoImpl extends AbstractSearchTextDao<DeviceEntity> implement
}
}
});
return result;
return Futures.transform(result, new Function<List<TenantDeviceTypeEntity>, List<TenantDeviceType>>() {
@Nullable
@Override
public List<TenantDeviceType> apply(@Nullable List<TenantDeviceTypeEntity> entityList) {
List<TenantDeviceType> list = Collections.emptyList();
if (entityList != null && !entityList.isEmpty()) {
list = new ArrayList<>();
for (TenantDeviceTypeEntity object : entityList) {
list.add(object.toTenantDeviceType());
}
}
return list;
}
});
}
}

15
dao/src/main/java/org/thingsboard/server/dao/device/DeviceCredentialsDao.java

@ -15,18 +15,15 @@
*/
package org.thingsboard.server.dao.device;
import java.util.UUID;
import org.thingsboard.server.common.data.security.DeviceCredentials;
import org.thingsboard.server.dao.Dao;
import org.thingsboard.server.dao.model.DeviceCredentialsEntity;
import java.util.UUID;
/**
* The Interface DeviceCredentialsDao.
*
* @param <T> the generic type
*/
public interface DeviceCredentialsDao extends Dao<DeviceCredentialsEntity> {
public interface DeviceCredentialsDao extends Dao<DeviceCredentials> {
/**
* Save or update device credentials object
@ -34,7 +31,7 @@ public interface DeviceCredentialsDao extends Dao<DeviceCredentialsEntity> {
* @param deviceCredentials the device credentials object
* @return saved device credentials object
*/
DeviceCredentialsEntity save(DeviceCredentials deviceCredentials);
DeviceCredentials save(DeviceCredentials deviceCredentials);
/**
* Find device credentials by device id.
@ -42,7 +39,7 @@ public interface DeviceCredentialsDao extends Dao<DeviceCredentialsEntity> {
* @param deviceId the device id
* @return the device credentials object
*/
DeviceCredentialsEntity findByDeviceId(UUID deviceId);
DeviceCredentials findByDeviceId(UUID deviceId);
/**
* Find device credentials by credentials id.
@ -50,6 +47,6 @@ public interface DeviceCredentialsDao extends Dao<DeviceCredentialsEntity> {
* @param credentialsId the credentials id
* @return the device credentials object
*/
DeviceCredentialsEntity findByCredentialsId(String credentialsId);
DeviceCredentials findByCredentialsId(String credentialsId);
}

7
dao/src/main/java/org/thingsboard/server/dao/device/DeviceCredentialsService.java

@ -15,25 +15,18 @@
*/
package org.thingsboard.server.dao.device;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.thingsboard.server.common.data.id.DeviceId;
import org.thingsboard.server.common.data.security.DeviceCredentials;
import static org.thingsboard.server.common.data.CacheConstants.DEVICE_CREDENTIALS_CACHE;
public interface DeviceCredentialsService {
DeviceCredentials findDeviceCredentialsByDeviceId(DeviceId deviceId);
@Cacheable(cacheNames = DEVICE_CREDENTIALS_CACHE, unless="#result == null")
DeviceCredentials findDeviceCredentialsByCredentialsId(String credentialsId);
@CacheEvict(cacheNames = DEVICE_CREDENTIALS_CACHE, keyGenerator="previousDeviceCredentialsId", beforeInvocation = true)
DeviceCredentials updateDeviceCredentials(DeviceCredentials deviceCredentials);
DeviceCredentials createDeviceCredentials(DeviceCredentials deviceCredentials);
@CacheEvict(cacheNames = DEVICE_CREDENTIALS_CACHE, key="#deviceCredentials.credentialsId")
void deleteDeviceCredentials(DeviceCredentials deviceCredentials);
}

26
dao/src/main/java/org/thingsboard/server/dao/device/DeviceCredentialsServiceImpl.java

@ -18,6 +18,8 @@ package org.thingsboard.server.dao.device;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.thingsboard.server.common.data.Device;
@ -26,10 +28,9 @@ import org.thingsboard.server.common.data.security.DeviceCredentials;
import org.thingsboard.server.common.data.security.DeviceCredentialsType;
import org.thingsboard.server.dao.EncryptionUtil;
import org.thingsboard.server.dao.exception.DataValidationException;
import org.thingsboard.server.dao.model.DeviceCredentialsEntity;
import org.thingsboard.server.dao.service.DataValidator;
import static org.thingsboard.server.dao.DaoUtil.getData;
import static org.thingsboard.server.common.data.CacheConstants.DEVICE_CREDENTIALS_CACHE;
import static org.thingsboard.server.dao.service.Validator.validateId;
import static org.thingsboard.server.dao.service.Validator.validateString;
@ -47,19 +48,19 @@ public class DeviceCredentialsServiceImpl implements DeviceCredentialsService {
public DeviceCredentials findDeviceCredentialsByDeviceId(DeviceId deviceId) {
log.trace("Executing findDeviceCredentialsByDeviceId [{}]", deviceId);
validateId(deviceId, "Incorrect deviceId " + deviceId);
DeviceCredentialsEntity deviceCredentialsEntity = deviceCredentialsDao.findByDeviceId(deviceId.getId());
return getData(deviceCredentialsEntity);
return deviceCredentialsDao.findByDeviceId(deviceId.getId());
}
@Override
@Cacheable(cacheNames = DEVICE_CREDENTIALS_CACHE, unless="#result == null")
public DeviceCredentials findDeviceCredentialsByCredentialsId(String credentialsId) {
log.trace("Executing findDeviceCredentialsByCredentialsId [{}]", credentialsId);
validateString(credentialsId, "Incorrect credentialsId " + credentialsId);
DeviceCredentialsEntity deviceCredentialsEntity = deviceCredentialsDao.findByCredentialsId(credentialsId);
return getData(deviceCredentialsEntity);
return deviceCredentialsDao.findByCredentialsId(credentialsId);
}
@Override
@CacheEvict(cacheNames = DEVICE_CREDENTIALS_CACHE, keyGenerator="previousDeviceCredentialsId", beforeInvocation = true)
public DeviceCredentials updateDeviceCredentials(DeviceCredentials deviceCredentials) {
return saveOrUpdare(deviceCredentials);
}
@ -75,7 +76,7 @@ public class DeviceCredentialsServiceImpl implements DeviceCredentialsService {
}
log.trace("Executing updateDeviceCredentials [{}]", deviceCredentials);
credentialsValidator.validate(deviceCredentials);
return getData(deviceCredentialsDao.save(deviceCredentials));
return deviceCredentialsDao.save(deviceCredentials);
}
private void formatCertData(DeviceCredentials deviceCredentials) {
@ -86,6 +87,7 @@ public class DeviceCredentialsServiceImpl implements DeviceCredentialsService {
}
@Override
@CacheEvict(cacheNames = DEVICE_CREDENTIALS_CACHE, key="#deviceCredentials.credentialsId")
public void deleteDeviceCredentials(DeviceCredentials deviceCredentials) {
log.trace("Executing deleteDeviceCredentials [{}]", deviceCredentials);
deviceCredentialsDao.removeById(deviceCredentials.getUuidId());
@ -96,7 +98,7 @@ public class DeviceCredentialsServiceImpl implements DeviceCredentialsService {
@Override
protected void validateCreate(DeviceCredentials deviceCredentials) {
DeviceCredentialsEntity existingCredentialsEntity = deviceCredentialsDao.findByCredentialsId(deviceCredentials.getCredentialsId());
DeviceCredentials existingCredentialsEntity = deviceCredentialsDao.findByCredentialsId(deviceCredentials.getCredentialsId());
if (existingCredentialsEntity != null) {
throw new DataValidationException("Create of existent device credentials!");
}
@ -104,12 +106,12 @@ public class DeviceCredentialsServiceImpl implements DeviceCredentialsService {
@Override
protected void validateUpdate(DeviceCredentials deviceCredentials) {
DeviceCredentialsEntity existingCredentialsEntity = deviceCredentialsDao.findById(deviceCredentials.getUuidId());
if (existingCredentialsEntity == null) {
DeviceCredentials existingCredentials = deviceCredentialsDao.findById(deviceCredentials.getUuidId());
if (existingCredentials == null) {
throw new DataValidationException("Unable to update non-existent device credentials!");
}
DeviceCredentialsEntity sameCredentialsIdEntity = deviceCredentialsDao.findByCredentialsId(deviceCredentials.getCredentialsId());
if (sameCredentialsIdEntity != null && !sameCredentialsIdEntity.getId().equals(deviceCredentials.getUuidId())) {
DeviceCredentials sameCredentialsId = deviceCredentialsDao.findByCredentialsId(deviceCredentials.getCredentialsId());
if (sameCredentialsId != null && !sameCredentialsId.getUuidId().equals(deviceCredentials.getUuidId())) {
throw new DataValidationException("Specified credentials are already registered!");
}
}

30
dao/src/main/java/org/thingsboard/server/dao/device/DeviceDao.java

@ -15,22 +15,22 @@
*/
package org.thingsboard.server.dao.device;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import com.google.common.util.concurrent.ListenableFuture;
import org.thingsboard.server.common.data.Device;
import org.thingsboard.server.common.data.TenantDeviceType;
import org.thingsboard.server.common.data.page.TextPageLink;
import org.thingsboard.server.dao.Dao;
import org.thingsboard.server.dao.model.DeviceEntity;
import org.thingsboard.server.dao.model.TenantDeviceTypeEntity;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
/**
* The Interface DeviceDao.
*
*/
public interface DeviceDao extends Dao<DeviceEntity> {
public interface DeviceDao extends Dao<Device> {
/**
* Save or update device object
@ -38,7 +38,7 @@ public interface DeviceDao extends Dao<DeviceEntity> {
* @param device the device object
* @return saved device object
*/
DeviceEntity save(Device device);
Device save(Device device);
/**
* Find devices by tenantId and page link.
@ -47,7 +47,7 @@ public interface DeviceDao extends Dao<DeviceEntity> {
* @param pageLink the page link
* @return the list of device objects
*/
List<DeviceEntity> findDevicesByTenantId(UUID tenantId, TextPageLink pageLink);
List<Device> findDevicesByTenantId(UUID tenantId, TextPageLink pageLink);
/**
* Find devices by tenantId, type and page link.
@ -57,7 +57,7 @@ public interface DeviceDao extends Dao<DeviceEntity> {
* @param pageLink the page link
* @return the list of device objects
*/
List<DeviceEntity> findDevicesByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink);
List<Device> findDevicesByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink);
/**
* Find devices by tenantId and devices Ids.
@ -66,7 +66,7 @@ public interface DeviceDao extends Dao<DeviceEntity> {
* @param deviceIds the device Ids
* @return the list of device objects
*/
ListenableFuture<List<DeviceEntity>> findDevicesByTenantIdAndIdsAsync(UUID tenantId, List<UUID> deviceIds);
ListenableFuture<List<Device>> findDevicesByTenantIdAndIdsAsync(UUID tenantId, List<UUID> deviceIds);
/**
* Find devices by tenantId, customerId and page link.
@ -76,7 +76,7 @@ public interface DeviceDao extends Dao<DeviceEntity> {
* @param pageLink the page link
* @return the list of device objects
*/
List<DeviceEntity> findDevicesByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink);
List<Device> findDevicesByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink);
/**
* Find devices by tenantId, customerId, type and page link.
@ -87,7 +87,7 @@ public interface DeviceDao extends Dao<DeviceEntity> {
* @param pageLink the page link
* @return the list of device objects
*/
List<DeviceEntity> findDevicesByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink);
List<Device> findDevicesByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink);
/**
@ -98,7 +98,7 @@ public interface DeviceDao extends Dao<DeviceEntity> {
* @param deviceIds the device Ids
* @return the list of device objects
*/
ListenableFuture<List<DeviceEntity>> findDevicesByTenantIdCustomerIdAndIdsAsync(UUID tenantId, UUID customerId, List<UUID> deviceIds);
ListenableFuture<List<Device>> findDevicesByTenantIdCustomerIdAndIdsAsync(UUID tenantId, UUID customerId, List<UUID> deviceIds);
/**
* Find devices by tenantId and device name.
@ -107,12 +107,12 @@ public interface DeviceDao extends Dao<DeviceEntity> {
* @param name the device name
* @return the optional device object
*/
Optional<DeviceEntity> findDevicesByTenantIdAndName(UUID tenantId, String name);
Optional<Device> findDeviceByTenantIdAndName(UUID tenantId, String name);
/**
* Find tenants device types.
*
* @return the list of tenant device type objects
*/
ListenableFuture<List<TenantDeviceTypeEntity>> findTenantDeviceTypesAsync();
ListenableFuture<List<TenantDeviceType>> findTenantDeviceTypesAsync();
}

2
dao/src/main/java/org/thingsboard/server/dao/device/DeviceSearchQuery.java

@ -18,9 +18,9 @@ package org.thingsboard.server.dao.device;
import lombok.Data;
import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.relation.EntityRelation;
import org.thingsboard.server.dao.relation.RelationsSearchParameters;
import org.thingsboard.server.dao.relation.EntityRelationsQuery;
import org.thingsboard.server.dao.relation.EntityTypeFilter;
import org.thingsboard.server.dao.relation.RelationsSearchParameters;
import javax.annotation.Nullable;
import java.util.Collections;

97
dao/src/main/java/org/thingsboard/server/dao/device/DeviceServiceImpl.java

@ -24,9 +24,7 @@ import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.thingsboard.server.common.data.Device;
import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.TenantDeviceType;
import org.thingsboard.server.common.data.*;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.DeviceId;
import org.thingsboard.server.common.data.id.EntityId;
@ -39,20 +37,19 @@ import org.thingsboard.server.common.data.security.DeviceCredentialsType;
import org.thingsboard.server.dao.customer.CustomerDao;
import org.thingsboard.server.dao.entity.AbstractEntityService;
import org.thingsboard.server.dao.exception.DataValidationException;
import org.thingsboard.server.dao.model.CustomerEntity;
import org.thingsboard.server.dao.model.DeviceEntity;
import org.thingsboard.server.dao.model.TenantDeviceTypeEntity;
import org.thingsboard.server.dao.model.TenantEntity;
import org.thingsboard.server.dao.relation.EntitySearchDirection;
import org.thingsboard.server.dao.service.DataValidator;
import org.thingsboard.server.dao.service.PaginatedRemover;
import org.thingsboard.server.dao.tenant.TenantDao;
import javax.annotation.Nullable;
import java.util.*;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import static org.thingsboard.server.dao.DaoUtil.*;
import static org.thingsboard.server.dao.DaoUtil.toUUIDs;
import static org.thingsboard.server.dao.model.ModelConstants.NULL_UUID;
import static org.thingsboard.server.dao.service.Validator.*;
@ -76,25 +73,23 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
public Device findDeviceById(DeviceId deviceId) {
log.trace("Executing findDeviceById [{}]", deviceId);
validateId(deviceId, "Incorrect deviceId " + deviceId);
DeviceEntity deviceEntity = deviceDao.findById(deviceId.getId());
return getData(deviceEntity);
return deviceDao.findById(deviceId.getId());
}
@Override
public ListenableFuture<Device> findDeviceByIdAsync(DeviceId deviceId) {
log.trace("Executing findDeviceById [{}]", deviceId);
validateId(deviceId, "Incorrect deviceId " + deviceId);
ListenableFuture<DeviceEntity> deviceEntity = deviceDao.findByIdAsync(deviceId.getId());
return Futures.transform(deviceEntity, (Function<? super DeviceEntity, ? extends Device>) input -> getData(input));
return deviceDao.findByIdAsync(deviceId.getId());
}
@Override
public Optional<Device> findDeviceByTenantIdAndName(TenantId tenantId, String name) {
log.trace("Executing findDeviceByTenantIdAndName [{}][{}]", tenantId, name);
validateId(tenantId, "Incorrect tenantId " + tenantId);
Optional<DeviceEntity> deviceEntityOpt = deviceDao.findDevicesByTenantIdAndName(tenantId.getId(), name);
if (deviceEntityOpt.isPresent()) {
return Optional.of(getData(deviceEntityOpt.get()));
Optional<Device> deviceOpt = deviceDao.findDeviceByTenantIdAndName(tenantId.getId(), name);
if (deviceOpt.isPresent()) {
return Optional.of(deviceOpt.get());
} else {
return Optional.empty();
}
@ -104,15 +99,15 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
public Device saveDevice(Device device) {
log.trace("Executing saveDevice [{}]", device);
deviceValidator.validate(device);
DeviceEntity deviceEntity = deviceDao.save(device);
Device savedDevice = deviceDao.save(device);
if (device.getId() == null) {
DeviceCredentials deviceCredentials = new DeviceCredentials();
deviceCredentials.setDeviceId(new DeviceId(deviceEntity.getId()));
deviceCredentials.setDeviceId(new DeviceId(savedDevice.getUuidId()));
deviceCredentials.setCredentialsType(DeviceCredentialsType.ACCESS_TOKEN);
deviceCredentials.setCredentialsId(RandomStringUtils.randomAlphanumeric(20));
deviceCredentialsService.createDeviceCredentials(deviceCredentials);
}
return getData(deviceEntity);
return savedDevice;
}
@Override
@ -146,8 +141,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
log.trace("Executing findDevicesByTenantId, tenantId [{}], pageLink [{}]", tenantId, pageLink);
validateId(tenantId, "Incorrect tenantId " + tenantId);
validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<DeviceEntity> deviceEntities = deviceDao.findDevicesByTenantId(tenantId.getId(), pageLink);
List<Device> devices = convertDataList(deviceEntities);
List<Device> devices = deviceDao.findDevicesByTenantId(tenantId.getId(), pageLink);
return new TextPageData<>(devices, pageLink);
}
@ -157,8 +151,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateString(type, "Incorrect type " + type);
validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<DeviceEntity> deviceEntities = deviceDao.findDevicesByTenantIdAndType(tenantId.getId(), type, pageLink);
List<Device> devices = convertDataList(deviceEntities);
List<Device> devices = deviceDao.findDevicesByTenantIdAndType(tenantId.getId(), type, pageLink);
return new TextPageData<>(devices, pageLink);
}
@ -167,8 +160,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
log.trace("Executing findDevicesByTenantIdAndIdsAsync, tenantId [{}], deviceIds [{}]", tenantId, deviceIds);
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateIds(deviceIds, "Incorrect deviceIds " + deviceIds);
ListenableFuture<List<DeviceEntity>> deviceEntities = deviceDao.findDevicesByTenantIdAndIdsAsync(tenantId.getId(), toUUIDs(deviceIds));
return Futures.transform(deviceEntities, (Function<List<DeviceEntity>, List<Device>>) input -> convertDataList(input));
return deviceDao.findDevicesByTenantIdAndIdsAsync(tenantId.getId(), toUUIDs(deviceIds));
}
@ -176,7 +168,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
public void deleteDevicesByTenantId(TenantId tenantId) {
log.trace("Executing deleteDevicesByTenantId, tenantId [{}]", tenantId);
validateId(tenantId, "Incorrect tenantId " + tenantId);
tenantDevicesRemover.removeEntitites(tenantId);
tenantDevicesRemover.removeEntities(tenantId);
}
@Override
@ -185,8 +177,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateId(customerId, "Incorrect customerId " + customerId);
validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<DeviceEntity> deviceEntities = deviceDao.findDevicesByTenantIdAndCustomerId(tenantId.getId(), customerId.getId(), pageLink);
List<Device> devices = convertDataList(deviceEntities);
List<Device> devices = deviceDao.findDevicesByTenantIdAndCustomerId(tenantId.getId(), customerId.getId(), pageLink);
return new TextPageData<>(devices, pageLink);
}
@ -197,8 +188,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
validateId(customerId, "Incorrect customerId " + customerId);
validateString(type, "Incorrect type " + type);
validatePageLink(pageLink, "Incorrect page link " + pageLink);
List<DeviceEntity> deviceEntities = deviceDao.findDevicesByTenantIdAndCustomerIdAndType(tenantId.getId(), customerId.getId(), type, pageLink);
List<Device> devices = convertDataList(deviceEntities);
List<Device> devices = deviceDao.findDevicesByTenantIdAndCustomerIdAndType(tenantId.getId(), customerId.getId(), type, pageLink);
return new TextPageData<>(devices, pageLink);
}
@ -208,9 +198,8 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateId(customerId, "Incorrect customerId " + customerId);
validateIds(deviceIds, "Incorrect deviceIds " + deviceIds);
ListenableFuture<List<DeviceEntity>> deviceEntities = deviceDao.findDevicesByTenantIdCustomerIdAndIdsAsync(tenantId.getId(),
return deviceDao.findDevicesByTenantIdCustomerIdAndIdsAsync(tenantId.getId(),
customerId.getId(), toUUIDs(deviceIds));
return Futures.transform(deviceEntities, (Function<List<DeviceEntity>, List<Device>>) input -> convertDataList(input));
}
@Override
@ -218,7 +207,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
log.trace("Executing unassignCustomerDevices, tenantId [{}], customerId [{}]", tenantId, customerId);
validateId(tenantId, "Incorrect tenantId " + tenantId);
validateId(customerId, "Incorrect customerId " + customerId);
new CustomerDevicesUnassigner(tenantId).removeEntitites(customerId);
new CustomerDevicesUnassigner(tenantId).removeEntities(customerId);
}
@Override
@ -251,16 +240,16 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
public ListenableFuture<List<TenantDeviceType>> findDeviceTypesByTenantId(TenantId tenantId) {
log.trace("Executing findDeviceTypesByTenantId, tenantId [{}]", tenantId);
validateId(tenantId, "Incorrect tenantId " + tenantId);
ListenableFuture<List<TenantDeviceTypeEntity>> tenantDeviceTypeEntities = deviceDao.findTenantDeviceTypesAsync();
ListenableFuture<List<TenantDeviceType>> tenantDeviceTypeEntities = deviceDao.findTenantDeviceTypesAsync();
ListenableFuture<List<TenantDeviceType>> tenantDeviceTypes = Futures.transform(tenantDeviceTypeEntities,
(Function<List<TenantDeviceTypeEntity>, List<TenantDeviceType>>) deviceTypeEntities -> {
(Function<List<TenantDeviceType>, List<TenantDeviceType>>) deviceTypeEntities -> {
List<TenantDeviceType> deviceTypes = new ArrayList<>();
for (TenantDeviceTypeEntity deviceTypeEntity : deviceTypeEntities) {
if (deviceTypeEntity.getTenantId().equals(tenantId.getId())) {
deviceTypes.add(deviceTypeEntity.toTenantDeviceType());
for (TenantDeviceType deviceType : deviceTypeEntities) {
if (deviceType.getTenantId().equals(tenantId)) {
deviceTypes.add(deviceType);
}
}
deviceTypes.sort((TenantDeviceType o1, TenantDeviceType o2) -> o1.getType().compareTo(o2.getType()));
deviceTypes.sort(Comparator.comparing(TenantDeviceType::getType));
return deviceTypes;
});
return tenantDeviceTypes;
@ -271,7 +260,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
@Override
protected void validateCreate(Device device) {
deviceDao.findDevicesByTenantIdAndName(device.getTenantId().getId(), device.getName()).ifPresent(
deviceDao.findDeviceByTenantIdAndName(device.getTenantId().getId(), device.getName()).ifPresent(
d -> {
throw new DataValidationException("Device with such name already exists!");
}
@ -280,9 +269,9 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
@Override
protected void validateUpdate(Device device) {
deviceDao.findDevicesByTenantIdAndName(device.getTenantId().getId(), device.getName()).ifPresent(
deviceDao.findDeviceByTenantIdAndName(device.getTenantId().getId(), device.getName()).ifPresent(
d -> {
if (!d.getId().equals(device.getUuidId())) {
if (!d.getUuidId().equals(device.getUuidId())) {
throw new DataValidationException("Device with such name already exists!");
}
}
@ -300,7 +289,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
if (device.getTenantId() == null) {
throw new DataValidationException("Device should be assigned to tenant!");
} else {
TenantEntity tenant = tenantDao.findById(device.getTenantId().getId());
Tenant tenant = tenantDao.findById(device.getTenantId().getId());
if (tenant == null) {
throw new DataValidationException("Device is referencing to non-existent tenant!");
}
@ -308,32 +297,32 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
if (device.getCustomerId() == null) {
device.setCustomerId(new CustomerId(NULL_UUID));
} else if (!device.getCustomerId().getId().equals(NULL_UUID)) {
CustomerEntity customer = customerDao.findById(device.getCustomerId().getId());
Customer customer = customerDao.findById(device.getCustomerId().getId());
if (customer == null) {
throw new DataValidationException("Can't assign device to non-existent customer!");
}
if (!customer.getTenantId().equals(device.getTenantId().getId())) {
if (!customer.getTenantId().getId().equals(device.getTenantId().getId())) {
throw new DataValidationException("Can't assign device to customer from different tenant!");
}
}
}
};
private PaginatedRemover<TenantId, DeviceEntity> tenantDevicesRemover =
new PaginatedRemover<TenantId, DeviceEntity>() {
private PaginatedRemover<TenantId, Device> tenantDevicesRemover =
new PaginatedRemover<TenantId, Device>() {
@Override
protected List<DeviceEntity> findEntities(TenantId id, TextPageLink pageLink) {
protected List<Device> findEntities(TenantId id, TextPageLink pageLink) {
return deviceDao.findDevicesByTenantId(id.getId(), pageLink);
}
@Override
protected void removeEntity(DeviceEntity entity) {
deleteDevice(new DeviceId(entity.getId()));
protected void removeEntity(Device entity) {
deleteDevice(new DeviceId(entity.getUuidId()));
}
};
class CustomerDevicesUnassigner extends PaginatedRemover<CustomerId, DeviceEntity> {
private class CustomerDevicesUnassigner extends PaginatedRemover<CustomerId, Device> {
private TenantId tenantId;
@ -342,13 +331,13 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
}
@Override
protected List<DeviceEntity> findEntities(CustomerId id, TextPageLink pageLink) {
protected List<Device> findEntities(CustomerId id, TextPageLink pageLink) {
return deviceDao.findDevicesByTenantIdAndCustomerId(tenantId.getId(), id.getId(), pageLink);
}
@Override
protected void removeEntity(DeviceEntity entity) {
unassignDeviceFromCustomer(new DeviceId(entity.getId()));
protected void removeEntity(Device entity) {
unassignDeviceFromCustomer(new DeviceId(entity.getUuidId()));
}
}

46
dao/src/main/java/org/thingsboard/server/dao/event/BaseEventService.java

@ -15,51 +15,32 @@
*/
package org.thingsboard.server.dao.event;
import com.datastax.driver.core.utils.UUIDs;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.thingsboard.server.common.data.Event;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.id.EventId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.page.TimePageData;
import org.thingsboard.server.common.data.page.TimePageLink;
import org.thingsboard.server.dao.exception.DataValidationException;
import org.thingsboard.server.dao.model.EventEntity;
import org.thingsboard.server.dao.service.DataValidator;
import java.util.List;
import java.util.Optional;
import static org.thingsboard.server.dao.DaoUtil.convertDataList;
import static org.thingsboard.server.dao.DaoUtil.getData;
import static org.thingsboard.server.dao.model.ModelConstants.NULL_UUID;
@Service
@Slf4j
public class BaseEventService implements EventService {
private final TenantId systemTenantId = new TenantId(NULL_UUID);
@Autowired
public EventDao eventDao;
@Override
public Event save(Event event) {
eventValidator.validate(event);
if (event.getTenantId() == null) {
log.trace("Save system event with predefined id {}", systemTenantId);
event.setTenantId(systemTenantId);
}
if (event.getId() == null) {
event.setId(new EventId(UUIDs.timeBased()));
}
if (StringUtils.isEmpty(event.getUid())) {
event.setUid(event.getId().toString());
}
return getData(eventDao.save(event));
return eventDao.save(event);
}
@Override
@ -68,15 +49,7 @@ public class BaseEventService implements EventService {
if (StringUtils.isEmpty(event.getUid())) {
throw new DataValidationException("Event uid should be specified!.");
}
if (event.getTenantId() == null) {
log.trace("Save system event with predefined id {}", systemTenantId);
event.setTenantId(systemTenantId);
}
if (event.getId() == null) {
event.setId(new EventId(UUIDs.timeBased()));
}
Optional<EventEntity> result = eventDao.saveIfNotExists(event);
return result.isPresent() ? Optional.of(getData(result.get())) : Optional.empty();
return eventDao.saveIfNotExists(event);
}
@Override
@ -93,23 +66,20 @@ public class BaseEventService implements EventService {
if (StringUtils.isEmpty(eventUid)) {
throw new DataValidationException("Event uid should be specified!.");
}
EventEntity entity = eventDao.findEvent(tenantId.getId(), entityId, eventType, eventUid);
return entity != null ? Optional.of(getData(entity)) : Optional.empty();
Event event = eventDao.findEvent(tenantId.getId(), entityId, eventType, eventUid);
return event != null ? Optional.of(event) : Optional.empty();
}
@Override
public TimePageData<Event> findEvents(TenantId tenantId, EntityId entityId, TimePageLink pageLink) {
List<EventEntity> entities = eventDao.findEvents(tenantId.getId(), entityId, pageLink);
List<Event> events = convertDataList(entities);
return new TimePageData<Event>(events, pageLink);
List<Event> events = eventDao.findEvents(tenantId.getId(), entityId, pageLink);
return new TimePageData<>(events, pageLink);
}
@Override
public TimePageData<Event> findEvents(TenantId tenantId, EntityId entityId, String eventType, TimePageLink pageLink) {
List<EventEntity> entities = eventDao.findEvents(tenantId.getId(), entityId, eventType, pageLink);
List<Event> events = convertDataList(entities);
return new TimePageData<Event>(events, pageLink);
List<Event> events = eventDao.findEvents(tenantId.getId(), entityId, eventType, pageLink);
return new TimePageData<>(events, pageLink);
}
private DataValidator<Event> eventValidator =

57
dao/src/main/java/org/thingsboard/server/dao/event/BaseEventDao.java → dao/src/main/java/org/thingsboard/server/dao/event/CassandraBaseEventDao.java

@ -21,13 +21,18 @@ import com.datastax.driver.core.querybuilder.QueryBuilder;
import com.datastax.driver.core.querybuilder.Select;
import com.datastax.driver.core.utils.UUIDs;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import org.thingsboard.server.common.data.Event;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.id.EventId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.page.TimePageLink;
import org.thingsboard.server.dao.AbstractSearchTimeDao;
import org.thingsboard.server.dao.model.EventEntity;
import org.thingsboard.server.dao.nosql.CassandraAbstractSearchTimeDao;
import org.thingsboard.server.dao.DaoUtil;
import org.thingsboard.server.dao.util.NoSqlDao;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.dao.model.nosql.EventEntity;
import java.util.Arrays;
import java.util.List;
@ -36,13 +41,14 @@ import java.util.UUID;
import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
import static org.thingsboard.server.dao.model.ModelConstants.EVENT_BY_ID_VIEW_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.EVENT_BY_TYPE_AND_ID_VIEW_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.EVENT_COLUMN_FAMILY_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Component
@Slf4j
public class BaseEventDao extends AbstractSearchTimeDao<EventEntity> implements EventDao {
@NoSqlDao
public class CassandraBaseEventDao extends CassandraAbstractSearchTimeDao<EventEntity, Event> implements EventDao {
private final TenantId systemTenantId = new TenantId(NULL_UUID);
@Override
protected Class<EventEntity> getColumnFamilyClass() {
@ -55,18 +61,35 @@ public class BaseEventDao extends AbstractSearchTimeDao<EventEntity> implements
}
@Override
public EventEntity save(Event event) {
public Event save(Event event) {
log.debug("Save event [{}] ", event);
if (event.getTenantId() == null) {
log.trace("Save system event with predefined id {}", systemTenantId);
event.setTenantId(systemTenantId);
}
if (event.getId() == null) {
event.setId(new EventId(UUIDs.timeBased()));
}
if (StringUtils.isEmpty(event.getUid())) {
event.setUid(event.getId().toString());
}
return save(new EventEntity(event), false).orElse(null);
}
@Override
public Optional<EventEntity> saveIfNotExists(Event event) {
public Optional<Event> saveIfNotExists(Event event) {
if (event.getTenantId() == null) {
log.trace("Save system event with predefined id {}", systemTenantId);
event.setTenantId(systemTenantId);
}
if (event.getId() == null) {
event.setId(new EventId(UUIDs.timeBased()));
}
return save(new EventEntity(event), true);
}
@Override
public EventEntity findEvent(UUID tenantId, EntityId entityId, String eventType, String eventUid) {
public Event findEvent(UUID tenantId, EntityId entityId, String eventType, String eventUid) {
log.debug("Search event entity by [{}][{}][{}][{}]", tenantId, entityId, eventType, eventUid);
Select.Where query = select().from(getColumnFamilyName()).where(
eq(ModelConstants.EVENT_TENANT_ID_PROPERTY, tenantId))
@ -81,11 +104,11 @@ public class BaseEventDao extends AbstractSearchTimeDao<EventEntity> implements
} else {
log.debug("Search result: [{}]", entity != null);
}
return entity;
return DaoUtil.getData(entity);
}
@Override
public List<EventEntity> findEvents(UUID tenantId, EntityId entityId, TimePageLink pageLink) {
public List<Event> findEvents(UUID tenantId, EntityId entityId, TimePageLink pageLink) {
log.trace("Try to find events by tenant [{}], entity [{}]and pageLink [{}]", tenantId, entityId, pageLink);
List<EventEntity> entities = findPageWithTimeSearch(EVENT_BY_ID_VIEW_NAME,
Arrays.asList(eq(ModelConstants.EVENT_TENANT_ID_PROPERTY, tenantId),
@ -93,11 +116,11 @@ public class BaseEventDao extends AbstractSearchTimeDao<EventEntity> implements
eq(ModelConstants.EVENT_ENTITY_ID_PROPERTY, entityId.getId())),
pageLink);
log.trace("Found events by tenant [{}], entity [{}] and pageLink [{}]", tenantId, entityId, pageLink);
return entities;
return DaoUtil.convertDataList(entities);
}
@Override
public List<EventEntity> findEvents(UUID tenantId, EntityId entityId, String eventType, TimePageLink pageLink) {
public List<Event> findEvents(UUID tenantId, EntityId entityId, String eventType, TimePageLink pageLink) {
log.trace("Try to find events by tenant [{}], entity [{}], type [{}] and pageLink [{}]", tenantId, entityId, eventType, pageLink);
List<EventEntity> entities = findPageWithTimeSearch(EVENT_BY_TYPE_AND_ID_VIEW_NAME,
Arrays.asList(eq(ModelConstants.EVENT_TENANT_ID_PROPERTY, tenantId),
@ -108,10 +131,10 @@ public class BaseEventDao extends AbstractSearchTimeDao<EventEntity> implements
QueryBuilder.desc(ModelConstants.EVENT_TYPE_PROPERTY),
pageLink);
log.trace("Found events by tenant [{}], entity [{}], type [{}] and pageLink [{}]", tenantId, entityId, eventType, pageLink);
return entities;
return DaoUtil.convertDataList(entities);
}
private Optional<EventEntity> save(EventEntity entity, boolean ifNotExists) {
private Optional<Event> save(EventEntity entity, boolean ifNotExists) {
if (entity.getId() == null) {
entity.setId(UUIDs.timeBased());
}
@ -121,14 +144,14 @@ public class BaseEventDao extends AbstractSearchTimeDao<EventEntity> implements
.value(ModelConstants.EVENT_ENTITY_TYPE_PROPERTY, entity.getEntityType())
.value(ModelConstants.EVENT_ENTITY_ID_PROPERTY, entity.getEntityId())
.value(ModelConstants.EVENT_TYPE_PROPERTY, entity.getEventType())
.value(ModelConstants.EVENT_UID_PROPERTY, entity.getEventUId())
.value(ModelConstants.EVENT_UID_PROPERTY, entity.getEventUid())
.value(ModelConstants.EVENT_BODY_PROPERTY, entity.getBody());
if (ifNotExists) {
insert = insert.ifNotExists();
}
ResultSet rs = executeWrite(insert);
if (rs.wasApplied()) {
return Optional.of(entity);
return Optional.of(DaoUtil.getData(entity));
} else {
return Optional.empty();
}

15
dao/src/main/java/org/thingsboard/server/dao/event/EventDao.java

@ -19,7 +19,6 @@ import org.thingsboard.server.common.data.Event;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.page.TimePageLink;
import org.thingsboard.server.dao.Dao;
import org.thingsboard.server.dao.model.EventEntity;
import java.util.List;
import java.util.Optional;
@ -27,10 +26,8 @@ import java.util.UUID;
/**
* The Interface DeviceDao.
*
* @param <T> the generic type
*/
public interface EventDao extends Dao<EventEntity> {
public interface EventDao extends Dao<Event> {
/**
* Save or update event object
@ -38,7 +35,7 @@ public interface EventDao extends Dao<EventEntity> {
* @param event the event object
* @return saved event object
*/
EventEntity save(Event event);
Event save(Event event);
/**
* Save event object if it is not yet saved
@ -46,7 +43,7 @@ public interface EventDao extends Dao<EventEntity> {
* @param event the event object
* @return saved event object
*/
Optional<EventEntity> saveIfNotExists(Event event);
Optional<Event> saveIfNotExists(Event event);
/**
* Find event by tenantId, entityId and eventUid.
@ -57,7 +54,7 @@ public interface EventDao extends Dao<EventEntity> {
* @param eventUid the eventUid
* @return the event
*/
EventEntity findEvent(UUID tenantId, EntityId entityId, String eventType, String eventUid);
Event findEvent(UUID tenantId, EntityId entityId, String eventType, String eventUid);
/**
* Find events by tenantId, entityId and pageLink.
@ -67,7 +64,7 @@ public interface EventDao extends Dao<EventEntity> {
* @param pageLink the pageLink
* @return the event list
*/
List<EventEntity> findEvents(UUID tenantId, EntityId entityId, TimePageLink pageLink);
List<Event> findEvents(UUID tenantId, EntityId entityId, TimePageLink pageLink);
/**
* Find events by tenantId, entityId, eventType and pageLink.
@ -78,5 +75,5 @@ public interface EventDao extends Dao<EventEntity> {
* @param pageLink the pageLink
* @return the event list
*/
List<EventEntity> findEvents(UUID tenantId, EntityId entityId, String eventType, TimePageLink pageLink);
List<Event> findEvents(UUID tenantId, EntityId entityId, String eventType, TimePageLink pageLink);
}

1
dao/src/main/java/org/thingsboard/server/dao/event/EventService.java

@ -21,7 +21,6 @@ import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.page.TimePageData;
import org.thingsboard.server.common.data.page.TimePageLink;
import java.util.List;
import java.util.Optional;
public interface EventService {

26
dao/src/main/java/org/thingsboard/server/dao/exception/DatabaseException.java

@ -17,22 +17,22 @@ package org.thingsboard.server.dao.exception;
public class DatabaseException extends RuntimeException {
private static final long serialVersionUID = 3463762014441887103L;
private static final long serialVersionUID = 3463762014441887103L;
public DatabaseException() {
super();
}
public DatabaseException() {
super();
}
public DatabaseException(String message, Throwable cause) {
super(message, cause);
}
public DatabaseException(String message, Throwable cause) {
super(message, cause);
}
public DatabaseException(String message) {
super(message);
}
public DatabaseException(String message) {
super(message);
}
public DatabaseException(Throwable cause) {
super(cause);
}
public DatabaseException(Throwable cause) {
super(cause);
}
}

4
dao/src/main/java/org/thingsboard/server/dao/exception/IncorrectParameterException.java

@ -18,9 +18,9 @@ package org.thingsboard.server.dao.exception;
public class IncorrectParameterException extends RuntimeException {
private static final long serialVersionUID = 601995650578985289L;
private static final long serialVersionUID = 601995650578985289L;
public IncorrectParameterException(String message) {
public IncorrectParameterException(String message) {
super(message);
}

25
dao/src/main/java/org/thingsboard/server/dao/model/ModelConstants.java

@ -33,7 +33,7 @@ public class ModelConstants {
*/
public static final String ID_PROPERTY = "id";
public static final String USER_ID_PROPERTY = "user_id";
public static final String TENTANT_ID_PROPERTY = "tenant_id";
public static final String TENANT_ID_PROPERTY = "tenant_id";
public static final String CUSTOMER_ID_PROPERTY = "customer_id";
public static final String DEVICE_ID_PROPERTY = "device_id";
public static final String TITLE_PROPERTY = "title";
@ -45,7 +45,8 @@ public class ModelConstants {
* Cassandra user constants.
*/
public static final String USER_COLUMN_FAMILY_NAME = "user";
public static final String USER_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String USER_PG_HIBERNATE_COLUMN_FAMILY_NAME = "tb_user";
public static final String USER_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String USER_CUSTOMER_ID_PROPERTY = CUSTOMER_ID_PROPERTY;
public static final String USER_EMAIL_PROPERTY = "email";
public static final String USER_AUTHORITY_PROPERTY = "authority";
@ -106,7 +107,7 @@ public class ModelConstants {
* Cassandra customer constants.
*/
public static final String CUSTOMER_COLUMN_FAMILY_NAME = "customer";
public static final String CUSTOMER_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String CUSTOMER_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String CUSTOMER_TITLE_PROPERTY = TITLE_PROPERTY;
public static final String CUSTOMER_ADDITIONAL_INFO_PROPERTY = ADDITIONAL_INFO_PROPERTY;
@ -117,7 +118,7 @@ public class ModelConstants {
* Cassandra device constants.
*/
public static final String DEVICE_COLUMN_FAMILY_NAME = "device";
public static final String DEVICE_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String DEVICE_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String DEVICE_CUSTOMER_ID_PROPERTY = CUSTOMER_ID_PROPERTY;
public static final String DEVICE_NAME_PROPERTY = "name";
public static final String DEVICE_TYPE_PROPERTY = "type";
@ -134,7 +135,7 @@ public class ModelConstants {
* Cassandra asset constants.
*/
public static final String ASSET_COLUMN_FAMILY_NAME = "asset";
public static final String ASSET_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String ASSET_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String ASSET_CUSTOMER_ID_PROPERTY = CUSTOMER_ID_PROPERTY;
public static final String ASSET_NAME_PROPERTY = "name";
public static final String ASSET_TYPE_PROPERTY = "type";
@ -151,7 +152,7 @@ public class ModelConstants {
* Cassandra alarm constants.
*/
public static final String ALARM_COLUMN_FAMILY_NAME = "alarm";
public static final String ALARM_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String ALARM_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String ALARM_TYPE_PROPERTY = "type";
public static final String ALARM_DETAILS_PROPERTY = "details";
public static final String ALARM_ORIGINATOR_ID_PROPERTY = "originator_id";
@ -197,7 +198,7 @@ public class ModelConstants {
* Cassandra widgets_bundle constants.
*/
public static final String WIDGETS_BUNDLE_COLUMN_FAMILY_NAME = "widgets_bundle";
public static final String WIDGETS_BUNDLE_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String WIDGETS_BUNDLE_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String WIDGETS_BUNDLE_ALIAS_PROPERTY = ALIAS_PROPERTY;
public static final String WIDGETS_BUNDLE_TITLE_PROPERTY = TITLE_PROPERTY;
public static final String WIDGETS_BUNDLE_IMAGE_PROPERTY = "image";
@ -209,7 +210,7 @@ public class ModelConstants {
* Cassandra widget_type constants.
*/
public static final String WIDGET_TYPE_COLUMN_FAMILY_NAME = "widget_type";
public static final String WIDGET_TYPE_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String WIDGET_TYPE_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String WIDGET_TYPE_BUNDLE_ALIAS_PROPERTY = "bundle_alias";
public static final String WIDGET_TYPE_ALIAS_PROPERTY = ALIAS_PROPERTY;
public static final String WIDGET_TYPE_NAME_PROPERTY = "name";
@ -221,7 +222,7 @@ public class ModelConstants {
* Cassandra dashboard constants.
*/
public static final String DASHBOARD_COLUMN_FAMILY_NAME = "dashboard";
public static final String DASHBOARD_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String DASHBOARD_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String DASHBOARD_CUSTOMER_ID_PROPERTY = CUSTOMER_ID_PROPERTY;
public static final String DASHBOARD_TITLE_PROPERTY = TITLE_PROPERTY;
public static final String DASHBOARD_CONFIGURATION_PROPERTY = "configuration";
@ -234,7 +235,7 @@ public class ModelConstants {
* Cassandra plugin metadata constants.
*/
public static final String PLUGIN_COLUMN_FAMILY_NAME = "plugin";
public static final String PLUGIN_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String PLUGIN_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String PLUGIN_NAME_PROPERTY = "name";
public static final String PLUGIN_API_TOKEN_PROPERTY = "api_token";
public static final String PLUGIN_CLASS_PROPERTY = "plugin_class";
@ -264,7 +265,7 @@ public class ModelConstants {
* Cassandra rule metadata constants.
*/
public static final String RULE_COLUMN_FAMILY_NAME = "rule";
public static final String RULE_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String RULE_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String RULE_NAME_PROPERTY = "name";
public static final String RULE_STATE_PROPERTY = "state";
public static final String RULE_WEIGHT_PROPERTY = "weight";
@ -280,7 +281,7 @@ public class ModelConstants {
* Cassandra event constants.
*/
public static final String EVENT_COLUMN_FAMILY_NAME = "event";
public static final String EVENT_TENANT_ID_PROPERTY = TENTANT_ID_PROPERTY;
public static final String EVENT_TENANT_ID_PROPERTY = TENANT_ID_PROPERTY;
public static final String EVENT_TYPE_PROPERTY = "event_type";
public static final String EVENT_UID_PROPERTY = "event_uid";
public static final String EVENT_ENTITY_TYPE_PROPERTY = "entity_type";

3
dao/src/main/java/org/thingsboard/server/dao/model/AdminSettingsEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/AdminSettingsEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import static org.thingsboard.server.dao.model.ModelConstants.ADMIN_SETTINGS_COLUMN_FAMILY_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.ADMIN_SETTINGS_JSON_VALUE_PROPERTY;
@ -24,6 +24,7 @@ import java.util.UUID;
import org.thingsboard.server.common.data.AdminSettings;
import org.thingsboard.server.common.data.id.AdminSettingsId;
import org.thingsboard.server.dao.model.BaseEntity;
import org.thingsboard.server.dao.model.type.JsonCodec;
import com.datastax.driver.core.utils.UUIDs;

3
dao/src/main/java/org/thingsboard/server/dao/model/AlarmEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/AlarmEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import com.datastax.driver.core.utils.UUIDs;
import com.datastax.driver.mapping.annotations.*;
@ -25,6 +25,7 @@ import org.thingsboard.server.common.data.alarm.AlarmSeverity;
import org.thingsboard.server.common.data.alarm.AlarmStatus;
import org.thingsboard.server.common.data.id.EntityIdFactory;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.BaseEntity;
import org.thingsboard.server.dao.model.type.AlarmSeverityCodec;
import org.thingsboard.server.dao.model.type.AlarmStatusCodec;
import org.thingsboard.server.dao.model.type.EntityTypeCodec;

3
dao/src/main/java/org/thingsboard/server/dao/model/AssetEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/AssetEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import com.datastax.driver.core.utils.UUIDs;
import com.datastax.driver.mapping.annotations.Column;
@ -25,6 +25,7 @@ import org.thingsboard.server.common.data.asset.Asset;
import org.thingsboard.server.common.data.id.AssetId;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.model.type.JsonCodec;
import java.util.UUID;

23
dao/src/main/java/org/thingsboard/server/dao/model/ComponentDescriptorEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/ComponentDescriptorEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import com.datastax.driver.mapping.annotations.Column;
import com.datastax.driver.mapping.annotations.PartitionKey;
@ -23,41 +23,44 @@ import org.thingsboard.server.common.data.id.ComponentDescriptorId;
import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
import org.thingsboard.server.common.data.plugin.ComponentScope;
import org.thingsboard.server.common.data.plugin.ComponentType;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.model.type.JsonCodec;
import java.util.UUID;
import static org.thingsboard.server.dao.model.ModelConstants.*;
/**
* @author Andrew Shvayka
*/
@Table(name = ModelConstants.COMPONENT_DESCRIPTOR_COLUMN_FAMILY_NAME)
@Table(name = COMPONENT_DESCRIPTOR_COLUMN_FAMILY_NAME)
public class ComponentDescriptorEntity implements SearchTextEntity<ComponentDescriptor> {
private static final long serialVersionUID = 1L;
@PartitionKey
@Column(name = ModelConstants.ID_PROPERTY)
@Column(name = ID_PROPERTY)
private UUID id;
@Column(name = ModelConstants.COMPONENT_DESCRIPTOR_TYPE_PROPERTY)
@Column(name = COMPONENT_DESCRIPTOR_TYPE_PROPERTY)
private ComponentType type;
@Column(name = ModelConstants.COMPONENT_DESCRIPTOR_SCOPE_PROPERTY)
@Column(name = COMPONENT_DESCRIPTOR_SCOPE_PROPERTY)
private ComponentScope scope;
@Column(name = ModelConstants.COMPONENT_DESCRIPTOR_NAME_PROPERTY)
@Column(name = COMPONENT_DESCRIPTOR_NAME_PROPERTY)
private String name;
@Column(name = ModelConstants.COMPONENT_DESCRIPTOR_CLASS_PROPERTY)
@Column(name = COMPONENT_DESCRIPTOR_CLASS_PROPERTY)
private String clazz;
@Column(name = ModelConstants.COMPONENT_DESCRIPTOR_CONFIGURATION_DESCRIPTOR_PROPERTY, codec = JsonCodec.class)
@Column(name = COMPONENT_DESCRIPTOR_CONFIGURATION_DESCRIPTOR_PROPERTY, codec = JsonCodec.class)
private JsonNode configurationDescriptor;
@Column(name = ModelConstants.COMPONENT_DESCRIPTOR_ACTIONS_PROPERTY)
@Column(name = COMPONENT_DESCRIPTOR_ACTIONS_PROPERTY)
private String actions;
@Column(name = ModelConstants.SEARCH_TEXT_PROPERTY)
@Column(name = SEARCH_TEXT_PROPERTY)
private String searchText;
public ComponentDescriptorEntity() {

20
dao/src/main/java/org/thingsboard/server/dao/model/CustomerEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/CustomerEntity.java

@ -13,28 +13,14 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
import static org.thingsboard.server.dao.model.ModelConstants.ADDRESS2_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.ADDRESS_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.CITY_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.COUNTRY_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_ADDITIONAL_INFO_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_COLUMN_FAMILY_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_TENANT_ID_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_TITLE_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.EMAIL_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.ID_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.PHONE_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.SEARCH_TEXT_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.STATE_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.ZIP_PROPERTY;
package org.thingsboard.server.dao.model.nosql;
import java.util.UUID;
import org.thingsboard.server.common.data.Customer;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.model.type.JsonCodec;
import com.datastax.driver.core.utils.UUIDs;
@ -44,6 +30,8 @@ import com.datastax.driver.mapping.annotations.Table;
import com.datastax.driver.mapping.annotations.Transient;
import com.fasterxml.jackson.databind.JsonNode;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Table(name = CUSTOMER_COLUMN_FAMILY_NAME)
public final class CustomerEntity implements SearchTextEntity<Customer> {

19
dao/src/main/java/org/thingsboard/server/dao/model/DashboardEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/DashboardEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import java.util.UUID;
@ -21,6 +21,7 @@ import org.thingsboard.server.common.data.Dashboard;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.DashboardId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.model.type.JsonCodec;
import com.datastax.driver.core.utils.UUIDs;
@ -30,31 +31,33 @@ import com.datastax.driver.mapping.annotations.Table;
import com.datastax.driver.mapping.annotations.Transient;
import com.fasterxml.jackson.databind.JsonNode;
@Table(name = ModelConstants.DASHBOARD_COLUMN_FAMILY_NAME)
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Table(name = DASHBOARD_COLUMN_FAMILY_NAME)
public final class DashboardEntity implements SearchTextEntity<Dashboard> {
@Transient
private static final long serialVersionUID = 2998395951247446191L;
@PartitionKey(value = 0)
@Column(name = ModelConstants.ID_PROPERTY)
@Column(name = ID_PROPERTY)
private UUID id;
@PartitionKey(value = 1)
@Column(name = ModelConstants.DASHBOARD_TENANT_ID_PROPERTY)
@Column(name = DASHBOARD_TENANT_ID_PROPERTY)
private UUID tenantId;
@PartitionKey(value = 2)
@Column(name = ModelConstants.DASHBOARD_CUSTOMER_ID_PROPERTY)
@Column(name = DASHBOARD_CUSTOMER_ID_PROPERTY)
private UUID customerId;
@Column(name = ModelConstants.DASHBOARD_TITLE_PROPERTY)
@Column(name = DASHBOARD_TITLE_PROPERTY)
private String title;
@Column(name = ModelConstants.SEARCH_TEXT_PROPERTY)
@Column(name = SEARCH_TEXT_PROPERTY)
private String searchText;
@Column(name = ModelConstants.DASHBOARD_CONFIGURATION_PROPERTY, codec = JsonCodec.class)
@Column(name = DASHBOARD_CONFIGURATION_PROPERTY, codec = JsonCodec.class)
private JsonNode configuration;
public DashboardEntity() {

20
dao/src/main/java/org/thingsboard/server/dao/model/DashboardInfoEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/DashboardInfoEntity.java

@ -13,46 +13,46 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import java.util.UUID;
import org.thingsboard.server.common.data.Dashboard;
import org.thingsboard.server.common.data.DashboardInfo;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.DashboardId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.type.JsonCodec;
import org.thingsboard.server.dao.model.SearchTextEntity;
import com.datastax.driver.core.utils.UUIDs;
import com.datastax.driver.mapping.annotations.Column;
import com.datastax.driver.mapping.annotations.PartitionKey;
import com.datastax.driver.mapping.annotations.Table;
import com.datastax.driver.mapping.annotations.Transient;
import com.fasterxml.jackson.databind.JsonNode;
@Table(name = ModelConstants.DASHBOARD_COLUMN_FAMILY_NAME)
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Table(name = DASHBOARD_COLUMN_FAMILY_NAME)
public class DashboardInfoEntity implements SearchTextEntity<DashboardInfo> {
@Transient
private static final long serialVersionUID = 2998395951247446191L;
@PartitionKey(value = 0)
@Column(name = ModelConstants.ID_PROPERTY)
@Column(name = ID_PROPERTY)
private UUID id;
@PartitionKey(value = 1)
@Column(name = ModelConstants.DASHBOARD_TENANT_ID_PROPERTY)
@Column(name = DASHBOARD_TENANT_ID_PROPERTY)
private UUID tenantId;
@PartitionKey(value = 2)
@Column(name = ModelConstants.DASHBOARD_CUSTOMER_ID_PROPERTY)
@Column(name = DASHBOARD_CUSTOMER_ID_PROPERTY)
private UUID customerId;
@Column(name = ModelConstants.DASHBOARD_TITLE_PROPERTY)
@Column(name = DASHBOARD_TITLE_PROPERTY)
private String title;
@Column(name = ModelConstants.SEARCH_TEXT_PROPERTY)
@Column(name = SEARCH_TEXT_PROPERTY)
private String searchText;
public DashboardInfoEntity() {

17
dao/src/main/java/org/thingsboard/server/dao/model/DeviceCredentialsEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/DeviceCredentialsEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import java.util.UUID;
@ -21,6 +21,7 @@ import org.thingsboard.server.common.data.id.DeviceCredentialsId;
import org.thingsboard.server.common.data.id.DeviceId;
import org.thingsboard.server.common.data.security.DeviceCredentials;
import org.thingsboard.server.common.data.security.DeviceCredentialsType;
import org.thingsboard.server.dao.model.BaseEntity;
import org.thingsboard.server.dao.model.type.DeviceCredentialsTypeCodec;
import com.datastax.driver.core.utils.UUIDs;
@ -29,26 +30,28 @@ import com.datastax.driver.mapping.annotations.PartitionKey;
import com.datastax.driver.mapping.annotations.Table;
import com.datastax.driver.mapping.annotations.Transient;
@Table(name = ModelConstants.DEVICE_CREDENTIALS_COLUMN_FAMILY_NAME)
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Table(name = DEVICE_CREDENTIALS_COLUMN_FAMILY_NAME)
public final class DeviceCredentialsEntity implements BaseEntity<DeviceCredentials> {
@Transient
private static final long serialVersionUID = -2667310560260623272L;
@PartitionKey(value = 0)
@Column(name = ModelConstants.ID_PROPERTY)
@Column(name = ID_PROPERTY)
private UUID id;
@Column(name = ModelConstants.DEVICE_CREDENTIALS_DEVICE_ID_PROPERTY)
@Column(name = DEVICE_CREDENTIALS_DEVICE_ID_PROPERTY)
private UUID deviceId;
@Column(name = ModelConstants.DEVICE_CREDENTIALS_CREDENTIALS_TYPE_PROPERTY, codec = DeviceCredentialsTypeCodec.class)
@Column(name = DEVICE_CREDENTIALS_CREDENTIALS_TYPE_PROPERTY, codec = DeviceCredentialsTypeCodec.class)
private DeviceCredentialsType credentialsType;
@Column(name = ModelConstants.DEVICE_CREDENTIALS_CREDENTIALS_ID_PROPERTY)
@Column(name = DEVICE_CREDENTIALS_CREDENTIALS_ID_PROPERTY)
private String credentialsId;
@Column(name = ModelConstants.DEVICE_CREDENTIALS_CREDENTIALS_VALUE_PROPERTY)
@Column(name = DEVICE_CREDENTIALS_CREDENTIALS_VALUE_PROPERTY)
private String credentialsValue;
public DeviceCredentialsEntity() {

7
dao/src/main/java/org/thingsboard/server/dao/model/DeviceEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/DeviceEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import com.datastax.driver.core.utils.UUIDs;
import com.datastax.driver.mapping.annotations.Column;
@ -25,12 +25,13 @@ import org.thingsboard.server.common.data.Device;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.DeviceId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.model.type.JsonCodec;
import java.util.UUID;
import static org.thingsboard.server.dao.model.ModelConstants.*;
import java.util.UUID;
@Table(name = DEVICE_COLUMN_FAMILY_NAME)
public final class DeviceEntity implements SearchTextEntity<Device> {

13
dao/src/main/java/org/thingsboard/server/dao/model/EventEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/EventEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import com.datastax.driver.core.utils.UUIDs;
import com.datastax.driver.mapping.annotations.*;
@ -22,7 +22,10 @@ import lombok.Data;
import lombok.NoArgsConstructor;
import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.Event;
import org.thingsboard.server.common.data.id.*;
import org.thingsboard.server.common.data.id.EntityIdFactory;
import org.thingsboard.server.common.data.id.EventId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.BaseEntity;
import org.thingsboard.server.dao.model.type.EntityTypeCodec;
import org.thingsboard.server.dao.model.type.JsonCodec;
@ -62,7 +65,7 @@ public class EventEntity implements BaseEntity<Event> {
@ClusteringColumn(value = 1)
@Column(name = EVENT_UID_PROPERTY)
private String eventUId;
private String eventUid;
@Column(name = EVENT_BODY_PROPERTY, codec = JsonCodec.class)
private JsonNode body;
@ -79,7 +82,7 @@ public class EventEntity implements BaseEntity<Event> {
this.entityId = event.getEntityId().getId();
}
this.eventType = event.getType();
this.eventUId = event.getUid();
this.eventUid = event.getUid();
this.body = event.getBody();
}
@ -101,7 +104,7 @@ public class EventEntity implements BaseEntity<Event> {
event.setEntityId(EntityIdFactory.getByTypeAndUuid(entityType, entityId));
event.setBody(body);
event.setType(eventType);
event.setUid(eventUId);
event.setUid(eventUid);
return event;
}
}

36
dao/src/main/java/org/thingsboard/server/dao/model/PluginMetaDataEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/PluginMetaDataEntity.java

@ -13,59 +13,57 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import com.datastax.driver.core.utils.UUIDs;
import com.datastax.driver.mapping.annotations.ClusteringColumn;
import com.datastax.driver.mapping.annotations.Column;
import com.datastax.driver.mapping.annotations.PartitionKey;
import com.datastax.driver.mapping.annotations.Table;
import com.datastax.driver.mapping.annotations.*;
import com.fasterxml.jackson.databind.JsonNode;
import org.thingsboard.server.common.data.id.PluginId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.plugin.ComponentLifecycleState;
import org.thingsboard.server.common.data.plugin.PluginMetaData;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.model.type.ComponentLifecycleStateCodec;
import org.thingsboard.server.dao.model.type.JsonCodec;
import static org.thingsboard.server.dao.model.ModelConstants.*;
import java.util.Objects;
import java.util.UUID;
import static org.thingsboard.server.dao.model.ModelConstants.ADDITIONAL_INFO_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.RULE_ACTION;
@Table(name = ModelConstants.PLUGIN_COLUMN_FAMILY_NAME)
@Table(name = PLUGIN_COLUMN_FAMILY_NAME)
public class PluginMetaDataEntity implements SearchTextEntity<PluginMetaData> {
private static final long serialVersionUID = 1L;
@Transient
private static final long serialVersionUID = -5231612734979707866L;
@PartitionKey
@Column(name = ModelConstants.ID_PROPERTY)
@Column(name = ID_PROPERTY)
private UUID id;
@Column(name = ModelConstants.PLUGIN_API_TOKEN_PROPERTY)
@Column(name = PLUGIN_API_TOKEN_PROPERTY)
private String apiToken;
@ClusteringColumn
@Column(name = ModelConstants.PLUGIN_TENANT_ID_PROPERTY)
@Column(name = PLUGIN_TENANT_ID_PROPERTY)
private UUID tenantId;
@Column(name = ModelConstants.PLUGIN_NAME_PROPERTY)
@Column(name = PLUGIN_NAME_PROPERTY)
private String name;
@Column(name = ModelConstants.PLUGIN_CLASS_PROPERTY)
@Column(name = PLUGIN_CLASS_PROPERTY)
private String clazz;
@Column(name = ModelConstants.PLUGIN_ACCESS_PROPERTY)
@Column(name = PLUGIN_ACCESS_PROPERTY)
private boolean publicAccess;
@Column(name = ModelConstants.PLUGIN_STATE_PROPERTY, codec = ComponentLifecycleStateCodec.class)
@Column(name = PLUGIN_STATE_PROPERTY, codec = ComponentLifecycleStateCodec.class)
private ComponentLifecycleState state;
@Column(name = ModelConstants.PLUGIN_CONFIGURATION_PROPERTY, codec = JsonCodec.class)
@Column(name = PLUGIN_CONFIGURATION_PROPERTY, codec = JsonCodec.class)
private JsonNode configuration;
@Column(name = ModelConstants.SEARCH_TEXT_PROPERTY)
@Column(name = SEARCH_TEXT_PROPERTY)
private String searchText;
@Column(name = ADDITIONAL_INFO_PROPERTY, codec = JsonCodec.class)

12
dao/src/main/java/org/thingsboard/server/dao/model/RuleMetaDataEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/RuleMetaDataEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import com.datastax.driver.core.utils.UUIDs;
import com.datastax.driver.mapping.annotations.ClusteringColumn;
@ -26,17 +26,21 @@ import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.plugin.ComponentLifecycleState;
import org.thingsboard.server.common.data.rule.RuleMetaData;
import org.thingsboard.server.dao.DaoUtil;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.model.type.ComponentLifecycleStateCodec;
import org.thingsboard.server.dao.model.type.JsonCodec;
import static org.thingsboard.server.dao.model.ModelConstants.*;
import javax.persistence.Transient;
import java.util.Objects;
import java.util.UUID;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Table(name = RULE_COLUMN_FAMILY_NAME)
public class RuleMetaDataEntity implements SearchTextEntity<RuleMetaData> {
@Transient
private static final long serialVersionUID = 4011728715100800304L;
@PartitionKey
@Column(name = ID_PROPERTY)
private UUID id;
@ -45,7 +49,7 @@ public class RuleMetaDataEntity implements SearchTextEntity<RuleMetaData> {
private UUID tenantId;
@Column(name = RULE_NAME_PROPERTY)
private String name;
@Column(name = ModelConstants.RULE_STATE_PROPERTY, codec = ComponentLifecycleStateCodec.class)
@Column(name = RULE_STATE_PROPERTY, codec = ComponentLifecycleStateCodec.class)
private ComponentLifecycleState state;
@Column(name = RULE_WEIGHT_PROPERTY)
private int weight;

19
dao/src/main/java/org/thingsboard/server/dao/model/TenantEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/TenantEntity.java

@ -13,27 +13,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
import static org.thingsboard.server.dao.model.ModelConstants.ADDRESS2_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.ADDRESS_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.CITY_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.COUNTRY_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.EMAIL_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.ID_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.PHONE_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.STATE_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.TENANT_ADDITIONAL_INFO_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.TENANT_COLUMN_FAMILY_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.TENANT_REGION_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.TENANT_TITLE_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.ZIP_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.SEARCH_TEXT_PROPERTY;
package org.thingsboard.server.dao.model.nosql;
import java.util.UUID;
import org.thingsboard.server.common.data.Tenant;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.model.type.JsonCodec;
import com.datastax.driver.core.utils.UUIDs;
@ -42,6 +28,7 @@ import com.datastax.driver.mapping.annotations.PartitionKey;
import com.datastax.driver.mapping.annotations.Table;
import com.datastax.driver.mapping.annotations.Transient;
import com.fasterxml.jackson.databind.JsonNode;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Table(name = TENANT_COLUMN_FAMILY_NAME)
public final class TenantEntity implements SearchTextEntity<Tenant> {

12
dao/src/main/java/org/thingsboard/server/dao/model/UserCredentialsEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/UserCredentialsEntity.java

@ -13,15 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
import static org.thingsboard.server.dao.model.ModelConstants.ID_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_CREDENTIALS_ACTIVATE_TOKEN_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_CREDENTIALS_COLUMN_FAMILY_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.USER_CREDENTIALS_PASSWORD_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_CREDENTIALS_USER_ID_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_CREDENTIALS_ENABLED_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_CREDENTIALS_RESET_TOKEN_PROPERTY;
package org.thingsboard.server.dao.model.nosql;
import java.util.UUID;
@ -34,6 +26,8 @@ import com.datastax.driver.mapping.annotations.Column;
import com.datastax.driver.mapping.annotations.PartitionKey;
import com.datastax.driver.mapping.annotations.Table;
import com.datastax.driver.mapping.annotations.Transient;
import org.thingsboard.server.dao.model.BaseEntity;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Table(name = USER_CREDENTIALS_COLUMN_FAMILY_NAME)
public final class UserCredentialsEntity implements BaseEntity<UserCredentials> {

15
dao/src/main/java/org/thingsboard/server/dao/model/UserEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/UserEntity.java

@ -13,18 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
import static org.thingsboard.server.dao.model.ModelConstants.ID_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.SEARCH_TEXT_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_ADDITIONAL_INFO_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_AUTHORITY_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_COLUMN_FAMILY_NAME;
import static org.thingsboard.server.dao.model.ModelConstants.USER_CUSTOMER_ID_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_EMAIL_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_FIRST_NAME_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_LAST_NAME_PROPERTY;
import static org.thingsboard.server.dao.model.ModelConstants.USER_TENANT_ID_PROPERTY;
package org.thingsboard.server.dao.model.nosql;
import java.util.UUID;
@ -33,6 +22,7 @@ import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.id.UserId;
import org.thingsboard.server.common.data.security.Authority;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.model.type.AuthorityCodec;
import org.thingsboard.server.dao.model.type.JsonCodec;
@ -42,6 +32,7 @@ import com.datastax.driver.mapping.annotations.PartitionKey;
import com.datastax.driver.mapping.annotations.Table;
import com.datastax.driver.mapping.annotations.Transient;
import com.fasterxml.jackson.databind.JsonNode;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Table(name = USER_COLUMN_FAMILY_NAME)
public final class UserEntity implements SearchTextEntity<User> {

20
dao/src/main/java/org/thingsboard/server/dao/model/WidgetTypeEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/WidgetTypeEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import com.datastax.driver.core.utils.UUIDs;
import com.datastax.driver.mapping.annotations.Column;
@ -24,35 +24,37 @@ import com.fasterxml.jackson.databind.JsonNode;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.id.WidgetTypeId;
import org.thingsboard.server.common.data.widget.WidgetType;
import org.thingsboard.server.dao.model.BaseEntity;
import org.thingsboard.server.dao.model.type.JsonCodec;
import static org.thingsboard.server.dao.model.ModelConstants.*;
import java.util.UUID;
@Table(name = ModelConstants.WIDGET_TYPE_COLUMN_FAMILY_NAME)
@Table(name = WIDGET_TYPE_COLUMN_FAMILY_NAME)
public final class WidgetTypeEntity implements BaseEntity<WidgetType> {
@Transient
private static final long serialVersionUID = 3591054897680176342L;
@PartitionKey(value = 0)
@Column(name = ModelConstants.ID_PROPERTY)
@Column(name = ID_PROPERTY)
private UUID id;
@PartitionKey(value = 1)
@Column(name = ModelConstants.WIDGET_TYPE_TENANT_ID_PROPERTY)
@Column(name = WIDGET_TYPE_TENANT_ID_PROPERTY)
private UUID tenantId;
@PartitionKey(value = 2)
@Column(name = ModelConstants.WIDGET_TYPE_BUNDLE_ALIAS_PROPERTY)
@Column(name = WIDGET_TYPE_BUNDLE_ALIAS_PROPERTY)
private String bundleAlias;
@Column(name = ModelConstants.WIDGET_TYPE_ALIAS_PROPERTY)
@Column(name = WIDGET_TYPE_ALIAS_PROPERTY)
private String alias;
@Column(name = ModelConstants.WIDGET_TYPE_NAME_PROPERTY)
@Column(name = WIDGET_TYPE_NAME_PROPERTY)
private String name;
@Column(name = ModelConstants.WIDGET_TYPE_DESCRIPTOR_PROPERTY, codec = JsonCodec.class)
@Column(name = WIDGET_TYPE_DESCRIPTOR_PROPERTY, codec = JsonCodec.class)
private JsonNode descriptor;
public WidgetTypeEntity() {
@ -155,7 +157,7 @@ public final class WidgetTypeEntity implements BaseEntity<WidgetType> {
sb.append(", tenantId=").append(tenantId);
sb.append(", bundleAlias='").append(bundleAlias).append('\'');
sb.append(", alias='").append(alias).append('\'');
sb.append(", name='").append(name).append('\'');
sb.append(", name ='").append(name).append('\'');
sb.append(", descriptor=").append(descriptor);
sb.append('}');
return sb.toString();

18
dao/src/main/java/org/thingsboard/server/dao/model/WidgetsBundleEntity.java → dao/src/main/java/org/thingsboard/server/dao/model/nosql/WidgetsBundleEntity.java

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.thingsboard.server.dao.model;
package org.thingsboard.server.dao.model.nosql;
import com.datastax.driver.core.utils.UUIDs;
@ -24,34 +24,36 @@ import com.datastax.driver.mapping.annotations.Transient;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.id.WidgetsBundleId;
import org.thingsboard.server.common.data.widget.WidgetsBundle;
import org.thingsboard.server.dao.model.SearchTextEntity;
import static org.thingsboard.server.dao.model.ModelConstants.*;
import java.nio.ByteBuffer;
import java.util.UUID;
@Table(name = ModelConstants.WIDGETS_BUNDLE_COLUMN_FAMILY_NAME)
@Table(name = WIDGETS_BUNDLE_COLUMN_FAMILY_NAME)
public final class WidgetsBundleEntity implements SearchTextEntity<WidgetsBundle> {
@Transient
private static final long serialVersionUID = -8842195928585650849L;
@PartitionKey(value = 0)
@Column(name = ModelConstants.ID_PROPERTY)
@Column(name = ID_PROPERTY)
private UUID id;
@PartitionKey(value = 1)
@Column(name = ModelConstants.WIDGETS_BUNDLE_TENANT_ID_PROPERTY)
@Column(name = WIDGETS_BUNDLE_TENANT_ID_PROPERTY)
private UUID tenantId;
@Column(name = ModelConstants.WIDGETS_BUNDLE_ALIAS_PROPERTY)
@Column(name = WIDGETS_BUNDLE_ALIAS_PROPERTY)
private String alias;
@Column(name = ModelConstants.WIDGETS_BUNDLE_TITLE_PROPERTY)
@Column(name = WIDGETS_BUNDLE_TITLE_PROPERTY)
private String title;
@Column(name = ModelConstants.SEARCH_TEXT_PROPERTY)
@Column(name = SEARCH_TEXT_PROPERTY)
private String searchText;
@Column(name = ModelConstants.WIDGETS_BUNDLE_IMAGE_PROPERTY)
@Column(name = WIDGETS_BUNDLE_IMAGE_PROPERTY)
private ByteBuffer image;
public WidgetsBundleEntity() {

84
dao/src/main/java/org/thingsboard/server/dao/model/sql/AdminSettingsEntity.java

@ -0,0 +1,84 @@
/**
* Copyright © 2016-2017 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.dao.model.sql;
import com.datastax.driver.core.utils.UUIDs;
import com.fasterxml.jackson.databind.JsonNode;
import lombok.Data;
import org.hibernate.annotations.Type;
import org.hibernate.annotations.TypeDef;
import org.thingsboard.server.common.data.AdminSettings;
import org.thingsboard.server.common.data.id.AdminSettingsId;
import org.thingsboard.server.dao.model.BaseEntity;
import org.thingsboard.server.dao.util.mapping.JsonStringType;
import javax.persistence.*;
import java.util.UUID;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Data
@Entity
@TypeDef(name = "json", typeClass = JsonStringType.class)
@Table(name = ADMIN_SETTINGS_COLUMN_FAMILY_NAME)
public final class AdminSettingsEntity implements BaseEntity<AdminSettings> {
@Transient
private static final long serialVersionUID = 842759712850362147L;
@Id
@Column(name = ID_PROPERTY)
private UUID id;
@Column(name = ADMIN_SETTINGS_KEY_PROPERTY)
private String key;
@Type(type = "json")
@Column(name = ADMIN_SETTINGS_JSON_VALUE_PROPERTY)
private JsonNode jsonValue;
public AdminSettingsEntity() {
super();
}
public AdminSettingsEntity(AdminSettings adminSettings) {
if (adminSettings.getId() != null) {
this.id = adminSettings.getId().getId();
}
this.key = adminSettings.getKey();
this.jsonValue = adminSettings.getJsonValue();
}
@Override
public UUID getId() {
return id;
}
@Override
public void setId(UUID id) {
this.id = id;
}
@Override
public AdminSettings toData() {
AdminSettings adminSettings = new AdminSettings(new AdminSettingsId(id));
adminSettings.setCreatedTime(UUIDs.unixTimestamp(id));
adminSettings.setKey(key);
adminSettings.setJsonValue(jsonValue);
return adminSettings;
}
}

136
dao/src/main/java/org/thingsboard/server/dao/model/sql/AlarmEntity.java

@ -0,0 +1,136 @@
/**
* Copyright © 2016-2017 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.dao.model.sql;
import com.datastax.driver.core.utils.UUIDs;
import com.fasterxml.jackson.databind.JsonNode;
import lombok.Data;
import org.hibernate.annotations.Type;
import org.hibernate.annotations.TypeDef;
import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.alarm.Alarm;
import org.thingsboard.server.common.data.alarm.AlarmId;
import org.thingsboard.server.common.data.alarm.AlarmSeverity;
import org.thingsboard.server.common.data.alarm.AlarmStatus;
import org.thingsboard.server.common.data.id.EntityIdFactory;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.BaseEntity;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.dao.util.mapping.JsonStringType;
import javax.persistence.*;
import java.util.UUID;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Data
@Entity
@TypeDef(name = "json", typeClass = JsonStringType.class)
@Table(name = ALARM_COLUMN_FAMILY_NAME)
public final class AlarmEntity implements BaseEntity<Alarm> {
@Transient
private static final long serialVersionUID = -339979717281685984L;
@Id
@Column(name = ID_PROPERTY)
private UUID id;
@Column(name = ALARM_TENANT_ID_PROPERTY)
private UUID tenantId;
@Column(name = ALARM_ORIGINATOR_ID_PROPERTY)
private UUID originatorId;
@Column(name = ALARM_ORIGINATOR_TYPE_PROPERTY)
private EntityType originatorType;
@Column(name = ALARM_TYPE_PROPERTY)
private String type;
@Enumerated(EnumType.STRING)
@Column(name = ALARM_SEVERITY_PROPERTY)
private AlarmSeverity severity;
@Enumerated(EnumType.STRING)
@Column(name = ALARM_STATUS_PROPERTY)
private AlarmStatus status;
@Column(name = ALARM_START_TS_PROPERTY)
private Long startTs;
@Column(name = ALARM_END_TS_PROPERTY)
private Long endTs;
@Column(name = ALARM_ACK_TS_PROPERTY)
private Long ackTs;
@Column(name = ALARM_CLEAR_TS_PROPERTY)
private Long clearTs;
@Type(type = "json")
@Column(name = ModelConstants.ASSET_ADDITIONAL_INFO_PROPERTY)
private JsonNode details;
@Column(name = ALARM_PROPAGATE_PROPERTY)
private Boolean propagate;
public AlarmEntity() {
super();
}
public AlarmEntity(Alarm alarm) {
if (alarm.getId() != null) {
this.id = alarm.getId().getId();
}
if (alarm.getTenantId() != null) {
this.tenantId = alarm.getTenantId().getId();
}
this.type = alarm.getType();
this.originatorId = alarm.getOriginator().getId();
this.originatorType = alarm.getOriginator().getEntityType();
this.type = alarm.getType();
this.severity = alarm.getSeverity();
this.status = alarm.getStatus();
this.propagate = alarm.isPropagate();
this.startTs = alarm.getStartTs();
this.endTs = alarm.getEndTs();
this.ackTs = alarm.getAckTs();
this.clearTs = alarm.getClearTs();
this.details = alarm.getDetails();
}
@Override
public Alarm toData() {
Alarm alarm = new Alarm(new AlarmId(id));
alarm.setCreatedTime(UUIDs.unixTimestamp(id));
if (tenantId != null) {
alarm.setTenantId(new TenantId(tenantId));
}
alarm.setOriginator(EntityIdFactory.getByTypeAndUuid(originatorType, originatorId));
alarm.setType(type);
alarm.setSeverity(severity);
alarm.setStatus(status);
alarm.setPropagate(propagate);
alarm.setStartTs(startTs);
alarm.setEndTs(endTs);
alarm.setAckTs(ackTs);
alarm.setClearTs(clearTs);
alarm.setDetails(details);
return alarm;
}
}

117
dao/src/main/java/org/thingsboard/server/dao/model/sql/AssetEntity.java

@ -0,0 +1,117 @@
/**
* Copyright © 2016-2017 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.dao.model.sql;
import com.datastax.driver.core.utils.UUIDs;
import com.fasterxml.jackson.databind.JsonNode;
import lombok.Data;
import org.hibernate.annotations.Type;
import org.hibernate.annotations.TypeDef;
import org.thingsboard.server.common.data.asset.Asset;
import org.thingsboard.server.common.data.id.AssetId;
import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.model.ModelConstants;
import org.thingsboard.server.dao.model.SearchTextEntity;
import org.thingsboard.server.dao.util.mapping.JsonStringType;
import javax.persistence.*;
import java.util.UUID;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Data
@Entity
@TypeDef(name = "json", typeClass = JsonStringType.class)
@Table(name = ASSET_COLUMN_FAMILY_NAME)
public final class AssetEntity implements SearchTextEntity<Asset> {
@Transient
private static final long serialVersionUID = -4089175869616037592L;
@Id
@Column(name = ID_PROPERTY)
private UUID id;
@Column(name = ASSET_TENANT_ID_PROPERTY)
private UUID tenantId;
@Column(name = ASSET_CUSTOMER_ID_PROPERTY)
private UUID customerId;
@Column(name = ASSET_NAME_PROPERTY)
private String name;
@Column(name = ASSET_TYPE_PROPERTY)
private String type;
@Column(name = SEARCH_TEXT_PROPERTY)
private String searchText;
@Type(type = "json")
@Column(name = ModelConstants.ASSET_ADDITIONAL_INFO_PROPERTY)
private JsonNode additionalInfo;
public AssetEntity() {
super();
}
public AssetEntity(Asset asset) {
if (asset.getId() != null) {
this.id = asset.getId().getId();
}
if (asset.getTenantId() != null) {
this.tenantId = asset.getTenantId().getId();
}
if (asset.getCustomerId() != null) {
this.customerId = asset.getCustomerId().getId();
}
this.name = asset.getName();
this.type = asset.getType();
this.additionalInfo = asset.getAdditionalInfo();
}
@Override
public String getSearchTextSource() {
return name;
}
@Override
public void setSearchText(String searchText) {
this.searchText = searchText;
}
public String getSearchText() {
return searchText;
}
@Override
public Asset toData() {
Asset asset = new Asset(new AssetId(id));
asset.setCreatedTime(UUIDs.unixTimestamp(id));
if (tenantId != null) {
asset.setTenantId(new TenantId(tenantId));
}
if (customerId != null) {
asset.setCustomerId(new CustomerId(customerId));
}
asset.setName(name);
asset.setType(type);
asset.setAdditionalInfo(additionalInfo);
return asset;
}
}

34
dao/src/main/java/org/thingsboard/server/dao/model/sql/AttributeKvCompositeKey.java

@ -0,0 +1,34 @@
/**
* Copyright © 2016-2017 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.dao.model.sql;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.thingsboard.server.common.data.EntityType;
import java.io.Serializable;
import java.util.UUID;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class AttributeKvCompositeKey implements Serializable {
private EntityType entityType;
private UUID entityId;
private String attributeType;
private String attributeKey;
}

81
dao/src/main/java/org/thingsboard/server/dao/model/sql/AttributeKvEntity.java

@ -0,0 +1,81 @@
/**
* Copyright © 2016-2017 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.dao.model.sql;
import lombok.Data;
import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.kv.*;
import org.thingsboard.server.dao.model.ToData;
import javax.persistence.*;
import java.io.Serializable;
import java.util.UUID;
import static org.thingsboard.server.dao.model.ModelConstants.*;
@Data
@Entity
@Table(name = "attribute_kv")
@IdClass(AttributeKvCompositeKey.class)
public class AttributeKvEntity implements ToData<AttributeKvEntry>, Serializable {
@Id
@Enumerated(EnumType.STRING)
@Column(name = ENTITY_TYPE_COLUMN)
private EntityType entityType;
@Id
@Column(name = ENTITY_ID_COLUMN)
private UUID entityId;
@Id
@Column(name = ATTRIBUTE_TYPE_COLUMN)
private String attributeType;
@Id
@Column(name = ATTRIBUTE_KEY_COLUMN)
private String attributeKey;
@Column(name = BOOLEAN_VALUE_COLUMN)
private Boolean booleanValue;
@Column(name = STRING_VALUE_COLUMN)
private String strValue;
@Column(name = LONG_VALUE_COLUMN)
private Long longValue;
@Column(name = DOUBLE_VALUE_COLUMN)
private Double doubleValue;
@Column(name = LAST_UPDATE_TS_COLUMN)
private Long lastUpdateTs;
@Override
public AttributeKvEntry toData() {
KvEntry kvEntry = null;
if (strValue != null) {
kvEntry = new StringDataEntry(attributeKey, strValue);
} else if (booleanValue != null) {
kvEntry = new BooleanDataEntry(attributeKey, booleanValue);
} else if (doubleValue != null) {
kvEntry = new DoubleDataEntry(attributeKey, doubleValue);
} else if (longValue != null) {
kvEntry = new LongDataEntry(attributeKey, longValue);
}
return new BaseAttributeKvEntry(kvEntry, lastUpdateTs);
}
}

Some files were not shown because too many files changed in this diff

Loading…
Cancel
Save