dendi-wang/thingsboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Multi-Root Query implementation improvements

Browse Source
This commit is contained in:
Andrii Shvaika 2022-01-14 14:01:43 +02:00
commit 20c9e77083
7 changed files with 326 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
application/src/main/java/org/thingsboard/server/controller/SystemInfoController.java Normal file
View File

@ -0,0 +1,71 @@
/**
* Copyright © 2016-2021 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.controller;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.info.BuildProperties;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.thingsboard.server.queue.util.TbCoreComponent;
import springfox.documentation.annotations.ApiIgnore;
import javax.annotation.PostConstruct;
@ApiIgnore
@RestController
@TbCoreComponent
@RequestMapping("/api")
@Slf4j
public class SystemInfoController {
@Autowired(required = false)
private BuildProperties buildProperties;
@PostConstruct
public void init() {
JsonNode info = buildInfoObject();
log.info("System build info: {}", info);
}
@PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN', 'CUSTOMER_USER')")
@RequestMapping(value = "/system/info", method = RequestMethod.GET)
@ResponseBody
public JsonNode getSystemVersionInfo() {
return buildInfoObject();
}
private JsonNode buildInfoObject() {
ObjectMapper objectMapper = new ObjectMapper();
ObjectNode infoObject = objectMapper.createObjectNode();
if (buildProperties != null) {
infoObject.put("version", buildProperties.getVersion());
infoObject.put("artifact", buildProperties.getArtifact());
infoObject.put("name", buildProperties.getName());
} else {
infoObject.put("version", "unknown");
}
return infoObject;
}
}

5
common/data/src/main/java/org/thingsboard/server/common/data/query/RelationsQueryFilter.java
View File

@ -16,11 +16,13 @@
package org.thingsboard.server.common.data.query;
import lombok.Data;
import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.relation.EntitySearchDirection;
import org.thingsboard.server.common.data.relation.RelationEntityTypeFilter;
import java.util.List;
import java.util.Set;
@Data
public class RelationsQueryFilter implements EntityFilter {
@ -31,6 +33,9 @@ public class RelationsQueryFilter implements EntityFilter {
}
private EntityId rootEntity;
private boolean isMultiRoot;
private EntityType multiRootEntitiesType;
private Set<String> multiRootEntityIds;
private EntitySearchDirection direction;
private List<RelationEntityTypeFilter> filters;
private int maxLevel;

19
dao/src/main/java/org/thingsboard/server/dao/entity/BaseEntityService.java
View File

@ -22,6 +22,7 @@ import com.google.common.util.concurrent.MoreExecutors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.thingsboard.server.common.data.HasCustomerId;
import org.thingsboard.server.common.data.HasName;
import org.thingsboard.server.common.data.id.AlarmId;
@ -42,6 +43,8 @@ import org.thingsboard.server.common.data.query.EntityCountQuery;
import org.thingsboard.server.common.data.query.EntityData;
import org.thingsboard.server.common.data.query.EntityDataPageLink;
import org.thingsboard.server.common.data.query.EntityDataQuery;
import org.thingsboard.server.common.data.query.EntityFilterType;
import org.thingsboard.server.common.data.query.RelationsQueryFilter;
import org.thingsboard.server.dao.alarm.AlarmService;
import org.thingsboard.server.dao.asset.AssetService;
import org.thingsboard.server.dao.customer.CustomerService;
@ -204,7 +207,8 @@ public class BaseEntityService extends AbstractEntityService implements EntitySe
case ALARM:
try {
hasCustomerId = alarmService.findAlarmByIdAsync(tenantId, new AlarmId(entityId.getId())).get();
} catch (Exception e) {}
} catch (Exception e) {
}
break;
case ENTITY_VIEW:
hasCustomerId = entityViewService.findEntityViewById(tenantId, new EntityViewId(entityId.getId()));
@ -223,6 +227,8 @@ public class BaseEntityService extends AbstractEntityService implements EntitySe
throw new IncorrectParameterException("Query entity filter must be specified.");
} else if (query.getEntityFilter().getType() == null) {
throw new IncorrectParameterException("Query entity filter type must be specified.");
} else if (query.getEntityFilter().getType().equals(EntityFilterType.RELATIONS_QUERY)) {
validateRelationQuery((RelationsQueryFilter) query.getEntityFilter());
}
}
@ -241,4 +247,15 @@ public class BaseEntityService extends AbstractEntityService implements EntitySe
}
}
private static void validateRelationQuery(RelationsQueryFilter queryFilter) {
if (queryFilter.isMultiRoot() && queryFilter.getMultiRootEntitiesType() ==null){
throw new IncorrectParameterException("Multi-root relation query filter should contain 'multiRootEntitiesType'");
}
if (queryFilter.isMultiRoot() && CollectionUtils.isEmpty(queryFilter.getMultiRootEntityIds())) {
throw new IncorrectParameterException("Multi-root relation query filter should contain 'multiRootEntityIds' array that contains string representation of UUIDs");
}
if (!queryFilter.isMultiRoot() && queryFilter.getRootEntity() == null) {
throw new IncorrectParameterException("Relation query filter root entity should not be blank");
}
}
}

58
dao/src/main/java/org/thingsboard/server/dao/sql/query/DefaultEntityQueryRepository.java
View File

@ -222,6 +222,8 @@ public class DefaultEntityQueryRepository implements EntityQueryRepository {
" THEN (select additional_info from edge where id = entity_id)" +
" END as additional_info";
private static final String SELECT_RELATED_PARENT_ID = "entity.parent_id AS parent_id";
private static final String SELECT_API_USAGE_STATE = "(select aus.id, aus.created_time, aus.tenant_id, aus.entity_id, " +
"coalesce((select title from tenant where id = aus.entity_id), (select title from customer where id = aus.entity_id)) as name " +
"from api_usage_state as aus)";
@ -246,7 +248,7 @@ public class DefaultEntityQueryRepository implements EntityQueryRepository {
" 1 as lvl," +
" ARRAY[$in_id] as path" + // initial path
" FROM relation " +
" WHERE $in_id = :relation_root_id and $in_type = :relation_root_type and relation_type_group = 'COMMON'" +
" WHERE $in_id $rootIdCondition and $in_type = :relation_root_type and relation_type_group = 'COMMON'" +
" GROUP BY from_id, from_type, to_id, to_type, lvl, path" +
" UNION ALL" +
" SELECT r.from_id, r.from_type, r.to_id, r.to_type," +
@ -260,14 +262,34 @@ public class DefaultEntityQueryRepository implements EntityQueryRepository {
" %s" +
" GROUP BY r.from_id, r.from_type, r.to_id, r.to_type, (re.lvl + 1), (re.path || ARRAY[r.$in_id])" +
" )" +
" SELECT re.$out_id entity_id, re.$out_type entity_type, max(r_int.lvl) lvl" +
" SELECT re.$out_id entity_id, re.$out_type entity_type, $parenIdExp max(r_int.lvl) lvl" +
" from related_entities r_int" +
" INNER JOIN relation re ON re.from_id = r_int.from_id AND re.from_type = r_int.from_type" +
" AND re.to_id = r_int.to_id AND re.to_type = r_int.to_type" +
" AND re.relation_type_group = 'COMMON'" +
" %s GROUP BY entity_id, entity_type) entity";
private static final String HIERARCHICAL_TO_QUERY_TEMPLATE = HIERARCHICAL_QUERY_TEMPLATE.replace("$in", "to").replace("$out", "from");
private static final String HIERARCHICAL_FROM_QUERY_TEMPLATE = HIERARCHICAL_QUERY_TEMPLATE.replace("$in", "from").replace("$out", "to");
" %s GROUP BY entity_id, entity_type $parenIdSelection) entity";
private static final String HIERARCHICAL_TO_QUERY_TEMPLATE = HIERARCHICAL_QUERY_TEMPLATE
.replace("$parenIdExp", "")
.replace("$parenIdSelection", "")
.replace("$in", "to").replace("$out", "from")
.replace("$rootIdCondition", "= :relation_root_id");
private static final String HIERARCHICAL_TO_MR_QUERY_TEMPLATE = HIERARCHICAL_QUERY_TEMPLATE
.replace("$parenIdExp", "re.$in_id parent_id, ")
.replace("$parenIdSelection", ", parent_id")
.replace("$in", "to").replace("$out", "from")
.replace("$rootIdCondition", "in (:relation_root_ids)");
private static final String HIERARCHICAL_FROM_QUERY_TEMPLATE = HIERARCHICAL_QUERY_TEMPLATE
.replace("$parenIdExp", "")
.replace("$parenIdSelection", "")
.replace("$in", "from").replace("$out", "to")
.replace("$rootIdCondition", "= :relation_root_id");
private static final String HIERARCHICAL_FROM_MR_QUERY_TEMPLATE = HIERARCHICAL_QUERY_TEMPLATE
.replace("$parenIdExp", "re.$in_id parent_id, ")
.replace("$parenIdSelection", ", parent_id")
.replace("$in", "from").replace("$out", "to")
.replace("$rootIdCondition", "in (:relation_root_ids)");
@Getter
@Value("${sql.relations.max_level:50}")
@ -580,7 +602,7 @@ public class DefaultEntityQueryRepository implements EntityQueryRepository {
String selectFields = "SELECT tenant_id, customer_id, id, created_time, type, name, additional_info "
+ (entityType.equals(EntityType.ENTITY_VIEW) ? "" : ", label ")
+ "FROM " + entityType.name() + " WHERE id in ( SELECT entity_id";
String from = getQueryTemplate(entityFilter.getDirection());
String from = getQueryTemplate(entityFilter.getDirection(), false);
String whereFilter = " WHERE";
if (!StringUtils.isEmpty(entityFilter.getRelationType())) {
ctx.addStringParameter("where_relation_type", entityFilter.getRelationType());
@ -623,11 +645,18 @@ public class DefaultEntityQueryRepository implements EntityQueryRepository {
+ SELECT_TYPE + ", " + SELECT_NAME + ", " + SELECT_LABEL + ", " +
SELECT_FIRST_NAME + ", " + SELECT_LAST_NAME + ", " + SELECT_EMAIL + ", " + SELECT_REGION + ", " +
SELECT_TITLE + ", " + SELECT_COUNTRY + ", " + SELECT_STATE + ", " + SELECT_CITY + ", " +
SELECT_ADDRESS + ", " + SELECT_ADDRESS_2 + ", " + SELECT_ZIP + ", " + SELECT_PHONE + ", " + SELECT_ADDITIONAL_INFO +
SELECT_ADDRESS + ", " + SELECT_ADDRESS_2 + ", " + SELECT_ZIP + ", " + SELECT_PHONE + ", " +
SELECT_ADDITIONAL_INFO + (entityFilter.isMultiRoot() ? (", " + SELECT_RELATED_PARENT_ID) : "") +
", entity.entity_type as entity_type";
String from = getQueryTemplate(entityFilter.getDirection());
ctx.addUuidParameter("relation_root_id", rootId.getId());
ctx.addStringParameter("relation_root_type", rootId.getEntityType().name());
String from = getQueryTemplate(entityFilter.getDirection(), entityFilter.isMultiRoot());
if (entityFilter.isMultiRoot()) {
ctx.addUuidListParameter("relation_root_ids", entityFilter.getMultiRootEntityIds().stream().map(UUID::fromString).collect(Collectors.toList()));
ctx.addStringParameter("relation_root_type", entityFilter.getMultiRootEntitiesType().name());
} else {
ctx.addUuidParameter("relation_root_id", rootId.getId());
ctx.addStringParameter("relation_root_type", rootId.getEntityType().name());
}
StringBuilder whereFilter = new StringBuilder();
@ -720,12 +749,12 @@ public class DefaultEntityQueryRepository implements EntityQueryRepository {
return (maxLevel <= 0 || maxLevel > this.maxLevelAllowed) ? this.maxLevelAllowed : maxLevel;
}
private String getQueryTemplate(EntitySearchDirection direction) {
private String getQueryTemplate(EntitySearchDirection direction, boolean isMultiRoot) {
String from;
if (direction.equals(EntitySearchDirection.FROM)) {
from = HIERARCHICAL_FROM_QUERY_TEMPLATE;
from = isMultiRoot ? HIERARCHICAL_FROM_MR_QUERY_TEMPLATE : HIERARCHICAL_FROM_QUERY_TEMPLATE;
} else {
from = HIERARCHICAL_TO_QUERY_TEMPLATE;
from = isMultiRoot ? HIERARCHICAL_TO_MR_QUERY_TEMPLATE : HIERARCHICAL_TO_QUERY_TEMPLATE;
}
return from;
}
@ -813,7 +842,8 @@ public class DefaultEntityQueryRepository implements EntityQueryRepository {
case EDGE_SEARCH_QUERY:
return EntityType.EDGE;
case RELATIONS_QUERY:
return ((RelationsQueryFilter) entityFilter).getRootEntity().getEntityType();
RelationsQueryFilter rgf = (RelationsQueryFilter) entityFilter;
return rgf.isMultiRoot() ? rgf.getMultiRootEntitiesType() : rgf.getRootEntity().getEntityType();
case API_USAGE_STATE:
return EntityType.API_USAGE_STATE;
default:

4
dao/src/main/java/org/thingsboard/server/dao/sql/query/EntityKeyMapping.java
View File

@ -72,6 +72,7 @@ public class EntityKeyMapping {
public static final String ZIP = "zip";
public static final String PHONE = "phone";
public static final String ADDITIONAL_INFO = "additionalInfo";
public static final String RELATED_PARENT_ID = "parentId";
public static final List<String> typedEntityFields = Arrays.asList(CREATED_TIME, ENTITY_TYPE, NAME, TYPE, ADDITIONAL_INFO);
public static final List<String> widgetEntityFields = Arrays.asList(CREATED_TIME, ENTITY_TYPE, NAME);
@ -82,7 +83,7 @@ public class EntityKeyMapping {
public static final Set<String> apiUsageStateEntityFields = new HashSet<>(Arrays.asList(CREATED_TIME, ENTITY_TYPE, NAME));
public static final Set<String> commonEntityFieldsSet = new HashSet<>(commonEntityFields);
public static final Set<String> relationQueryEntityFieldsSet = new HashSet<>(Arrays.asList(CREATED_TIME, ENTITY_TYPE, NAME, TYPE, LABEL, FIRST_NAME, LAST_NAME, EMAIL, REGION, TITLE, COUNTRY, STATE, CITY, ADDRESS, ADDRESS_2, ZIP, PHONE, ADDITIONAL_INFO));
public static final Set<String> relationQueryEntityFieldsSet = new HashSet<>(Arrays.asList(CREATED_TIME, ENTITY_TYPE, NAME, TYPE, LABEL, FIRST_NAME, LAST_NAME, EMAIL, REGION, TITLE, COUNTRY, STATE, CITY, ADDRESS, ADDRESS_2, ZIP, PHONE, ADDITIONAL_INFO, RELATED_PARENT_ID));
static {
allowedEntityFieldMap.put(EntityType.DEVICE, new HashSet<>(labeledEntityFields));
@ -120,6 +121,7 @@ public class EntityKeyMapping {
entityFieldColumnMap.put(ZIP, ModelConstants.ZIP_PROPERTY);
entityFieldColumnMap.put(PHONE, ModelConstants.PHONE_PROPERTY);
entityFieldColumnMap.put(ADDITIONAL_INFO, ModelConstants.ADDITIONAL_INFO_PROPERTY);
entityFieldColumnMap.put(RELATED_PARENT_ID, "parent_id");
Map<String, String> contactBasedAliases = new HashMap<>();
contactBasedAliases.put(NAME, TITLE);

184
dao/src/test/java/org/thingsboard/server/dao/service/BaseEntityServiceTest.java
View File

@ -15,12 +15,14 @@
*/
package org.thingsboard.server.dao.service;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.RandomUtils;
import org.hamcrest.Matchers;
import org.apache.commons.lang3.StringUtils;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@ -38,6 +40,7 @@ import org.thingsboard.server.common.data.id.CustomerId;
import org.thingsboard.server.common.data.id.DeviceId;
import org.thingsboard.server.common.data.id.EdgeId;
import org.thingsboard.server.common.data.id.EntityId;
import org.thingsboard.server.common.data.id.IdBased;
import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.kv.AttributeKvEntry;
import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry;
@ -79,8 +82,11 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@ -400,6 +406,112 @@ public abstract class BaseEntityServiceTest extends AbstractServiceTest {
deviceService.deleteDevicesByTenantId(tenantId);
}
@Test
public void testCountHierarchicalEntitiesByMultiRootQuery() throws InterruptedException {
List<Asset> buildings = new ArrayList<>();
List<Asset> apartments = new ArrayList<>();
Map<String, Map<UUID, String>> entityNameByTypeMap = new HashMap<>();
Map<UUID, UUID> childParentRelationMap = new HashMap<>();
createMultiRootHierarchy(buildings, apartments, entityNameByTypeMap, childParentRelationMap);
RelationsQueryFilter filter = new RelationsQueryFilter();
filter.setMultiRoot(true);
filter.setMultiRootEntitiesType(EntityType.ASSET);
filter.setMultiRootEntityIds(buildings.stream().map(IdBased::getId).map(d -> d.getId().toString()).collect(Collectors.toSet()));
filter.setDirection(EntitySearchDirection.FROM);
EntityCountQuery countQuery = new EntityCountQuery(filter);
long count = entityService.countEntitiesByQuery(tenantId, new CustomerId(CustomerId.NULL_UUID), countQuery);
Assert.assertEquals(63, count);
filter.setFilters(Collections.singletonList(new RelationEntityTypeFilter("AptToHeat", Collections.singletonList(EntityType.DEVICE))));
count = entityService.countEntitiesByQuery(tenantId, new CustomerId(CustomerId.NULL_UUID), countQuery);
Assert.assertEquals(27, count);
filter.setMultiRootEntitiesType(EntityType.ASSET);
filter.setMultiRootEntityIds(apartments.stream().map(IdBased::getId).map(d -> d.getId().toString()).collect(Collectors.toSet()));
filter.setDirection(EntitySearchDirection.TO);
filter.setFilters(Lists.newArrayList(
new RelationEntityTypeFilter("buildingToApt", Collections.singletonList(EntityType.ASSET)),
new RelationEntityTypeFilter("AptToEnergy", Collections.singletonList(EntityType.DEVICE))));
count = entityService.countEntitiesByQuery(tenantId, new CustomerId(CustomerId.NULL_UUID), countQuery);
Assert.assertEquals(9, count);
deviceService.deleteDevicesByTenantId(tenantId);
assetService.deleteAssetsByTenantId(tenantId);
}
@Test
public void testMultiRootHierarchicalFindEntityDataWithAttributesByQuery() throws ExecutionException, InterruptedException {
List<Asset> buildings = new ArrayList<>();
List<Asset> apartments = new ArrayList<>();
Map<String, Map<UUID, String>> entityNameByTypeMap = new HashMap<>();
Map<UUID, UUID> childParentRelationMap = new HashMap<>();
createMultiRootHierarchy(buildings, apartments, entityNameByTypeMap, childParentRelationMap);
RelationsQueryFilter filter = new RelationsQueryFilter();
filter.setMultiRoot(true);
filter.setMultiRootEntitiesType(EntityType.ASSET);
filter.setMultiRootEntityIds(buildings.stream().map(IdBased::getId).map(d -> d.getId().toString()).collect(Collectors.toSet()));
filter.setDirection(EntitySearchDirection.FROM);
EntityDataSortOrder sortOrder = new EntityDataSortOrder(
new EntityKey(EntityKeyType.ENTITY_FIELD, "createdTime"), EntityDataSortOrder.Direction.ASC
);
EntityDataPageLink pageLink = new EntityDataPageLink(10, 0, null, sortOrder);
List<EntityKey> entityFields = Lists.newArrayList(
new EntityKey(EntityKeyType.ENTITY_FIELD, "name"),
new EntityKey(EntityKeyType.ENTITY_FIELD, "parentId"),
new EntityKey(EntityKeyType.ENTITY_FIELD, "type")
);
List<EntityKey> latestValues = Collections.singletonList(new EntityKey(EntityKeyType.ATTRIBUTE, "status"));
KeyFilter onlineStatusFilter = new KeyFilter();
onlineStatusFilter.setKey(new EntityKey(EntityKeyType.ENTITY_FIELD, "name"));
StringFilterPredicate predicate = new StringFilterPredicate();
predicate.setOperation(StringOperation.ENDS_WITH);
predicate.setValue(FilterPredicateValue.fromString("_1"));
onlineStatusFilter.setPredicate(predicate);
List<KeyFilter> keyFilters = Collections.singletonList(onlineStatusFilter);
EntityDataQuery query = new EntityDataQuery(filter, pageLink, entityFields, latestValues, keyFilters);
PageData<EntityData> data = entityService.findEntityDataByQuery(tenantId, new CustomerId(CustomerId.NULL_UUID), query);
List<EntityData> loadedEntities = new ArrayList<>(data.getData());
while (data.hasNext()) {
query = query.next();
data = entityService.findEntityDataByQuery(tenantId, new CustomerId(CustomerId.NULL_UUID), query);
loadedEntities.addAll(data.getData());
}
long expectedEntitiesCnt = entityNameByTypeMap.entrySet()
.stream()
.filter(e -> !e.getKey().equals("building"))
.flatMap(e -> e.getValue().entrySet().stream())
.map(Map.Entry::getValue)
.filter(e -> StringUtils.endsWith(e, "_1"))
.count();
Assert.assertEquals(expectedEntitiesCnt, loadedEntities.size());
Map<UUID, UUID> actualRelations = new HashMap<>();
loadedEntities.forEach(ed -> {
UUID parentId = UUID.fromString(ed.getLatest().get(EntityKeyType.ENTITY_FIELD).get("parentId").getValue());
UUID entityId = ed.getEntityId().getId();
Assert.assertEquals(childParentRelationMap.get(entityId), parentId);
actualRelations.put(entityId, parentId);
String entityType = ed.getLatest().get(EntityKeyType.ENTITY_FIELD).get("type").getValue();
String actualEntityName = ed.getLatest().get(EntityKeyType.ENTITY_FIELD).get("name").getValue();
String expectedEntityName = entityNameByTypeMap.get(entityType).get(entityId);
Assert.assertEquals(expectedEntityName, actualEntityName);
});
deviceService.deleteDevicesByTenantId(tenantId);
assetService.deleteAssetsByTenantId(tenantId);
}
@Test
public void testHierarchicalFindDevicesWithAttributesByQuery() throws ExecutionException, InterruptedException {
List<Asset> assets = new ArrayList<>();
@ -1674,4 +1786,76 @@ public abstract class BaseEntityServiceTest extends AbstractServiceTest {
BasicTsKvEntry timeseries = new BasicTsKvEntry(42L, telemetryValue);
return timeseriesService.save(SYSTEM_TENANT_ID, entityId, timeseries);
}
private void createMultiRootHierarchy(List<Asset> buildings, List<Asset> apartments,
Map<String, Map<UUID, String>> entityNameByTypeMap,
Map<UUID, UUID> childParentRelationMap) throws InterruptedException {
for (int k = 0; k < 3; k++) {
Asset building = new Asset();
building.setTenantId(tenantId);
building.setName("Building _" + k);
building.setType("building");
building.setLabel("building label" + k);
building = assetService.saveAsset(building);
buildings.add(building);
entityNameByTypeMap.computeIfAbsent(building.getType(), n -> new HashMap<>()).put(building.getId().getId(), building.getName());
for (int i = 0; i < 3; i++) {
Asset asset = new Asset();
asset.setTenantId(tenantId);
asset.setName("Apt " + k + "_" + i);
asset.setType("apartment");
asset.setLabel("apartment " + i);
asset = assetService.saveAsset(asset);
//TO make sure devices have different created time
Thread.sleep(1);
entityNameByTypeMap.computeIfAbsent(asset.getType(), n -> new HashMap<>()).put(asset.getId().getId(), asset.getName());
apartments.add(asset);
EntityRelation er = new EntityRelation();
er.setFrom(building.getId());
er.setTo(asset.getId());
er.setType("buildingToApt");
er.setTypeGroup(RelationTypeGroup.COMMON);
relationService.saveRelation(tenantId, er);
childParentRelationMap.put(asset.getUuidId(), building.getUuidId());
for (int j = 0; j < 3; j++) {
Device device = new Device();
device.setTenantId(tenantId);
device.setName("Heat" + k + "_" + i + "_" + j);
device.setType("heatmeter");
device.setLabel("heatmeter" + (int) (Math.random() * 1000));
device = deviceService.saveDevice(device);
//TO make sure devices have different created time
Thread.sleep(1);
entityNameByTypeMap.computeIfAbsent(device.getType(), n -> new HashMap<>()).put(device.getId().getId(), device.getName());
er = new EntityRelation();
er.setFrom(asset.getId());
er.setTo(device.getId());
er.setType("AptToHeat");
er.setTypeGroup(RelationTypeGroup.COMMON);
relationService.saveRelation(tenantId, er);
childParentRelationMap.put(device.getUuidId(), asset.getUuidId());
}
for (int j = 0; j < 3; j++) {
Device device = new Device();
device.setTenantId(tenantId);
device.setName("Energy" + k + "_" + i + "_" + j);
device.setType("energymeter");
device.setLabel("energymeter" + (int) (Math.random() * 1000));
device = deviceService.saveDevice(device);
//TO make sure devices have different created time
Thread.sleep(1);
entityNameByTypeMap.computeIfAbsent(device.getType(), n -> new HashMap<>()).put(device.getId().getId(), device.getName());
er = new EntityRelation();
er.setFrom(asset.getId());
er.setTo(device.getId());
er.setType("AptToEnergy");
er.setTypeGroup(RelationTypeGroup.COMMON);
relationService.saveRelation(tenantId, er);
childParentRelationMap.put(device.getUuidId(), asset.getUuidId());
}
}
}
}
}

1
pom.xml
View File

@ -485,6 +485,7 @@
<execution>
<goals>
<goal>repackage</goal>
<goal>build-info</goal>
</goals>
</execution>
</executions>