added TbRelationActionNodes (#1287)

* added TbRelationActionNodes

* refactoring RelationActionNodes

* update license header

* fix TbAssignToCustomerNode

* refactoring relation action node

* refactoring CreateRelationNode

* update license header

* refactoring TbCreateRelationNode

* refactoring TbCreateRelationNode

* refactoring TbCreateRelationNode

* update license header

* refactoring TbCreateRelationNode & TbAssignToCustomerNode

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbAbstractCustomerActionNodeConfiguration.java

@@ -17,9 +17,6 @@ package org.thingsboard.rule.engine.action;
 
 import lombok.Data;
 
-/**
- * Created by igor on 6/1/18.
- */
 @Data
 public abstract class TbAbstractCustomerActionNodeConfiguration {
 

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbAbstractRelationActionNode.java

@@ -0,0 +1,222 @@
+/**
+ * Copyright © 2016-2018 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.rule.engine.action;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.rule.engine.api.TbContext;
+import org.thingsboard.rule.engine.api.TbNode;
+import org.thingsboard.rule.engine.api.TbNodeConfiguration;
+import org.thingsboard.rule.engine.api.TbNodeException;
+import org.thingsboard.rule.engine.api.util.TbNodeUtils;
+import org.thingsboard.rule.engine.util.EntityContainer;
+import org.thingsboard.server.common.data.Customer;
+import org.thingsboard.server.common.data.DashboardInfo;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.EntityView;
+import org.thingsboard.server.common.data.asset.Asset;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.EntityIdFactory;
+import org.thingsboard.server.common.data.page.TextPageData;
+import org.thingsboard.server.common.data.page.TextPageLink;
+import org.thingsboard.server.common.data.relation.EntitySearchDirection;
+import org.thingsboard.server.common.msg.TbMsg;
+import org.thingsboard.server.dao.asset.AssetService;
+import org.thingsboard.server.dao.customer.CustomerService;
+import org.thingsboard.server.dao.dashboard.DashboardService;
+import org.thingsboard.server.dao.device.DeviceService;
+import org.thingsboard.server.dao.entityview.EntityViewService;
+
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+
+import static org.thingsboard.rule.engine.api.TbRelationTypes.FAILURE;
+import static org.thingsboard.rule.engine.api.TbRelationTypes.SUCCESS;
+import static org.thingsboard.rule.engine.api.util.DonAsynchron.withCallback;
+
+@Slf4j
+public abstract class TbAbstractRelationActionNode<C extends TbAbstractRelationActionNodeConfiguration> implements TbNode {
+
+    protected C config;
+    protected EntityId fromId;
+    protected EntityId toId;
+
+    private LoadingCache<Entitykey, EntityContainer> entityIdCache;
+
+    @Override
+    public void init(TbContext ctx, TbNodeConfiguration configuration) throws TbNodeException {
+        this.config = loadEntityNodeActionConfig(configuration);
+        CacheBuilder cacheBuilder = CacheBuilder.newBuilder();
+        if (this.config.getEntityCacheExpiration() > 0) {
+            cacheBuilder.expireAfterWrite(this.config.getEntityCacheExpiration(), TimeUnit.SECONDS);
+        }
+        entityIdCache = cacheBuilder
+                .build(new EntityCacheLoader(ctx, createEntityIfNotExists()));
+    }
+
+    @Override
+    public void onMsg(TbContext ctx, TbMsg msg) {
+        withCallback(processEntityRelationAction(ctx, msg),
+                filterResult -> ctx.tellNext(msg, filterResult ? SUCCESS : FAILURE), t -> ctx.tellFailure(msg, t), ctx.getDbCallbackExecutor());
+    }
+
+    @Override
+    public void destroy() {
+    }
+
+    private ListenableFuture<Boolean> processEntityRelationAction(TbContext ctx, TbMsg msg) {
+        return Futures.transformAsync(getEntity(ctx, msg), entityContainer -> doProcessEntityRelationAction(ctx, msg, entityContainer));
+    }
+
+    protected abstract boolean createEntityIfNotExists();
+
+    protected abstract ListenableFuture<Boolean> doProcessEntityRelationAction(TbContext ctx, TbMsg msg, EntityContainer entityContainer);
+
+    protected abstract C loadEntityNodeActionConfig(TbNodeConfiguration configuration) throws TbNodeException;
+
+    protected ListenableFuture<EntityContainer> getEntity(TbContext ctx, TbMsg msg) {
+        String entityName = TbNodeUtils.processPattern(this.config.getEntityNamePattern(), msg.getMetaData());
+        String type = null;
+        if (this.config.getEntityTypePattern() != null) {
+            type = TbNodeUtils.processPattern(this.config.getEntityTypePattern(), msg.getMetaData());
+        }
+        EntityType entityType = EntityType.valueOf(this.config.getEntityType());
+        Entitykey key = new Entitykey(entityName, type, entityType);
+        return ctx.getDbCallbackExecutor().executeAsync(() -> {
+            EntityContainer entityContainer = entityIdCache.get(key);
+            if (entityContainer.getEntityId() == null) {
+                throw new RuntimeException("No entity found with type '" + key.getEntityType() + " ' and name '" + key.getEntityName() + "'.");
+            }
+            return entityContainer;
+        });
+    }
+
+    protected void processSearchDirection(TbMsg msg, EntityContainer entityContainer) {
+        if (EntitySearchDirection.FROM.name().equals(config.getDirection())) {
+            fromId = EntityIdFactory.getByTypeAndId(entityContainer.getEntityType().name(), entityContainer.getEntityId().toString());
+            toId = msg.getOriginator();
+        } else {
+            toId = EntityIdFactory.getByTypeAndId(entityContainer.getEntityType().name(), entityContainer.getEntityId().toString());
+            fromId = msg.getOriginator();
+        }
+    }
+
+    @Data
+    @AllArgsConstructor
+    private static class Entitykey {
+        private String entityName;
+        private String type;
+        private EntityType entityType;
+    }
+
+    private static class EntityCacheLoader extends CacheLoader<Entitykey, EntityContainer> {
+
+        private final TbContext ctx;
+        private final boolean createIfNotExists;
+
+        private EntityCacheLoader(TbContext ctx, boolean createIfNotExists) {
+            this.ctx = ctx;
+            this.createIfNotExists = createIfNotExists;
+        }
+
+        @Override
+        public EntityContainer load(Entitykey key) {
+            return loadEntity(key);
+        }
+
+        private EntityContainer loadEntity(Entitykey entitykey) {
+            EntityType type = entitykey.getEntityType();
+            EntityContainer targetEntity = new EntityContainer();
+            targetEntity.setEntityType(type);
+            switch (type) {
+                case DEVICE:
+                    DeviceService deviceService = ctx.getDeviceService();
+                    Device device = deviceService.findDeviceByTenantIdAndName(ctx.getTenantId(), entitykey.getEntityName());
+                    if (device != null) {
+                        targetEntity.setEntityId(device.getId());
+                    } else if (createIfNotExists) {
+                        Device newDevice = new Device();
+                        newDevice.setName(entitykey.getEntityName());
+                        newDevice.setType(entitykey.getType());
+                        newDevice.setTenantId(ctx.getTenantId());
+                        Device savedDevice = deviceService.saveDevice(newDevice);
+                        targetEntity.setEntityId(savedDevice.getId());
+                    }
+                    break;
+                case ASSET:
+                    AssetService assetService = ctx.getAssetService();
+                    Asset asset = assetService.findAssetByTenantIdAndName(ctx.getTenantId(), entitykey.getEntityName());
+                    if (asset != null) {
+                        targetEntity.setEntityId(asset.getId());
+                    } else if (createIfNotExists) {
+                        Asset newAsset = new Asset();
+                        newAsset.setName(entitykey.getEntityName());
+                        newAsset.setType(entitykey.getType());
+                        newAsset.setTenantId(ctx.getTenantId());
+                        Asset savedAsset = assetService.saveAsset(newAsset);
+                        targetEntity.setEntityId(savedAsset.getId());
+                    }
+                    break;
+                case CUSTOMER:
+                    CustomerService customerService = ctx.getCustomerService();
+                    Optional<Customer> customerOptional = customerService.findCustomerByTenantIdAndTitle(ctx.getTenantId(), entitykey.getEntityName());
+                    if (customerOptional.isPresent()) {
+                        targetEntity.setEntityId(customerOptional.get().getId());
+                    } else if (createIfNotExists) {
+                        Customer newCustomer = new Customer();
+                        newCustomer.setTitle(entitykey.getEntityName());
+                        newCustomer.setTenantId(ctx.getTenantId());
+                        Customer savedCustomer = customerService.saveCustomer(newCustomer);
+                        targetEntity.setEntityId(savedCustomer.getId());
+                    }
+                    break;
+                case TENANT:
+                    targetEntity.setEntityId(ctx.getTenantId());
+                    break;
+                case ENTITY_VIEW:
+                    EntityViewService entityViewService = ctx.getEntityViewService();
+                    EntityView entityView = entityViewService.findEntityViewByTenantIdAndName(ctx.getTenantId(), entitykey.getEntityName());
+                    if (entityView != null) {
+                        targetEntity.setEntityId(entityView.getId());
+                    }
+                    break;
+                case DASHBOARD:
+                    DashboardService dashboardService = ctx.getDashboardService();
+                    TextPageData<DashboardInfo> dashboardInfoTextPageData = dashboardService.findDashboardsByTenantId(ctx.getTenantId(), new TextPageLink(200, entitykey.getEntityName()));
+                    for (DashboardInfo dashboardInfo : dashboardInfoTextPageData.getData()) {
+                        if (dashboardInfo.getTitle().equals(entitykey.getEntityName())) {
+                            targetEntity.setEntityId(dashboardInfo.getId());
+                        }
+                    }
+                    break;
+                default:
+                    return targetEntity;
+            }
+            return targetEntity;
+        }
+
+
+    }
+
+
+}

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbAbstractRelationActionNodeConfiguration.java

@@ -0,0 +1,32 @@
+/**
+ * Copyright © 2016-2018 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.rule.engine.action;
+
+import lombok.Data;
+
+@Data
+public abstract class TbAbstractRelationActionNodeConfiguration {
+
+    private String direction;
+    private String relationType;
+
+    private String entityType;
+    private String entityNamePattern;
+    private String entityTypePattern;
+
+    private long entityCacheExpiration;
+
+}

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbAssignToCustomerNode.java

@@ -52,6 +52,10 @@ public class TbAssignToCustomerNode extends TbAbstractCustomerActionNode<TbAssig
 
     @Override
     protected void doProcessCustomerAction(TbContext ctx, TbMsg msg, CustomerId customerId) {
+        processAssign(ctx, msg, customerId);
+    }
+
+    private void processAssign(TbContext ctx, TbMsg msg, CustomerId customerId) {
         EntityType originatorType = msg.getOriginator().getEntityType();
         switch (originatorType) {
             case DEVICE:

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbCreateRelationNode.java

@@ -0,0 +1,156 @@
+/**
+ * Copyright © 2016-2018 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.rule.engine.action;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.rule.engine.api.RuleNode;
+import org.thingsboard.rule.engine.api.TbContext;
+import org.thingsboard.rule.engine.api.TbNodeConfiguration;
+import org.thingsboard.rule.engine.api.TbNodeException;
+import org.thingsboard.rule.engine.api.util.TbNodeUtils;
+import org.thingsboard.rule.engine.util.EntityContainer;
+import org.thingsboard.server.common.data.id.AssetId;
+import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.DashboardId;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EntityViewId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.plugin.ComponentType;
+import org.thingsboard.server.common.data.relation.EntityRelation;
+import org.thingsboard.server.common.data.relation.RelationTypeGroup;
+import org.thingsboard.server.common.msg.TbMsg;
+
+@Slf4j
+@RuleNode(
+        type = ComponentType.ACTION,
+        name = "create relation",
+        configClazz = TbCreateRelationNodeConfiguration.class,
+        nodeDescription = "Finds target Entity by entity name pattern and (entity type pattern for Asset, Device) and then create a relation to Originator Entity by type and direction." +
+                " If Selected entity type: Asset, Device or Customer will create new Entity if it doesn't exist and 'Create new entity if not exists' is set to true.",
+        nodeDetails = "If the relation already exists or successfully created -  Message send via <b>Success</b> chain, otherwise <b>Failure</b> chain will be used.",
+        uiResources = {"static/rulenode/rulenode-core-config.js"},
+        configDirective = "tbActionNodeCreateRelationConfig",
+        icon = "add_circle"
+)
+public class TbCreateRelationNode extends TbAbstractRelationActionNode<TbCreateRelationNodeConfiguration> {
+
+    @Override
+    protected TbCreateRelationNodeConfiguration loadEntityNodeActionConfig(TbNodeConfiguration configuration) throws TbNodeException {
+        return TbNodeUtils.convert(configuration, TbCreateRelationNodeConfiguration.class);
+    }
+
+    @Override
+    protected boolean createEntityIfNotExists() {
+        return config.isCreateEntityIfNotExists();
+    }
+
+    @Override
+    protected ListenableFuture<Boolean> doProcessEntityRelationAction(TbContext ctx, TbMsg msg, EntityContainer entity) {
+        return createIfAbsent(ctx, msg, entity);
+    }
+
+    private ListenableFuture<Boolean> createIfAbsent(TbContext ctx, TbMsg msg, EntityContainer entityContainer) {
+        processSearchDirection(msg, entityContainer);
+        return Futures.transformAsync(ctx.getRelationService().checkRelation(ctx.getTenantId(), fromId, toId, config.getRelationType(), RelationTypeGroup.COMMON),
+                result -> {
+                    if (!result) {
+                        return processCreateRelation(ctx, entityContainer);
+                    }
+                    return Futures.immediateFuture(true);
+                });
+    }
+
+    private ListenableFuture<Boolean> processCreateRelation(TbContext ctx, EntityContainer entityContainer) {
+        switch (entityContainer.getEntityType()) {
+            case ASSET:
+                return processAsset(ctx, entityContainer);
+            case DEVICE:
+                return processDevice(ctx, entityContainer);
+            case CUSTOMER:
+                return processCustomer(ctx, entityContainer);
+            case DASHBOARD:
+                return processDashboard(ctx, entityContainer);
+            case ENTITY_VIEW:
+                return processView(ctx, entityContainer);
+            case TENANT:
+                return processTenant(ctx, entityContainer);
+        }
+        return Futures.immediateFuture(true);
+    }
+
+    private ListenableFuture<Boolean> processView(TbContext ctx, EntityContainer entityContainer) {
+        return Futures.transformAsync(ctx.getEntityViewService().findEntityViewByIdAsync(ctx.getTenantId(), new EntityViewId(entityContainer.getEntityId().getId())), entityView -> {
+            if (entityView != null) {
+                return ctx.getRelationService().saveRelationAsync(ctx.getTenantId(), new EntityRelation(fromId, toId, config.getRelationType(), RelationTypeGroup.COMMON));
+            } else {
+                return Futures.immediateFuture(true);
+            }
+        });
+    }
+
+    private ListenableFuture<Boolean> processDevice(TbContext ctx, EntityContainer entityContainer) {
+        return Futures.transformAsync(ctx.getDeviceService().findDeviceByIdAsync(ctx.getTenantId(), new DeviceId(entityContainer.getEntityId().getId())), device -> {
+            if (device != null) {
+                return ctx.getRelationService().saveRelationAsync(ctx.getTenantId(), new EntityRelation(fromId, toId, config.getRelationType(), RelationTypeGroup.COMMON));
+            } else {
+                return Futures.immediateFuture(true);
+            }
+        });
+    }
+
+    private ListenableFuture<Boolean> processAsset(TbContext ctx, EntityContainer entityContainer) {
+        return Futures.transformAsync(ctx.getAssetService().findAssetByIdAsync(ctx.getTenantId(), new AssetId(entityContainer.getEntityId().getId())), asset -> {
+            if (asset != null) {
+                return ctx.getRelationService().saveRelationAsync(ctx.getTenantId(), new EntityRelation(fromId, toId, config.getRelationType(), RelationTypeGroup.COMMON));
+            } else {
+                return Futures.immediateFuture(true);
+            }
+        });
+    }
+
+    private ListenableFuture<Boolean> processCustomer(TbContext ctx, EntityContainer entityContainer) {
+        return Futures.transformAsync(ctx.getCustomerService().findCustomerByIdAsync(ctx.getTenantId(), new CustomerId(entityContainer.getEntityId().getId())), customer -> {
+            if (customer != null) {
+                return ctx.getRelationService().saveRelationAsync(ctx.getTenantId(), new EntityRelation(fromId, toId, config.getRelationType(), RelationTypeGroup.COMMON));
+            } else {
+                return Futures.immediateFuture(true);
+            }
+        });
+    }
+
+    private ListenableFuture<Boolean> processDashboard(TbContext ctx, EntityContainer entityContainer) {
+        return Futures.transformAsync(ctx.getDashboardService().findDashboardByIdAsync(ctx.getTenantId(), new DashboardId(entityContainer.getEntityId().getId())), dashboard -> {
+            if (dashboard != null) {
+                return ctx.getRelationService().saveRelationAsync(ctx.getTenantId(), new EntityRelation(fromId, toId, config.getRelationType(), RelationTypeGroup.COMMON));
+            } else {
+                return Futures.immediateFuture(true);
+            }
+        });
+    }
+
+    private ListenableFuture<Boolean> processTenant(TbContext ctx, EntityContainer entityContainer) {
+        return Futures.transformAsync(ctx.getTenantService().findTenantByIdAsync(ctx.getTenantId(), new TenantId(entityContainer.getEntityId().getId())), tenant -> {
+            if (tenant != null) {
+                return ctx.getRelationService().saveRelationAsync(ctx.getTenantId(), new EntityRelation(fromId, toId, config.getRelationType(), RelationTypeGroup.COMMON));
+            } else {
+                return Futures.immediateFuture(true);
+            }
+        });
+    }
+
+}

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbCreateRelationNodeConfiguration.java

@@ -0,0 +1,37 @@
+/**
+ * Copyright © 2016-2018 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.rule.engine.action;
+
+import lombok.Data;
+import org.thingsboard.rule.engine.api.NodeConfiguration;
+import org.thingsboard.server.common.data.relation.EntitySearchDirection;
+
+@Data
+public class TbCreateRelationNodeConfiguration extends TbAbstractRelationActionNodeConfiguration implements NodeConfiguration<TbCreateRelationNodeConfiguration> {
+
+    private boolean createEntityIfNotExists;
+
+    @Override
+    public TbCreateRelationNodeConfiguration defaultConfiguration() {
+        TbCreateRelationNodeConfiguration configuration = new TbCreateRelationNodeConfiguration();
+        configuration.setDirection(EntitySearchDirection.FROM.name());
+        configuration.setRelationType("Contains");
+        configuration.setEntityNamePattern("");
+        configuration.setEntityCacheExpiration(300);
+        configuration.setCreateEntityIfNotExists(false);
+        return configuration;
+    }
+}

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbDeleteRelationNode.java

@@ -0,0 +1,74 @@
+/**
+ * Copyright © 2016-2018 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.rule.engine.action;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.rule.engine.api.RuleNode;
+import org.thingsboard.rule.engine.api.TbContext;
+import org.thingsboard.rule.engine.api.TbNodeConfiguration;
+import org.thingsboard.rule.engine.api.TbNodeException;
+import org.thingsboard.rule.engine.api.util.TbNodeUtils;
+import org.thingsboard.rule.engine.util.EntityContainer;
+import org.thingsboard.server.common.data.plugin.ComponentType;
+import org.thingsboard.server.common.data.relation.RelationTypeGroup;
+import org.thingsboard.server.common.msg.TbMsg;
+
+@Slf4j
+@RuleNode(
+        type = ComponentType.ACTION,
+        name = "delete relation",
+        configClazz = TbDeleteRelationNodeConfiguration.class,
+        nodeDescription = "Finds target Entity by entity name pattern and then delete a relation to Originator Entity by type and direction.",
+        nodeDetails = "If the relation successfully deleted -  Message send via <b>Success</b> chain, otherwise <b>Failure</b> chain will be used.",
+        uiResources = {"static/rulenode/rulenode-core-config.js"},
+        configDirective = "tbActionNodeDeleteRelationConfig",
+        icon = "remove_circle"
+)
+public class TbDeleteRelationNode extends TbAbstractRelationActionNode<TbDeleteRelationNodeConfiguration> {
+
+    @Override
+    protected TbDeleteRelationNodeConfiguration loadEntityNodeActionConfig(TbNodeConfiguration configuration) throws TbNodeException {
+        return TbNodeUtils.convert(configuration, TbDeleteRelationNodeConfiguration.class);
+    }
+
+    @Override
+    protected boolean createEntityIfNotExists() {
+        return false;
+    }
+
+    @Override
+    protected ListenableFuture<Boolean> doProcessEntityRelationAction(TbContext ctx, TbMsg msg, EntityContainer entityContainer) {
+        return deleteIfExist(ctx, msg, entityContainer);
+    }
+
+    private ListenableFuture<Boolean> deleteIfExist(TbContext ctx, TbMsg msg, EntityContainer entityContainer) {
+        processSearchDirection(msg, entityContainer);
+        return Futures.transformAsync(ctx.getRelationService().checkRelation(ctx.getTenantId(), fromId, toId, config.getRelationType(), RelationTypeGroup.COMMON),
+                result -> {
+                    if (result) {
+                        return processDeleteRelation(ctx);
+                    }
+                    return Futures.immediateFuture(true);
+                });
+    }
+
+    private ListenableFuture<Boolean> processDeleteRelation(TbContext ctx) {
+        return ctx.getRelationService().deleteRelationAsync(ctx.getTenantId(), fromId, toId, config.getRelationType(), RelationTypeGroup.COMMON);
+    }
+
+}

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbDeleteRelationNodeConfiguration.java

@@ -0,0 +1,35 @@
+/**
+ * Copyright © 2016-2018 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.rule.engine.action;
+
+import lombok.Data;
+import org.thingsboard.rule.engine.api.NodeConfiguration;
+import org.thingsboard.server.common.data.relation.EntitySearchDirection;
+
+@Data
+public class TbDeleteRelationNodeConfiguration extends TbAbstractRelationActionNodeConfiguration implements NodeConfiguration<TbDeleteRelationNodeConfiguration> {
+
+
+    @Override
+    public TbDeleteRelationNodeConfiguration defaultConfiguration() {
+        TbDeleteRelationNodeConfiguration configuration = new TbDeleteRelationNodeConfiguration();
+        configuration.setDirection(EntitySearchDirection.FROM.name());
+        configuration.setRelationType("Contains");
+        configuration.setEntityNamePattern("");
+        configuration.setEntityCacheExpiration(300);
+        return configuration;
+    }
+}

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/util/EntityContainer.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright © 2016-2018 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.rule.engine.util;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.id.EntityId;
+
+@Data
+public class EntityContainer {
+
+    private EntityId entityId;
+    private EntityType entityType;
+
+}