Merge pull request #8636 from imbeacon/fix/removing-relations

[Fix] Changed method for removing relations from all to removing only COMMON relations

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

@@ -117,8 +117,8 @@ public class EntityRelationController extends BaseController {
         tbEntityRelationService.delete(getTenantId(), getCurrentUser().getCustomerId(), relation, getCurrentUser());
     }
 
-    @ApiOperation(value = "Delete Relations (deleteRelations)",
-            notes = "Deletes all the relation (both 'from' and 'to' direction) for the specified entity. " +
+    @ApiOperation(value = "Delete common relations (deleteCommonRelations)",
+            notes = "Deletes all the relations ('from' and 'to' direction) for the specified entity and relation type group: 'COMMON'. " +
                     SECURITY_CHECKS_ENTITY_DESCRIPTION)
     @PreAuthorize("hasAnyAuthority('SYS_ADMIN','TENANT_ADMIN', 'CUSTOMER_USER')")
     @RequestMapping(value = "/relations", method = RequestMethod.DELETE, params = {"entityId", "entityType"})
@@ -129,7 +129,7 @@ public class EntityRelationController extends BaseController {
         checkParameter("entityType", strType);
         EntityId entityId = EntityIdFactory.getByTypeAndId(strType, strId);
         checkEntityId(entityId, Operation.WRITE);
-        tbEntityRelationService.deleteRelations(getTenantId(), getCurrentUser().getCustomerId(), entityId, getCurrentUser());
+        tbEntityRelationService.deleteCommonRelations(getTenantId(), getCurrentUser().getCustomerId(), entityId, getCurrentUser());
     }
 
     @ApiOperation(value = "Get Relation (getRelation)",

application/src/main/java/org/thingsboard/server/service/entitiy/entity/relation/DefaultTbEntityRelationService.java

@@ -72,9 +72,9 @@ public class DefaultTbEntityRelationService extends AbstractTbEntityService impl
     }
 
     @Override
-    public void deleteRelations(TenantId tenantId, CustomerId customerId, EntityId entityId, User user) throws ThingsboardException {
+    public void deleteCommonRelations(TenantId tenantId, CustomerId customerId, EntityId entityId, User user) throws ThingsboardException {
         try {
-            relationService.deleteEntityRelations(tenantId, entityId);
+            relationService.deleteEntityCommonRelations(tenantId, entityId);
             notificationEntityService.logEntityAction(tenantId, entityId, null, customerId, ActionType.RELATIONS_DELETED, user);
         } catch (Exception e) {
             notificationEntityService.logEntityAction(tenantId, entityId, null, customerId,

application/src/main/java/org/thingsboard/server/service/entitiy/entity/relation/TbEntityRelationService.java

@@ -28,6 +28,6 @@ public interface TbEntityRelationService {
 
     void delete(TenantId tenantId, CustomerId customerId, EntityRelation entity, User user) throws ThingsboardException;
 
-    void deleteRelations(TenantId tenantId, CustomerId customerId, EntityId entityId, User user) throws ThingsboardException;
+    void deleteCommonRelations(TenantId tenantId, CustomerId customerId, EntityId entityId, User user) throws ThingsboardException;
 
 }

common/dao-api/src/main/java/org/thingsboard/server/dao/relation/RelationService.java

@@ -53,6 +53,8 @@ public interface RelationService {
 
     void deleteEntityRelations(TenantId tenantId, EntityId entity);
 
+    void deleteEntityCommonRelations(TenantId tenantId, EntityId entity);
+
     List<EntityRelation> findByFrom(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup);
 
     ListenableFuture<List<EntityRelation>> findByFromAsync(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup);

dao/src/main/java/org/thingsboard/server/dao/relation/BaseRelationService.java

@@ -220,17 +220,36 @@ public class BaseRelationService implements RelationService {
         return future;
     }
 
+    @Transactional
+    @Override
+    public void deleteEntityCommonRelations(TenantId tenantId, EntityId entityId) {
+        deleteEntityRelations(tenantId, entityId, RelationTypeGroup.COMMON);
+    }
+
     @Transactional
     @Override
     public void deleteEntityRelations(TenantId tenantId, EntityId entityId) {
+        deleteEntityRelations(tenantId, entityId, null);
+    }
+
+    @Transactional
+    public void deleteEntityRelations(TenantId tenantId, EntityId entityId, RelationTypeGroup relationTypeGroup) {
         log.trace("Executing deleteEntityRelations [{}]", entityId);
         validate(entityId);
-        List<EntityRelation> inboundRelations = new ArrayList<>(relationDao.findAllByTo(tenantId, entityId));
-        List<EntityRelation> outboundRelations = new ArrayList<>(relationDao.findAllByFrom(tenantId, entityId));
+        List<EntityRelation> inboundRelations = relationTypeGroup == null
+                    ? relationDao.findAllByTo(tenantId, entityId)
+                    : relationDao.findAllByTo(tenantId, entityId, relationTypeGroup);
+        List<EntityRelation> outboundRelations = relationTypeGroup == null
+                    ? relationDao.findAllByFrom(tenantId, entityId)
+                    : relationDao.findAllByFrom(tenantId, entityId, relationTypeGroup);
 
         if (!inboundRelations.isEmpty()) {
             try {
-                relationDao.deleteInboundRelations(tenantId, entityId);
+                if (relationTypeGroup == null) {
+                    relationDao.deleteInboundRelations(tenantId, entityId);
+                } else {
+                    relationDao.deleteInboundRelations(tenantId, entityId, relationTypeGroup);
+                }
             } catch (ConcurrencyFailureException e) {
                 log.debug("Concurrency exception while deleting relations [{}]", inboundRelations, e);
             }
@@ -241,7 +260,11 @@ public class BaseRelationService implements RelationService {
         }
 
         if (!outboundRelations.isEmpty()) {
-            relationDao.deleteOutboundRelations(tenantId, entityId);
+            if (relationTypeGroup == null) {
+                relationDao.deleteOutboundRelations(tenantId, entityId);
+            } else {
+                relationDao.deleteOutboundRelations(tenantId, entityId, relationTypeGroup);
+            }
 
             for (EntityRelation relation : outboundRelations) {
                 eventPublisher.publishEvent(EntityRelationEvent.from(relation));

dao/src/main/java/org/thingsboard/server/dao/relation/RelationDao.java

@@ -64,8 +64,12 @@ public interface RelationDao {
 
     void deleteOutboundRelations(TenantId tenantId, EntityId entity);
 
+    void deleteOutboundRelations(TenantId tenantId, EntityId entity, RelationTypeGroup relationTypeGroup);
+
     void deleteInboundRelations(TenantId tenantId, EntityId entity);
 
+    void deleteInboundRelations(TenantId tenantId, EntityId entity, RelationTypeGroup relationTypeGroup);
+
     ListenableFuture<Boolean> deleteOutboundRelationsAsync(TenantId tenantId, EntityId entity);
 
     List<EntityRelation> findRuleNodeToRuleChainRelations(RuleChainType ruleChainType, int limit);

dao/src/main/java/org/thingsboard/server/dao/sql/relation/JpaRelationDao.java

@@ -37,6 +37,7 @@ import org.thingsboard.server.dao.util.SqlDao;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -205,6 +206,15 @@ public class JpaRelationDao extends JpaAbstractDaoListeningExecutorService imple
         }
     }
 
+    @Override
+    public void deleteOutboundRelations(TenantId tenantId, EntityId entity, RelationTypeGroup relationTypeGroup) {
+        try {
+            relationRepository.deleteByFromIdAndFromTypeAndRelationTypeGroupIn(entity.getId(), entity.getEntityType().name(), Collections.singletonList(relationTypeGroup.name()));
+        } catch (ConcurrencyFailureException e) {
+            log.debug("Concurrency exception while deleting relations [{}]", entity, e);
+        }
+    }
+
     @Override
     public void deleteInboundRelations(TenantId tenantId, EntityId entity) {
         try {
@@ -214,6 +224,15 @@ public class JpaRelationDao extends JpaAbstractDaoListeningExecutorService imple
         }
     }
 
+    @Override
+    public void deleteInboundRelations(TenantId tenantId, EntityId entity, RelationTypeGroup relationTypeGroup) {
+        try {
+            relationRepository.deleteByToIdAndToTypeAndRelationTypeGroupIn(entity.getId(), entity.getEntityType().name(), Collections.singletonList(relationTypeGroup.name()));
+        } catch (ConcurrencyFailureException e) {
+            log.debug("Concurrency exception while deleting relations [{}]", entity, e);
+        }
+    }
+
     @Override
     public ListenableFuture<Boolean> deleteOutboundRelationsAsync(TenantId tenantId, EntityId entity) {
         return service.submit(

dao/src/main/java/org/thingsboard/server/dao/sql/relation/RelationRepository.java

@@ -82,4 +82,9 @@ public interface RelationRepository
     @Query("DELETE FROM RelationEntity r where r.toId = :toId and r.toType = :toType and r.relationTypeGroup in :relationTypeGroups")
     void deleteByToIdAndToTypeAndRelationTypeGroupIn(@Param("toId") UUID toId, @Param("toType") String toType, @Param("relationTypeGroups") List<String> relationTypeGroups);
 
+    @Transactional
+    @Modifying
+    @Query("DELETE FROM RelationEntity r where r.fromId = :fromId and r.fromType = :fromType and r.relationTypeGroup in :relationTypeGroups")
+    void deleteByFromIdAndFromTypeAndRelationTypeGroupIn(@Param("fromId") UUID fromId, @Param("fromType") String fromType, @Param("relationTypeGroups") List<String> relationTypeGroups);
+
 }

dao/src/test/java/org/thingsboard/server/dao/service/RelationServiceTest.java

@@ -131,6 +131,31 @@ public class RelationServiceTest extends AbstractServiceTest {
         Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, childId, subChildId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON));
     }
 
+    @Test
+    public void testDeleteEntityCommonRelations() {
+        AssetId parentId = new AssetId(Uuids.timeBased());
+        AssetId childId = new AssetId(Uuids.timeBased());
+        AssetId subChildId = new AssetId(Uuids.timeBased());
+
+        EntityRelation relationA = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
+        EntityRelation relationB = new EntityRelation(childId, subChildId, EntityRelation.CONTAINS_TYPE);
+        EntityRelation relationC = new EntityRelation(parentId, childId, EntityRelation.MANAGES_TYPE, RelationTypeGroup.EDGE);
+        EntityRelation relationD = new EntityRelation(childId, subChildId, EntityRelation.MANAGES_TYPE, RelationTypeGroup.EDGE);
+
+        saveRelation(relationA);
+        saveRelation(relationB);
+        saveRelation(relationC);
+        saveRelation(relationD);
+
+        relationService.deleteEntityCommonRelations(SYSTEM_TENANT_ID, childId);
+
+        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON));
+        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, childId, subChildId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON));
+
+        Assert.assertTrue(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, EntityRelation.MANAGES_TYPE, RelationTypeGroup.EDGE));
+        Assert.assertTrue(relationService.checkRelation(SYSTEM_TENANT_ID, childId, subChildId, EntityRelation.MANAGES_TYPE, RelationTypeGroup.EDGE));
+    }
+
     @Test
     public void testFindFrom() throws ExecutionException, InterruptedException {
         AssetId parentA = new AssetId(Uuids.timeBased());