Naming conventions update

6 years ago · df11b383c1
15 changed files with 98 additions and 98 deletions
--- a/application/src/main/java/org/thingsboard/server/controller/EdgeController.java
+++ b/application/src/main/java/org/thingsboard/server/controller/EdgeController.java
@ -92,10 +92,10 @@ public class EdgeController extends BaseController {
            edge.setTenantId(tenantId);
            boolean created = edge.getId() == null;

-            RuleChain defaultRootEdgeRuleChain = null;
+            RuleChain edgeTemplateRootRuleChain = null;
            if (created) {
-                defaultRootEdgeRuleChain = ruleChainService.getDefaultRootEdgeRuleChain(tenantId);
-                if (defaultRootEdgeRuleChain == null) {
+                edgeTemplateRootRuleChain = ruleChainService.getEdgeTemplateRootRuleChain(tenantId);
+                if (edgeTemplateRootRuleChain == null) {
                    throw new DataValidationException("Root edge rule chain is not available!");
                }
            }
@ -108,8 +108,8 @@ public class EdgeController extends BaseController {
            Edge savedEdge = checkNotNull(edgeService.saveEdge(edge));

            if (created) {
-                ruleChainService.assignRuleChainToEdge(tenantId, defaultRootEdgeRuleChain.getId(), savedEdge.getId());
-                edgeNotificationService.setEdgeRootRuleChain(tenantId, savedEdge, defaultRootEdgeRuleChain.getId());
+                ruleChainService.assignRuleChainToEdge(tenantId, edgeTemplateRootRuleChain.getId(), savedEdge.getId());
+                edgeNotificationService.setEdgeRootRuleChain(tenantId, savedEdge, edgeTemplateRootRuleChain.getId());
                edgeService.assignDefaultRuleChainsToEdge(tenantId, savedEdge.getId());
            }

--- a/application/src/main/java/org/thingsboard/server/controller/RuleChainController.java
+++ b/application/src/main/java/org/thingsboard/server/controller/RuleChainController.java
@ -495,14 +495,14 @@ public class RuleChainController extends BaseController {
    }

    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
-    @RequestMapping(value = "/ruleChain/{ruleChainId}/defaultRootEdge", method = RequestMethod.POST)
+    @RequestMapping(value = "/ruleChain/{ruleChainId}/edgeTemplateRoot", method = RequestMethod.POST)
    @ResponseBody
-    public RuleChain setDefaultRootEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
+    public RuleChain setEdgeTemplateRootRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
        checkParameter(RULE_CHAIN_ID, strRuleChainId);
        try {
            RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
            RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.WRITE);
-            ruleChainService.setDefaultRootEdgeRuleChain(getTenantId(), ruleChainId);
+            ruleChainService.setEdgeTemplateRootRuleChain(getTenantId(), ruleChainId);
            return ruleChain;
        } catch (Exception e) {
            logEntityAction(emptyId(EntityType.RULE_CHAIN),
@ -514,14 +514,14 @@ public class RuleChainController extends BaseController {
    }

    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
-    @RequestMapping(value = "/ruleChain/{ruleChainId}/defaultEdge", method = RequestMethod.POST)
+    @RequestMapping(value = "/ruleChain/{ruleChainId}/autoAssignToEdge", method = RequestMethod.POST)
    @ResponseBody
-    public RuleChain addDefaultEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
+    public RuleChain setAutoAssignToEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
        checkParameter(RULE_CHAIN_ID, strRuleChainId);
        try {
            RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
            RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.WRITE);
-            ruleChainService.addDefaultEdgeRuleChain(getTenantId(), ruleChainId);
+            ruleChainService.setAutoAssignToEdgeRuleChain(getTenantId(), ruleChainId);
            return ruleChain;
        } catch (Exception e) {
            logEntityAction(emptyId(EntityType.RULE_CHAIN),
@ -533,14 +533,14 @@ public class RuleChainController extends BaseController {
    }

    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
-    @RequestMapping(value = "/ruleChain/{ruleChainId}/defaultEdge", method = RequestMethod.DELETE)
+    @RequestMapping(value = "/ruleChain/{ruleChainId}/autoAssignToEdge", method = RequestMethod.DELETE)
    @ResponseBody
-    public RuleChain removeDefaultEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
+    public RuleChain unsetAutoAssignToEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
        checkParameter(RULE_CHAIN_ID, strRuleChainId);
        try {
            RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
            RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.WRITE);
-            ruleChainService.removeDefaultEdgeRuleChain(getTenantId(), ruleChainId);
+            ruleChainService.unsetAutoAssignToEdgeRuleChain(getTenantId(), ruleChainId);
            return ruleChain;
        } catch (Exception e) {
            logEntityAction(emptyId(EntityType.RULE_CHAIN),
@ -552,12 +552,12 @@ public class RuleChainController extends BaseController {
    }

    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
-    @RequestMapping(value = "/ruleChain/defaultEdgeRuleChains", method = RequestMethod.GET)
+    @RequestMapping(value = "/ruleChain/autoAssignToEdgeRuleChains", method = RequestMethod.GET)
    @ResponseBody
-    public List<RuleChain> getDefaultEdgeRuleChains() throws ThingsboardException {
+    public List<RuleChain> getAutoAssignToEdgeRuleChains() throws ThingsboardException {
        try {
            TenantId tenantId = getCurrentUser().getTenantId();
-            return checkNotNull(ruleChainService.findDefaultEdgeRuleChainsByTenantId(tenantId)).get();
+            return checkNotNull(ruleChainService.findAutoAssignToEdgeRuleChainsByTenantId(tenantId)).get();
        } catch (Exception e) {
            throw handleException(e);
        }
--- a/application/src/main/java/org/thingsboard/server/service/install/update/DefaultDataUpdateService.java
+++ b/application/src/main/java/org/thingsboard/server/service/install/update/DefaultDataUpdateService.java
@ -89,7 +89,7 @@ public class DefaultDataUpdateService implements DataUpdateService {
                @Override
                protected void updateEntity(Tenant tenant) {
                    try {
-                        RuleChain defaultEdgeRuleChain = ruleChainService.getDefaultRootEdgeRuleChain(tenant.getId());
+                        RuleChain defaultEdgeRuleChain = ruleChainService.getEdgeTemplateRootRuleChain(tenant.getId());
                        if (defaultEdgeRuleChain == null) {
                            installScripts.createDefaultEdgeRuleChains(tenant.getId());
                        }
--- a/common/dao-api/src/main/java/org/thingsboard/server/dao/rule/RuleChainService.java
+++ b/common/dao-api/src/main/java/org/thingsboard/server/dao/rule/RuleChainService.java
@ -73,14 +73,14 @@ public interface RuleChainService {

    ListenableFuture<TimePageData<RuleChain>> findRuleChainsByTenantIdAndEdgeId(TenantId tenantId, EdgeId edgeId, TimePageLink pageLink);

-    RuleChain getDefaultRootEdgeRuleChain(TenantId tenantId);
+    RuleChain getEdgeTemplateRootRuleChain(TenantId tenantId);

-    boolean setDefaultRootEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);
+    boolean setEdgeTemplateRootRuleChain(TenantId tenantId, RuleChainId ruleChainId);

-    boolean addDefaultEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);
+    boolean setAutoAssignToEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);

-    boolean removeDefaultEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);
+    boolean unsetAutoAssignToEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);

-    ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(TenantId tenantId);
+    ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(TenantId tenantId);

 }
--- a/common/data/src/main/java/org/thingsboard/server/common/data/relation/RelationTypeGroup.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/relation/RelationTypeGroup.java
@ -23,6 +23,6 @@ public enum RelationTypeGroup {
    RULE_CHAIN,
    RULE_NODE,
    EDGE,
-    EDGE_DEFAULT_RULE_CHAIN
+    EDGE_AUTO_ASSIGN_RULE_CHAIN

 }
--- a/dao/src/main/java/org/thingsboard/server/dao/edge/EdgeServiceImpl.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/edge/EdgeServiceImpl.java
@ -340,7 +340,7 @@ public class EdgeServiceImpl extends AbstractEntityService implements EdgeServic
    @Override
    public void assignDefaultRuleChainsToEdge(TenantId tenantId, EdgeId edgeId) {
        log.trace("Executing assignDefaultRuleChainsToEdge, tenantId [{}], edgeId [{}]", tenantId, edgeId);
-        ListenableFuture<List<RuleChain>> future = ruleChainService.findDefaultEdgeRuleChainsByTenantId(tenantId);
+        ListenableFuture<List<RuleChain>> future = ruleChainService.findAutoAssignToEdgeRuleChainsByTenantId(tenantId);
        Futures.addCallback(future, new FutureCallback<List<RuleChain>>() {
            @Override
            public void onSuccess(List<RuleChain> ruleChains) {
--- a/dao/src/main/java/org/thingsboard/server/dao/rule/BaseRuleChainService.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/rule/BaseRuleChainService.java
@ -484,21 +484,21 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
    }

    @Override
-    public RuleChain getDefaultRootEdgeRuleChain(TenantId tenantId) {
+    public RuleChain getEdgeTemplateRootRuleChain(TenantId tenantId) {
        return getRootRuleChainByType(tenantId, RuleChainType.EDGE);
    }

    @Override
-    public boolean setDefaultRootEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
+    public boolean setEdgeTemplateRootRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
        RuleChain ruleChain = ruleChainDao.findById(tenantId, ruleChainId.getId());
-        RuleChain previousDefaultRootEdgeRuleChain = getDefaultRootEdgeRuleChain(ruleChain.getTenantId());
-        if (previousDefaultRootEdgeRuleChain == null || !previousDefaultRootEdgeRuleChain.getId().equals(ruleChain.getId())) {
+        RuleChain previousEdgeTemplateRootRuleChain = getEdgeTemplateRootRuleChain(ruleChain.getTenantId());
+        if (previousEdgeTemplateRootRuleChain == null || !previousEdgeTemplateRootRuleChain.getId().equals(ruleChain.getId())) {
            try {
-                if (previousDefaultRootEdgeRuleChain != null) {
-                    deleteRelation(tenantId, new EntityRelation(previousDefaultRootEdgeRuleChain.getTenantId(), previousDefaultRootEdgeRuleChain.getId(),
+                if (previousEdgeTemplateRootRuleChain != null) {
+                    deleteRelation(tenantId, new EntityRelation(previousEdgeTemplateRootRuleChain.getTenantId(), previousEdgeTemplateRootRuleChain.getId(),
                            EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
-                    previousDefaultRootEdgeRuleChain.setRoot(false);
-                    ruleChainDao.save(tenantId, previousDefaultRootEdgeRuleChain);
+                    previousEdgeTemplateRootRuleChain.setRoot(false);
+                    ruleChainDao.save(tenantId, previousEdgeTemplateRootRuleChain);
                }
                createRelation(tenantId, new EntityRelation(ruleChain.getTenantId(), ruleChain.getId(),
                        EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
@ -506,7 +506,7 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
                ruleChainDao.save(tenantId, ruleChain);
                return true;
            } catch (Exception e) {
-                log.warn("Failed to set default root edge rule chain, ruleChainId: [{}]", ruleChainId, e);
+                log.warn("Failed to set edge template root rule chain, ruleChainId: [{}]", ruleChainId, e);
                throw new RuntimeException(e);
            }
        }
@ -514,34 +514,34 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
    }

    @Override
-    public boolean addDefaultEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
+    public boolean setAutoAssignToEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
        try {
            createRelation(tenantId, new EntityRelation(tenantId, ruleChainId,
-                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_DEFAULT_RULE_CHAIN));
+                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_AUTO_ASSIGN_RULE_CHAIN));
            return true;
        } catch (Exception e) {
-            log.warn("Failed to add default edge rule chain, ruleChainId: [{}]", ruleChainId, e);
+            log.warn("Failed to set auto assign to edge rule chain, ruleChainId: [{}]", ruleChainId, e);
            throw new RuntimeException(e);
        }
    }

    @Override
-    public boolean removeDefaultEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
+    public boolean unsetAutoAssignToEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
        try {
            deleteRelation(tenantId, new EntityRelation(tenantId, ruleChainId,
-                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_DEFAULT_RULE_CHAIN));
+                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_AUTO_ASSIGN_RULE_CHAIN));
            return true;
        } catch (Exception e) {
-            log.warn("Failed to remove default edge rule chain, ruleChainId: [{}]", ruleChainId, e);
+            log.warn("Failed to unset auto assign to edge rule chain, ruleChainId: [{}]", ruleChainId, e);
            throw new RuntimeException(e);
        }
    }

    @Override
-    public ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(TenantId tenantId) {
-        log.trace("Executing findDefaultEdgeRuleChainsByTenantId, tenantId [{}]", tenantId);
+    public ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(TenantId tenantId) {
+        log.trace("Executing findAutoAssignToEdgeRuleChainsByTenantId, tenantId [{}]", tenantId);
        validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
-        return ruleChainDao.findDefaultEdgeRuleChainsByTenantId(tenantId.getId());
+        return ruleChainDao.findAutoAssignToEdgeRuleChainsByTenantId(tenantId.getId());
    }


@ -592,9 +592,9 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
                        }
                    }
                    if (ruleChain.isRoot() && RuleChainType.EDGE.equals(ruleChain.getType())) {
-                        RuleChain defaultRootEdgeRuleChain = getDefaultRootEdgeRuleChain(ruleChain.getTenantId());
-                        if (defaultRootEdgeRuleChain != null && !defaultRootEdgeRuleChain.getId().equals(ruleChain.getId())) {
-                            throw new DataValidationException("Another default root edge rule chain is present in scope of current tenant!");
+                        RuleChain edgeTemplateRootRuleChain = getEdgeTemplateRootRuleChain(ruleChain.getTenantId());
+                        if (edgeTemplateRootRuleChain != null && !edgeTemplateRootRuleChain.getId().equals(ruleChain.getId())) {
+                            throw new DataValidationException("Another edge template root rule chain is present in scope of current tenant!");
                        }
                    }
                }
--- a/dao/src/main/java/org/thingsboard/server/dao/rule/CassandraRuleChainDao.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/rule/CassandraRuleChainDao.java
@ -103,9 +103,10 @@ public class CassandraRuleChainDao extends CassandraAbstractSearchTextDao<RuleCh
    }

    @Override
-    public ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(UUID tenantId) {
-        log.debug("Try to find default edge rule chains by tenantId [{}]", tenantId);
-        ListenableFuture<List<EntityRelation>> relations = relationDao.findAllByFromAndType(new TenantId(tenantId), new TenantId(tenantId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_DEFAULT_RULE_CHAIN);
+    public ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(UUID tenantId) {
+        log.debug("Try to find auto assign to edge rule chains by tenantId [{}]", tenantId);
+        ListenableFuture<List<EntityRelation>> relations =
+                relationDao.findAllByFromAndType(new TenantId(tenantId), new TenantId(tenantId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_AUTO_ASSIGN_RULE_CHAIN);
        return Futures.transformAsync(relations, input -> {
            List<ListenableFuture<RuleChain>> ruleChainFutures = new ArrayList<>(input.size());
            for (EntityRelation relation : input) {
--- a/dao/src/main/java/org/thingsboard/server/dao/rule/RuleChainDao.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/rule/RuleChainDao.java
@ -60,10 +60,10 @@ public interface RuleChainDao extends Dao<RuleChain> {
    ListenableFuture<List<RuleChain>> findRuleChainsByTenantIdAndEdgeId(UUID tenantId, UUID edgeId, TimePageLink pageLink);

    /**
-     * Find default edge rule chains by tenantId.
+     * Find auto assign to edge rule chains by tenantId.
     *
     * @param tenantId the tenantId
     * @return the list of rule chain objects
     */
-    ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(UUID tenantId);
+    ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(UUID tenantId);
 }
--- a/dao/src/main/java/org/thingsboard/server/dao/sql/rule/JpaRuleChainDao.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/sql/rule/JpaRuleChainDao.java
@ -25,9 +25,7 @@ import org.springframework.data.repository.CrudRepository;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.UUIDConverter;
-import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.id.EdgeId;
-import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
@ -107,9 +105,10 @@ public class JpaRuleChainDao extends JpaAbstractSearchTextDao<RuleChainEntity, R
    }

    @Override
-    public ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(UUID tenantId) {
-        log.debug("Try to find default edge rule chains by tenantId [{}]", tenantId);
-        ListenableFuture<List<EntityRelation>> relations = relationDao.findAllByFromAndType(new TenantId(tenantId), new TenantId(tenantId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_DEFAULT_RULE_CHAIN);
+    public ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(UUID tenantId) {
+        log.debug("Try to find auto assign to edge rule chains by tenantId [{}]", tenantId);
+        ListenableFuture<List<EntityRelation>> relations =
+                relationDao.findAllByFromAndType(new TenantId(tenantId), new TenantId(tenantId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_AUTO_ASSIGN_RULE_CHAIN);
        return Futures.transformAsync(relations, input -> {
            List<ListenableFuture<RuleChain>> ruleChainsFutures = new ArrayList<>(input.size());
            for (EntityRelation relation : input) {
--- a/dao/src/test/java/org/thingsboard/server/dao/service/BaseRuleChainServiceTest.java
+++ b/dao/src/test/java/org/thingsboard/server/dao/service/BaseRuleChainServiceTest.java
@ -331,24 +331,24 @@ public abstract class BaseRuleChainServiceTest extends AbstractServiceTest {

    @Test
    public void testGetDefaultEdgeRuleChains() throws Exception {
-        RuleChainId ruleChainId = saveRuleChainAndSetDefaultEdge("Default Edge Rule Chain 1");
-        saveRuleChainAndSetDefaultEdge("Default Edge Rule Chain 2");
-        List<RuleChain> result = ruleChainService.findDefaultEdgeRuleChainsByTenantId(tenantId).get();
+        RuleChainId ruleChainId = saveRuleChainAndSetAutoAssignToEdge("Default Edge Rule Chain 1");
+        saveRuleChainAndSetAutoAssignToEdge("Default Edge Rule Chain 2");
+        List<RuleChain> result = ruleChainService.findAutoAssignToEdgeRuleChainsByTenantId(tenantId).get();
        Assert.assertEquals(2, result.size());

-        ruleChainService.removeDefaultEdgeRuleChain(tenantId, ruleChainId);
+        ruleChainService.unsetAutoAssignToEdgeRuleChain(tenantId, ruleChainId);

-        result = ruleChainService.findDefaultEdgeRuleChainsByTenantId(tenantId).get();
+        result = ruleChainService.findAutoAssignToEdgeRuleChainsByTenantId(tenantId).get();
        Assert.assertEquals(1, result.size());
    }

    @Test
-    public void setDefaultRootEdgeRuleChain() throws Exception {
-        RuleChainId ruleChainId1 = saveRuleChainAndSetDefaultEdge("Default Edge Rule Chain 1");
-        RuleChainId ruleChainId2 = saveRuleChainAndSetDefaultEdge("Default Edge Rule Chain 2");
+    public void setEdgeTemplateRootRuleChain() throws Exception {
+        RuleChainId ruleChainId1 = saveRuleChainAndSetAutoAssignToEdge("Default Edge Rule Chain 1");
+        RuleChainId ruleChainId2 = saveRuleChainAndSetAutoAssignToEdge("Default Edge Rule Chain 2");

-        ruleChainService.setDefaultRootEdgeRuleChain(tenantId, ruleChainId1);
-        ruleChainService.setDefaultRootEdgeRuleChain(tenantId, ruleChainId2);
+        ruleChainService.setEdgeTemplateRootRuleChain(tenantId, ruleChainId1);
+        ruleChainService.setEdgeTemplateRootRuleChain(tenantId, ruleChainId2);

        RuleChain ruleChainById = ruleChainService.findRuleChainById(tenantId, ruleChainId1);
        Assert.assertFalse(ruleChainById.isRoot());
@ -357,13 +357,13 @@ public abstract class BaseRuleChainServiceTest extends AbstractServiceTest {
        Assert.assertTrue(ruleChainById.isRoot());
    }

-    private RuleChainId saveRuleChainAndSetDefaultEdge(String name) {
+    private RuleChainId saveRuleChainAndSetAutoAssignToEdge(String name) {
        RuleChain edgeRuleChain = new RuleChain();
        edgeRuleChain.setTenantId(tenantId);
        edgeRuleChain.setType(RuleChainType.EDGE);
        edgeRuleChain.setName(name);
        RuleChain savedEdgeRuleChain = ruleChainService.saveRuleChain(edgeRuleChain);
-        ruleChainService.addDefaultEdgeRuleChain(tenantId, savedEdgeRuleChain.getId());
+        ruleChainService.setAutoAssignToEdgeRuleChain(tenantId, savedEdgeRuleChain.getId());
        return savedEdgeRuleChain.getId();
    }

--- a/rest-client/src/main/java/org/thingsboard/rest/client/RestClient.java
+++ b/rest-client/src/main/java/org/thingsboard/rest/client/RestClient.java
@ -2262,9 +2262,9 @@ public class RestClient implements ClientHttpRequestInterceptor, Closeable {
                }, params).getBody();
    }

-    public Optional<RuleChain> addDefaultEdgeRuleChain(RuleChainId ruleChainId) {
+    public Optional<RuleChain> setAutoAssignToEdgeRuleChain(RuleChainId ruleChainId) {
        try {
-            ResponseEntity<RuleChain> ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/defaultEdge", null, RuleChain.class, ruleChainId.getId());
+            ResponseEntity<RuleChain> ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/autoAssignToEdge", null, RuleChain.class, ruleChainId.getId());
            return Optional.ofNullable(ruleChain.getBody());
        } catch (HttpClientErrorException exception) {
            if (exception.getStatusCode() == HttpStatus.NOT_FOUND) {
@ -2275,9 +2275,9 @@ public class RestClient implements ClientHttpRequestInterceptor, Closeable {
        }
    }

-    public Optional<RuleChain> removeDefaultEdgeRuleChain(RuleChainId ruleChainId) {
+    public Optional<RuleChain> unsetAutoAssignToEdgeRuleChain(RuleChainId ruleChainId) {
        try {
-            ResponseEntity<RuleChain> ruleChain = restTemplate.exchange(baseURL + "/api/ruleChain/{ruleChainId}/defaultEdge", HttpMethod.DELETE, HttpEntity.EMPTY, RuleChain.class, ruleChainId.getId());
+            ResponseEntity<RuleChain> ruleChain = restTemplate.exchange(baseURL + "/api/ruleChain/{ruleChainId}/autoAssignToEdge", HttpMethod.DELETE, HttpEntity.EMPTY, RuleChain.class, ruleChainId.getId());
            return Optional.ofNullable(ruleChain.getBody());
        } catch (HttpClientErrorException exception) {
            if (exception.getStatusCode() == HttpStatus.NOT_FOUND) {
@ -2288,17 +2288,17 @@ public class RestClient implements ClientHttpRequestInterceptor, Closeable {
        }
    }

-    public List<RuleChain> getDefaultEdgeRuleChains() {
-        return restTemplate.exchange(baseURL + "/api/ruleChain/defaultEdgeRuleChains",
+    public List<RuleChain> getAutoAssignToEdgeRuleChains() {
+        return restTemplate.exchange(baseURL + "/api/ruleChain/autoAssignToEdgeRuleChains",
                HttpMethod.GET,
                HttpEntity.EMPTY,
                new ParameterizedTypeReference<List<RuleChain>>() {
                }).getBody();
    }

-    public Optional<RuleChain> setDefaultRootEdgeRuleChain(RuleChainId ruleChainId) {
+    public Optional<RuleChain> setRootEdgeTemplateRuleChain(RuleChainId ruleChainId) {
        try {
-            ResponseEntity<RuleChain> ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/defaultRootEdge", null, RuleChain.class, ruleChainId.getId());
+            ResponseEntity<RuleChain> ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/edgeTemplateRoot", null, RuleChain.class, ruleChainId.getId());
            return Optional.ofNullable(ruleChain.getBody());
        } catch (HttpClientErrorException exception) {
            if (exception.getStatusCode() == HttpStatus.NOT_FOUND) {
--- a/ui/src/app/api/rule-chain.service.js
+++ b/ui/src/app/api/rule-chain.service.js
@ -40,10 +40,10 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
        getEdgesRuleChains: getEdgesRuleChains,
        assignRuleChainToEdge: assignRuleChainToEdge,
        unassignRuleChainFromEdge: unassignRuleChainFromEdge,
-        setDefaultRootEdgeRuleChain: setDefaultRootEdgeRuleChain,
-        addDefaultEdgeRuleChain: addDefaultEdgeRuleChain,
-        removeDefaultEdgeRuleChain: removeDefaultEdgeRuleChain,
-        getDefaultEdgeRuleChains: getDefaultEdgeRuleChains
+        setEdgeTemplateRootRuleChain: setEdgeTemplateRootRuleChain,
+        setAutoAssignToEdgeRuleChain: setAutoAssignToEdgeRuleChain,
+        unsetAutoAssignToEdgeRuleChain: unsetAutoAssignToEdgeRuleChain,
+        getAutoAssignToEdgeRuleChains: getAutoAssignToEdgeRuleChains
    };

    return service;
@ -350,9 +350,9 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
        return deferred.promise;
    }

-    function setDefaultRootEdgeRuleChain(ruleChainId) {
+    function setEdgeTemplateRootRuleChain(ruleChainId) {
        var deferred = $q.defer();
-        var url = '/api/ruleChain/' + ruleChainId + '/defaultRootEdge';
+        var url = '/api/ruleChain/' + ruleChainId + '/edgeTemplateRoot';
        $http.post(url).then(function success(response) {
            deferred.resolve(response.data);
        }, function fail() {
@ -361,9 +361,9 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
        return deferred.promise;
    }

-    function addDefaultEdgeRuleChain(ruleChainId) {
+    function setAutoAssignToEdgeRuleChain(ruleChainId) {
        var deferred = $q.defer();
-        var url = '/api/ruleChain/' + ruleChainId + '/defaultEdge';
+        var url = '/api/ruleChain/' + ruleChainId + '/autoAssignToEdge';
        $http.post(url, null).then(function success(response) {
            deferred.resolve(response.data);
        }, function fail() {
@ -372,9 +372,9 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
        return deferred.promise;
    }

-    function removeDefaultEdgeRuleChain(ruleChainId) {
+    function unsetAutoAssignToEdgeRuleChain(ruleChainId) {
        var deferred = $q.defer();
-        var url = '/api/ruleChain/' + ruleChainId + '/defaultEdge';
+        var url = '/api/ruleChain/' + ruleChainId + '/autoAssignToEdge';
        $http.delete(url).then(function success(response) {
            deferred.resolve(response.data);
        }, function fail() {
@ -383,9 +383,9 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
        return deferred.promise;
    }

-    function getDefaultEdgeRuleChains(config) {
+    function getAutoAssignToEdgeRuleChains(config) {
        var deferred = $q.defer();
-        var url = '/api/ruleChain/defaultEdgeRuleChains';
+        var url = '/api/ruleChain/autoAssignToEdgeRuleChains';
        $http.get(url, config).then(function success(response) {
            deferred.resolve(response.data);
        }, function fail() {
--- a/ui/src/app/rulechain/rulechains.controller.js
+++ b/ui/src/app/rulechain/rulechains.controller.js
@ -98,7 +98,7 @@ export default function RuleChainsController(ruleChainService, userService, impo
    vm.exportRuleChain = exportRuleChain;
    vm.setRootRuleChain = setRootRuleChain;
    vm.setDefaultEdgeRuleChain = setDefaultEdgeRuleChain;
-    vm.removeDefaultEdgeRuleChain = removeDefaultEdgeRuleChain;
+    vm.unsetAutoAssignToEdgeRuleChain = unsetAutoAssignToEdgeRuleChain;
    
    initController();

@ -195,7 +195,7 @@ export default function RuleChainsController(ruleChainService, userService, impo

            ruleChainActionsList.push({
                onAction: function ($event, item) {
-                    removeDefaultEdgeRuleChain($event, item);
+                    unsetAutoAssignToEdgeRuleChain($event, item);
                },
                name: function() { return $translate.instant('rulechain.remove-default-edge') },
                details: function() { return $translate.instant('rulechain.remove-default-edge') },
@ -205,7 +205,7 @@ export default function RuleChainsController(ruleChainService, userService, impo

            ruleChainActionsList.push({
                onAction: function ($event, item) {
-                    setDefaultRootEdgeRuleChain($event, item);
+                    setEdgeTemplateRootRuleChain($event, item);
                },
                name: function() { return $translate.instant('rulechain.set-default-root-edge') },
                details: function() { return $translate.instant('rulechain.set-default-root-edge') },
@ -339,7 +339,7 @@ export default function RuleChainsController(ruleChainService, userService, impo

    function mapRuleChainsWithDefaultEdges(ruleChains) {
        var deferred = $q.defer();
-        ruleChainService.getDefaultEdgeRuleChains(null).then(
+        ruleChainService.getAutoAssignToEdgeRuleChains(null).then(
            function success(response) {
                let defaultEdgeRuleChainIds = [];
                response.map(function (ruleChain) {
@ -481,7 +481,7 @@ export default function RuleChainsController(ruleChainService, userService, impo
            .cancel($translate.instant('action.no'))
            .ok($translate.instant('action.yes'));
        $mdDialog.show(confirm).then(function () {
-            ruleChainService.addDefaultEdgeRuleChain(ruleChain.id.id).then(
+            ruleChainService.setAutoAssignToEdgeRuleChain(ruleChain.id.id).then(
                    () => {
                        vm.grid.refreshList();
                    }
@ -489,7 +489,7 @@ export default function RuleChainsController(ruleChainService, userService, impo
        });
    }

-    function removeDefaultEdgeRuleChain($event, ruleChain) {
+    function unsetAutoAssignToEdgeRuleChain($event, ruleChain) {
        $event.stopPropagation();
        var confirm = $mdDialog.confirm()
            .targetEvent($event)
@ -499,7 +499,7 @@ export default function RuleChainsController(ruleChainService, userService, impo
            .cancel($translate.instant('action.no'))
            .ok($translate.instant('action.yes'));
        $mdDialog.show(confirm).then(function () {
-            ruleChainService.removeDefaultEdgeRuleChain(ruleChain.id.id).then(
+            ruleChainService.unsetAutoAssignToEdgeRuleChain(ruleChain.id.id).then(
                () => {
                    vm.grid.refreshList();
                }
@ -507,7 +507,7 @@ export default function RuleChainsController(ruleChainService, userService, impo
        });
    }

-    function setDefaultRootEdgeRuleChain($event, ruleChain) {
+    function setEdgeTemplateRootRuleChain($event, ruleChain) {
        $event.stopPropagation();
        var confirm = $mdDialog.confirm()
            .targetEvent($event)
@ -517,7 +517,7 @@ export default function RuleChainsController(ruleChainService, userService, impo
            .cancel($translate.instant('action.no'))
            .ok($translate.instant('action.yes'));
        $mdDialog.show(confirm).then(function () {
-            ruleChainService.setDefaultRootEdgeRuleChain(ruleChain.id.id).then(
+            ruleChainService.setEdgeTemplateRootRuleChain(ruleChain.id.id).then(
                () => {
                    vm.grid.refreshList();
                }
--- a/ui/src/app/rulechain/rulechains.tpl.html
+++ b/ui/src/app/rulechain/rulechains.tpl.html
@ -29,7 +29,7 @@
                     rule-chains-scope="vm.ruleChainsScope"
                     edge="vm.edge"
                     on-set-default-edge-rule-chain="vm.setDefaultEdgeRuleChain(event, vm.grid.detailsConfig.currentItem)"
-                     on-remove-default-edge-rule-chain="vm.removeDefaultEdgeRuleChain(event, vm.grid.detailsConfig.currentItem)"
+                     on-remove-default-edge-rule-chain="vm.unsetAutoAssignToEdgeRuleChain(event, vm.grid.detailsConfig.currentItem)"
                     on-set-root-rule-chain="vm.setRootRuleChain(event, vm.grid.detailsConfig.currentItem)"
                     on-export-rule-chain="vm.exportRuleChain(event, vm.grid.detailsConfig.currentItem)"
                     on-delete-rule-chain="vm.grid.deleteItem(event, vm.grid.detailsConfig.currentItem)">