Merge pull request #14141 from irynamatveieva/feature/aggregation-cf

Related entities aggregation calculated field

application/src/main/data/upgrade/basic/schema_update.sql

@@ -40,6 +40,12 @@ SET profile_data = jsonb_set(
                             WHEN (profile_data -> 'configuration') ? 'maxRelatedEntitiesToReturnPerCfArgument'
                                 THEN NULL
                             ELSE to_jsonb(100)
+                            END,
+                        'minAllowedDeduplicationIntervalInSecForCF',
+                        CASE
+                            WHEN (profile_data -> 'configuration') ? 'minAllowedDeduplicationIntervalInSecForCF'
+                                THEN NULL
+                            ELSE to_jsonb(3600)
                             END
                 )
                ),
@@ -51,6 +57,8 @@ WHERE NOT (
     (profile_data -> 'configuration') ? 'maxRelationLevelPerCfArgument'
         AND
     (profile_data -> 'configuration') ? 'maxRelatedEntitiesToReturnPerCfArgument'
+        AND
+    (profile_data -> 'configuration') ? 'minAllowedDeduplicationIntervalInSecForCF'
     );
 
 -- UPDATE TENANT PROFILE CONFIGURATION END

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldEntityActor.java

@@ -73,6 +73,9 @@ public class CalculatedFieldEntityActor extends AbstractCalculatedFieldActor {
             case CF_ENTITY_DELETE_MSG:
                 processor.process((CalculatedFieldEntityDeleteMsg) msg);
                 break;
+            case CF_RELATION_ACTION_MSG:
+                processor.process((CalculatedFieldRelationActionMsg) msg);
+                break;
             case CF_ENTITY_TELEMETRY_MSG:
                 processor.process((EntityCalculatedFieldTelemetryMsg) msg);
                 break;

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldEntityMessageProcessor.java

@@ -52,6 +52,7 @@ import org.thingsboard.server.service.cf.ctx.state.ArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldCtx;
 import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.SingleValueArgumentEntry;
+import org.thingsboard.server.service.cf.ctx.state.aggregation.RelatedEntitiesAggregationCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.alarm.AlarmCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingCalculatedFieldState;
@@ -122,6 +123,9 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
         if (state != null) {
             state.setCtx(msg.getCtx(), actorCtx);
             state.setPartition(msg.getPartition());
+            if (state instanceof RelatedEntitiesAggregationCalculatedFieldState relatedEntitiesAggState) {
+                relatedEntitiesAggState.scheduleReevaluation();
+            }
             states.put(cfId, state);
         } else {
             removeState(cfId);
@@ -188,7 +192,7 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
         }
     }
 
-    public void process(CalculatedFieldEntityDeleteMsg msg) {
+    public void process(CalculatedFieldEntityDeleteMsg msg) throws CalculatedFieldException {
         log.debug("[{}] Processing CF entity delete msg.", msg.getEntityId());
         if (this.entityId.equals(msg.getEntityId())) {
             if (states.isEmpty()) {
@@ -209,6 +213,68 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
         }
     }
 
+    public void process(CalculatedFieldRelationActionMsg msg) throws CalculatedFieldException {
+        log.debug("[{}] Processing CF {} related entity msg.", msg.getRelatedEntityId(), msg.getAction());
+        switch (msg.getAction()) {
+            case UPDATED -> handleRelationUpdate(msg);
+            case DELETED -> handleRelationDelete(msg);
+            default -> msg.getCallback().onSuccess();
+        }
+    }
+
+    private void handleRelationUpdate(CalculatedFieldRelationActionMsg msg) throws CalculatedFieldException {
+        CalculatedFieldCtx ctx = msg.getCalculatedField();
+        var callback = new MultipleTbCallback(CALLBACKS_PER_CF, msg.getCallback());
+        var state = states.get(ctx.getCfId());
+        try {
+            Map<String, ArgumentEntry> updatedArgs = new HashMap<>();
+            if (state == null) {
+                state = createState(ctx);
+            } else {
+                if (state instanceof RelatedEntitiesAggregationCalculatedFieldState relatedEntitiesAggState) {
+                    Map<String, ArgumentEntry> fetchedArgs = cfService.fetchArgsFromDb(tenantId, msg.getRelatedEntityId(), ctx.getArguments());
+                    updatedArgs = relatedEntitiesAggState.updateEntityData(setEntityIdToSingleEntityArguments(msg.getRelatedEntityId(), fetchedArgs));
+                }
+
+                state.checkStateSize(new CalculatedFieldEntityCtxId(tenantId, ctx.getCfId(), entityId), ctx.getMaxStateSize());
+            }
+            if (state.isSizeOk()) {
+                processStateIfReady(state, updatedArgs, ctx, Collections.singletonList(ctx.getCfId()), null, null, callback);
+            } else {
+                throw CalculatedFieldException.builder().ctx(ctx).eventEntity(entityId).errorMessage(ctx.getSizeExceedsLimitMessage()).build();
+            }
+        } catch (Exception e) {
+            log.debug("[{}][{}] Failed to initialize CF state", entityId, ctx.getCfId(), e);
+            if (e instanceof CalculatedFieldException cfe) {
+                throw cfe;
+            }
+            throw CalculatedFieldException.builder().ctx(ctx).eventEntity(entityId).cause(e).build();
+        }
+    }
+
+    private void handleRelationDelete(CalculatedFieldRelationActionMsg msg) throws CalculatedFieldException {
+        CalculatedFieldCtx ctx = msg.getCalculatedField();
+        CalculatedFieldId cfId = ctx.getCfId();
+        CalculatedFieldState state = states.get(cfId);
+        if (state == null) {
+            msg.getCallback().onSuccess();
+            return;
+        }
+        if (state instanceof RelatedEntitiesAggregationCalculatedFieldState aggState) {
+            aggState.cleanupEntityData(msg.getRelatedEntityId());
+
+            state.checkStateSize(new CalculatedFieldEntityCtxId(tenantId, ctx.getCfId(), entityId), ctx.getMaxStateSize());
+
+            if (state.isSizeOk()) {
+                processStateIfReady(state, Collections.emptyMap(), ctx, Collections.singletonList(ctx.getCfId()), null, null, msg.getCallback());
+            } else {
+                throw new RuntimeException(ctx.getSizeExceedsLimitMessage());
+            }
+        } else {
+            msg.getCallback().onSuccess();
+        }
+    }
+
     public void process(EntityCalculatedFieldTelemetryMsg msg) throws CalculatedFieldException {
         log.trace("[{}] Processing CF telemetry msg: {}", msg.getEntityId(), msg);
         var proto = msg.getProto();
@@ -239,7 +305,7 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
                 } else if (proto.getAttrDataCount() > 0) {
                     processArgumentValuesUpdate(ctx, cfIds, callback, mapToArguments(ctx, msg.getEntityId(), proto.getScope(), proto.getAttrDataList()), toTbMsgId(proto), toTbMsgType(proto));
                 } else if (proto.getRemovedTsKeysCount() > 0) {
-                    processArgumentValuesUpdate(ctx, cfIds, callback, mapToArgumentsWithFetchedValue(ctx, proto.getRemovedTsKeysList()), toTbMsgId(proto), toTbMsgType(proto));
+                    processArgumentValuesUpdate(ctx, cfIds, callback, mapToArgumentsWithFetchedValue(ctx, msg.getEntityId(), proto.getRemovedTsKeysList()), toTbMsgId(proto), toTbMsgType(proto));
                 } else if (proto.getRemovedAttrKeysCount() > 0) {
                     processArgumentValuesUpdate(ctx, cfIds, callback, mapToArgumentsWithDefaultValue(ctx, msg.getEntityId(), proto.getScope(), proto.getRemovedAttrKeysList()), toTbMsgId(proto), toTbMsgType(proto));
                 } else {
@@ -315,7 +381,7 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
     }
 
     private void processRemovedTelemetry(CalculatedFieldCtx ctx, CalculatedFieldTelemetryMsgProto proto, List<CalculatedFieldId> cfIdList, TbCallback callback) throws CalculatedFieldException {
-        processArgumentValuesUpdate(ctx, cfIdList, callback, mapToArgumentsWithFetchedValue(ctx, proto.getRemovedTsKeysList()), toTbMsgId(proto), toTbMsgType(proto));
+        processArgumentValuesUpdate(ctx, cfIdList, callback, mapToArgumentsWithFetchedValue(ctx, entityId, proto.getRemovedTsKeysList()), toTbMsgId(proto), toTbMsgType(proto));
     }
 
     private void processRemovedAttributes(CalculatedFieldCtx ctx, CalculatedFieldTelemetryMsgProto proto, List<CalculatedFieldId> cfIdList, TbCallback callback) throws CalculatedFieldException {
@@ -465,56 +531,67 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
     }
 
     private Map<String, ArgumentEntry> mapToArguments(CalculatedFieldCtx ctx, List<TsKvProto> data) {
-        return mapToArguments(ctx.getMainEntityArguments(), data);
+        return mapToArguments(entityId, ctx.getMainEntityArguments(), Collections.emptyMap(), data);
     }
 
     private Map<String, ArgumentEntry> mapToArguments(CalculatedFieldCtx ctx, EntityId entityId, List<TsKvProto> data) {
-        return mapToArguments(ctx.getLinkedAndDynamicArgs(entityId), data);
+        return mapToArguments(entityId, ctx.getLinkedAndDynamicArgs(entityId), ctx.getRelatedEntityArguments(), data);
     }
 
-    private Map<String, ArgumentEntry> mapToArguments(Map<ReferencedEntityKey, Set<String>> args, List<TsKvProto> data) {
-        if (args.isEmpty()) {
-            return Collections.emptyMap();
-        }
+    private Map<String, ArgumentEntry> mapToArguments(EntityId originator, Map<ReferencedEntityKey, Set<String>> args, Map<ReferencedEntityKey, Set<String>> relatedEntityArgs, List<TsKvProto> data) {
         Map<String, ArgumentEntry> arguments = new HashMap<>();
-        for (TsKvProto item : data) {
-            ReferencedEntityKey key = new ReferencedEntityKey(item.getKv().getKey(), ArgumentType.TS_LATEST, null);
-            Set<String> argNames = args.get(key);
-            if (argNames != null) {
-                argNames.forEach(argName -> {
-                    arguments.put(argName, new SingleValueArgumentEntry(item));
-                });
-            }
-
-            key = new ReferencedEntityKey(item.getKv().getKey(), ArgumentType.TS_ROLLING, null);
-            argNames = args.get(key);
-            if (argNames != null) {
-                argNames.forEach(argName -> {
-                    arguments.put(argName, new SingleValueArgumentEntry(item));
-                });
+        if (!relatedEntityArgs.isEmpty() || !args.isEmpty()) {
+            for (TsKvProto item : data) {
+                ReferencedEntityKey key = new ReferencedEntityKey(item.getKv().getKey(), ArgumentType.TS_LATEST, null);
+                Set<String> argNames = relatedEntityArgs.get(key);
+                if (argNames != null) {
+                    argNames.forEach(argName -> {
+                        arguments.put(argName, new SingleValueArgumentEntry(originator, item));
+                    });
+                }
+                argNames = args.get(key);
+                if (argNames != null) {
+                    argNames.forEach(argName -> {
+                        arguments.put(argName, new SingleValueArgumentEntry(item));
+                    });
+                }
+                key = new ReferencedEntityKey(item.getKv().getKey(), ArgumentType.TS_ROLLING, null);
+                argNames = args.get(key);
+                if (argNames != null) {
+                    argNames.forEach(argName -> {
+                        arguments.put(argName, new SingleValueArgumentEntry(item));
+                    });
+                }
             }
         }
         return arguments;
     }
 
     private Map<String, ArgumentEntry> mapToArguments(CalculatedFieldCtx ctx, AttributeScopeProto scope, List<AttributeValueProto> attrDataList) {
-        return mapToArguments(entityId, ctx.getMainEntityArguments(), ctx.getMainEntityGeofencingArgumentNames(), scope, attrDataList);
+        return mapToArguments(entityId, ctx.getMainEntityArguments(), ctx.getMainEntityGeofencingArgumentNames(), Collections.emptyMap(), scope, attrDataList);
     }
 
     private Map<String, ArgumentEntry> mapToArguments(CalculatedFieldCtx ctx, EntityId entityId, AttributeScopeProto scope, List<AttributeValueProto> attrDataList) {
-        var argNames = ctx.getLinkedAndDynamicArgs(entityId);
-        if (argNames.isEmpty()) {
-            return Collections.emptyMap();
-        }
+        var args = ctx.getLinkedAndDynamicArgs(entityId);
+        var relatedEntityArgs = ctx.getRelatedEntityArguments();
         List<String> geofencingArgumentNames = ctx.getLinkedEntityAndCurrentOwnerGeofencingArgumentNames();
-        return mapToArguments(entityId, argNames, geofencingArgumentNames, scope, attrDataList);
+        return mapToArguments(entityId, args, geofencingArgumentNames, relatedEntityArgs, scope, attrDataList);
     }
 
-    private Map<String, ArgumentEntry> mapToArguments(EntityId entityId, Map<ReferencedEntityKey, Set<String>> args, List<String> geofencingArgNames, AttributeScopeProto scope, List<AttributeValueProto> attrDataList) {
+    private Map<String, ArgumentEntry> mapToArguments(EntityId entityId, Map<ReferencedEntityKey, Set<String>> args, List<String> geofencingArgNames, Map<ReferencedEntityKey, Set<String>> relatedEntityArgs, AttributeScopeProto scope, List<AttributeValueProto> attrDataList) {
+        if (args.isEmpty() && relatedEntityArgs.isEmpty()) {
+            return Collections.emptyMap();
+        }
         Map<String, ArgumentEntry> arguments = new HashMap<>();
         for (AttributeValueProto item : attrDataList) {
             ReferencedEntityKey key = new ReferencedEntityKey(item.getKey(), ArgumentType.ATTRIBUTE, AttributeScope.valueOf(scope.name()));
-            Set<String> argNames = args.get(key);
+            Set<String> argNames = relatedEntityArgs.get(key);
+            if (argNames != null) {
+                argNames.forEach(argName -> {
+                    arguments.put(argName, new SingleValueArgumentEntry(entityId, item));
+                });
+            }
+            argNames = args.get(key);
             if (argNames == null) {
                 continue;
             }
@@ -530,23 +607,38 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
     }
 
     private Map<String, ArgumentEntry> mapToArgumentsWithDefaultValue(CalculatedFieldCtx ctx, EntityId entityId, AttributeScopeProto scope, List<String> removedAttrKeys) {
-        var argNames = ctx.getLinkedAndDynamicArgs(entityId);
-        if (argNames.isEmpty()) {
-            return Collections.emptyMap();
-        }
+        var args = ctx.getLinkedAndDynamicArgs(entityId);
+        var relatedEntityArgs = ctx.getRelatedEntityArguments();
         List<String> geofencingArgumentNames = ctx.getLinkedEntityAndCurrentOwnerGeofencingArgumentNames();
-        return mapToArgumentsWithDefaultValue(argNames, ctx.getArguments(), geofencingArgumentNames, scope, removedAttrKeys);
+        return mapToArgumentsWithDefaultValue(entityId, args, ctx.getArguments(), geofencingArgumentNames, relatedEntityArgs, scope, removedAttrKeys);
     }
 
     private Map<String, ArgumentEntry> mapToArgumentsWithDefaultValue(CalculatedFieldCtx ctx, AttributeScopeProto scope, List<String> removedAttrKeys) {
-        return mapToArgumentsWithDefaultValue(ctx.getMainEntityArguments(), ctx.getArguments(), ctx.getMainEntityGeofencingArgumentNames(), scope, removedAttrKeys);
+        return mapToArgumentsWithDefaultValue(null, ctx.getMainEntityArguments(), ctx.getArguments(), ctx.getMainEntityGeofencingArgumentNames(), Collections.emptyMap(), scope, removedAttrKeys);
     }
 
-    private Map<String, ArgumentEntry> mapToArgumentsWithDefaultValue(Map<ReferencedEntityKey, Set<String>> args, Map<String, Argument> configArguments, List<String> geofencingArgNames, AttributeScopeProto scope, List<String> removedAttrKeys) {
+    private Map<String, ArgumentEntry> mapToArgumentsWithDefaultValue(EntityId msgEntityId,
+                                                                      Map<ReferencedEntityKey, Set<String>> args,
+                                                                      Map<String, Argument> configArguments,
+                                                                      List<String> geofencingArgNames,
+                                                                      Map<ReferencedEntityKey, Set<String>> relatedEntityArgs,
+                                                                      AttributeScopeProto scope,
+                                                                      List<String> removedAttrKeys) {
+        if (args.isEmpty() && relatedEntityArgs.isEmpty()) {
+            return Collections.emptyMap();
+        }
         Map<String, ArgumentEntry> arguments = new HashMap<>();
         for (String removedKey : removedAttrKeys) {
             ReferencedEntityKey key = new ReferencedEntityKey(removedKey, ArgumentType.ATTRIBUTE, AttributeScope.valueOf(scope.name()));
-            Set<String> argNames = args.get(key);
+            Set<String> argNames = relatedEntityArgs.get(key);
+            if (argNames != null) {
+                argNames.forEach(argName -> {
+                    String defaultValue = getDefaultValue(configArguments, argName);
+                    SingleValueArgumentEntry argumentEntry = buildSingleValue(removedKey, defaultValue, System.currentTimeMillis());
+                    arguments.put(argName, new SingleValueArgumentEntry(msgEntityId, argumentEntry));
+                });
+            }
+            argNames = args.get(key);
             if (argNames == null) {
                 continue;
             }
@@ -554,28 +646,49 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
                 if (geofencingArgNames.contains(argName)) {
                     arguments.put(argName, new GeofencingArgumentEntry());
                 } else {
-                    Argument argument = configArguments.get(argName);
-                    String defaultValue = (argument != null) ? argument.getDefaultValue() : null;
-                    arguments.put(argName, StringUtils.isNotEmpty(defaultValue)
-                            ? new SingleValueArgumentEntry(System.currentTimeMillis(), new StringDataEntry(removedKey, defaultValue), null)
-                            : new SingleValueArgumentEntry());
+                    String defaultValue = getDefaultValue(configArguments, argName);
+                    SingleValueArgumentEntry argumentEntry = buildSingleValue(removedKey, defaultValue, System.currentTimeMillis());
+                    arguments.put(argName, new SingleValueArgumentEntry(argumentEntry));
                 }
             });
         }
         return arguments;
     }
 
-    private Map<String, ArgumentEntry> mapToArgumentsWithFetchedValue(CalculatedFieldCtx ctx, List<String> removedTelemetryKeys) {
+    private String getDefaultValue(Map<String, Argument> configArguments, String argNames) {
+        Argument argument = configArguments.get(argNames);
+        return argument != null ? argument.getDefaultValue() : null;
+    }
+
+    private SingleValueArgumentEntry buildSingleValue(String attrKey, String defaultValue, long ts) {
+        return StringUtils.isNotEmpty(defaultValue)
+                ? new SingleValueArgumentEntry(ts, new StringDataEntry(attrKey, defaultValue), null)
+                : new SingleValueArgumentEntry();
+    }
+
+    private Map<String, ArgumentEntry> mapToArgumentsWithFetchedValue(CalculatedFieldCtx ctx, EntityId entityId, List<String> removedTelemetryKeys) {
         Map<String, Argument> deletedArguments = ctx.getArguments().entrySet().stream()
                 .filter(entry -> removedTelemetryKeys.contains(entry.getValue().getRefEntityKey().getKey()))
                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
 
         Map<String, ArgumentEntry> fetchedArgs = cfService.fetchArgsFromDb(tenantId, entityId, deletedArguments);
 
+        if (CalculatedFieldType.RELATED_ENTITIES_AGGREGATION.equals(ctx.getCfType())) {
+            fetchedArgs = setEntityIdToSingleEntityArguments(entityId, fetchedArgs);
+        }
         fetchedArgs.values().forEach(arg -> arg.setForceResetPrevious(true));
+
         return fetchedArgs;
     }
 
+    private Map<String, ArgumentEntry> setEntityIdToSingleEntityArguments(EntityId relatedEntityId, Map<String, ArgumentEntry> fetchedArgs) {
+        return fetchedArgs.entrySet().stream()
+                .collect(Collectors.toMap(
+                        Map.Entry::getKey,
+                        argEntry -> new SingleValueArgumentEntry(relatedEntityId, argEntry.getValue())
+                ));
+    }
+
     private static List<CalculatedFieldId> getCalculatedFieldIds(CalculatedFieldTelemetryMsgProto proto) {
         List<CalculatedFieldId> cfIds = new LinkedList<>();
         for (var cfId : proto.getPreviousCalculatedFieldsList()) {

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldManagerMessageProcessor.java

@@ -16,6 +16,7 @@
 package org.thingsboard.server.actors.calculatedField;
 
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.function.TriConsumer;
 import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.actors.ActorSystemContext;
 import org.thingsboard.server.actors.TbActorCtx;
@@ -29,14 +30,22 @@ import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.ProfileEntityIdInfo;
 import org.thingsboard.server.common.data.alarm.Alarm;
+import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
+import org.thingsboard.server.common.data.cf.CalculatedFieldType;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.RelatedEntitiesAggregationCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageDataIterable;
+import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
+import org.thingsboard.server.common.data.relation.EntityRelation;
+import org.thingsboard.server.common.data.relation.EntityRelationPathQuery;
+import org.thingsboard.server.common.data.relation.EntitySearchDirection;
+import org.thingsboard.server.common.data.relation.RelationPathLevel;
 import org.thingsboard.server.common.msg.CalculatedFieldStatePartitionRestoreMsg;
 import org.thingsboard.server.common.msg.cf.CalculatedFieldCacheInitMsg;
 import org.thingsboard.server.common.msg.cf.CalculatedFieldEntityLifecycleMsg;
@@ -48,6 +57,7 @@ import org.thingsboard.server.dao.asset.AssetService;
 import org.thingsboard.server.dao.cf.CalculatedFieldService;
 import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.dao.device.DeviceService;
+import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.queue.settings.TbQueueCalculatedFieldSettings;
 import org.thingsboard.server.service.cf.CalculatedFieldProcessingService;
 import org.thingsboard.server.service.cf.CalculatedFieldStateService;
@@ -69,6 +79,7 @@ import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import static org.thingsboard.server.utils.CalculatedFieldUtils.fromProto;
 
@@ -90,6 +101,7 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
     private final DeviceService deviceService;
     private final AssetService assetService;
     private final CustomerService customerService;
+    private final RelationService relationService;
     private final TbAssetProfileCache assetProfileCache;
     private final TbDeviceProfileCache deviceProfileCache;
     private final TenantEntityProfileCache entityProfileCache;
@@ -107,6 +119,7 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
         this.deviceService = systemContext.getDeviceService();
         this.assetService = systemContext.getAssetService();
         this.customerService = systemContext.getCustomerService();
+        this.relationService = systemContext.getRelationService();
         this.assetProfileCache = systemContext.getAssetProfileCache();
         this.deviceProfileCache = systemContext.getDeviceProfileCache();
         this.entityProfileCache = new TenantEntityProfileCache();
@@ -175,9 +188,14 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
     }
 
     public void onEntityLifecycleMsg(CalculatedFieldEntityLifecycleMsg msg) throws CalculatedFieldException {
-        log.debug("Processing entity lifecycle event: [{}] for entity: [{}]", msg.getData().getEvent(), msg.getData().getEntityId());
-        var entityType = msg.getData().getEntityId().getEntityType();
         var event = msg.getData().getEvent();
+        if (ComponentLifecycleEvent.RELATION_UPDATED.equals(event) || ComponentLifecycleEvent.RELATION_DELETED.equals(event)) {
+            log.debug("Processing relation [{}] event from entity: [{}]", event, msg.getData().getEntityId());
+            onRelationChangedEvent(msg.getData(), msg.getCallback());
+            return;
+        }
+        log.debug("Processing entity lifecycle event: [{}] for entity: [{}]", event, msg.getData().getEntityId());
+        var entityType = msg.getData().getEntityId().getEntityType();
         switch (entityType) {
             case CALCULATED_FIELD -> {
                 switch (event) {
@@ -233,6 +251,7 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
             entityProfileCache.add(profileId, entityId);
         }
         updateEntityOwner(entityId);
+
         if (!isMyPartition(entityId, callback)) {
             return;
         }
@@ -284,6 +303,55 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
         }
     }
 
+    private void onRelationChangedEvent(ComponentLifecycleMsg msg, TbCallback callback) {
+        Function<EntityId, TriConsumer<EntityId, CalculatedFieldCtx, TbCallback>> relationAction = switch (msg.getEvent()) {
+            case RELATION_UPDATED -> relatedId -> (entityId, ctx, cb) -> initRelatedEntity(entityId, relatedId, ctx, cb);
+            case RELATION_DELETED -> relatedId -> (entityId, ctx, cb) -> deleteRelatedEntity(entityId, relatedId, ctx, cb);
+            default -> null;
+        };
+
+        if (relationAction == null) {
+            callback.onSuccess();
+            return;
+        }
+
+        EntityRelation entityRelation = JacksonUtil.treeToValue(msg.getInfo(), EntityRelation.class);
+        EntityId toId = entityRelation.getTo();
+        EntityId fromId = entityRelation.getFrom();
+        String relationType = entityRelation.getType();
+
+        MultipleTbCallback callbackForToAndFrom = new MultipleTbCallback(2, callback);
+        processRelationByDirection(EntitySearchDirection.TO, relationType, toId, callbackForToAndFrom, relationAction.apply(fromId));
+        processRelationByDirection(EntitySearchDirection.FROM, relationType, fromId, callbackForToAndFrom, relationAction.apply(toId));
+    }
+
+
+    private void processRelationByDirection(EntitySearchDirection direction,
+                                            String relationType,
+                                            EntityId mainId,
+                                            MultipleTbCallback parentCallback,
+                                            TriConsumer<EntityId, CalculatedFieldCtx, TbCallback> relationAction) {
+        List<CalculatedFieldCtx> cfsByEntityIdAndProfile = getCalculatedFieldsByEntityIdAndProfile(mainId);
+        if (cfsByEntityIdAndProfile.isEmpty()) {
+            parentCallback.onSuccess();
+            return;
+        }
+
+        List<CalculatedFieldCtx> matchingCfs = cfsByEntityIdAndProfile.stream()
+                .filter(cf -> {
+                    var config = (RelatedEntitiesAggregationCalculatedFieldConfiguration) cf.getCalculatedField().getConfiguration();
+                    RelationPathLevel relation = config.getRelation();
+                    return direction.equals(relation.direction()) && relationType.equals(relation.relationType());
+                })
+                .toList();
+
+        MultipleTbCallback directionCallback = new MultipleTbCallback(matchingCfs.size(), parentCallback);
+
+        matchingCfs.forEach(ctx ->
+                applyToTargetCfEntityActors(ctx, directionCallback, (entityId, cb) -> relationAction.accept(entityId, ctx, cb))
+        );
+    }
+
     private void onCfCreated(ComponentLifecycleMsg msg, TbCallback callback) throws CalculatedFieldException {
         var cfId = new CalculatedFieldId(msg.getEntityId().getId());
         if (calculatedFields.containsKey(cfId)) {
@@ -411,8 +479,8 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
     public void onTelemetryMsg(CalculatedFieldTelemetryMsg msg) {
         EntityId entityId = msg.getEntityId();
         log.debug("Received telemetry msg from entity [{}]", entityId);
-        // 3 = 1 for CF processing + 1 for links processing + 1 for owner entity processing
-        MultipleTbCallback callback = new MultipleTbCallback(3, msg.getCallback());
+        // 4 = 1 for CF processing + 1 for links processing + 1 for owner entity processing + 1 for aggregation processing
+        MultipleTbCallback callback = new MultipleTbCallback(4, msg.getCallback());
         // process all cfs related to entity, or it's profile;
         var entityIdFields = getCalculatedFieldsByEntityId(entityId);
         var profileIdFields = getCalculatedFieldsByEntityId(getProfileId(tenantId, entityId));
@@ -441,6 +509,49 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
         } else {
             callback.onSuccess();
         }
+        // process all aggregation cfs (if any);
+        List<CalculatedFieldEntityCtxId> aggregationCalculatedFields = filterAggregationCfs(msg);
+        if (!aggregationCalculatedFields.isEmpty()) {
+            cfExecService.pushMsgToLinks(msg, aggregationCalculatedFields, callback);
+        } else {
+            callback.onSuccess();
+        }
+    }
+
+    private List<CalculatedFieldEntityCtxId> filterAggregationCfs(CalculatedFieldTelemetryMsg msg) {
+        EntityId entityId = msg.getEntityId();
+        return calculatedFields.values().stream()
+                .filter(cf -> CalculatedFieldType.RELATED_ENTITIES_AGGREGATION.equals(cf.getCfType()))
+                .filter(cf -> cf.relatedEntityMatches(msg.getProto()))
+                .flatMap(cf -> findRelationsForCf(entityId, cf).stream())
+                .toList();
+    }
+
+    private List<CalculatedFieldEntityCtxId> findRelationsForCf(EntityId entityId, CalculatedFieldCtx cf) {
+        List<CalculatedFieldEntityCtxId> result = new ArrayList<>();
+        if (cf.getCalculatedField().getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration configuration) {
+            RelationPathLevel relation = configuration.getRelation();
+            EntitySearchDirection inverseDirection = switch (relation.direction()) {
+                case FROM -> EntitySearchDirection.TO;
+                case TO -> EntitySearchDirection.FROM;
+            };
+            RelationPathLevel inverseRelation = new RelationPathLevel(inverseDirection, relation.relationType());
+            List<EntityRelation> byRelationPathQuery = relationService.findByRelationPathQuery(tenantId, new EntityRelationPathQuery(entityId, List.of(inverseRelation)));
+            if (byRelationPathQuery != null && !byRelationPathQuery.isEmpty()) {
+                switch (relation.direction()) {
+                    case FROM -> {
+                        EntityRelation entityRelation = byRelationPathQuery.get(0); // only one supported
+                        result.add(new CalculatedFieldEntityCtxId(tenantId, cf.getCfId(), entityRelation.getFrom()));
+                    }
+                    case TO -> {
+                        byRelationPathQuery.stream()
+                                .filter(entityRelation -> entityRelation.getTo().equals(cf.getEntityId()))
+                                .forEach(entityRelation -> result.add(new CalculatedFieldEntityCtxId(tenantId, cf.getCfId(), entityRelation.getTo())));
+                    }
+                }
+            }
+        }
+        return result;
     }
 
     public void onLinkedTelemetryMsg(CalculatedFieldLinkedTelemetryMsg msg) {
@@ -467,9 +578,7 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
         EntityId entityId = msg.getEntityId();
         log.debug("Received changed owner msg from entity [{}]", entityId);
         updateEntityOwner(entityId);
-        List<CalculatedFieldCtx> cfs = new ArrayList<>();
-        cfs.addAll(getCalculatedFieldsByEntityId(entityId));
-        cfs.addAll(getCalculatedFieldsByEntityId(getProfileId(tenantId, entityId)));
+        List<CalculatedFieldCtx> cfs = getCalculatedFieldsByEntityIdAndProfile(entityId);
         if (cfs.isEmpty()) {
             msgCallback.onSuccess();
             return;
@@ -533,6 +642,16 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
         return result;
     }
 
+    private List<CalculatedFieldCtx> getCalculatedFieldsByEntityIdAndProfile(EntityId entityId) {
+        List<CalculatedFieldCtx> cfsByEntityIdAndProfile = new ArrayList<>();
+        cfsByEntityIdAndProfile.addAll(getCalculatedFieldsByEntityId(entityId));
+        EntityId profileId = getProfileId(tenantId, entityId);
+        if (profileId != null) {
+            cfsByEntityIdAndProfile.addAll(getCalculatedFieldsByEntityId(profileId));
+        }
+        return cfsByEntityIdAndProfile;
+    }
+
     private List<CalculatedFieldLink> getCalculatedFieldLinksByEntityId(EntityId entityId) {
         if (entityId == null) {
             return Collections.emptyList();
@@ -560,6 +679,16 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
         getOrCreateActor(entityId).tell(msg);
     }
 
+    private void deleteRelatedEntity(EntityId entityId, EntityId relatedEntityId, CalculatedFieldCtx cf, TbCallback callback) {
+        log.debug("Pushing delete related entity msg to specific actor [{}]", relatedEntityId);
+        getOrCreateActor(entityId).tell(new CalculatedFieldRelationActionMsg(tenantId, relatedEntityId, ActionType.DELETED, cf, callback));
+    }
+
+    private void initRelatedEntity(EntityId entityId, EntityId relatedEntityId, CalculatedFieldCtx cf, TbCallback callback) {
+        log.debug("Pushing init related entity msg to specific actor [{}]", relatedEntityId);
+        getOrCreateActor(entityId).tell(new CalculatedFieldRelationActionMsg(tenantId, relatedEntityId, ActionType.UPDATED, cf, callback));
+    }
+
     private void deleteCfForEntity(EntityId entityId, CalculatedFieldId cfId, TbCallback callback) {
         log.debug("Pushing delete CF msg to specific actor [{}]", entityId);
         getOrCreateActor(entityId).tell(new CalculatedFieldEntityDeleteMsg(tenantId, cfId, callback));

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldRelationActionMsg.java

@@ -0,0 +1,52 @@
+/**
+ * Copyright © 2016-2025 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.actors.calculatedField;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.MsgType;
+import org.thingsboard.server.common.msg.ToCalculatedFieldSystemMsg;
+import org.thingsboard.server.common.msg.queue.TbCallback;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldCtx;
+
+@Data
+public class CalculatedFieldRelationActionMsg implements ToCalculatedFieldSystemMsg {
+
+    private final TenantId tenantId;
+    private final EntityId relatedEntityId;
+    private final ActionType action;
+    private final CalculatedFieldCtx calculatedField;
+    private final TbCallback callback;
+
+    public CalculatedFieldRelationActionMsg(TenantId tenantId,
+                                            EntityId relatedEntityId, ActionType action,
+                                            CalculatedFieldCtx calculatedField,
+                                            TbCallback callback) {
+        this.tenantId = tenantId;
+        this.relatedEntityId = relatedEntityId;
+        this.action = action;
+        this.calculatedField = calculatedField;
+        this.callback = callback;
+    }
+
+    @Override
+    public MsgType getMsgType() {
+        return MsgType.CF_RELATION_ACTION_MSG;
+    }
+
+}

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

@@ -164,6 +164,7 @@ public class SystemInfoController extends BaseController {
             systemParams.setMaxDataPointsPerRollingArg(tenantProfileConfiguration.getMaxDataPointsPerRollingArg());
             systemParams.setMinAllowedScheduledUpdateIntervalInSecForCF(tenantProfileConfiguration.getMinAllowedScheduledUpdateIntervalInSecForCF());
             systemParams.setMaxRelationLevelPerCfArgument(tenantProfileConfiguration.getMaxRelationLevelPerCfArgument());
+            systemParams.setMinAllowedDeduplicationIntervalInSecForCF(tenantProfileConfiguration.getMinAllowedDeduplicationIntervalInSecForCF());
             systemParams.setTrendzSettings(trendzSettingsService.findTrendzSettings(currentUser.getTenantId()));
         }
         systemParams.setMobileQrEnabled(Optional.ofNullable(qrCodeSettingService.findQrCodeSettings(TenantId.SYS_TENANT_ID))

application/src/main/java/org/thingsboard/server/service/cf/AbstractCalculatedFieldProcessingService.java

@@ -27,6 +27,7 @@ import org.thingsboard.common.util.ThingsBoardExecutors;
 import org.thingsboard.server.common.data.cf.configuration.Argument;
 import org.thingsboard.server.common.data.cf.configuration.ArgumentType;
 import org.thingsboard.server.common.data.cf.configuration.RelationPathQueryDynamicSourceConfiguration;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.RelatedEntitiesAggregationCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.Aggregation;
@@ -36,6 +37,9 @@ import org.thingsboard.server.common.data.kv.BaseReadTsKvQuery;
 import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
 import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
+import org.thingsboard.server.common.data.relation.EntityRelation;
+import org.thingsboard.server.common.data.relation.EntityRelationPathQuery;
+import org.thingsboard.server.common.data.relation.RelationPathLevel;
 import org.thingsboard.server.common.data.tenant.profile.DefaultTenantProfileConfiguration;
 import org.thingsboard.server.dao.attributes.AttributesService;
 import org.thingsboard.server.dao.relation.RelationService;
@@ -45,6 +49,7 @@ import org.thingsboard.server.service.cf.ctx.state.ArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldCtx;
 import org.thingsboard.server.service.cf.ctx.state.SingleValueArgumentEntry;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -92,6 +97,7 @@ public abstract class AbstractCalculatedFieldProcessingService {
         Map<String, ListenableFuture<ArgumentEntry>> argFutures = switch (ctx.getCfType()) {
             case GEOFENCING -> fetchGeofencingCalculatedFieldArguments(ctx, entityId, false, ts);
             case SIMPLE, SCRIPT, ALARM, PROPAGATION -> getBaseCalculatedFieldArguments(ctx, entityId, ts);
+            case RELATED_ENTITIES_AGGREGATION -> fetchRelatedEntitiesAggArguments(ctx, entityId, ts);
         };
         if (ctx.getCfType() == PROPAGATION) {
             argFutures.put(PROPAGATION_CONFIG_ARGUMENT, fetchPropagationCalculatedFieldArgument(ctx, entityId));
@@ -165,6 +171,35 @@ public abstract class AbstractCalculatedFieldProcessingService {
         return argFutures;
     }
 
+    protected Map<String, ListenableFuture<ArgumentEntry>> fetchRelatedEntitiesAggArguments(CalculatedFieldCtx ctx, EntityId entityId, long ts) {
+        RelatedEntitiesAggregationCalculatedFieldConfiguration aggConfig = (RelatedEntitiesAggregationCalculatedFieldConfiguration) ctx.getCalculatedField().getConfiguration();
+
+        ListenableFuture<List<EntityId>> relatedEntitiesFut = resolveRelatedEntities(ctx.getTenantId(), entityId, aggConfig.getRelation());
+
+        return aggConfig.getArguments().entrySet().stream()
+                .collect(Collectors.toMap(
+                        Map.Entry::getKey,
+                        entry -> Futures.transformAsync(relatedEntitiesFut, relatedEntities -> fetchRelatedEntitiesArgumentEntry(ctx.getTenantId(), relatedEntities, entry.getValue(), ts), MoreExecutors.directExecutor())
+                ));
+    }
+
+    private ListenableFuture<List<EntityId>> resolveRelatedEntities(TenantId tenantId, EntityId entityId, RelationPathLevel relation) {
+        ListenableFuture<List<EntityRelation>> relationsFut = relationService.findByRelationPathQueryAsync(tenantId, new EntityRelationPathQuery(entityId, List.of(relation)));
+
+        return Futures.transform(relationsFut, relations -> {
+            if (relations == null) {
+                return Collections.emptyList();
+            }
+
+            return switch (relation.direction()) {
+                case FROM -> relations.stream()
+                        .map(EntityRelation::getTo)
+                        .toList();
+                case TO -> relations.isEmpty() ? List.of() : List.of(relations.get(0).getFrom());
+            };
+        }, calculatedFieldCallbackExecutor);
+    }
+
     private ListenableFuture<List<EntityId>> resolveGeofencingEntityIds(TenantId tenantId, EntityId entityId, Map.Entry<String, Argument> entry) {
         Argument value = entry.getValue();
         if (value.getRefEntityId() != null) {
@@ -216,6 +251,23 @@ public abstract class AbstractCalculatedFieldProcessingService {
                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))), MoreExecutors.directExecutor());
     }
 
+    public ListenableFuture<ArgumentEntry> fetchRelatedEntitiesArgumentEntry(TenantId tenantId, List<EntityId> aggEntities, Argument argument, long startTs) {
+        List<ListenableFuture<Map.Entry<EntityId, ArgumentEntry>>> futures = aggEntities.stream()
+                .map(entityId -> {
+                    ListenableFuture<ArgumentEntry> argumentEntryFut = fetchArgumentValue(tenantId, entityId, argument, startTs);
+                    return Futures.transform(argumentEntryFut, argumentEntry -> Map.entry(entityId, ArgumentEntry.createSingleValueArgument(entityId, argumentEntry)), MoreExecutors.directExecutor());
+                })
+                .toList();
+
+        ListenableFuture<List<Map.Entry<EntityId, ? extends ArgumentEntry>>> allFutures = Futures.allAsList(futures);
+
+        return Futures.transform(allFutures,
+                entries -> ArgumentEntry.createAggArgument(
+                        entries.stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))
+                ),
+                MoreExecutors.directExecutor());
+    }
+
     protected ListenableFuture<ArgumentEntry> fetchArgumentValue(TenantId tenantId, EntityId entityId, Argument argument, long startTs) {
         return switch (argument.getRefEntityKey().getType()) {
             case TS_ROLLING -> fetchTsRolling(tenantId, entityId, argument, startTs);

application/src/main/java/org/thingsboard/server/service/cf/CalculatedFieldCache.java

@@ -38,6 +38,8 @@ public interface CalculatedFieldCache {
 
     List<CalculatedFieldCtx> getCalculatedFieldCtxsByEntityId(EntityId entityId);
 
+    List<CalculatedFieldCtx> getAggCalculatedFieldCtxsByFilter(Predicate<CalculatedFieldCtx> relatedEntityFilter);
+
     boolean hasCalculatedFields(TenantId tenantId, EntityId entityId, Predicate<CalculatedFieldCtx> filter);
 
     void addCalculatedField(TenantId tenantId, CalculatedFieldId calculatedFieldId);

application/src/main/java/org/thingsboard/server/service/cf/DefaultCalculatedFieldCache.java

@@ -26,6 +26,7 @@ import org.thingsboard.server.actors.ActorSystemContext;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
+import org.thingsboard.server.common.data.cf.CalculatedFieldType;
 import org.thingsboard.server.common.data.cf.configuration.CalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
@@ -146,6 +147,15 @@ public class DefaultCalculatedFieldCache implements CalculatedFieldCache {
                 .toList();
     }
 
+    @Override
+    public List<CalculatedFieldCtx> getAggCalculatedFieldCtxsByFilter(Predicate<CalculatedFieldCtx> relatedEntityFilter) {
+        return calculatedFields.values().stream()
+                .filter(cf -> CalculatedFieldType.RELATED_ENTITIES_AGGREGATION.equals(cf.getType()))
+                .map(cf -> getCalculatedFieldCtx(cf.getId()))
+                .filter(relatedEntityFilter)
+                .toList();
+    }
+
     @Override
     public boolean hasCalculatedFields(TenantId tenantId, EntityId entityId, Predicate<CalculatedFieldCtx> filter) {
         List<CalculatedFieldCtx> entityCfs = getCalculatedFieldCtxsByEntityId(entityId);
@@ -155,6 +165,10 @@ public class DefaultCalculatedFieldCache implements CalculatedFieldCache {
             }
         }
 
+        return hasCalculatedFieldsByProfile(tenantId, entityId, filter);
+    }
+
+    public boolean hasCalculatedFieldsByProfile(TenantId tenantId, EntityId entityId, Predicate<CalculatedFieldCtx> filter) {
         EntityId profileId = getProfileId(tenantId, entityId);
         if (profileId != null) {
             List<CalculatedFieldCtx> profileCfs = getCalculatedFieldCtxsByEntityId(profileId);

application/src/main/java/org/thingsboard/server/service/cf/DefaultCalculatedFieldQueueService.java

@@ -27,6 +27,7 @@ import org.thingsboard.server.cluster.TbClusterService;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.RelatedEntitiesAggregationCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -35,7 +36,12 @@ import org.thingsboard.server.common.data.kv.AttributesSaveResult;
 import org.thingsboard.server.common.data.kv.TimeseriesSaveResult;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
 import org.thingsboard.server.common.data.msg.TbMsgType;
+import org.thingsboard.server.common.data.relation.EntityRelation;
+import org.thingsboard.server.common.data.relation.EntityRelationPathQuery;
+import org.thingsboard.server.common.data.relation.EntitySearchDirection;
+import org.thingsboard.server.common.data.relation.RelationPathLevel;
 import org.thingsboard.server.common.util.ProtoUtils;
+import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.gen.transport.TransportProtos.AttributeScopeProto;
 import org.thingsboard.server.gen.transport.TransportProtos.AttributeValueProto;
 import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldTelemetryMsgProto;
@@ -71,6 +77,7 @@ public class DefaultCalculatedFieldQueueService implements CalculatedFieldQueueS
 
     private final CalculatedFieldCache calculatedFieldCache;
     private final TbClusterService clusterService;
+    private final RelationService relationService;
 
     @Override
     public void pushRequestToQueue(TimeseriesSaveRequest request, TimeseriesSaveResult result, FutureCallback<Void> callback) {
@@ -81,6 +88,7 @@ public class DefaultCalculatedFieldQueueService implements CalculatedFieldQueueS
                 cf -> cf.matches(entries),
                 cf -> cf.linkMatches(entityId, entries),
                 cf -> cf.dynamicSourceMatches(request.getEntries()),
+                cf -> cf.relatedEntityMatches(entries),
                 () -> toCalculatedFieldTelemetryMsgProto(request, result), callback);
     }
 
@@ -99,6 +107,7 @@ public class DefaultCalculatedFieldQueueService implements CalculatedFieldQueueS
                 cf -> cf.matches(entries, scope),
                 cf -> cf.linkMatches(entityId, entries, scope),
                 cf -> cf.dynamicSourceMatches(request.getEntries(), request.getScope()),
+                cf -> cf.relatedEntityMatches(entries, scope),
                 () -> toCalculatedFieldTelemetryMsgProto(request, result), callback);
     }
 
@@ -116,6 +125,7 @@ public class DefaultCalculatedFieldQueueService implements CalculatedFieldQueueS
                 cf -> cf.matchesKeys(result, scope),
                 cf -> cf.linkMatchesAttrKeys(entityId, result, scope),
                 cf -> cf.matchesDynamicSourceKeys(result, request.getScope()),
+                cf -> cf.matchesRelatedEntityKeys(result, scope),
                 () -> toCalculatedFieldTelemetryMsgProto(request, result), callback);
     }
 
@@ -127,6 +137,7 @@ public class DefaultCalculatedFieldQueueService implements CalculatedFieldQueueS
                 cf -> cf.matchesKeys(result),
                 cf -> cf.linkMatchesTsKeys(entityId, result),
                 cf -> cf.matchesDynamicSourceKeys(result),
+                cf -> cf.matchesRelatedEntityKeys(result),
                 () -> toCalculatedFieldTelemetryMsgProto(request, result), callback);
     }
 
@@ -134,11 +145,12 @@ public class DefaultCalculatedFieldQueueService implements CalculatedFieldQueueS
                                            Predicate<CalculatedFieldCtx> mainEntityFilter,
                                            Predicate<CalculatedFieldCtx> linkedEntityFilter,
                                            Predicate<CalculatedFieldCtx> dynamicSourceFilter,
+                                           Predicate<CalculatedFieldCtx> relatedEntityFilter,
                                            Supplier<ToCalculatedFieldMsg> msg, FutureCallback<Void> callback) {
         if (EntityType.TENANT.equals(entityId.getEntityType())) {
             tenantId = (TenantId) entityId;
         }
-        boolean send = checkEntityForCalculatedFields(tenantId, entityId, mainEntityFilter, linkedEntityFilter, dynamicSourceFilter);
+        boolean send = checkEntityForCalculatedFields(tenantId, entityId, mainEntityFilter, linkedEntityFilter, dynamicSourceFilter, relatedEntityFilter);
         if (send) {
             ToCalculatedFieldMsg calculatedFieldMsg = msg.get();
             clusterService.pushMsgToCalculatedFields(tenantId, entityId, calculatedFieldMsg, wrap(callback));
@@ -149,7 +161,7 @@ public class DefaultCalculatedFieldQueueService implements CalculatedFieldQueueS
         }
     }
 
-    private boolean checkEntityForCalculatedFields(TenantId tenantId, EntityId entityId, Predicate<CalculatedFieldCtx> filter, Predicate<CalculatedFieldCtx> linkedEntityFilter, Predicate<CalculatedFieldCtx> dynamicSourceFilter) {
+    private boolean checkEntityForCalculatedFields(TenantId tenantId, EntityId entityId, Predicate<CalculatedFieldCtx> filter, Predicate<CalculatedFieldCtx> linkedEntityFilter, Predicate<CalculatedFieldCtx> dynamicSourceFilter, Predicate<CalculatedFieldCtx> relatedEntityFilter) {
         if (!CalculatedField.SUPPORTED_REFERENCED_ENTITIES.contains(entityId.getEntityType())) {
             return false;
         }
@@ -176,6 +188,29 @@ public class DefaultCalculatedFieldQueueService implements CalculatedFieldQueueS
             }
         }
 
+        List<CalculatedFieldCtx> cfCtxs = calculatedFieldCache.getAggCalculatedFieldCtxsByFilter(relatedEntityFilter);
+        for (CalculatedFieldCtx cfCtx : cfCtxs) {
+            if (cfCtx.getCalculatedField().getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration aggConfig) {
+                RelationPathLevel relation = aggConfig.getRelation();
+                EntitySearchDirection inverseDirection = switch (relation.direction()) {
+                    case FROM -> EntitySearchDirection.TO;
+                    case TO -> EntitySearchDirection.FROM;
+                };
+                RelationPathLevel inverseRelation = new RelationPathLevel(inverseDirection, relation.relationType());
+                List<EntityRelation> byRelationPathQuery = relationService.findByRelationPathQuery(tenantId, new EntityRelationPathQuery(entityId, List.of(inverseRelation)));
+                if (!byRelationPathQuery.isEmpty()) {
+                    EntityId cfEntityId = cfCtx.getEntityId();
+                    for (EntityRelation entityRelation : byRelationPathQuery) {
+                        EntityId relatedId = (inverseDirection == EntitySearchDirection.FROM) ? entityRelation.getTo() : entityRelation.getFrom();
+                        if (cfEntityId.equals(relatedId) || cfEntityId.equals(calculatedFieldCache.getProfileId(tenantId, relatedId))) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            }
+        }
+
         return false;
     }
 

application/src/main/java/org/thingsboard/server/service/cf/TelemetryCalculatedFieldResult.java

@@ -39,6 +39,8 @@ public final class TelemetryCalculatedFieldResult implements CalculatedFieldResu
     private final AttributeScope scope;
     private final JsonNode result;
 
+    public static final TelemetryCalculatedFieldResult EMPTY = TelemetryCalculatedFieldResult.builder().result(null).build();
+
     @Override
     public TbMsg toTbMsg(EntityId entityId, List<CalculatedFieldId> cfIds) {
         TbMsgType msgType = switch (type) {
@@ -66,9 +68,9 @@ public final class TelemetryCalculatedFieldResult implements CalculatedFieldResu
     @Override
     public boolean isEmpty() {
         return result == null || result.isMissingNode() || result.isNull() ||
-               (result.isObject() && result.isEmpty()) ||
-               (result.isArray() && result.isEmpty()) ||
-               (result.isTextual() && result.asText().isEmpty());
+                (result.isObject() && result.isEmpty()) ||
+                (result.isArray() && result.isEmpty()) ||
+                (result.isTextual() && result.asText().isEmpty());
     }
 
 }

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/ArgumentEntry.java

@@ -22,6 +22,7 @@ import org.thingsboard.script.api.tbel.TbelCfArg;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.kv.KvEntry;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
+import org.thingsboard.server.service.cf.ctx.state.aggregation.RelatedEntitiesArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.propagation.PropagationArgumentEntry;
 
@@ -37,7 +38,8 @@ import java.util.Map;
         @JsonSubTypes.Type(value = SingleValueArgumentEntry.class, name = "SINGLE_VALUE"),
         @JsonSubTypes.Type(value = TsRollingArgumentEntry.class, name = "TS_ROLLING"),
         @JsonSubTypes.Type(value = GeofencingArgumentEntry.class, name = "GEOFENCING"),
-        @JsonSubTypes.Type(value = PropagationArgumentEntry.class, name = "PROPAGATION")
+        @JsonSubTypes.Type(value = PropagationArgumentEntry.class, name = "PROPAGATION"),
+        @JsonSubTypes.Type(value = RelatedEntitiesArgumentEntry.class, name = "RELATED_ENTITIES")
 })
 public interface ArgumentEntry {
 
@@ -60,6 +62,10 @@ public interface ArgumentEntry {
         return new SingleValueArgumentEntry(kvEntry);
     }
 
+    static ArgumentEntry createSingleValueArgument(EntityId entityId, ArgumentEntry argumentEntry) {
+        return new SingleValueArgumentEntry(entityId, argumentEntry);
+    }
+
     static ArgumentEntry createTsRollingArgument(List<TsKvEntry> kvEntries, int limit, long timeWindow) {
         return new TsRollingArgumentEntry(kvEntries, limit, timeWindow);
     }
@@ -72,4 +78,8 @@ public interface ArgumentEntry {
         return new PropagationArgumentEntry(entityIds);
     }
 
+    static ArgumentEntry createAggArgument(Map<EntityId, ArgumentEntry> entityIdkvEntryMap) {
+        return new RelatedEntitiesArgumentEntry(entityIdkvEntryMap, false);
+    }
+
 }

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/ArgumentEntryType.java

@@ -16,5 +16,5 @@
 package org.thingsboard.server.service.cf.ctx.state;
 
 public enum ArgumentEntryType {
-    SINGLE_VALUE, TS_ROLLING, GEOFENCING, PROPAGATION
+    SINGLE_VALUE, TS_ROLLING, GEOFENCING, PROPAGATION, RELATED_ENTITIES
 }

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/BaseCalculatedFieldState.java

@@ -23,6 +23,7 @@ import org.thingsboard.server.actors.TbActorRef;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
 import org.thingsboard.server.service.cf.ctx.CalculatedFieldEntityCtxId;
+import org.thingsboard.server.service.cf.ctx.state.aggregation.RelatedEntitiesArgumentEntry;
 import org.thingsboard.server.utils.CalculatedFieldUtils;
 
 import java.io.Closeable;
@@ -76,7 +77,11 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
 
             if (existingEntry == null || newEntry.isForceResetPrevious()) {
                 validateNewEntry(key, newEntry);
-                arguments.put(key, newEntry);
+                if (existingEntry instanceof RelatedEntitiesArgumentEntry relatedEntitiesArgumentEntry) {
+                    relatedEntitiesArgumentEntry.updateEntry(newEntry);
+                } else {
+                    arguments.put(key, newEntry);
+                }
                 entryUpdated = true;
             } else {
                 entryUpdated = existingEntry.updateEntry(newEntry);
@@ -109,7 +114,7 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
     @Override
     public boolean isReady() {
         return arguments.keySet().containsAll(requiredArguments) &&
-               arguments.values().stream().noneMatch(ArgumentEntry::isEmpty);
+                arguments.values().stream().noneMatch(ArgumentEntry::isEmpty);
     }
 
     @Override
@@ -121,9 +126,11 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
     }
 
     @Override
-    public void close() {}
+    public void close() {
+    }
 
-    protected void validateNewEntry(String key, ArgumentEntry newEntry) {}
+    protected void validateNewEntry(String key, ArgumentEntry newEntry) {
+    }
 
     protected ObjectNode toSimpleResult(boolean useLatestTs, ObjectNode valuesNode) {
         if (!useLatestTs) {

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/CalculatedFieldCtx.java

@@ -43,6 +43,8 @@ import org.thingsboard.server.common.data.cf.configuration.PropagationCalculated
 import org.thingsboard.server.common.data.cf.configuration.ReferencedEntityKey;
 import org.thingsboard.server.common.data.cf.configuration.ScheduledUpdateSupportedCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.cf.configuration.SimpleCalculatedFieldConfiguration;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunctionInput;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.RelatedEntitiesAggregationCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.cf.configuration.geofencing.GeofencingCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
 import org.thingsboard.server.common.data.id.EntityId;
@@ -69,6 +71,7 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
 
 @Data
 @Slf4j
@@ -84,6 +87,7 @@ public class CalculatedFieldCtx implements Closeable {
     private final Map<ReferencedEntityKey, Set<String>> mainEntityArguments;
     private final Map<EntityId, Map<ReferencedEntityKey, Set<String>>> linkedEntityArguments;
     private final Map<ReferencedEntityKey, Set<String>> dynamicEntityArguments;
+    private final Map<ReferencedEntityKey, Set<String>> relatedEntityArguments;
     private final List<String> argNames;
     private Output output;
     private String expression;
@@ -107,6 +111,7 @@ public class CalculatedFieldCtx implements Closeable {
     private boolean relationQueryDynamicArguments;
     private List<String> mainEntityGeofencingArgumentNames;
     private List<String> linkedEntityAndCurrentOwnerGeofencingArgumentNames;
+    private List<String> relatedEntityArgumentNames;
 
     private long scheduledUpdateIntervalMillis;
 
@@ -125,9 +130,11 @@ public class CalculatedFieldCtx implements Closeable {
         this.mainEntityArguments = new HashMap<>();
         this.linkedEntityArguments = new HashMap<>();
         this.dynamicEntityArguments = new HashMap<>();
+        this.relatedEntityArguments = new HashMap<>();
         this.argNames = new ArrayList<>();
         this.mainEntityGeofencingArgumentNames = new ArrayList<>();
         this.linkedEntityAndCurrentOwnerGeofencingArgumentNames = new ArrayList<>();
+        this.relatedEntityArgumentNames = new ArrayList<>();
         this.output = calculatedField.getConfiguration().getOutput();
         if (calculatedField.getConfiguration() instanceof ArgumentsBasedCalculatedFieldConfiguration argBasedConfig) {
             this.arguments.putAll(argBasedConfig.getArguments());
@@ -135,6 +142,10 @@ public class CalculatedFieldCtx implements Closeable {
                 var refId = entry.getValue().getRefEntityId();
                 var refKey = entry.getValue().getRefEntityKey();
                 if (refId == null) {
+                    if (CalculatedFieldType.RELATED_ENTITIES_AGGREGATION.equals(cfType)) {
+                        relatedEntityArguments.compute(refKey, (key, existingNames) -> CollectionsUtil.addToSet(existingNames, entry.getKey()));
+                        continue;
+                    }
                     if (entry.getValue().hasRelationQuerySource()) {
                         relationQueryDynamicArguments = true;
                         continue;
@@ -152,6 +163,9 @@ public class CalculatedFieldCtx implements Closeable {
                 }
             }
             this.argNames.addAll(arguments.keySet());
+            this.relatedEntityArgumentNames = relatedEntityArguments.values().stream()
+                    .flatMap(Set::stream)
+                    .collect(Collectors.toList());
             if (argBasedConfig instanceof ExpressionBasedCalculatedFieldConfiguration expressionBasedConfig) {
                 this.expression = expressionBasedConfig.getExpression();
                 this.useLatestTs = CalculatedFieldType.SIMPLE.equals(calculatedField.getType()) && ((SimpleCalculatedFieldConfiguration) argBasedConfig).isUseLatestTs();
@@ -177,6 +191,9 @@ public class CalculatedFieldCtx implements Closeable {
             this.scheduledUpdateIntervalMillis = scheduledConfig.isScheduledUpdateEnabled() ? TimeUnit.SECONDS.toMillis(scheduledConfig.getScheduledUpdateInterval()) : -1L;
         }
         this.requiresScheduledReevaluation = calculatedField.getConfiguration().requiresScheduledReevaluation();
+        if (calculatedField.getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration aggConfig) {
+            this.useLatestTs = aggConfig.isUseLatestTs();
+        }
         this.systemContext = systemContext;
         this.tbelInvokeService = systemContext.getTbelInvokeService();
         this.relationService = systemContext.getRelationService();
@@ -214,6 +231,19 @@ public class CalculatedFieldCtx implements Closeable {
                 }
                 initialized = true;
             }
+            case RELATED_ENTITIES_AGGREGATION -> {
+                RelatedEntitiesAggregationCalculatedFieldConfiguration configuration = (RelatedEntitiesAggregationCalculatedFieldConfiguration) calculatedField.getConfiguration();
+                configuration.getMetrics().forEach((key, metric) -> {
+                    if (metric.getInput() instanceof AggFunctionInput functionInput) {
+                        initTbelExpression(functionInput.getFunction());
+                    }
+                    String filter = metric.getFilter();
+                    if (filter != null && !filter.isEmpty()) {
+                        initTbelExpression(filter);
+                    }
+                });
+                initialized = true;
+            }
         }
     }
 
@@ -236,15 +266,23 @@ public class CalculatedFieldCtx implements Closeable {
     }
 
     public ListenableFuture<Object> evaluateTbelExpression(String expression, CalculatedFieldState state) {
-        return evaluateTbelExpression(tbelExpressions.get(expression), state);
+        return evaluateTbelExpression(tbelExpressions.get(expression), state.getArguments(), state.getLatestTimestamp());
     }
 
     public ListenableFuture<Object> evaluateTbelExpression(CalculatedFieldScriptEngine expression, CalculatedFieldState state) {
+        return evaluateTbelExpression(expression, state.getArguments(), state.getLatestTimestamp());
+    }
+
+    public ListenableFuture<Object> evaluateTbelExpression(String expression, Map<String, ArgumentEntry> entries, long latestTimestamp) {
+        return evaluateTbelExpression(tbelExpressions.get(expression), entries, latestTimestamp);
+    }
+
+    public ListenableFuture<Object> evaluateTbelExpression(CalculatedFieldScriptEngine expression, Map<String, ArgumentEntry> entries, long latestTimestamp) {
         Map<String, TbelCfArg> arguments = new LinkedHashMap<>();
         List<Object> args = new ArrayList<>(argNames.size() + 1);
         args.add(new Object()); // first element is a ctx, but we will set it later;
         for (String argName : argNames) {
-            var arg = toTbelArgument(argName, state);
+            var arg = toTbelArgument(argName, entries);
             arguments.put(argName, arg);
             if (arg instanceof TbelCfSingleValueArg svArg) {
                 args.add(svArg.getValue());
@@ -252,7 +290,7 @@ public class CalculatedFieldCtx implements Closeable {
                 args.add(arg);
             }
         }
-        args.set(0, new TbelCfCtx(arguments, state.getLatestTimestamp()));
+        args.set(0, new TbelCfCtx(arguments, latestTimestamp));
 
         return expression.executeScriptAsync(args.toArray());
     }
@@ -262,8 +300,8 @@ public class CalculatedFieldCtx implements Closeable {
         return systemContext.scheduleMsgWithDelay(actorCtx, new CalculatedFieldReevaluateMsg(tenantId, this), delayMs);
     }
 
-    private TbelCfArg toTbelArgument(String key, CalculatedFieldState state) {
-        return state.getArguments().get(key).toTbelCfArg();
+    private TbelCfArg toTbelArgument(String key, Map<String, ArgumentEntry> arguments) {
+        return arguments.get(key).toTbelCfArg();
     }
 
     private void initTbelExpression(String expression) {
@@ -446,6 +484,41 @@ public class CalculatedFieldCtx implements Closeable {
         return map != null && matchesTimeSeriesKeys(map, keys);
     }
 
+    public boolean relatedEntityMatches(List<TsKvEntry> values) {
+        return matchesTimeSeries(relatedEntityArguments, values);
+    }
+
+    public boolean relatedEntityMatches(List<AttributeKvEntry> values, AttributeScope scope) {
+        return matchesAttributes(relatedEntityArguments, values, scope);
+    }
+
+    public boolean matchesRelatedEntityKeys(List<String> keys, AttributeScope scope) {
+        return matchesAttributesKeys(relatedEntityArguments, keys, scope);
+    }
+
+    public boolean matchesRelatedEntityKeys(List<String> keys) {
+        return matchesTimeSeriesKeys(relatedEntityArguments, keys);
+    }
+
+    public boolean relatedEntityMatches(CalculatedFieldTelemetryMsgProto proto) {
+        if (!proto.getTsDataList().isEmpty()) {
+            List<TsKvEntry> updatedTelemetry = proto.getTsDataList().stream()
+                    .map(ProtoUtils::fromProto)
+                    .toList();
+            return relatedEntityMatches(updatedTelemetry);
+        } else if (!proto.getAttrDataList().isEmpty()) {
+            AttributeScope scope = AttributeScope.valueOf(proto.getScope().name());
+            List<AttributeKvEntry> updatedTelemetry = proto.getAttrDataList().stream()
+                    .map(ProtoUtils::fromProto)
+                    .toList();
+            return relatedEntityMatches(updatedTelemetry, scope);
+        } else if (!proto.getRemovedTsKeysList().isEmpty()) {
+            return matchesRelatedEntityKeys(proto.getRemovedTsKeysList());
+        } else {
+            return matchesRelatedEntityKeys(proto.getRemovedAttrKeysList(), AttributeScope.valueOf(proto.getScope().name()));
+        }
+    }
+
     public boolean dynamicSourceMatches(CalculatedFieldTelemetryMsgProto proto) {
         if (!proto.getTsDataList().isEmpty()) {
             List<TsKvEntry> updatedTelemetry = proto.getTsDataList().stream()
@@ -507,6 +580,11 @@ public class CalculatedFieldCtx implements Closeable {
         if (!Objects.equals(output, other.output)) {
             return true;
         }
+        if (calculatedField.getConfiguration() instanceof SimpleCalculatedFieldConfiguration thisConfig
+                && other.calculatedField.getConfiguration() instanceof SimpleCalculatedFieldConfiguration otherConfig
+                && thisConfig.isUseLatestTs() != otherConfig.isUseLatestTs()) {
+            return true;
+        }
         if (cfType == CalculatedFieldType.ALARM) {
             if (!calculatedField.getName().equals(other.getCalculatedField().getName())) {
                 return true;
@@ -519,7 +597,15 @@ public class CalculatedFieldCtx implements Closeable {
                 return true;
             }
         }
-        return scheduledUpdateIntervalMillis != other.scheduledUpdateIntervalMillis;
+        if (scheduledUpdateIntervalMillis != other.scheduledUpdateIntervalMillis) {
+            return true;
+        }
+        if (calculatedField.getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration thisConfig
+                && other.getCalculatedField().getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration otherConfig
+                && (thisConfig.getDeduplicationIntervalInSec() != otherConfig.getDeduplicationIntervalInSec() || !thisConfig.getMetrics().equals(otherConfig.getMetrics()))) {
+            return true;
+        }
+        return false;
     }
 
     public boolean hasStateChanges(CalculatedFieldCtx other) {
@@ -536,17 +622,31 @@ public class CalculatedFieldCtx implements Closeable {
                 return true;
             }
         }
-        return hasGeofencingZoneGroupConfigurationChanges(other);
+        if (hasGeofencingZoneGroupConfigurationChanges(other)) {
+            return true;
+        }
+        if (hasRelatedEntitiesAggregationConfigurationChanges(other)) {
+            return true;
+        }
+        return false;
     }
 
     private boolean hasGeofencingZoneGroupConfigurationChanges(CalculatedFieldCtx other) {
         if (calculatedField.getConfiguration() instanceof GeofencingCalculatedFieldConfiguration thisConfig
-            && other.calculatedField.getConfiguration() instanceof GeofencingCalculatedFieldConfiguration otherConfig) {
+                && other.calculatedField.getConfiguration() instanceof GeofencingCalculatedFieldConfiguration otherConfig) {
             return !thisConfig.getZoneGroups().equals(otherConfig.getZoneGroups());
         }
         return false;
     }
 
+    private boolean hasRelatedEntitiesAggregationConfigurationChanges(CalculatedFieldCtx other) {
+        if (calculatedField.getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration thisConfig
+                && other.calculatedField.getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration otherConfig) {
+            return !thisConfig.getRelation().equals(otherConfig.getRelation());
+        }
+        return false;
+    }
+
     private boolean isScheduledUpdateEnabled() {
         return scheduledUpdateIntervalMillis != -1;
     }
@@ -566,7 +666,7 @@ public class CalculatedFieldCtx implements Closeable {
                     yield true;
                 }
                 yield geofencingState.getLastDynamicArgumentsRefreshTs() <
-                      System.currentTimeMillis() - scheduledUpdateIntervalMillis;
+                        System.currentTimeMillis() - scheduledUpdateIntervalMillis;
             }
             default -> false;
         };
@@ -597,10 +697,10 @@ public class CalculatedFieldCtx implements Closeable {
     @Override
     public String toString() {
         return "CalculatedFieldCtx{" +
-               "cfId=" + cfId +
-               ", cfType=" + cfType +
-               ", entityId=" + entityId +
-               '}';
+                "cfId=" + cfId +
+                ", cfType=" + cfType +
+                ", entityId=" + entityId +
+                '}';
     }
 
 }

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/CalculatedFieldState.java

@@ -26,6 +26,7 @@ import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
 import org.thingsboard.server.service.cf.CalculatedFieldResult;
 import org.thingsboard.server.service.cf.ctx.CalculatedFieldEntityCtxId;
+import org.thingsboard.server.service.cf.ctx.state.aggregation.RelatedEntitiesAggregationCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.alarm.AlarmCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingCalculatedFieldState;
@@ -42,7 +43,8 @@ import static org.thingsboard.server.utils.CalculatedFieldUtils.toSingleValueArg
         @Type(value = ScriptCalculatedFieldState.class, name = "SCRIPT"),
         @Type(value = GeofencingCalculatedFieldState.class, name = "GEOFENCING"),
         @Type(value = AlarmCalculatedFieldState.class, name = "ALARM"),
-        @Type(value = PropagationCalculatedFieldState.class, name = "PROPAGATION")
+        @Type(value = PropagationCalculatedFieldState.class, name = "PROPAGATION"),
+        @Type(value = RelatedEntitiesAggregationCalculatedFieldState.class, name = "RELATED_ENTITIES_AGGREGATION")
 })
 public interface CalculatedFieldState extends Closeable {
 
@@ -63,7 +65,7 @@ public interface CalculatedFieldState extends Closeable {
 
     void reset();
 
-    ListenableFuture<CalculatedFieldResult> performCalculation(Map<String, ArgumentEntry> updatedArgs, CalculatedFieldCtx ctx);
+    ListenableFuture<CalculatedFieldResult> performCalculation(Map<String, ArgumentEntry> updatedArgs, CalculatedFieldCtx ctx) throws Exception;
 
     @JsonIgnore
     boolean isReady();

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/SimpleCalculatedFieldState.java

@@ -52,7 +52,7 @@ public class SimpleCalculatedFieldState extends BaseCalculatedFieldState {
         double expressionResult = ctx.evaluateSimpleExpression(expression.get(), this);
 
         Output output = ctx.getOutput();
-        Object result = formatResult(expressionResult, output.getDecimalsByDefault());
+        Object result = TbUtils.roundResult(expressionResult, output.getDecimalsByDefault());
         JsonNode outputResult = createResultJson(ctx.isUseLatestTs(), output.getName(), result);
 
         return Futures.immediateFuture(TelemetryCalculatedFieldResult.builder()
@@ -62,16 +62,6 @@ public class SimpleCalculatedFieldState extends BaseCalculatedFieldState {
                 .build());
     }
 
-    private Object formatResult(double expressionResult, Integer decimals) {
-        if (decimals == null) {
-            return expressionResult;
-        }
-        if (decimals.equals(0)) {
-            return TbUtils.toInt(expressionResult);
-        }
-        return TbUtils.toFixed(expressionResult, decimals);
-    }
-
     private JsonNode createResultJson(boolean useLatestTs, String outputName, Object result) {
         ObjectNode valuesNode = JacksonUtil.newObjectNode();
         if (result instanceof Double doubleValue) {

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/SingleValueArgumentEntry.java

@@ -20,9 +20,11 @@ import com.fasterxml.jackson.core.type.TypeReference;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
+import org.springframework.lang.Nullable;
 import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.script.api.tbel.TbelCfArg;
 import org.thingsboard.script.api.tbel.TbelCfSingleValueArg;
+import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.BasicKvEntry;
 import org.thingsboard.server.common.data.kv.JsonDataEntry;
@@ -37,14 +39,36 @@ import org.thingsboard.server.gen.transport.TransportProtos.TsKvProto;
 @AllArgsConstructor
 public class SingleValueArgumentEntry implements ArgumentEntry {
 
-    private long ts;
-    private BasicKvEntry kvEntryValue;
-    private Long version;
+    @Nullable
+    protected EntityId entityId;
 
-    private boolean forceResetPrevious;
+    protected long ts;
+    protected BasicKvEntry kvEntryValue;
+    protected Long version;
+
+    protected boolean forceResetPrevious;
 
     public static final Long DEFAULT_VERSION = -1L;
 
+    public SingleValueArgumentEntry(EntityId entityId, ArgumentEntry entry) {
+        this(entry);
+        this.entityId = entityId;
+    }
+
+    public SingleValueArgumentEntry(ArgumentEntry entry) {
+        if (entry instanceof SingleValueArgumentEntry singleValueArgumentEntry) {
+            this.ts = singleValueArgumentEntry.ts;
+            this.kvEntryValue = singleValueArgumentEntry.kvEntryValue;
+            this.version = singleValueArgumentEntry.version;
+            this.forceResetPrevious = singleValueArgumentEntry.forceResetPrevious;
+        }
+    }
+
+    public SingleValueArgumentEntry(EntityId entityId, TsKvProto entry) {
+        this(entry);
+        this.entityId = entityId;
+    }
+
     public SingleValueArgumentEntry(TsKvProto entry) {
         this.ts = entry.getTs();
         if (entry.hasVersion()) {
@@ -53,6 +77,11 @@ public class SingleValueArgumentEntry implements ArgumentEntry {
         this.kvEntryValue = ProtoUtils.fromProto(entry.getKv());
     }
 
+    public SingleValueArgumentEntry(EntityId entityId, AttributeValueProto entry) {
+        this(entry);
+        this.entityId = entityId;
+    }
+
     public SingleValueArgumentEntry(AttributeValueProto entry) {
         this.ts = entry.getLastUpdateTs();
         if (entry.hasVersion()) {
@@ -61,6 +90,11 @@ public class SingleValueArgumentEntry implements ArgumentEntry {
         this.kvEntryValue = ProtoUtils.basicKvEntryFromProto(entry);
     }
 
+    public SingleValueArgumentEntry(EntityId entityId, KvEntry entry) {
+        this(entry);
+        this.entityId = entityId;
+    }
+
     public SingleValueArgumentEntry(KvEntry entry) {
         if (entry instanceof TsKvEntry tsKvEntry) {
             this.ts = tsKvEntry.getTs();
@@ -72,6 +106,11 @@ public class SingleValueArgumentEntry implements ArgumentEntry {
         this.kvEntryValue = ProtoUtils.basicKvEntryFromKvEntry(entry);
     }
 
+    public SingleValueArgumentEntry(EntityId entityId, long ts, BasicKvEntry kvEntryValue, Long version) {
+        this(ts, kvEntryValue, version);
+        this.entityId = entityId;
+    }
+
     public SingleValueArgumentEntry(long ts, BasicKvEntry kvEntryValue, Long version) {
         this.ts = ts;
         this.kvEntryValue = kvEntryValue;

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/RelatedEntitiesAggregationCalculatedFieldState.java

@@ -0,0 +1,188 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.common.util.JacksonUtil;
+import org.thingsboard.server.actors.TbActorRef;
+import org.thingsboard.server.common.data.cf.CalculatedFieldType;
+import org.thingsboard.server.common.data.cf.configuration.Output;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunctionInput;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggInput;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggKeyInput;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggMetric;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.RelatedEntitiesAggregationCalculatedFieldConfiguration;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.service.cf.CalculatedFieldResult;
+import org.thingsboard.server.service.cf.TelemetryCalculatedFieldResult;
+import org.thingsboard.server.service.cf.ctx.state.ArgumentEntry;
+import org.thingsboard.server.service.cf.ctx.state.BaseCalculatedFieldState;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldCtx;
+import org.thingsboard.server.service.cf.ctx.state.aggregation.function.AggEntry;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+@Slf4j
+@Getter
+public class RelatedEntitiesAggregationCalculatedFieldState extends BaseCalculatedFieldState {
+
+    @Setter
+    private long lastArgsRefreshTs = -1;
+    @Setter
+    private long lastMetricsEvalTs = -1;
+    private long deduplicationIntervalMs = -1;
+    private Map<String, AggMetric> metrics;
+
+    public RelatedEntitiesAggregationCalculatedFieldState(EntityId entityId) {
+        super(entityId);
+    }
+
+    @Override
+    public void setCtx(CalculatedFieldCtx ctx, TbActorRef actorCtx) {
+        super.setCtx(ctx, actorCtx);
+        var configuration = (RelatedEntitiesAggregationCalculatedFieldConfiguration) ctx.getCalculatedField().getConfiguration();
+        metrics = configuration.getMetrics();
+        deduplicationIntervalMs = SECONDS.toMillis(configuration.getDeduplicationIntervalInSec());
+    }
+
+    public void scheduleReevaluation() {
+        ctx.scheduleReevaluation(deduplicationIntervalMs, actorCtx);
+    }
+
+    @Override
+    public void reset() { // must reset everything dependent on arguments
+        super.reset();
+        lastArgsRefreshTs = -1;
+        lastMetricsEvalTs = -1;
+        metrics = null;
+    }
+
+    @Override
+    public CalculatedFieldType getType() {
+        return CalculatedFieldType.RELATED_ENTITIES_AGGREGATION;
+    }
+
+    @Override
+    public Map<String, ArgumentEntry> update(Map<String, ArgumentEntry> argumentValues, CalculatedFieldCtx ctx) {
+        lastArgsRefreshTs = System.currentTimeMillis();
+        return super.update(argumentValues, ctx);
+    }
+
+    @Override
+    public ListenableFuture<CalculatedFieldResult> performCalculation(Map<String, ArgumentEntry> updatedArgs, CalculatedFieldCtx ctx) throws Exception {
+        boolean cfUpdated = updatedArgs != null && updatedArgs.isEmpty();
+        if (shouldRecalculate() || cfUpdated) {
+            Output output = ctx.getOutput();
+            ObjectNode aggResult = aggregateMetrics(output);
+            lastMetricsEvalTs = System.currentTimeMillis();
+            ctx.scheduleReevaluation(deduplicationIntervalMs, actorCtx);
+            return Futures.immediateFuture(TelemetryCalculatedFieldResult.builder()
+                    .type(output.getType())
+                    .scope(output.getScope())
+                    .result(toSimpleResult(ctx.isUseLatestTs(), aggResult))
+                    .build());
+        } else {
+            return Futures.immediateFuture(TelemetryCalculatedFieldResult.EMPTY);
+        }
+    }
+
+    public Map<String, ArgumentEntry> updateEntityData(Map<String, ArgumentEntry> fetchedArgs) {
+        lastMetricsEvalTs = -1;
+        return update(fetchedArgs, ctx);
+    }
+
+    public void cleanupEntityData(EntityId relatedEntityId) {
+        arguments.values().forEach(argEntry -> {
+            RelatedEntitiesArgumentEntry aggEntry = (RelatedEntitiesArgumentEntry) argEntry;
+            aggEntry.getEntityInputs().remove(relatedEntityId);
+        });
+        lastMetricsEvalTs = -1;
+        lastArgsRefreshTs = System.currentTimeMillis();
+    }
+
+    private boolean shouldRecalculate() {
+        boolean intervalPassed = lastMetricsEvalTs <= System.currentTimeMillis() - deduplicationIntervalMs;
+        boolean argsUpdatedDuringInterval = lastArgsRefreshTs > lastMetricsEvalTs;
+        return intervalPassed && argsUpdatedDuringInterval;
+    }
+
+    private Map<EntityId, Map<String, ArgumentEntry>> prepareInputs() {
+        Map<EntityId, Map<String, ArgumentEntry>> inputs = new HashMap<>();
+        for (Map.Entry<String, ArgumentEntry> argEntry : arguments.entrySet()) {
+            String key = argEntry.getKey();
+            RelatedEntitiesArgumentEntry relatedEntitiesArgumentEntry = (RelatedEntitiesArgumentEntry) argEntry.getValue();
+            relatedEntitiesArgumentEntry.getEntityInputs().forEach((entityId, argumentEntry) -> {
+                inputs.computeIfAbsent(entityId, k -> new HashMap<>()).put(key, argumentEntry);
+            });
+        }
+        return inputs;
+    }
+
+    private ObjectNode aggregateMetrics(Output output) throws Exception {
+        ObjectNode aggResult = JacksonUtil.newObjectNode();
+        Map<EntityId, Map<String, ArgumentEntry>> inputs = prepareInputs();
+        for (Entry<String, AggMetric> entry : metrics.entrySet()) {
+            String metricKey = entry.getKey();
+            AggMetric metric = entry.getValue();
+
+            AggEntry aggMetricEntry = AggEntry.createAggFunction(metric.getFunction());
+            aggregateMetric(metric, aggMetricEntry, inputs);
+            aggMetricEntry.result(output.getDecimalsByDefault()).ifPresent(result -> {
+                aggResult.set(metricKey, JacksonUtil.valueToTree(result));
+            });
+        }
+        return aggResult;
+    }
+
+    private void aggregateMetric(AggMetric metric, AggEntry aggEntry, Map<EntityId, Map<String, ArgumentEntry>> inputs) throws Exception {
+        for (Map<String, ArgumentEntry> entityInputs : inputs.values()) {
+            if (applyAggregation(metric.getFilter(), entityInputs)) {
+                Object arg = resolveAggregationInput(metric.getInput(), entityInputs);
+                if (arg != null) {
+                    aggEntry.update(arg);
+                }
+            }
+        }
+    }
+
+    private boolean applyAggregation(String filter, Map<String, ArgumentEntry> entityInputs) throws Exception {
+        if (filter == null || filter.isEmpty()) {
+            return true;
+        } else {
+            Object filterResult = ctx.evaluateTbelExpression(filter, entityInputs, getLatestTimestamp()).get();
+            return filterResult instanceof Boolean booleanResult && booleanResult;
+        }
+    }
+
+    private Object resolveAggregationInput(AggInput aggInput, Map<String, ArgumentEntry> entityInputs) throws Exception {
+        if (aggInput instanceof AggFunctionInput functionInput) {
+            return ctx.evaluateTbelExpression(functionInput.getFunction(), entityInputs, getLatestTimestamp()).get();
+        } else {
+            String inputKey = ((AggKeyInput) aggInput).getKey();
+            return entityInputs.get(inputKey).getValue();
+        }
+    }
+
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/RelatedEntitiesArgumentEntry.java

@@ -0,0 +1,86 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import org.thingsboard.script.api.tbel.TbelCfArg;
+import org.thingsboard.script.api.tbel.TbelCfRelatedEntitiesArgumentValue;
+import org.thingsboard.script.api.tbel.TbelCfSingleValueArg;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.service.cf.ctx.state.ArgumentEntry;
+import org.thingsboard.server.service.cf.ctx.state.ArgumentEntryType;
+import org.thingsboard.server.service.cf.ctx.state.SingleValueArgumentEntry;
+
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Data
+@AllArgsConstructor
+public class RelatedEntitiesArgumentEntry implements ArgumentEntry {
+
+    private final Map<EntityId, ArgumentEntry> entityInputs;
+
+    private boolean forceResetPrevious;
+
+    @Override
+    public ArgumentEntryType getType() {
+        return ArgumentEntryType.RELATED_ENTITIES;
+    }
+
+    @Override
+    public Object getValue() {
+        return entityInputs;
+    }
+
+    @Override
+    public boolean updateEntry(ArgumentEntry entry) {
+        if (entry instanceof RelatedEntitiesArgumentEntry relatedEntitiesArgumentEntry) {
+            entityInputs.putAll(relatedEntitiesArgumentEntry.entityInputs);
+            return true;
+        } else if (entry instanceof SingleValueArgumentEntry singleValueArgumentEntry) {
+            if (entry.isForceResetPrevious()) {
+                entityInputs.put(singleValueArgumentEntry.getEntityId(), singleValueArgumentEntry);
+                return true;
+            }
+            ArgumentEntry argumentEntry = entityInputs.get(singleValueArgumentEntry.getEntityId());
+            if (argumentEntry != null) {
+                argumentEntry.updateEntry(singleValueArgumentEntry);
+            } else {
+                entityInputs.put(singleValueArgumentEntry.getEntityId(), singleValueArgumentEntry);
+            }
+            return true;
+        } else {
+            throw new IllegalArgumentException("Unsupported argument entry type for aggregation argument entry: " + entry.getType());
+        }
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return entityInputs.isEmpty();
+    }
+
+    @Override
+    public TbelCfArg toTbelCfArg() {
+        var inputs = entityInputs.entrySet().stream()
+                .collect(Collectors.toMap(
+                        e -> e.getKey().getId(),
+                        e -> (TbelCfSingleValueArg) e.getValue().toTbelCfArg()
+                ));
+        return new TbelCfRelatedEntitiesArgumentValue(inputs);
+    }
+
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/function/AggEntry.java

@@ -0,0 +1,58 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation.function;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunction;
+
+import java.util.Optional;
+
+@JsonTypeInfo(
+        use = JsonTypeInfo.Id.NAME,
+        include = JsonTypeInfo.As.PROPERTY,
+        property = "type"
+)
+@JsonSubTypes({
+        @JsonSubTypes.Type(value = AvgAggEntry.class, name = "AVG"),
+        @JsonSubTypes.Type(value = CountAggEntry.class, name = "COUNT"),
+        @JsonSubTypes.Type(value = CountUniqueAggEntry.class, name = "COUNT_UNIQUE"),
+        @JsonSubTypes.Type(value = MaxAggEntry.class, name = "MAX"),
+        @JsonSubTypes.Type(value = MinAggEntry.class, name = "MIN"),
+        @JsonSubTypes.Type(value = SumAggEntry.class, name = "SUM")
+})
+public interface AggEntry {
+
+    @JsonIgnore
+    AggFunction getType();
+
+    void update(Object value);
+
+    Optional<Object> result(Integer precision);
+
+    static AggEntry createAggFunction(AggFunction function) {
+        return switch (function) {
+            case MIN -> new MinAggEntry();
+            case MAX -> new MaxAggEntry();
+            case SUM -> new SumAggEntry();
+            case AVG -> new AvgAggEntry();
+            case COUNT -> new CountAggEntry();
+            case COUNT_UNIQUE -> new CountUniqueAggEntry();
+        };
+    }
+
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/function/AvgAggEntry.java

@@ -0,0 +1,47 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation.function;
+
+import org.thingsboard.script.api.tbel.TbUtils;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunction;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class AvgAggEntry extends BaseAggEntry {
+
+    private BigDecimal sum = BigDecimal.ZERO;
+    private long count = 0L;
+
+    @Override
+    protected void doUpdate(double value) {
+        if (value != 0.0) {
+            sum = sum.add(BigDecimal.valueOf(value));
+        }
+        this.count++;
+    }
+
+    @Override
+    protected Object prepareResult(Integer precision) {
+        double result = sum.divide(BigDecimal.valueOf(count), RoundingMode.HALF_UP).doubleValue();
+        return TbUtils.roundResult(result, precision);
+    }
+
+    @Override
+    public AggFunction getType() {
+        return AggFunction.AVG;
+    }
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/function/BaseAggEntry.java

@@ -0,0 +1,55 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation.function;
+
+import java.util.Optional;
+
+public abstract class BaseAggEntry implements AggEntry {
+
+    private boolean hasResult = false;
+
+    @Override
+    public void update(Object value) {
+        doUpdate(extractDoubleValue(value));
+        hasResult = true;
+    }
+
+    @Override
+    public Optional<Object> result(Integer precision) {
+        if (hasResult) {
+            hasResult = false;
+            return Optional.of(prepareResult(precision));
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    protected abstract void doUpdate(double value);
+
+    protected abstract Object prepareResult(Integer precision);
+
+    protected double extractDoubleValue(Object value) {
+        try {
+            if (value instanceof Number number) {
+                return number.doubleValue();
+            }
+            return Double.parseDouble(value.toString());
+        } catch (Exception e) {
+            throw new NumberFormatException("Cannot parse value " + value.toString());
+        }
+    }
+
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/function/CountAggEntry.java

@@ -0,0 +1,41 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation.function;
+
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunction;
+
+import java.util.Optional;
+
+public class CountAggEntry implements AggEntry {
+
+    private long count = 0L;
+
+    @Override
+    public void update(Object value) {
+        count++;
+    }
+
+    @Override
+    public Optional<Object> result(Integer precision) {
+        return Optional.of(count);
+    }
+
+    @Override
+    public AggFunction getType() {
+        return AggFunction.COUNT;
+    }
+
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/function/CountUniqueAggEntry.java

@@ -0,0 +1,43 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation.function;
+
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunction;
+
+import java.util.Optional;
+import java.util.Set;
+
+public class CountUniqueAggEntry implements AggEntry {
+
+    private Set<String> items;
+
+    @Override
+    public void update(Object value) {
+        if (value != null) {
+            items.add(String.valueOf(value));
+        }
+    }
+
+    @Override
+    public Optional<Object> result(Integer precision) {
+        return Optional.of(items.size());
+    }
+
+    @Override
+    public AggFunction getType() {
+        return AggFunction.COUNT_UNIQUE;
+    }
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/function/MaxAggEntry.java

@@ -0,0 +1,41 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation.function;
+
+import org.thingsboard.script.api.tbel.TbUtils;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunction;
+
+public class MaxAggEntry extends BaseAggEntry {
+
+    private double max = Double.MIN_VALUE;
+
+    @Override
+    protected void doUpdate(double value) {
+        if (value > max) {
+            max = value;
+        }
+    }
+
+    @Override
+    protected Object prepareResult(Integer precision) {
+        return TbUtils.roundResult(max, precision);
+    }
+
+    @Override
+    public AggFunction getType() {
+        return AggFunction.MAX;
+    }
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/function/MinAggEntry.java

@@ -0,0 +1,41 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation.function;
+
+import org.thingsboard.script.api.tbel.TbUtils;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunction;
+
+public class MinAggEntry extends BaseAggEntry {
+
+    private double min = Double.MAX_VALUE;
+
+    @Override
+    protected void doUpdate(double value) {
+        if (value < min) {
+            min = value;
+        }
+    }
+
+    @Override
+    protected Object prepareResult(Integer precision) {
+        return TbUtils.roundResult(min, precision);
+    }
+
+    @Override
+    public AggFunction getType() {
+        return AggFunction.MIN;
+    }
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/aggregation/function/SumAggEntry.java

@@ -0,0 +1,43 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state.aggregation.function;
+
+import org.thingsboard.script.api.tbel.TbUtils;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunction;
+
+import java.math.BigDecimal;
+
+public class SumAggEntry extends BaseAggEntry {
+
+    private BigDecimal sum = BigDecimal.ZERO;
+
+    @Override
+    protected void doUpdate(double value) {
+        if (value != 0.0) {
+            sum = sum.add(BigDecimal.valueOf(value));
+        }
+    }
+
+    @Override
+    protected Object prepareResult(Integer precision) {
+        return TbUtils.roundResult(sum.doubleValue(), precision);
+    }
+
+    @Override
+    public AggFunction getType() {
+        return AggFunction.SUM;
+    }
+}

application/src/main/java/org/thingsboard/server/service/entitiy/EntityStateSourcingListener.java

@@ -29,6 +29,7 @@ import org.thingsboard.server.common.data.Customer;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.ObjectType;
 import org.thingsboard.server.common.data.TbResource;
 import org.thingsboard.server.common.data.TbResourceInfo;
 import org.thingsboard.server.common.data.Tenant;
@@ -61,6 +62,7 @@ import org.thingsboard.server.common.util.ProtoUtils;
 import org.thingsboard.server.dao.edge.EdgeSynchronizationManager;
 import org.thingsboard.server.dao.eventsourcing.ActionEntityEvent;
 import org.thingsboard.server.dao.eventsourcing.DeleteEntityEvent;
+import org.thingsboard.server.dao.eventsourcing.RelationActionEvent;
 import org.thingsboard.server.dao.eventsourcing.SaveEntityEvent;
 import org.thingsboard.server.dao.tenant.TenantService;
 import org.thingsboard.server.gen.transport.TransportProtos.EntityActionEventProto;
@@ -270,6 +272,15 @@ public class EntityStateSourcingListener {
         }
     }
 
+    @TransactionalEventListener(fallbackExecution = true)
+    public void handleEvent(RelationActionEvent relationEvent) {
+        if (relationEvent.getActionType() == ActionType.RELATION_ADD_OR_UPDATE) {
+            tbClusterService.onRelationUpdated(relationEvent.getTenantId(), relationEvent.getRelation(), TbQueueCallback.EMPTY);
+        } else if (relationEvent.getActionType() == ActionType.RELATION_DELETED) {
+            tbClusterService.onRelationDeleted(relationEvent.getTenantId(), relationEvent.getRelation(), TbQueueCallback.EMPTY);
+        }
+    }
+
     private void onTenantUpdate(Tenant tenant, ComponentLifecycleEvent lifecycleEvent) {
         tbClusterService.onTenantChange(tenant, null);
         tbClusterService.broadcastEntityStateChangeEvent(tenant.getId(), tenant.getId(), lifecycleEvent);

application/src/main/java/org/thingsboard/server/service/queue/DefaultTbClusterService.java

@@ -56,6 +56,7 @@ import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
 import org.thingsboard.server.common.data.queue.Queue;
+import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.ToDeviceActorNotificationMsg;
 import org.thingsboard.server.common.msg.edge.EdgeEventUpdateMsg;
@@ -723,6 +724,28 @@ public class DefaultTbClusterService implements TbClusterService {
         broadcastEntityStateChangeEvent(calculatedField.getTenantId(), calculatedField.getId(), ComponentLifecycleEvent.DELETED);
     }
 
+    @Override
+    public void onRelationUpdated(TenantId tenantId, EntityRelation entityRelation, TbQueueCallback callback) {
+        ComponentLifecycleMsg msg = ComponentLifecycleMsg.builder()
+                .tenantId(tenantId)
+                .entityId(entityRelation.getFrom())
+                .event(ComponentLifecycleEvent.RELATION_UPDATED)
+                .info(JacksonUtil.valueToTree(entityRelation))
+                .build();
+        broadcast(msg);
+    }
+
+    @Override
+    public void onRelationDeleted(TenantId tenantId, EntityRelation entityRelation, TbQueueCallback callback) {
+        ComponentLifecycleMsg msg = ComponentLifecycleMsg.builder()
+                .tenantId(tenantId)
+                .entityId(entityRelation.getFrom())
+                .event(ComponentLifecycleEvent.RELATION_DELETED)
+                .info(JacksonUtil.valueToTree(entityRelation))
+                .build();
+        broadcast(msg);
+    }
+
     @Override
     public void sendNotificationMsgToEdge(TenantId tenantId, EdgeId edgeId, EntityId entityId, String body, EdgeEventType type, EdgeEventActionType action, EdgeId originatorEdgeId) {
         if (!edgesEnabled) {

application/src/main/java/org/thingsboard/server/utils/CalculatedFieldArgumentUtils.java

@@ -34,6 +34,7 @@ import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.ScriptCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.SimpleCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.SingleValueArgumentEntry;
+import org.thingsboard.server.service.cf.ctx.state.aggregation.RelatedEntitiesAggregationCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.alarm.AlarmCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.propagation.PropagationCalculatedFieldState;
@@ -81,6 +82,7 @@ public class CalculatedFieldArgumentUtils {
             case GEOFENCING -> new GeofencingCalculatedFieldState(entityId);
             case ALARM -> new AlarmCalculatedFieldState(entityId);
             case PROPAGATION -> new PropagationCalculatedFieldState(entityId);
+            case RELATED_ENTITIES_AGGREGATION -> new RelatedEntitiesAggregationCalculatedFieldState(entityId);
         };
     }
 

application/src/main/java/org/thingsboard/server/utils/CalculatedFieldUtils.java

@@ -45,6 +45,8 @@ import org.thingsboard.server.service.cf.ctx.state.ScriptCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.SimpleCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.SingleValueArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.TsRollingArgumentEntry;
+import org.thingsboard.server.service.cf.ctx.state.aggregation.RelatedEntitiesAggregationCalculatedFieldState;
+import org.thingsboard.server.service.cf.ctx.state.aggregation.RelatedEntitiesArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.alarm.AlarmCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.alarm.AlarmRuleState;
 import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingArgumentEntry;
@@ -52,6 +54,7 @@ import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingCalculat
 import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingZoneState;
 import org.thingsboard.server.service.cf.ctx.state.propagation.PropagationCalculatedFieldState;
 
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
 import java.util.TreeMap;
@@ -97,6 +100,11 @@ public class CalculatedFieldUtils {
                 case SINGLE_VALUE -> builder.addSingleValueArguments(toSingleValueArgumentProto(argName, (SingleValueArgumentEntry) argEntry));
                 case TS_ROLLING -> builder.addRollingValueArguments(toRollingArgumentProto(argName, (TsRollingArgumentEntry) argEntry));
                 case GEOFENCING -> builder.addGeofencingArguments(toGeofencingArgumentProto(argName, (GeofencingArgumentEntry) argEntry));
+                case RELATED_ENTITIES -> {
+                    RelatedEntitiesArgumentEntry relatedEntitiesArgumentEntry = (RelatedEntitiesArgumentEntry) argEntry;
+                    relatedEntitiesArgumentEntry.getEntityInputs()
+                            .forEach((entityId, entry) -> builder.addSingleValueArguments(toSingleValueArgumentProto(argName, (SingleValueArgumentEntry) entry)));
+                }
             }
         });
         if (state instanceof AlarmCalculatedFieldState alarmState) {
@@ -108,6 +116,10 @@ public class CalculatedFieldUtils {
                 alarmStateProto.setClearRuleState(toAlarmRuleStateProto(alarmState.getClearRuleState()));
             }
         }
+        if (state instanceof RelatedEntitiesAggregationCalculatedFieldState aggState) {
+            builder.setLastArgsUpdateTs(aggState.getLastArgsRefreshTs());
+            builder.setLastMetricsEvalTs(aggState.getLastMetricsEvalTs());
+        }
         return builder.build();
     }
 
@@ -139,6 +151,10 @@ public class CalculatedFieldUtils {
 
         Optional.ofNullable(entry.getVersion()).ifPresent(builder::setVersion);
 
+        if (entry.getEntityId() != null) {
+            builder.setEntityId(ProtoUtils.toProto(entry.getEntityId()));
+        }
+
         return builder.build();
     }
 
@@ -187,8 +203,24 @@ public class CalculatedFieldUtils {
             case GEOFENCING -> new GeofencingCalculatedFieldState(id.entityId());
             case ALARM -> new AlarmCalculatedFieldState(id.entityId());
             case PROPAGATION -> new PropagationCalculatedFieldState(id.entityId());
+            case RELATED_ENTITIES_AGGREGATION -> new RelatedEntitiesAggregationCalculatedFieldState(id.entityId());
         };
 
+        if (state instanceof RelatedEntitiesAggregationCalculatedFieldState relatedEntitiesAggState) {
+            Map<String, Map<EntityId, ArgumentEntry>> arguments = new HashMap<>();
+            proto.getSingleValueArgumentsList().forEach(argProto -> {
+                SingleValueArgumentEntry entry = fromSingleValueArgumentProto(argProto);
+                arguments.computeIfAbsent(argProto.getArgName(), name -> new HashMap<>()).put(entry.getEntityId(), entry);
+            });
+            arguments.forEach((argName, entityInputs) -> {
+                relatedEntitiesAggState.getArguments().put(argName, new RelatedEntitiesArgumentEntry(entityInputs, false));
+            });
+            relatedEntitiesAggState.setLastArgsRefreshTs(proto.getLastArgsUpdateTs());
+            relatedEntitiesAggState.setLastMetricsEvalTs(proto.getLastMetricsEvalTs());
+
+            return relatedEntitiesAggState;
+        }
+
         proto.getSingleValueArgumentsList().forEach(argProto ->
                 state.getArguments().put(argProto.getArgName(), fromSingleValueArgumentProto(argProto)));
 
@@ -222,11 +254,14 @@ public class CalculatedFieldUtils {
             return new SingleValueArgumentEntry();
         }
         TsValueProto tsValueProto = proto.getValue();
-        return new SingleValueArgumentEntry(
-                tsValueProto.getTs(),
-                (BasicKvEntry) KvProtoUtil.fromTsValueProto(proto.getArgName(), tsValueProto),
-                proto.getVersion()
-        );
+        BasicKvEntry kvEntry = (BasicKvEntry) KvProtoUtil.fromTsValueProto(proto.getArgName(), tsValueProto);
+        long ts = tsValueProto.getTs();
+        long version = proto.getVersion();
+        if (proto.hasEntityId()) {
+            EntityId entityId = ProtoUtils.fromProto(proto.getEntityId());
+            return new SingleValueArgumentEntry(entityId, ts, kvEntry, version);
+        }
+        return new SingleValueArgumentEntry(ts, kvEntry, version);
     }
 
     public static TsRollingArgumentEntry fromRollingArgumentProto(TsRollingArgumentProto proto) {

application/src/test/java/org/thingsboard/server/cf/RelatedEntitiesAggregationCalculatedFieldTest.java

@@ -0,0 +1,786 @@
+/**
+ * Copyright © 2016-2025 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.cf;
+
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.test.annotation.DirtiesContext;
+import org.thingsboard.server.common.data.AttributeScope;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.Tenant;
+import org.thingsboard.server.common.data.User;
+import org.thingsboard.server.common.data.asset.Asset;
+import org.thingsboard.server.common.data.asset.AssetProfile;
+import org.thingsboard.server.common.data.cf.CalculatedField;
+import org.thingsboard.server.common.data.cf.CalculatedFieldType;
+import org.thingsboard.server.common.data.cf.configuration.Argument;
+import org.thingsboard.server.common.data.cf.configuration.ArgumentType;
+import org.thingsboard.server.common.data.cf.configuration.Output;
+import org.thingsboard.server.common.data.cf.configuration.OutputType;
+import org.thingsboard.server.common.data.cf.configuration.ReferencedEntityKey;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunction;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggFunctionInput;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggKeyInput;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.AggMetric;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.RelatedEntitiesAggregationCalculatedFieldConfiguration;
+import org.thingsboard.server.common.data.debug.DebugSettings;
+import org.thingsboard.server.common.data.device.data.DefaultDeviceConfiguration;
+import org.thingsboard.server.common.data.device.data.DefaultDeviceTransportConfiguration;
+import org.thingsboard.server.common.data.device.data.DeviceData;
+import org.thingsboard.server.common.data.id.AssetProfileId;
+import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.relation.EntityRelation;
+import org.thingsboard.server.common.data.relation.EntitySearchDirection;
+import org.thingsboard.server.common.data.relation.RelationPathLevel;
+import org.thingsboard.server.common.data.relation.RelationTypeGroup;
+import org.thingsboard.server.common.data.security.Authority;
+import org.thingsboard.server.controller.AbstractControllerTest;
+import org.thingsboard.server.dao.service.DaoSqlTest;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.thingsboard.server.cf.CalculatedFieldIntegrationTest.POLL_INTERVAL;
+
+@DaoSqlTest
+@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
+public class RelatedEntitiesAggregationCalculatedFieldTest extends AbstractControllerTest {
+
+    private Tenant savedTenant;
+
+    private DeviceProfile deviceProfile;
+    private Device device1;
+    private String accessToken1 = "1234567890111";
+    private Device device2;
+    private String accessToken2 = "1234567890222";
+
+    private AssetProfile assetProfile;
+    private Asset asset;
+
+    private final long deduplicationInterval = 5;
+
+    @Before
+    public void beforeEach() throws Exception {
+        loginSysAdmin();
+
+        updateDefaultTenantProfileConfig(tenantProfileConfig -> {
+            tenantProfileConfig.setMinAllowedDeduplicationIntervalInSecForCF(1);
+        });
+
+        Tenant tenant = new Tenant();
+        tenant.setTitle("My tenant");
+        savedTenant = saveTenant(tenant);
+        assertThat(savedTenant).isNotNull();
+
+        User tenantAdmin = new User();
+        tenantAdmin.setAuthority(Authority.TENANT_ADMIN);
+        tenantAdmin.setTenantId(savedTenant.getId());
+        tenantAdmin.setEmail("tenant@thingsboard.org");
+        tenantAdmin.setFirstName("John");
+        tenantAdmin.setLastName("Doe");
+
+        createUserAndLogin(tenantAdmin, "testPassword");
+
+        deviceProfile = doPost("/api/deviceProfile", createDeviceProfile("Device Profile"), DeviceProfile.class);
+        device1 = createDevice("Device 1", deviceProfile.getId(), accessToken1);
+        device2 = createDevice("Device 2", deviceProfile.getId(), accessToken2);
+
+        postTelemetry(device1.getId(), "{\"occupied\":true}");
+        postTelemetry(device2.getId(), "{\"occupied\":false}");
+
+        assetProfile = doPost("/api/assetProfile", createAssetProfile("Asset Profile"), AssetProfile.class);
+        asset = createAsset("Asset", assetProfile.getId());
+
+        createEntityRelation(asset.getId(), device1.getId(), "Contains");
+        createEntityRelation(asset.getId(), device2.getId(), "Contains");
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        loginSysAdmin();
+
+        deleteTenant(savedTenant.getId());
+    }
+
+    @Test
+    public void testCreateCfOnProfile_checkInitialAggregation() throws Exception {
+        Asset asset2 = createAsset("Asset 2", assetProfile.getId());
+        Device device3 = createDevice("Device 3", "1234567890333");
+        Device device4 = createDevice("Device 4", "1234567890444");
+
+        createEntityRelation(asset2.getId(), device3.getId(), "Contains");
+        createEntityRelation(asset2.getId(), device4.getId(), "Contains");
+
+        createOccupancyCF(assetProfile.getId());
+
+        await().alias("create CF and perform initial aggregation").atMost(TIMEOUT, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of(
+                            "freeSpaces", "1",
+                            "occupiedSpaces", "1",
+                            "totalSpaces", "2"
+                    ));
+
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "2",
+                            "occupiedSpaces", "0",
+                            "totalSpaces", "2"
+                    ));
+                });
+
+        postTelemetry(device3.getId(), "{\"occupied\":true}");
+
+        await().alias("update telemetry and perform aggregation")
+                .atLeast(deduplicationInterval / 2, TimeUnit.SECONDS)
+                .atMost(TIMEOUT, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "1",
+                            "occupiedSpaces", "1",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testAddEntityToProfile_checkAggregation() throws Exception {
+        createOccupancyCF(assetProfile.getId());
+
+        Device device3 = createDevice("Device 3", "1234567890333");
+        Device device4 = createDevice("Device 4", "1234567890444");
+        postTelemetry(device3.getId(), "{\"occupied\":true}");
+        postTelemetry(device4.getId(), "{\"occupied\":true}");
+
+        Asset asset2 = createAsset("Asset 2", assetProfile.getId());
+
+        await().alias("add entity to profile with no related entities and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    ObjectNode occupancy = getLatestTelemetry(asset2.getId(), "freeSpaces", "occupiedSpaces", "totalSpaces");
+                    assertThat(occupancy).isNotNull();
+                    assertThat(occupancy.get("freeSpaces").get(0).get("value").isNull()).isTrue();
+                    assertThat(occupancy.get("occupiedSpaces").get(0).get("value").isNull()).isTrue();
+                    assertThat(occupancy.get("totalSpaces").get(0).get("value").isNull()).isTrue();
+                });
+
+        createEntityRelation(asset2.getId(), device3.getId(), "Contains");
+        createEntityRelation(asset2.getId(), device4.getId(), "Contains");
+
+        await().alias("create relations and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "0",
+                            "occupiedSpaces", "2",
+                            "totalSpaces", "2"
+                    ));
+                });
+
+        postTelemetry(device3.getId(), "{\"occupied\":false}");
+
+        await().alias("update telemetry and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "1",
+                            "occupiedSpaces", "1",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testChangeEntityProfile_checkAggregation() throws Exception {
+        Asset asset2 = createAsset("Asset 2", assetProfile.getId());
+        Device device3 = createDevice("Device 3", "1234567890333");
+        Device device4 = createDevice("Device 4", "1234567890444");
+
+        createEntityRelation(asset2.getId(), device3.getId(), "Contains");
+        createEntityRelation(asset2.getId(), device4.getId(), "Contains");
+
+        createOccupancyCF(assetProfile.getId());
+
+        await().alias("create CF and perform initial aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of(
+                            "freeSpaces", "1",
+                            "occupiedSpaces", "1",
+                            "totalSpaces", "2"
+                    ));
+
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "2",
+                            "occupiedSpaces", "0",
+                            "totalSpaces", "2"
+                    ));
+                });
+
+        AssetProfile newAssetProfile = createAssetProfile("New Asset Profile");
+        asset2.setAssetProfileId(newAssetProfile.getId());
+        doPost("/api/asset", asset2, Asset.class);
+
+        postTelemetry(device3.getId(), "{\"occupied\":true}");
+
+        await().alias("change profile and no aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "2",
+                            "occupiedSpaces", "0",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testCreateCfOnAssetAndNoTelemetryOnDevices_checkDefaultValueUsed() throws Exception {
+        Asset asset2 = createAsset("Asset 2", assetProfile.getId());
+        Device device3 = createDevice("Device 3", "1234567890333");
+        Device device4 = createDevice("Device 4", "1234567890444");
+
+        createEntityRelation(asset2.getId(), device3.getId(), "Contains");
+        createEntityRelation(asset2.getId(), device4.getId(), "Contains");
+
+        createOccupancyCF(asset2.getId());
+
+        await().alias("create CF and perform aggregation with default values").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "2",
+                            "occupiedSpaces", "0",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testCreateCfAndUpdateTelemetry_checkAggregation() throws Exception {
+        createOccupancyCF(asset.getId());
+        checkInitialCalculation();
+
+        postTelemetry(device1.getId(), "{\"occupied\":false}");
+
+        await().alias("update telemetry and perform aggregation")
+                .atLeast(deduplicationInterval / 2, TimeUnit.SECONDS)
+                .atMost(TIMEOUT, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of(
+                            "freeSpaces", "2",
+                            "occupiedSpaces", "0",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testDeleteCf_checkNoAggregation() throws Exception {
+        CalculatedField cf = createOccupancyCF(asset.getId());
+        checkInitialCalculation();
+
+        doDelete("/api/calculatedField/" + cf.getId().getId().toString())
+                .andExpect(status().isOk());
+
+        postTelemetry(device1.getId(), "{\"occupied\":false}");
+
+        await().alias("delete cf and update telemetry and no aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of(
+                            "freeSpaces", "1",
+                            "occupiedSpaces", "1",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testUpdateTelemetry_checkAggregationNotExecutedUntilDeduplicationInterval() throws Exception {
+        createOccupancyCF(asset.getId());
+        checkInitialCalculation();
+
+        postTelemetry(device1.getId(), "{\"occupied\":false}");
+
+        await().alias("update telemetry -> no changes").atMost(TIMEOUT, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(this::checkInitialCalculationValues);
+
+        postTelemetry(device2.getId(), "{\"occupied\":false}");
+
+        await().alias("create CF and perform initial calculation")
+                .atLeast(deduplicationInterval / 2, TimeUnit.SECONDS)
+                .atMost(TIMEOUT, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of(
+                            "freeSpaces", "2",
+                            "occupiedSpaces", "0",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testDeleteTelemetry_checkAggregationWithPreviousValuesOrDefault() throws Exception {
+        Asset asset2 = createAsset("Asset 2", assetProfile.getId());
+        Device device3 = createDevice("Device 3", "1234567890333");
+        Device device4 = createDevice("Device 4", "1234567890444");
+
+        createEntityRelation(asset2.getId(), device3.getId(), "Contains");
+        createEntityRelation(asset2.getId(), device4.getId(), "Contains");
+
+        long currentTime = System.currentTimeMillis();
+        long firstTs = currentTime - 10;
+        long secondTs = currentTime - 10;
+        long thirdTs = currentTime - 5;
+        postTelemetry(device3.getId(), "{\"ts\": " + firstTs + ", \"values\": {\"occupied\":true}}");
+        postTelemetry(device4.getId(), "{\"ts\": " + secondTs + ", \"values\": {\"occupied\":true}}");
+        postTelemetry(device3.getId(), "{\"ts\": " + thirdTs + ", \"values\": {\"occupied\":true}}");
+
+        createOccupancyCF(asset2.getId());
+
+        await().alias("create CF and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "0",
+                            "occupiedSpaces", "2",
+                            "totalSpaces", "2"
+                    ));
+                });
+
+        doDelete("/api/plugins/telemetry/DEVICE/" + device3.getId() + "/timeseries/delete?keys=occupied&deleteAllDataForKeys=false&rewriteLatestIfDeleted=true&deleteLatest=true&startTs=" + thirdTs + "&endTs=" + thirdTs + 1, String.class);
+        doDelete("/api/plugins/telemetry/DEVICE/" + device4.getId() + "/timeseries/delete?keys=occupied&deleteAllDataForKeys=false&rewriteLatestIfDeleted=true&deleteLatest=true&startTs=" + secondTs + "&endTs=" + secondTs + 1, String.class);
+
+        await().alias("delete latest telemetry and perform aggregation with previous or default values").atMost(deduplicationInterval * 2, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "1",
+                            "occupiedSpaces", "1",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testDeleteAttr_checkAggregationWithDefault() throws Exception {
+        Asset asset2 = createAsset("Asset 2", assetProfile.getId());
+        Device device3 = createDevice("Device 3", "1234567890333");
+        Device device4 = createDevice("Device 4", "1234567890444");
+
+        createEntityRelation(asset2.getId(), device3.getId(), "Contains");
+        createEntityRelation(asset2.getId(), device4.getId(), "Contains");
+
+        postAttributes(device3.getId(), AttributeScope.SERVER_SCOPE, "{\"occupied\":true}");
+        postAttributes(device4.getId(), AttributeScope.SERVER_SCOPE, "{\"occupied\":true}");
+
+        createOccupancyCFWithAttr(asset2.getId());
+
+        await().alias("create CF and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "0",
+                            "occupiedSpaces", "2",
+                            "totalSpaces", "2"
+                    ));
+                });
+
+        doDelete("/api/plugins/telemetry/DEVICE/" + device3.getUuidId() + "/SERVER_SCOPE?keys=occupied", String.class);
+        doDelete("/api/plugins/telemetry/DEVICE/" + device4.getUuidId() + "/SERVER_SCOPE?keys=occupied", String.class);
+
+        await().alias("delete attribute and perform aggregation with default values").atMost(deduplicationInterval * 2, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset2.getId(), Map.of(
+                            "freeSpaces", "2",
+                            "occupiedSpaces", "0",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testCreateRelation_checkAggregation() throws Exception {
+        createOccupancyCF(asset.getId());
+        checkInitialCalculation();
+
+        Device device3 = createDevice("Device 3", deviceProfile.getId(), "1234567890333");
+
+        postTelemetry(device3.getId(), "{\"occupied\":true}");
+
+        createEntityRelation(asset.getId(), device3.getId(), "Contains");
+
+        await().alias("create relation and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of(
+                            "freeSpaces", "1",
+                            "occupiedSpaces", "2",
+                            "totalSpaces", "3"
+                    ));
+                });
+    }
+
+    @Test
+    public void testDeleteRelation_checkAggregation() throws Exception {
+        createOccupancyCF(asset.getId());
+        checkInitialCalculation();
+
+        deleteEntityRelation(new EntityRelation(asset.getId(), device1.getId(), "Contains", RelationTypeGroup.COMMON));
+
+        await().alias("create relation and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of(
+                            "freeSpaces", "1",
+                            "occupiedSpaces", "0",
+                            "totalSpaces", "1"
+                    ));
+                });
+    }
+
+    @Test
+    public void testUpdateRelationPath_checkAggregation() throws Exception {
+        CalculatedField cf = createOccupancyCF(asset.getId());
+        checkInitialCalculation();
+
+        Device device3 = createDevice("Device 3", "1234567890333");
+        createEntityRelation(asset.getId(), device3.getId(), "Has");
+        postTelemetry(device3.getId(), "{\"occupied\":true}");
+
+        var configuration = (RelatedEntitiesAggregationCalculatedFieldConfiguration) cf.getConfiguration();
+        configuration.setRelation(new RelationPathLevel(EntitySearchDirection.FROM, "Has"));
+        saveCalculatedField(cf);
+
+        await().alias("update relation path and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of(
+                            "freeSpaces", "0",
+                            "occupiedSpaces", "1",
+                            "totalSpaces", "1"
+                    ));
+                });
+    }
+
+    @Test
+    public void testUpdateArguments_checkAggregation() throws Exception {
+        CalculatedField cf = createOccupancyCF(asset.getId());
+        checkInitialCalculation();
+
+        postTelemetry(device1.getId(), "{\"occupiedStatus\":false}");
+        postTelemetry(device2.getId(), "{\"occupiedStatus\":false}");
+
+        var configuration = (RelatedEntitiesAggregationCalculatedFieldConfiguration) cf.getConfiguration();
+        Argument argument = new Argument();
+        argument.setRefEntityKey(new ReferencedEntityKey("oc", ArgumentType.TS_LATEST, null));
+        argument.setDefaultValue("false");
+        configuration.setArguments(Map.of("oc", argument));
+        saveCalculatedField(cf);
+
+        await().alias("update arguments and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of(
+                            "freeSpaces", "2",
+                            "occupiedSpaces", "0",
+                            "totalSpaces", "2"
+                    ));
+                });
+    }
+
+    @Test
+    public void testUpdateMetrics_checkAggregation() throws Exception {
+        postTelemetry(device1.getId(), "{\"temperature\":24.2}");
+        postTelemetry(device2.getId(), "{\"temperature\":19.6}");
+        CalculatedField cf = createAvgTemperatureCF(asset.getId());
+
+        await().alias("create avg temp cf and perform initial aggregation").atMost(TIMEOUT, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of("avgTemperature", "24"));
+                });
+
+        var configuration = (RelatedEntitiesAggregationCalculatedFieldConfiguration) cf.getConfiguration();
+        AggMetric aggMetric = new AggMetric();
+        aggMetric.setInput(new AggKeyInput("temp"));
+        aggMetric.setFilter("return temp < 100;");
+        aggMetric.setFunction(AggFunction.MAX);
+        configuration.setMetrics(Map.of("maxTemperature", aggMetric));
+        saveCalculatedField(cf);
+
+        await().alias("update metrics and perform aggregation").atMost(TIMEOUT, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of("maxTemperature", "24"));
+                });
+
+        postTelemetry(device1.getId(), "{\"temperature\":101.3}");
+        postTelemetry(device2.getId(), "{\"temperature\":25.8}");
+
+        await().alias("update telemetry and perform aggregation")
+                .atLeast(deduplicationInterval / 2, TimeUnit.SECONDS)
+                .atMost(TIMEOUT, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of("maxTemperature", "26"));
+                });
+    }
+
+    @Test
+    public void testUpdateOutput_checkAggregation() throws Exception {
+        postTelemetry(device1.getId(), "{\"temperature\":24.2}");
+        postTelemetry(device2.getId(), "{\"temperature\":19.6}");
+        CalculatedField cf = createAvgTemperatureCF(asset.getId());
+
+        await().alias("create avg temp cf and perform initial aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of("avgTemperature", "24"));
+                });
+
+        var configuration = (RelatedEntitiesAggregationCalculatedFieldConfiguration) cf.getConfiguration();
+        Output output = new Output();
+        output.setType(OutputType.ATTRIBUTES);
+        output.setScope(AttributeScope.SERVER_SCOPE);
+        configuration.setOutput(output);
+        saveCalculatedField(cf);
+
+        await().alias("update output and perform aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    ArrayNode avgTemperature = getServerAttributes(asset.getId(), "avgTemperature");
+                    assertThat(avgTemperature).isNotNull();
+                    assertThat(avgTemperature.get(0)).isNotNull();
+                    assertThat(avgTemperature.get(0).get("value").asText()).isEqualTo("24.2");
+                });
+    }
+
+    @Test
+    public void testUpdateDeduplicationInterval_checkAggregationNotExecutedUntilDeduplicationInterval() throws Exception {
+        postTelemetry(device1.getId(), "{\"temperature\":24.2}");
+        postTelemetry(device2.getId(), "{\"temperature\":19.6}");
+        CalculatedField cf = createAvgTemperatureCF(asset.getId());
+
+        await().alias("create avg temp cf and perform initial aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of("avgTemperature", "24"));
+                });
+
+        var configuration = (RelatedEntitiesAggregationCalculatedFieldConfiguration) cf.getConfiguration();
+        configuration.setDeduplicationIntervalInSec(2 * deduplicationInterval);
+        saveCalculatedField(cf);
+
+        await().alias("update deduplication interval and perform aggregation").atMost(deduplicationInterval / 2, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of("avgTemperature", "24"));
+                });
+
+        postTelemetry(device2.getId(), "{\"temperature\":32.1}");
+
+        await().alias("update telemetry and perform aggregation").atMost(2 * deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    verifyTelemetry(asset.getId(), Map.of("avgTemperature", "28"));
+                });
+    }
+
+    private void checkInitialCalculation() {
+        await().alias("create CF and perform initial aggregation").atMost(deduplicationInterval, TimeUnit.SECONDS)
+                .pollInterval(POLL_INTERVAL, TimeUnit.SECONDS)
+                .untilAsserted(this::checkInitialCalculationValues);
+    }
+
+    private void checkInitialCalculationValues() throws Exception {
+        ObjectNode occupancy = getLatestTelemetry(asset.getId(), "freeSpaces", "occupiedSpaces", "totalSpaces");
+        assertThat(occupancy).isNotNull();
+        assertThat(occupancy.get("freeSpaces").get(0).get("value").asText()).isEqualTo("1");
+        assertThat(occupancy.get("occupiedSpaces").get(0).get("value").asText()).isEqualTo("1");
+        assertThat(occupancy.get("totalSpaces").get(0).get("value").asText()).isEqualTo("2");
+    }
+
+    private CalculatedField createAvgTemperatureCF(EntityId entityId) {
+        Map<String, Argument> arguments = new HashMap<>();
+        Argument argument = new Argument();
+        argument.setRefEntityKey(new ReferencedEntityKey("temperature", ArgumentType.TS_LATEST, null));
+        argument.setDefaultValue("20");
+        arguments.put("temp", argument);
+
+        Map<String, AggMetric> aggMetrics = new HashMap<>();
+
+        AggMetric avgMetric = new AggMetric();
+        avgMetric.setFunction(AggFunction.AVG);
+        avgMetric.setFilter("return temp >= 20;");
+        avgMetric.setInput(new AggKeyInput("temp"));
+        aggMetrics.put("avgTemperature", avgMetric);
+
+        Output output = new Output();
+        output.setType(OutputType.TIME_SERIES);
+        output.setDecimalsByDefault(0);
+
+        return createAggCf("Average temperature", entityId,
+                new RelationPathLevel(EntitySearchDirection.FROM, "Contains"),
+                arguments,
+                aggMetrics,
+                output);
+    }
+
+    private CalculatedField createOccupancyCF(EntityId entityId) {
+        Map<String, Argument> arguments = new HashMap<>();
+        Argument argument = new Argument();
+        argument.setRefEntityKey(new ReferencedEntityKey("occupied", ArgumentType.TS_LATEST, null));
+        argument.setDefaultValue("false");
+        arguments.put("oc", argument);
+
+        Map<String, AggMetric> aggMetrics = new HashMap<>();
+
+        AggMetric freeSpaces = new AggMetric();
+        freeSpaces.setFunction(AggFunction.COUNT);
+        freeSpaces.setFilter("return oc == false;");
+        freeSpaces.setInput(new AggKeyInput("oc"));
+        aggMetrics.put("freeSpaces", freeSpaces);
+
+        AggMetric occupiedSpaces = new AggMetric();
+        occupiedSpaces.setFunction(AggFunction.COUNT);
+        occupiedSpaces.setFilter("return oc == true;");
+        occupiedSpaces.setInput(new AggKeyInput("oc"));
+        aggMetrics.put("occupiedSpaces", occupiedSpaces);
+
+        AggMetric totalSpaces = new AggMetric();
+        totalSpaces.setFunction(AggFunction.COUNT);
+        totalSpaces.setInput(new AggFunctionInput("return 1;"));
+        aggMetrics.put("totalSpaces", totalSpaces);
+
+        Output output = new Output();
+        output.setType(OutputType.TIME_SERIES);
+        output.setDecimalsByDefault(0);
+
+        return createAggCf("Occupied spaces", entityId,
+                new RelationPathLevel(EntitySearchDirection.FROM, "Contains"),
+                arguments,
+                aggMetrics,
+                output);
+    }
+
+    private CalculatedField createOccupancyCFWithAttr(EntityId entityId) {
+        Map<String, Argument> arguments = new HashMap<>();
+        Argument argument = new Argument();
+        argument.setRefEntityKey(new ReferencedEntityKey("occupied", ArgumentType.ATTRIBUTE, AttributeScope.SERVER_SCOPE));
+        argument.setDefaultValue("false");
+        arguments.put("oc", argument);
+
+        Map<String, AggMetric> aggMetrics = new HashMap<>();
+
+        AggMetric freeSpaces = new AggMetric();
+        freeSpaces.setFunction(AggFunction.COUNT);
+        freeSpaces.setFilter("return oc == false;");
+        freeSpaces.setInput(new AggKeyInput("oc"));
+        aggMetrics.put("freeSpaces", freeSpaces);
+
+        AggMetric occupiedSpaces = new AggMetric();
+        occupiedSpaces.setFunction(AggFunction.COUNT);
+        occupiedSpaces.setFilter("return oc == true;");
+        occupiedSpaces.setInput(new AggKeyInput("oc"));
+        aggMetrics.put("occupiedSpaces", occupiedSpaces);
+
+        AggMetric totalSpaces = new AggMetric();
+        totalSpaces.setFunction(AggFunction.COUNT);
+        totalSpaces.setInput(new AggFunctionInput("return 1;"));
+        aggMetrics.put("totalSpaces", totalSpaces);
+
+        Output output = new Output();
+        output.setType(OutputType.TIME_SERIES);
+        output.setDecimalsByDefault(0);
+
+        return createAggCf("Occupied spaces", entityId,
+                new RelationPathLevel(EntitySearchDirection.FROM, "Contains"),
+                arguments,
+                aggMetrics,
+                output);
+    }
+
+    private CalculatedField createAggCf(String name,
+                                        EntityId entityId,
+                                        RelationPathLevel relation,
+                                        Map<String, Argument> inputs,
+                                        Map<String, AggMetric> metrics,
+                                        Output output) {
+        CalculatedField calculatedField = new CalculatedField();
+        calculatedField.setName(name);
+        calculatedField.setEntityId(entityId);
+        calculatedField.setType(CalculatedFieldType.RELATED_ENTITIES_AGGREGATION);
+
+        RelatedEntitiesAggregationCalculatedFieldConfiguration configuration = new RelatedEntitiesAggregationCalculatedFieldConfiguration();
+        configuration.setRelation(relation);
+        configuration.setArguments(inputs);
+        configuration.setDeduplicationIntervalInSec(deduplicationInterval);
+        configuration.setMetrics(metrics);
+        configuration.setOutput(output);
+
+        calculatedField.setConfiguration(configuration);
+        calculatedField.setDebugSettings(DebugSettings.all());
+        return saveCalculatedField(calculatedField);
+    }
+
+    private Device createDevice(String name, DeviceProfileId deviceProfileId, String accessToken) {
+        Device device = new Device();
+        device.setName(name);
+        device.setDeviceProfileId(deviceProfileId);
+        DeviceData deviceData = new DeviceData();
+        deviceData.setTransportConfiguration(new DefaultDeviceTransportConfiguration());
+        deviceData.setConfiguration(new DefaultDeviceConfiguration());
+        device.setDeviceData(deviceData);
+        return doPost("/api/device?accessToken=" + accessToken, device, Device.class);
+    }
+
+    private Asset createAsset(String name, AssetProfileId assetProfileId) {
+        Asset asset = new Asset();
+        asset.setName(name);
+        asset.setAssetProfileId(assetProfileId);
+        return doPost("/api/asset", asset, Asset.class);
+    }
+
+    private void verifyTelemetry(EntityId entityId, Map<String, String> expectedResults) throws Exception {
+        ObjectNode result = getLatestTelemetry(entityId, expectedResults.keySet().toArray(new String[0]));
+        assertThat(result).isNotNull();
+        expectedResults.forEach((key, value) -> assertThat(result.get(key).get(0).get("value").asText()).isEqualTo(value));
+    }
+
+    private ObjectNode getLatestTelemetry(EntityId entityId, String... keys) throws Exception {
+        return doGetAsync("/api/plugins/telemetry/" + entityId.getEntityType() + "/" + entityId.getId() + "/values/timeseries?keys=" + String.join(",", keys), ObjectNode.class);
+    }
+
+    private ArrayNode getServerAttributes(EntityId entityId, String... keys) throws Exception {
+        return doGetAsync("/api/plugins/telemetry/" + entityId.getEntityType() + "/" + entityId.getId() + "/values/attributes/SERVER_SCOPE?keys=" + String.join(",", keys), ArrayNode.class);
+    }
+
+}

application/src/test/java/org/thingsboard/server/controller/AbstractWebTest.java

@@ -1069,6 +1069,16 @@ public abstract class AbstractWebTest extends AbstractInMemoryStorageTest {
         doPost("/api/relation", relation);
     }
 
+    protected void deleteEntityRelation(EntityRelation entityRelation) throws Exception {
+        String url = String.format("/api/relation?fromId=%s&fromType=%s&relationType=%s&toId=%s&toType=%s",
+                entityRelation.getFrom().getId(),
+                entityRelation.getFrom().getEntityType(),
+                entityRelation.getType(),
+                entityRelation.getTo().getId(),
+                entityRelation.getTo().getEntityType());
+        doDelete(url);
+    }
+
     protected List<EntityRelation> findRelationsByTo(EntityId entityId) throws Exception {
         String url = String.format("/api/relations?toId=%s&toType=%s", entityId.getId(), entityId.getEntityType().name());
         MvcResult mvcResult = doGet(url).andReturn();

application/src/test/java/org/thingsboard/server/service/cf/ctx/state/RelatedEntitiesArgumentEntryTest.java

@@ -0,0 +1,100 @@
+/**
+ * Copyright © 2016-2025 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.service.cf.ctx.state;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
+import org.thingsboard.server.common.data.kv.LongDataEntry;
+import org.thingsboard.server.service.cf.ctx.state.aggregation.RelatedEntitiesArgumentEntry;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class RelatedEntitiesArgumentEntryTest {
+
+    private RelatedEntitiesArgumentEntry entry;
+
+    private final DeviceId device1 = new DeviceId(UUID.fromString("1984e5f4-9ff0-4187-84ae-e4438bba4c8a"));
+    private final DeviceId device2 = new DeviceId(UUID.fromString("937fc062-1a9d-438f-aa22-55a93fc908b7"));
+
+    private final long ts = System.currentTimeMillis();
+
+    @BeforeEach
+    void setUp() {
+        Map<EntityId, ArgumentEntry> aggInputs = new HashMap<>();
+        aggInputs.put(device1, new SingleValueArgumentEntry(device1, new BasicTsKvEntry(ts - 100, new LongDataEntry("key", 12L), 1L)));
+        aggInputs.put(device2, new SingleValueArgumentEntry(device2, new BasicTsKvEntry(ts - 150, new LongDataEntry("key", 16L), 6L)));
+
+        entry = new RelatedEntitiesArgumentEntry(aggInputs, false);
+    }
+
+    @Test
+    void testUpdateEntryWhenNotAggEntryPassed() {
+        assertThatThrownBy(() -> entry.updateEntry(new TsRollingArgumentEntry(5, 30000L)))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("Unsupported argument entry type for aggregation argument entry: " + ArgumentEntryType.TS_ROLLING);
+    }
+
+    @Test
+    void testUpdateEntryWhenAggArgumentEntryPasser() {
+        DeviceId device3 = new DeviceId(UUID.randomUUID());
+        DeviceId device4 = new DeviceId(UUID.randomUUID());
+
+        RelatedEntitiesArgumentEntry relatedEntitiesArgumentEntry = new RelatedEntitiesArgumentEntry(Map.of(
+                device3, new SingleValueArgumentEntry(device3, new BasicTsKvEntry(ts - 50, new LongDataEntry("key", 16L), 13L)),
+                device4, new SingleValueArgumentEntry(device4, new BasicTsKvEntry(ts - 60, new LongDataEntry("key", 23L), 7L))
+        ), false);
+
+        assertThat(entry.updateEntry(relatedEntitiesArgumentEntry)).isTrue();
+
+        Map<EntityId, ArgumentEntry> aggInputs = entry.getEntityInputs();
+        assertThat(aggInputs.size()).isEqualTo(4);
+        assertThat(aggInputs.get(device3)).isEqualTo(relatedEntitiesArgumentEntry.getEntityInputs().get(device3));
+        assertThat(aggInputs.get(device4)).isEqualTo(relatedEntitiesArgumentEntry.getEntityInputs().get(device4));
+    }
+
+    @Test
+    void testUpdateEntryWhenSingleValueArgumentEntryPassedAndNoEntriesById() {
+        DeviceId device3 = new DeviceId(UUID.randomUUID());
+
+        SingleValueArgumentEntry singleEntityArgumentEntry = new SingleValueArgumentEntry(device3, new BasicTsKvEntry(ts - 50, new LongDataEntry("key", 18L), 10L));
+
+        assertThat(entry.updateEntry(singleEntityArgumentEntry)).isTrue();
+
+        Map<EntityId, ArgumentEntry> aggInputs = entry.getEntityInputs();
+        assertThat(aggInputs.size()).isEqualTo(3);
+        assertThat(aggInputs.get(device3)).isEqualTo(singleEntityArgumentEntry);
+    }
+
+    @Test
+    void testUpdateEntryWhenSingleValueArgumentEntryPassedAndEntryByIdExist() {
+        SingleValueArgumentEntry singleEntityArgumentEntry = new SingleValueArgumentEntry(device2, new BasicTsKvEntry(ts - 50, new LongDataEntry("key", 18L), 10L));
+
+        assertThat(entry.updateEntry(singleEntityArgumentEntry)).isTrue();
+
+        Map<EntityId, ArgumentEntry> aggInputs = entry.getEntityInputs();
+        assertThat(aggInputs.size()).isEqualTo(2);
+        assertThat(aggInputs.get(device2)).isEqualTo(singleEntityArgumentEntry);
+    }
+
+}

common/cluster-api/src/main/java/org/thingsboard/server/cluster/TbClusterService.java

@@ -30,6 +30,7 @@ import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
+import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.ToDeviceActorNotificationMsg;
 import org.thingsboard.server.common.msg.edge.EdgeEventUpdateMsg;
@@ -137,4 +138,8 @@ public interface TbClusterService extends TbQueueClusterService {
 
     void onCalculatedFieldDeleted(CalculatedField calculatedField, TbQueueCallback callback);
 
+    void onRelationUpdated(TenantId tenantId, EntityRelation entityRelation, TbQueueCallback callback);
+
+    void onRelationDeleted(TenantId tenantId, EntityRelation entityRelation, TbQueueCallback callback);
+
 }

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

@@ -86,6 +86,8 @@ public interface RelationService {
 
     ListenableFuture<List<EntityRelation>> findByRelationPathQueryAsync(TenantId tenantId, EntityRelationPathQuery relationPathQuery);
 
+    List<EntityRelation> findByRelationPathQuery(TenantId tenantId, EntityRelationPathQuery relationPathQuery);
+
 //    TODO: This method may be useful for some validations in the future
 //    ListenableFuture<Boolean> checkRecursiveRelation(EntityId from, EntityId to);
 

common/data/src/main/java/org/thingsboard/server/common/data/SystemParams.java

@@ -40,5 +40,6 @@ public class SystemParams {
     long maxDataPointsPerRollingArg;
     int minAllowedScheduledUpdateIntervalInSecForCF;
     int maxRelationLevelPerCfArgument;
+    long minAllowedDeduplicationIntervalInSecForCF;
     TrendzSettings trendzSettings;
 }

common/data/src/main/java/org/thingsboard/server/common/data/cf/CalculatedFieldType.java

@@ -25,7 +25,8 @@ public enum CalculatedFieldType {
     SCRIPT,
     GEOFENCING,
     ALARM,
-    PROPAGATION;
+    PROPAGATION,
+    RELATED_ENTITIES_AGGREGATION;
 
     public static final Set<CalculatedFieldType> all = Collections.unmodifiableSet(EnumSet.allOf(CalculatedFieldType.class));
 

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/Argument.java

@@ -45,4 +45,8 @@ public class Argument {
         return hasDynamicSource() && refDynamicSourceConfiguration.getType() == CFArgumentDynamicSourceType.CURRENT_OWNER;
     }
 
+    public boolean hasTsRollingArgument() {
+        return ArgumentType.TS_ROLLING.equals(refEntityKey.getType());
+    }
+
 }

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/CalculatedFieldConfiguration.java

@@ -22,6 +22,7 @@ import com.fasterxml.jackson.annotation.JsonSubTypes.Type;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.cf.CalculatedFieldType;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.RelatedEntitiesAggregationCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.cf.configuration.geofencing.GeofencingCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
 import org.thingsboard.server.common.data.id.EntityId;
@@ -40,7 +41,8 @@ import java.util.stream.Collectors;
         @Type(value = ScriptCalculatedFieldConfiguration.class, name = "SCRIPT"),
         @Type(value = GeofencingCalculatedFieldConfiguration.class, name = "GEOFENCING"),
         @Type(value = AlarmCalculatedFieldConfiguration.class, name = "ALARM"),
-        @Type(value = PropagationCalculatedFieldConfiguration.class, name = "PROPAGATION")
+        @Type(value = PropagationCalculatedFieldConfiguration.class, name = "PROPAGATION"),
+        @Type(value = RelatedEntitiesAggregationCalculatedFieldConfiguration.class, name = "RELATED_ENTITIES_AGGREGATION")
 })
 @JsonIgnoreProperties(ignoreUnknown = true)
 public interface CalculatedFieldConfiguration {

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/aggregation/AggFunction.java

@@ -0,0 +1,20 @@
+/**
+ * Copyright © 2016-2025 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.common.data.cf.configuration.aggregation;
+
+public enum AggFunction {
+    MIN, MAX, SUM, AVG, COUNT, COUNT_UNIQUE
+}

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/aggregation/AggFunctionInput.java

@@ -0,0 +1,34 @@
+/**
+ * Copyright © 2016-2025 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.common.data.cf.configuration.aggregation;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class AggFunctionInput implements AggInput {
+
+    private String function;
+
+    @Override
+    public String getType() {
+        return "function";
+    }
+
+}

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/aggregation/AggInput.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright © 2016-2025 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.common.data.cf.configuration.aggregation;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+
+@JsonTypeInfo(
+        use = JsonTypeInfo.Id.NAME,
+        include = JsonTypeInfo.As.PROPERTY,
+        property = "type"
+)
+@JsonSubTypes({
+        @JsonSubTypes.Type(value = AggKeyInput.class, name = "key"),
+        @JsonSubTypes.Type(value = AggFunctionInput.class, name = "function")
+})
+@JsonIgnoreProperties(ignoreUnknown = true)
+public interface AggInput {
+
+    @JsonIgnore
+    String getType();
+
+}

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/aggregation/AggKeyInput.java

@@ -0,0 +1,34 @@
+/**
+ * Copyright © 2016-2025 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.common.data.cf.configuration.aggregation;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class AggKeyInput implements AggInput {
+
+    private String key;
+
+    @Override
+    public String getType() {
+        return "key";
+    }
+
+}

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/aggregation/AggMetric.java

@@ -0,0 +1,31 @@
+/**
+ * Copyright © 2016-2025 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.common.data.cf.configuration.aggregation;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import lombok.Data;
+
+@Data
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class AggMetric {
+
+    private AggFunction function;
+    private String filter;
+    private AggInput input;
+
+}

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/aggregation/RelatedEntitiesAggregationCalculatedFieldConfiguration.java

@@ -0,0 +1,59 @@
+/**
+ * Copyright © 2016-2025 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.common.data.cf.configuration.aggregation;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+import org.thingsboard.server.common.data.cf.CalculatedFieldType;
+import org.thingsboard.server.common.data.cf.configuration.Argument;
+import org.thingsboard.server.common.data.cf.configuration.ArgumentsBasedCalculatedFieldConfiguration;
+import org.thingsboard.server.common.data.cf.configuration.Output;
+import org.thingsboard.server.common.data.relation.RelationPathLevel;
+
+import java.util.Map;
+
+@Data
+public class RelatedEntitiesAggregationCalculatedFieldConfiguration implements ArgumentsBasedCalculatedFieldConfiguration {
+
+    @NotNull
+    private RelationPathLevel relation;
+    private Map<String, Argument> arguments;
+    private long deduplicationIntervalInSec;
+    @Valid
+    @NotEmpty
+    private Map<String, AggMetric> metrics;
+    private Output output;
+    private boolean useLatestTs;
+
+    @Override
+    public CalculatedFieldType getType() {
+        return CalculatedFieldType.RELATED_ENTITIES_AGGREGATION;
+    }
+
+    @Override
+    public void validate() {
+        relation.validate();
+        if (arguments.containsKey("ctx")) {
+            throw new IllegalArgumentException("Argument name 'ctx' is reserved and cannot be used.");
+        }
+        if (arguments.values().stream().anyMatch(Argument::hasTsRollingArgument)) {
+            throw new IllegalArgumentException("Calculated field with type: '" + getType() + "' doesn't support TS_ROLLING arguments.");
+        }
+    }
+
+}

common/data/src/main/java/org/thingsboard/server/common/data/plugin/ComponentLifecycleEvent.java

@@ -32,7 +32,9 @@ public enum ComponentLifecycleEvent implements Serializable {
     STOPPED(5),
     DELETED(6),
     FAILED(7),
-    DEACTIVATED(8);
+    DEACTIVATED(8),
+    RELATION_UPDATED(9),
+    RELATION_DELETED(10);
 
     @Getter
     private final int protoNumber; // corresponds to ComponentLifecycleEvent proto

common/data/src/main/java/org/thingsboard/server/common/data/tenant/profile/DefaultTenantProfileConfiguration.java

@@ -186,6 +186,8 @@ public class DefaultTenantProfileConfiguration implements TenantProfileConfigura
     private long maxStateSizeInKBytes = 32;
     @Schema(example = "2")
     private long maxSingleValueArgumentSizeInKBytes = 2;
+    @Schema(example = "3600")
+    private long minAllowedDeduplicationIntervalInSecForCF = 3600;
 
     @Override
     public long getProfileThreshold(ApiUsageRecordKey key) {

common/message/src/main/java/org/thingsboard/server/common/msg/MsgType.java

@@ -152,6 +152,8 @@ public enum MsgType {
     CF_ENTITY_INIT_CF_MSG,
     CF_ENTITY_DELETE_MSG,
 
+    CF_RELATION_ACTION_MSG,
+
     CF_ARGUMENT_RESET_MSG, // Sent to reset argument;
     CF_REEVALUATE_MSG;
 

common/proto/src/main/proto/queue.proto

@@ -888,6 +888,7 @@ message SingleValueArgumentProto {
   string argName = 1;
   TsValueProto value = 2;
   int64 version = 3;
+  EntityIdProto entityId = 4;
 }
 
 message TsDoubleValProto {
@@ -922,6 +923,8 @@ message CalculatedFieldStateProto {
   repeated TsRollingArgumentProto rollingValueArguments = 4;
   repeated GeofencingArgumentProto geofencingArguments = 5;
   AlarmStateProto alarmState = 6;
+  int64 lastArgsUpdateTs = 7;
+  int64 lastMetricsEvalTs = 8;
 }
 
 //Used to report session state to tb-Service and persist this state in the cache on the tb-Service level.
@@ -1274,6 +1277,8 @@ enum ComponentLifecycleEvent {
     DELETED       = 6;
     FAILED        = 7;
     DEACTIVATED   = 8;
+    RELATION_UPDATED = 9;
+    RELATION_DELETED = 10;
 }
 
 message ComponentLifecycleMsgProto {

common/script/script-api/src/main/java/org/thingsboard/script/api/tbel/TbUtils.java

@@ -264,6 +264,8 @@ public class TbUtils {
                 float.class, int.class)));
         parserConfig.addImport("toInt", new MethodStub(TbUtils.class.getMethod("toInt",
                 double.class)));
+        parserConfig.addImport("roundResult", new MethodStub(TbUtils.class.getMethod("roundResult",
+                double.class, Integer.class)));
         parserConfig.addImport("isNaN", new MethodStub(TbUtils.class.getMethod("isNaN",
                 double.class)));
         parserConfig.addImport("hexToBytes", new MethodStub(TbUtils.class.getMethod("hexToBytes",
@@ -1186,6 +1188,16 @@ public class TbUtils {
         return BigDecimal.valueOf(value).setScale(0, RoundingMode.HALF_UP).intValue();
     }
 
+    public static Object roundResult(double value, Integer precision) {
+        if (precision == null) {
+            return value;
+        }
+        if (precision.equals(0)) {
+            return toInt(value);
+        }
+        return toFixed(value, precision);
+    }
+
     public static boolean isNaN(double value) {
         return Double.isNaN(value);
     }

common/script/script-api/src/main/java/org/thingsboard/script/api/tbel/TbelCfArg.java

@@ -29,6 +29,7 @@ import com.fasterxml.jackson.annotation.JsonTypeInfo;
         @JsonSubTypes.Type(value = TbelCfTsRollingArg.class, name = "TS_ROLLING"),
         @JsonSubTypes.Type(value = TbelCfGeofencingArg.class, name = "GEOFENCING_CF_ARGUMENT_VALUE"),
         @JsonSubTypes.Type(value = TbelCfPropagationArg.class, name = "PROPAGATION_CF_ARGUMENT_VALUE"),
+        @JsonSubTypes.Type(value = TbelCfRelatedEntitiesArgumentValue.class, name = "RELATED_ENTITIES_ARGUMENT_VALUE")
 })
 public interface TbelCfArg extends TbelCfObject {
 

common/script/script-api/src/main/java/org/thingsboard/script/api/tbel/TbelCfRelatedEntitiesArgumentValue.java

@@ -0,0 +1,45 @@
+/**
+ * Copyright © 2016-2025 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.script.api.tbel;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.UUID;
+
+@Data
+public class TbelCfRelatedEntitiesArgumentValue implements TbelCfArg {
+
+    private final Map<UUID, TbelCfSingleValueArg> entityInputs;
+
+    @JsonCreator
+    public TbelCfRelatedEntitiesArgumentValue(@JsonProperty("entityInputs") Map<UUID, TbelCfSingleValueArg> values) {
+        this.entityInputs = Collections.unmodifiableMap(values);
+    }
+
+    @Override
+    public String getType() {
+        return "RELATED_ENTITIES_ARGUMENT_VALUE";
+    }
+
+    @Override
+    public long memorySize() {
+        return OBJ_SIZE;
+    }
+}

common/script/script-api/src/test/java/org/thingsboard/script/api/tbel/TbUtilsTest.java

@@ -1154,6 +1154,13 @@ public class TbUtilsTest {
         Assertions.assertEquals(28, TbUtils.toInt(28.0));
     }
 
+    @Test
+    public void roundResult() {
+        Assertions.assertEquals(1729.1729, TbUtils.roundResult(doubleVal, null));
+        Assertions.assertEquals(1729, TbUtils.roundResult(doubleVal, 0));
+        Assertions.assertEquals(1729.17, TbUtils.roundResult(doubleVal, 2));
+    }
+
     @Test
     public void isNaN() {
         assertFalse(TbUtils.isNaN(doubleVal));

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

@@ -524,6 +524,23 @@ public class BaseRelationService implements RelationService {
         return executor.submit(() -> relationDao.findByRelationPathQuery(tenantId, relationPathQuery, limit));
     }
 
+    @Override
+    public List<EntityRelation> findByRelationPathQuery(TenantId tenantId, EntityRelationPathQuery relationPathQuery) {
+        log.trace("Executing findByRelationPathQuery, tenantId [{}], relationPathQuery {}", tenantId, relationPathQuery);
+        validateId(tenantId, id -> "Invalid tenant id: " + id);
+        validate(relationPathQuery);
+        int limit = (int) apiLimitService.getLimit(tenantId, DefaultTenantProfileConfiguration::getMaxRelatedEntitiesToReturnPerCfArgument);
+        if (relationPathQuery.levels().size() == 1) {
+            RelationPathLevel relationPathLevel = relationPathQuery.levels().get(0);
+            var relations = switch (relationPathLevel.direction()) {
+                case FROM -> findByFromAndType(tenantId, relationPathQuery.rootEntityId(), relationPathLevel.relationType(), RelationTypeGroup.COMMON);
+                case TO -> findByToAndType(tenantId, relationPathQuery.rootEntityId(), relationPathLevel.relationType(), RelationTypeGroup.COMMON);
+            };
+            return relations.size() > limit ? relations.subList(0, limit) : relations;
+        }
+        return relationDao.findByRelationPathQuery(tenantId, relationPathQuery, limit);
+    }
+
     private void validate(EntityRelationPathQuery relationPathQuery) {
         validateId((UUIDBased) relationPathQuery.rootEntityId(), id -> "Invalid root entity id: " + id);
         List<RelationPathLevel> levels = relationPathQuery.levels();

dao/src/main/java/org/thingsboard/server/dao/service/validator/CalculatedFieldDataValidator.java

@@ -21,6 +21,7 @@ import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.configuration.ArgumentsBasedCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.cf.configuration.RelationPathQueryDynamicSourceConfiguration;
 import org.thingsboard.server.common.data.cf.configuration.ScheduledUpdateSupportedCalculatedFieldConfiguration;
+import org.thingsboard.server.common.data.cf.configuration.aggregation.RelatedEntitiesAggregationCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.tenant.profile.DefaultTenantProfileConfiguration;
 import org.thingsboard.server.dao.cf.CalculatedFieldDao;
@@ -46,6 +47,7 @@ public class CalculatedFieldDataValidator extends DataValidator<CalculatedField>
         validateCalculatedFieldConfiguration(calculatedField);
         validateSchedulingConfiguration(tenantId, calculatedField);
         validateRelationQuerySourceArguments(tenantId, calculatedField);
+        validateAggregationConfiguration(tenantId, calculatedField);
     }
 
     @Override
@@ -87,7 +89,7 @@ public class CalculatedFieldDataValidator extends DataValidator<CalculatedField>
 
     private void validateSchedulingConfiguration(TenantId tenantId, CalculatedField calculatedField) {
         if (!(calculatedField.getConfiguration() instanceof ScheduledUpdateSupportedCalculatedFieldConfiguration scheduledUpdateCfg)
-            || !scheduledUpdateCfg.isScheduledUpdateEnabled()) {
+                || !scheduledUpdateCfg.isScheduledUpdateEnabled()) {
             return;
         }
         long minAllowedScheduledUpdateInterval = apiLimitService.getLimit(tenantId, DefaultTenantProfileConfiguration::getMinAllowedScheduledUpdateIntervalInSecForCF);
@@ -110,6 +112,17 @@ public class CalculatedFieldDataValidator extends DataValidator<CalculatedField>
                 wrapAsDataValidation(() -> relationQueryDynamicSourceConfiguration.validateMaxRelationLevel(argumentName, maxRelationLevel)));
     }
 
+    private void validateAggregationConfiguration(TenantId tenantId, CalculatedField calculatedField) {
+        if (!(calculatedField.getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration aggConfiguration)) {
+            return;
+        }
+        long minAllowedDeduplicationInterval = apiLimitService.getLimit(tenantId, DefaultTenantProfileConfiguration::getMinAllowedDeduplicationIntervalInSecForCF);
+        if (aggConfiguration.getDeduplicationIntervalInSec() < minAllowedDeduplicationInterval) {
+            throw new IllegalArgumentException("Deduplication interval is less than configured " +
+                    "minimum allowed interval in tenant profile: " + minAllowedDeduplicationInterval);
+        }
+    }
+
     private static void wrapAsDataValidation(Runnable validation) {
         try {
             validation.run();

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

@@ -15,7 +15,6 @@
  */
 package org.thingsboard.server.dao.sql.relation;
 
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
@@ -96,4 +95,5 @@ public interface RelationRepository
                                        @Param("toId") UUID toId,
                                        @Param("toType") String toType,
                                        @Param("batchSize") int batchSize);
+
 }

ui-ngx/src/app/core/auth/auth.models.ts

@@ -31,6 +31,7 @@ export interface SysParamsState {
   maxDebugModeDurationMinutes: number;
   maxDataPointsPerRollingArg: number;
   maxArgumentsPerCF: number;
+  minAllowedDeduplicationIntervalInSecForCF: number;
   minAllowedScheduledUpdateIntervalInSecForCF: number;
   maxRelationLevelPerCfArgument: number;
   ruleChainDebugPerTenantLimitsConfiguration?: string;

ui-ngx/src/app/core/auth/auth.reducer.ts

@@ -33,6 +33,7 @@ const emptyUserAuthState: AuthPayload = {
   mobileQrEnabled: false,
   maxResourceSize: 0,
   maxArgumentsPerCF: 0,
+  minAllowedDeduplicationIntervalInSecForCF: 0,
   minAllowedScheduledUpdateIntervalInSecForCF: 0,
   maxRelationLevelPerCfArgument: 0,
   maxDataPointsPerRollingArg: 0,

ui-ngx/src/app/modules/home/components/calculated-fields/calculated-field.module.ts

@@ -38,6 +38,9 @@ import {
 import {
   PropagationConfigurationModule
 } from '@home/components/calculated-fields/components/propagation-configuration/propagation-configuration.module';
+import {
+  RelatedEntitiesAggregationComponentModule
+} from '@home/components/calculated-fields/components/related-entities-aggregation-configuration/related-entities-aggregation-component.module';
 
 @NgModule({
   declarations: [
@@ -52,6 +55,7 @@ import {
     EntityDebugSettingsButtonComponent,
     SimpleConfigurationModule,
     PropagationConfigurationModule,
+    RelatedEntitiesAggregationComponentModule,
   ],
   exports: [
     CalculatedFieldDialogComponent,

ui-ngx/src/app/modules/home/components/calculated-fields/calculated-fields-table-config.ts

@@ -111,7 +111,7 @@ export class CalculatedFieldsTableConfig extends EntityTableConfig<CalculatedFie
 
     this.defaultSortOrder = {property: 'createdTime', direction: Direction.DESC};
 
-    const expressionColumn = new EntityTableColumn<CalculatedField>('expression', 'calculated-fields.expression', '300px');
+    const expressionColumn = new EntityTableColumn<CalculatedField>('expression', 'calculated-fields.expression', '250px');
     expressionColumn.sortable = false;
     expressionColumn.cellContentFunction = entity => {
       const expressionLabel = this.getExpressionLabel(entity);
@@ -124,7 +124,7 @@ export class CalculatedFieldsTableConfig extends EntityTableConfig<CalculatedFie
 
     this.columns.push(new DateEntityTableColumn<CalculatedField>('createdTime', 'common.created-time', this.datePipe, '150px'));
     this.columns.push(new EntityTableColumn<CalculatedField>('name', 'common.name', '33%'));
-    this.columns.push(new EntityTableColumn<CalculatedField>('type', 'common.type', '80px', entity => this.translate.instant(CalculatedFieldTypeTranslations.get(entity.type))));
+    this.columns.push(new EntityTableColumn<CalculatedField>('type', 'common.type', '170px', entity => this.translate.instant(CalculatedFieldTypeTranslations.get(entity.type)), () => ({whiteSpace: 'nowrap' })));
     this.columns.push(expressionColumn);
 
     this.cellActionDescriptors.push(

ui-ngx/src/app/modules/home/components/calculated-fields/components/calculated-field-arguments/calculated-field-argument-panel.component.html

@@ -15,9 +15,14 @@
     limitations under the License.
 
 -->
-<div class="w-full max-w-xl" [formGroup]="argumentFormGroup">
-  <div class="tb-form-panel no-border no-padding mb-2">
-    <div class="tb-form-panel-title">{{ 'calculated-fields.argument-settings' | translate }}</div>
+<div class="tb-config-panel" [formGroup]="argumentFormGroup">
+  <div class="tb-config-panel-title tb-form-panel-title">{{ 'calculated-fields.argument-settings' | translate }}</div>
+  <div class="tb-config-panel-content tb-form-panel no-border no-padding">
+    @if (hint) {
+      <div class="tb-form-hint tb-primary-fill hint-container">
+        {{ hint | translate }}
+      </div>
+    }
     <div class="tb-form-panel no-border no-padding">
       @if (!isOutputKey) {
         <ng-container *ngTemplateOutlet="argumentNameTemplate; context: {
@@ -30,25 +35,27 @@
         }"></ng-container>
       }
       <ng-container>
-        <div class="tb-form-row">
-          <div class="fixed-title-width">{{ 'entity.entity-type' | translate }}</div>
-          <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
-            <mat-select [formControl]="argumentType">
-              @for (type of argumentEntityTypes; track type) {
-                <mat-option [value]="type">{{ ArgumentEntityTypeTranslations.get(type) | translate }}</mat-option>
+        @if (!hiddenEntityTypes) {
+          <div class="tb-form-row">
+            <div class="fixed-title-width">{{ 'entity.entity-type' | translate }}</div>
+            <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
+              <mat-select [formControl]="argumentType">
+                @for (type of argumentEntityTypes; track type) {
+                  <mat-option [value]="type">{{ ArgumentEntityTypeTranslations.get(type) | translate }}</mat-option>
+                }
+              </mat-select>
+              @if (argumentType.touched && argumentType.hasError('required')) {
+                <mat-icon matSuffix
+                          matTooltipPosition="above"
+                          matTooltipClass="tb-error-tooltip"
+                          [matTooltip]="'calculated-fields.hint.entity-type-required' | translate"
+                          class="tb-error">
+                  warning
+                </mat-icon>
               }
-            </mat-select>
-            @if (argumentType.touched && argumentType.hasError('required')) {
-              <mat-icon matSuffix
-                        matTooltipPosition="above"
-                        matTooltipClass="tb-error-tooltip"
-                        [matTooltip]="'calculated-fields.hint.entity-type-required' | translate"
-                        class="tb-error">
-                warning
-              </mat-icon>
-            }
-          </mat-form-field>
-        </div>
+            </mat-form-field>
+          </div>
+        }
         @if (ArgumentEntityTypeParamsMap.has(entityType)) {
           <div class="tb-form-row">
             <div class="fixed-title-width tb-required">{{ ArgumentEntityTypeParamsMap.get(entityType).title | translate }}</div>
@@ -143,9 +150,18 @@
       }
       @if (refEntityKeyFormGroup.get('type').value !== ArgumentType.Rolling) {
         <div class="tb-form-row">
-          <div class="fixed-title-width">{{ 'calculated-fields.default-value' | translate }}</div>
+          <div class="fixed-title-width" [class.tb-required]="defaultValueRequired">{{ 'calculated-fields.default-value' | translate }}</div>
           <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
             <input matInput autocomplete="off" name="value" formControlName="defaultValue" placeholder="{{ 'action.set' | translate }}"/>
+            @if (argumentFormGroup.get('defaultValue').touched && argumentFormGroup.get('defaultValue').hasError('required')) {
+              <mat-icon matSuffix
+                        matTooltipPosition="above"
+                        matTooltipClass="tb-error-tooltip"
+                        [matTooltip]="'calculated-fields.default-value-required' | translate"
+                        class="tb-error">
+                warning
+              </mat-icon>
+            }
           </mat-form-field>
         </div>
       } @else {
@@ -174,7 +190,7 @@
       }
     </div>
   </div>
-  <div class="flex justify-end gap-2">
+  <div class="tb-config-panel-buttons">
     <button mat-button
             color="primary"
             type="button"

ui-ngx/src/app/modules/home/components/calculated-fields/components/calculated-field-arguments/calculated-field-argument-panel.component.scss

@@ -15,22 +15,9 @@
  */
 @use '../../../../../../../scss/constants' as constants;
 
-$panel-width: 520px;
-
 :host {
-  display: flex;
-  width: $panel-width;
-  max-width: 100%;
-  max-height: 100vh;
-
-  .fixed-title-width {
-    @media #{constants.$mat-xs} {
-      min-width: 120px;
-    }
-  }
-
   .limit-field-row {
-    @media screen and (max-width: $panel-width) {
+    @media screen and (max-width: 520px) {
       display: flex;
       flex-direction: column;
 
@@ -40,6 +27,10 @@ $panel-width: 520px;
       }
     }
   }
+
+  .tb-primary-fill {
+    overflow: visible;
+  }
 }
 
 :host ::ng-deep {

ui-ngx/src/app/modules/home/components/calculated-fields/components/calculated-field-arguments/calculated-field-argument-panel.component.ts

@@ -36,7 +36,7 @@ import {
   CalculatedFieldArgumentValue,
   getCalculatedFieldCurrentEntityFilter
 } from '@shared/models/calculated-field.models';
-import { debounceTime, delay, distinctUntilChanged, filter } from 'rxjs/operators';
+import { debounceTime, distinctUntilChanged, filter } from 'rxjs/operators';
 import { EntityType } from '@shared/models/entity-type.models';
 import { AttributeScope, DataKeyType } from '@shared/models/telemetry/telemetry.models';
 import { DatasourceType } from '@shared/models/widget.models';
@@ -56,7 +56,7 @@ import { TenantId } from '@shared/models/id/tenant-id';
 @Component({
   selector: 'tb-calculated-field-argument-panel',
   templateUrl: './calculated-field-argument-panel.component.html',
-  styleUrls: ['./calculated-field-argument-panel.component.scss']
+  styleUrls: ['../common/calculated-field-panel.scss', './calculated-field-argument-panel.component.scss']
 })
 export class CalculatedFieldArgumentPanelComponent implements OnInit, AfterViewInit {
 
@@ -68,6 +68,9 @@ export class CalculatedFieldArgumentPanelComponent implements OnInit, AfterViewI
   @Input() isScript: boolean;
   @Input() usedArgumentNames: string[];
   @Input() isOutputKey = false;
+  @Input() hiddenEntityTypes = false;
+  @Input() defaultValueRequired = false;
+  @Input() hint: string;
   @Input() argumentEntityTypes = Object.values(ArgumentEntityType).filter(value => value !== ArgumentEntityType.RelationQuery) as ArgumentEntityType[];
 
   @ViewChild('entityAutocomplete') entityAutocomplete: EntityAutocompleteComponent;
@@ -118,7 +121,6 @@ export class CalculatedFieldArgumentPanelComponent implements OnInit, AfterViewI
     this.observeEntityFilterChanges();
     this.observeArgumentTypeChanges();
     this.observeEntityKeyChanges();
-    this.observeUpdatePosition();
   }
 
   get entityType(): ArgumentEntityType {
@@ -146,6 +148,11 @@ export class CalculatedFieldArgumentPanelComponent implements OnInit, AfterViewI
     this.setInitialEntityType();
     this.setWatchKeyChange();
 
+    if (this.defaultValueRequired) {
+      this.argumentFormGroup.get('defaultValue').addValidators(Validators.required);
+      this.argumentFormGroup.get('defaultValue').updateValueAndValidity({onlySelf: true});
+    }
+
     this.argumentTypes = Object.values(ArgumentType)
       .filter(type => type !== ArgumentType.Rolling || this.isScript);
   }
@@ -293,17 +300,6 @@ export class CalculatedFieldArgumentPanelComponent implements OnInit, AfterViewI
     };
   }
 
-  private observeUpdatePosition(): void {
-    merge(
-      this.argumentType.valueChanges,
-      this.refEntityKeyFormGroup.get('type').valueChanges,
-      this.argumentFormGroup.get('timeWindow').valueChanges,
-      this.argumentFormGroup.get('refEntityId').valueChanges.pipe(filter(Boolean)),
-    )
-      .pipe(delay(50), takeUntilDestroyed())
-      .subscribe(() => this.popover.updatePosition());
-  }
-
   private updatedRefEntityIdState(type: ArgumentEntityType): void {
     const isEntityWithId = !!type && type !== ArgumentEntityType.Tenant && type !== ArgumentEntityType.Current;
     this.argumentFormGroup.get('refEntityId')[isEntityWithId ? 'enable' : 'disable']();

ui-ngx/src/app/modules/home/components/calculated-fields/components/calculated-field-arguments/calculated-field-arguments-table.component.html

@@ -88,7 +88,7 @@
       <ng-container matColumnDef="actions" stickyEnd>
         <mat-header-cell *matHeaderCellDef class="w-20 min-w-20"/>
         <mat-cell *matCellDef="let argument;">
-          <div class="tb-form-table-row-cell-buttons flex w-20 min-w-20">
+          <div class="tb-form-table-row-cell-buttons min-w-20">
             <button type="button"
                     mat-icon-button
                     #button

ui-ngx/src/app/modules/home/components/calculated-fields/components/calculated-field-arguments/calculated-field-arguments-table.component.scss

@@ -51,6 +51,9 @@
     --mat-badge-legacy-small-size-container-size: 8px;
     --mat-badge-small-size-container-overlap-offset: -5px;
     --mat-badge-small-size-text-size: 0;
+    width: 100%;
+    display: flex;
+    justify-content: end;
   }
 }
 

ui-ngx/src/app/modules/home/components/calculated-fields/components/calculated-field-arguments/calculated-field-arguments-table.module.ts

@@ -26,6 +26,9 @@ import {
 import {
   PropagateArgumentsTableComponent
 } from '@home/components/calculated-fields/components/calculated-field-arguments/propagate-arguments-table.component';
+import {
+  RelatedAggregationArgumentsTableComponent
+} from '@home/components/calculated-fields/components/calculated-field-arguments/related-aggregation-arguments-table.component';
 
 @NgModule({
   imports: [
@@ -35,11 +38,13 @@ import {
   declarations: [
     CalculatedFieldArgumentPanelComponent,
     CalculatedFieldArgumentsTableComponent,
-    PropagateArgumentsTableComponent
+    PropagateArgumentsTableComponent,
+    RelatedAggregationArgumentsTableComponent
   ],
   exports: [
     CalculatedFieldArgumentsTableComponent,
-    PropagateArgumentsTableComponent
+    PropagateArgumentsTableComponent,
+    RelatedAggregationArgumentsTableComponent
   ]
 })
 export class CalculatedFieldArgumentsTableModule {}

ui-ngx/src/app/modules/home/components/calculated-fields/components/calculated-field-arguments/related-aggregation-arguments-table.component.ts

@@ -0,0 +1,70 @@
+///
+/// Copyright © 2016-2025 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.
+///
+
+import { ChangeDetectorRef, Component, DestroyRef, forwardRef, Renderer2, ViewContainerRef, } from '@angular/core';
+import { FormBuilder, NG_VALIDATORS, NG_VALUE_ACCESSOR, } from '@angular/forms';
+import { TbPopoverService } from '@shared/components/popover.service';
+import { EntityService } from '@core/http/entity.service';
+import { Store } from '@ngrx/store';
+import { AppState } from '@core/core.state';
+import {
+  CalculatedFieldArgumentsTableComponent
+} from '@home/components/calculated-fields/components/calculated-field-arguments/calculated-field-arguments-table.component';
+import { ArgumentEntityType } from '@shared/models/calculated-field.models';
+
+@Component({
+  selector: 'tb-related-aggregation-arguments-table',
+  templateUrl: './calculated-field-arguments-table.component.html',
+  styleUrls: [`calculated-field-arguments-table.component.scss`],
+  providers: [
+    {
+      provide: NG_VALUE_ACCESSOR,
+      useExisting: forwardRef(() => RelatedAggregationArgumentsTableComponent),
+      multi: true
+    },
+    {
+      provide: NG_VALIDATORS,
+      useExisting: forwardRef(() => RelatedAggregationArgumentsTableComponent),
+      multi: true
+    }
+  ],
+})
+export class RelatedAggregationArgumentsTableComponent extends CalculatedFieldArgumentsTableComponent {
+
+  constructor(
+    protected fb: FormBuilder,
+    protected popoverService: TbPopoverService,
+    protected viewContainerRef: ViewContainerRef,
+    protected cd: ChangeDetectorRef,
+    protected renderer: Renderer2,
+    protected entityService: EntityService,
+    protected destroyRef: DestroyRef,
+    protected store: Store<AppState>
+  ) {
+    super(fb, popoverService, viewContainerRef, cd, renderer, entityService, destroyRef, store);
+
+    this.argumentNameColumn = 'calculated-fields.argument-name';
+    this.displayColumns = ['name', 'type', 'key', 'actions'];
+    this.panelAdditionalCtx = {
+      hiddenEntityTypes: true,
+      defaultValueRequired: true,
+      argumentEntityTypes: [ArgumentEntityType.Current],
+      hint: 'calculated-fields.hint.setting-arguments-aggregation'
+    };
+
+    this.isScript = false;
+  }
+}

ui-ngx/src/app/modules/home/components/calculated-fields/components/common/calculated-field-panel.scss

@@ -0,0 +1,61 @@
+/**
+ * Copyright © 2016-2025 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.
+ */
+@import '../../../../../../../scss/constants';
+
+:host {
+  .tb-config-panel {
+    width: 520px;
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+    @media #{$mat-lt-md} {
+      max-width: fit-content;
+    }
+    @media #{$mat-xs} {
+      width: 90vw;
+    }
+
+    .tb-config-panel-title {
+      line-height: 24px;
+      letter-spacing: 0.25px;
+      color: rgba(0, 0, 0, 0.87);
+      font-weight: 500;
+      font-size: 16px;
+    }
+
+    .tb-config-panel-content {
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+      overflow: auto;
+
+      .fixed-title-width {
+        @media #{$mat-xs} {
+          min-width: 120px;
+        }
+      }
+    }
+
+    .tb-config-panel-buttons {
+      height: 40px;
+      display: flex;
+      flex-direction: row;
+      gap: 16px;
+      justify-content: flex-end;
+      align-items: flex-end;
+    }
+  }
+}

ui-ngx/src/app/modules/home/components/calculated-fields/components/dialog/calculated-field-dialog.component.html

@@ -75,6 +75,13 @@
                                         [testScript]="onTestScript.bind(this)">
           </tb-propagation-configuration>
         }
+        @case (CalculatedFieldType.RELATED_ENTITIES_AGGREGATION) {
+          <tb-related-entities-aggregation-component formControlName="configuration"
+                                                     [entityId]="data.entityId"
+                                                     [entityName]="data.entityName"
+                                                     [tenantId]="data.tenantId">
+          </tb-related-entities-aggregation-component>
+        }
         @default {
           <tb-simple-configuration formControlName="configuration"
                                    [entityId]="data.entityId"

ui-ngx/src/app/modules/home/components/calculated-fields/components/dialog/calculated-field-dialog.component.scss

@@ -17,6 +17,11 @@
 .calculated-field-dialog-container {
   width: 869px;
   max-width: 100%;
+  display: grid;
+  grid-template-rows: min-content minmax(auto, 1fr) min-content;
+  --mdc-outlined-text-field-outline-color: rgba(0,0,0,0.12);
+  --mdc-outlined-text-field-container-shape: 6px;
+  --mat-form-field-trailing-icon-color: rgba(0, 0, 0, 0.56);
 }
 
 .tbel-script-lang-chip {

ui-ngx/src/app/modules/home/components/calculated-fields/components/geofencing-configuration/calculated-field-geofencing-zone-groups-panel.component.html

@@ -15,23 +15,23 @@
     limitations under the License.
 
 -->
-<div class="w-full max-w-xl" [formGroup]="geofencingFormGroup">
-  <div class="tb-form-panel no-border no-padding mb-2">
-    <div class="tb-form-panel-title">{{ 'calculated-fields.geofencing-zone-groups-settings' | translate }}</div>
-    <div class="tb-form-panel no-border no-padding">
-      <div class="tb-form-row">
-        <div class="fixed-title-width tb-required">{{ 'calculated-fields.name' | translate }}</div>
-        <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
-          <input matInput autocomplete="new-name" name="value" formControlName="name" maxlength="255" placeholder="{{ 'action.set' | translate }}"/>
-          @if (geofencingFormGroup.get('name').touched && geofencingFormGroup.get('name').hasError('required')) {
-            <mat-icon matSuffix
-                      matTooltipPosition="above"
-                      matTooltipClass="tb-error-tooltip"
-                      [matTooltip]="'calculated-fields.hint.name-required' | translate"
-                      class="tb-error">
-              warning
-            </mat-icon>
-          } @else if (geofencingFormGroup.get('name').touched && geofencingFormGroup.get('name').hasError('duplicateName')) {
+<div class="tb-config-panel" [formGroup]="geofencingFormGroup">
+  <div class="tb-config-panel-title tb-form-panel-title">{{ 'calculated-fields.geofencing-zone-groups-settings' | translate }}</div>
+  <div class="tb-config-panel-content tb-form-panel no-border no-padding">
+    <div class="tb-form-row">
+      <div class="fixed-title-width tb-required">{{ 'calculated-fields.name' | translate }}</div>
+      <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
+        <input matInput autocomplete="new-name" name="value" formControlName="name" maxlength="255"
+               placeholder="{{ 'action.set' | translate }}"/>
+        @if (geofencingFormGroup.get('name').touched && geofencingFormGroup.get('name').hasError('required')) {
+          <mat-icon matSuffix
+                    matTooltipPosition="above"
+                    matTooltipClass="tb-error-tooltip"
+                    [matTooltip]="'calculated-fields.hint.name-required' | translate"
+                    class="tb-error">
+            warning
+          </mat-icon>
+        } @else if (geofencingFormGroup.get('name').touched && geofencingFormGroup.get('name').hasError('duplicateName')) {
           <mat-icon matSuffix
                     matTooltipPosition="above"
                     matTooltipClass="tb-error-tooltip"
@@ -40,216 +40,217 @@
             warning
           </mat-icon>
         } @else if (geofencingFormGroup.get('name').touched && geofencingFormGroup.get('name').hasError('pattern')) {
-            <mat-icon matSuffix
-                      matTooltipPosition="above"
-                      matTooltipClass="tb-error-tooltip"
-                      [matTooltip]="'calculated-fields.hint.name-pattern' | translate"
-                      class="tb-error">
-              warning
-            </mat-icon>
-          } @else if (geofencingFormGroup.get('name').touched && geofencingFormGroup.get('name').hasError('maxlength')) {
-            <mat-icon matSuffix
-                      matTooltipPosition="above"
-                      matTooltipClass="tb-error-tooltip"
-                      [matTooltip]="'calculated-fields.hint.name-max-length' | translate"
-                      class="tb-error">
-              warning
-            </mat-icon>
-          } @else if (geofencingFormGroup.get('name').touched && geofencingFormGroup.get('name').hasError('forbiddenName')) {
-            <mat-icon matSuffix
-                      matTooltipPosition="above"
-                      matTooltipClass="tb-error-tooltip"
-                      [matTooltip]="'calculated-fields.hint.name-forbidden' | translate"
-                      class="tb-error">
-              warning
-            </mat-icon>
-          }
+          <mat-icon matSuffix
+                    matTooltipPosition="above"
+                    matTooltipClass="tb-error-tooltip"
+                    [matTooltip]="'calculated-fields.hint.name-pattern' | translate"
+                    class="tb-error">
+            warning
+          </mat-icon>
+        } @else if (geofencingFormGroup.get('name').touched && geofencingFormGroup.get('name').hasError('maxlength')) {
+          <mat-icon matSuffix
+                    matTooltipPosition="above"
+                    matTooltipClass="tb-error-tooltip"
+                    [matTooltip]="'calculated-fields.hint.name-max-length' | translate"
+                    class="tb-error">
+            warning
+          </mat-icon>
+        } @else if (geofencingFormGroup.get('name').touched && geofencingFormGroup.get('name').hasError('forbiddenName')) {
+          <mat-icon matSuffix
+                    matTooltipPosition="above"
+                    matTooltipClass="tb-error-tooltip"
+                    [matTooltip]="'calculated-fields.hint.name-forbidden' | translate"
+                    class="tb-error">
+            warning
+          </mat-icon>
+        }
+      </mat-form-field>
+    </div>
+    <ng-container [formGroup]="refEntityIdFormGroup">
+      <div class="tb-form-row">
+        <div class="fixed-title-width">{{ 'entity.entity-type' | translate }}</div>
+        <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
+          <mat-select formControlName="entityType">
+            @for (type of argumentEntityTypes; track type) {
+              <mat-option [value]="type">{{ ArgumentEntityTypeTranslations.get(type) | translate }}</mat-option>
+            }
+          </mat-select>
         </mat-form-field>
       </div>
-      <ng-container [formGroup]="refEntityIdFormGroup">
+      @if (ArgumentEntityTypeParamsMap.has(entityType)) {
         <div class="tb-form-row">
-          <div class="fixed-title-width">{{ 'entity.entity-type' | translate }}</div>
-          <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
-            <mat-select formControlName="entityType">
-              @for (type of argumentEntityTypes; track type) {
-                <mat-option [value]="type">{{ ArgumentEntityTypeTranslations.get(type) | translate }}</mat-option>
-              }
-            </mat-select>
-          </mat-form-field>
-        </div>
-        @if (ArgumentEntityTypeParamsMap.has(entityType)) {
-          <div class="tb-form-row">
-            <div class="fixed-title-width tb-required">{{ ArgumentEntityTypeParamsMap.get(entityType).title | translate }}</div>
-            <tb-entity-autocomplete class="flex-1"
-                                    #entityAutocomplete
-                                    formControlName="id"
-                                    inlineField
-                                    appearance="outline"
-                                    [placeholder]="'action.set' | translate"
-                                    required
-                                    [entityType]="ArgumentEntityTypeParamsMap.get(entityType).entityType"
-                                    (entityChanged)="entityNameSubject.next($event?.name)"/>
-          </div>
-        }
-      </ng-container>
-      <ng-container [formGroup]="refDynamicSourceFormGroup">
-        <div class="tb-form-panel stroked" *ngIf="entityType === ArgumentEntityType.RelationQuery">
-          <mat-expansion-panel class="tb-settings" expanded>
-            <mat-expansion-panel-header>{{ 'calculated-fields.entity-zone-relationship' | translate }}</mat-expansion-panel-header>
-            <div class="tb-form-table">
-              <div class="tb-form-table-header">
-                <div class="tb-form-table-header-cell tb-actions-header"></div>
-                <div class="tb-form-table-header-cell" translate>calculated-fields.level</div>
-                <div class="tb-form-table-header-cell flex-1" translate>calculated-fields.direction-level</div>
-                <div class="tb-form-table-header-cell flex-1 tb-required" translate>calculated-fields.relation-type</div>
-                <div class="tb-form-table-header-cell tb-actions-header"></div>
-              </div>
-              @if (levelsFormArray()?.controls?.length) {
-                <div class="tb-form-table-body tb-drop-list"
-                     cdkDropList cdkDropListOrientation="vertical"
-                     [cdkDropListDisabled]="!dragEnabled"
-                     (cdkDropListDropped)="keyDrop($event)">
-                  @for (keyControl of levelsFormArray().controls; track trackByKey;) {
-                    <div cdkDrag [cdkDragDisabled]="!dragEnabled" class="tb-draggable-form-table-row">
-                      <div class="tb-form-table-row-cell-buttons">
-                        <button mat-icon-button
-                                type="button"
-                                cdkDragHandle
-                                class="lt-lg:!hidden"
-                                [class.tb-hidden]="!dragEnabled"
-                                matTooltip="{{ 'action.drag' | translate }}"
-                                matTooltipPosition="above">
-                          <mat-icon>drag_indicator</mat-icon>
-                        </button>
-                      </div>
-                      <div class="tb-form-row no-border flex-1" [formGroup]="keyControl">
-                        <div class="level-text">{{ $index+1 }}</div>
-                        <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
-                          <mat-select formControlName="direction">
-                            @for (direction of GeofencingDirectionList; track direction) {
-                              <mat-option [value]="direction">{{ GeofencingDirectionLevelTranslations.get(direction) | translate }}</mat-option>
-                            }
-                          </mat-select>
-                        </mat-form-field>
-                        <tb-string-autocomplete [fetchOptionsFn]="fetchOptions.bind(this)"
-                                                additionalClass="tb-suffix-show-on-hover"
-                                                class="flex-1"
-                                                appearance="outline"
-                                                panelWidth=""
-                                                required
-                                                [errorText]="'calculated-fields.hint.relation-type-required' | translate"
-                                                formControlName="relationType">
-                        </tb-string-autocomplete>
-                      </div>
-                      <div class="tb-form-table-row-cell-buttons">
-                        <button type="button"
-                                mat-icon-button
-                                (click)="removeKey($index)"
-                                matTooltip="{{ 'calculated-fields.delete-level' | translate }}"
-                                matTooltipPosition="above">
-                          <mat-icon>delete</mat-icon>
-                        </button>
-                      </div>
-                    </div>
-                  }
-                </div>
-              } @else {
-                <span class="tb-prompt flex items-center justify-center">{{ 'calculated-fields.no-level' | translate }}</span>
-              }
-              @if (levelsFormArray().errors) {
-                <tb-error noMargin error="{{ 'calculated-fields.levels-required' | translate }}" style="padding-left: 12px;"></tb-error>
-              }
-            </div>
-            <div>
-              @if (maxRelationLevelPerCfArgument && levelsFormArray().length >= maxRelationLevelPerCfArgument) {
-                <div class="tb-form-hint tb-primary-fill max-args-warning flex items-center gap-2">
-                  <mat-icon>warning</mat-icon>
-                  <span>{{ 'calculated-fields.max-allowed-levels-error' | translate }}</span>
-                </div>
-              } @else {
-                <button type="button" mat-stroked-button color="primary" (click)="addKey()">
-                  {{ 'calculated-fields.add-level' | translate }}
-                </button>
-              }
-            </div>
-        </mat-expansion-panel>
+          <div class="fixed-title-width tb-required">{{ ArgumentEntityTypeParamsMap.get(entityType).title | translate }}</div>
+          <tb-entity-autocomplete class="flex-1"
+                                  #entityAutocomplete
+                                  formControlName="id"
+                                  inlineField
+                                  appearance="outline"
+                                  [placeholder]="'action.set' | translate"
+                                  required
+                                  [entityType]="ArgumentEntityTypeParamsMap.get(entityType).entityType"
+                                  (entityChanged)="entityNameSubject.next($event?.name)"/>
         </div>
-      </ng-container>
-      <ng-container>
-        @if (entityFilter.singleEntity?.id) {
-          <div class="tb-form-row">
-            <div class="fixed-title-width tb-required" tb-hint-tooltip-icon="{{'calculated-fields.hint.perimeter-attribute-key' | translate}}">
-              {{ 'calculated-fields.perimeter-attribute-key' | translate }}
+      }
+    </ng-container>
+    <ng-container [formGroup]="refDynamicSourceFormGroup">
+      <div class="tb-form-panel stroked" *ngIf="entityType === ArgumentEntityType.RelationQuery">
+        <mat-expansion-panel class="tb-settings" expanded>
+          <mat-expansion-panel-header>{{ 'calculated-fields.entity-zone-relationship' | translate }}</mat-expansion-panel-header>
+          <div class="tb-form-table">
+            <div class="tb-form-table-header">
+              <div class="tb-form-table-header-cell tb-actions-header"></div>
+              <div class="tb-form-table-header-cell" translate>calculated-fields.level</div>
+              <div class="tb-form-table-header-cell flex-1" translate>calculated-fields.direction-level</div>
+              <div class="tb-form-table-header-cell tb-required flex-1" translate>calculated-fields.relation-type</div>
+              <div class="tb-form-table-header-cell tb-actions-header"></div>
             </div>
-            @if (entityType === ArgumentEntityType.RelationQuery) {
-              <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
-                <input matInput autocomplete="new-name" name="value" formControlName="perimeterKeyName" maxlength="255" placeholder="{{ 'action.set' | translate }}"/>
-                @if (geofencingFormGroup.get('perimeterKeyName').touched && geofencingFormGroup.get('perimeterKeyName').hasError('required')) {
-                  <mat-icon matSuffix
-                            matTooltipPosition="above"
-                            matTooltipClass="tb-error-tooltip"
-                            [matTooltip]="'calculated-fields.perimeter-attribute-key-required' | translate"
-                            class="tb-error">
-                    warning
-                  </mat-icon>
-                } @else if (geofencingFormGroup.get('perimeterKeyName').touched && geofencingFormGroup.get('perimeterKeyName').hasError('pattern')) {
-                  <mat-icon matSuffix
-                            matTooltipPosition="above"
-                            matTooltipClass="tb-error-tooltip"
-                            [matTooltip]="'calculated-fields.perimeter-attribute-key-pattern' | translate"
-                            class="tb-error">
-                    warning
-                  </mat-icon>
+            @if (levelsFormArray()?.controls?.length) {
+              <div class="tb-form-table-body tb-drop-list"
+                   cdkDropList cdkDropListOrientation="vertical"
+                   [cdkDropListDisabled]="!dragEnabled"
+                   (cdkDropListDropped)="keyDrop($event)">
+                @for (keyControl of levelsFormArray().controls; track trackByKey; ) {
+                  <div cdkDrag [cdkDragDisabled]="!dragEnabled" class="tb-draggable-form-table-row">
+                    <div class="tb-form-table-row-cell-buttons">
+                      <button mat-icon-button
+                              type="button"
+                              cdkDragHandle
+                              class="lt-lg:!hidden"
+                              [class.tb-hidden]="!dragEnabled"
+                              matTooltip="{{ 'action.drag' | translate }}"
+                              matTooltipPosition="above">
+                        <mat-icon>drag_indicator</mat-icon>
+                      </button>
+                    </div>
+                    <div class="tb-form-row no-border flex-1" [formGroup]="keyControl">
+                      <div class="level-text">{{ $index + 1 }}</div>
+                      <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
+                        <mat-select formControlName="direction">
+                          @for (direction of GeofencingDirectionList; track direction) {
+                            <mat-option [value]="direction">{{ GeofencingDirectionLevelTranslations.get(direction) | translate }}</mat-option>
+                          }
+                        </mat-select>
+                      </mat-form-field>
+                      <tb-string-autocomplete [fetchOptionsFn]="fetchOptions.bind(this)"
+                                              additionalClass="tb-suffix-show-on-hover"
+                                              class="flex-1"
+                                              appearance="outline"
+                                              panelWidth=""
+                                              required
+                                              [errorText]="'calculated-fields.hint.relation-type-required' | translate"
+                                              formControlName="relationType">
+                      </tb-string-autocomplete>
+                    </div>
+                    <div class="tb-form-table-row-cell-buttons">
+                      <button type="button"
+                              mat-icon-button
+                              (click)="removeKey($index)"
+                              matTooltip="{{ 'calculated-fields.delete-level' | translate }}"
+                              matTooltipPosition="above">
+                        <mat-icon>delete</mat-icon>
+                      </button>
+                    </div>
+                  </div>
                 }
-              </mat-form-field>
+              </div>
             } @else {
-              <tb-entity-key-autocomplete class="flex-1" formControlName="perimeterKeyName" [dataKeyType]="DataKeyType.attribute" [entityFilter]="entityFilter" [keyScopeType]="AttributeScope.SERVER_SCOPE"/>
+              <span class="tb-prompt flex items-center justify-center">{{ 'calculated-fields.no-level' | translate }}</span>
+            }
+            @if (levelsFormArray().errors) {
+              <tb-error noMargin error="{{ 'calculated-fields.levels-required' | translate }}" style="padding-left: 12px;"></tb-error>
             }
           </div>
-        }
+          <div>
+            @if (maxRelationLevelPerCfArgument && levelsFormArray().length >= maxRelationLevelPerCfArgument) {
+              <div class="tb-form-hint tb-primary-fill max-args-warning flex items-center gap-2">
+                <mat-icon>warning</mat-icon>
+                <span>{{ 'calculated-fields.max-allowed-levels-error' | translate }}</span>
+              </div>
+            } @else {
+              <button type="button" mat-stroked-button color="primary" (click)="addKey()">
+                {{ 'calculated-fields.add-level' | translate }}
+              </button>
+            }
+          </div>
+        </mat-expansion-panel>
+      </div>
+    </ng-container>
+    <ng-container>
+      @if (entityFilter.singleEntity?.id) {
         <div class="tb-form-row">
-          <div class="fixed-title-width" tb-hint-tooltip-icon="{{'calculated-fields.hint.report-strategy' | translate}}">{{ 'calculated-fields.report-strategy' | translate }}</div>
-          <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
-            <mat-select formControlName="reportStrategy">
-              @for (strategy of GeofencingReportStrategyList; track strategy) {
-                <mat-option [value]="strategy">{{ GeofencingReportStrategyTranslations.get(strategy) | translate }}</mat-option>
-              }
-            </mat-select>
-          </mat-form-field>
-        </div>
-      </ng-container>
-      <div class="tb-form-panel stroked">
-        <mat-slide-toggle class="mat-slide" formControlName="createRelationsWithMatchedZones" (click)="$event.stopPropagation()">
-          <div tb-hint-tooltip-icon="{{ 'calculated-fields.hint.create-relation-with-matched-zones' | translate }}">
-            {{ 'calculated-fields.create-relation-with-matched-zones' | translate }}
+          <div class="fixed-title-width tb-required" tb-hint-tooltip-icon="{{'calculated-fields.hint.perimeter-attribute-key' | translate}}">
+            {{ 'calculated-fields.perimeter-attribute-key' | translate }}
           </div>
-        </mat-slide-toggle>
-        <div class="tb-form-row" [class.!hidden]="!geofencingFormGroup.get('createRelationsWithMatchedZones').value">
-          <div class="fixed-title-width">{{ 'calculated-fields.direction' | translate }}</div>
-          <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
-            <mat-select formControlName="direction">
-              @for (direction of GeofencingDirectionList; track direction) {
-                <mat-option [value]="direction">{{ GeofencingDirectionTranslations.get(direction) | translate }}</mat-option>
+          @if (entityType === ArgumentEntityType.RelationQuery) {
+            <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
+              <input matInput autocomplete="new-name" name="value" formControlName="perimeterKeyName" maxlength="255" placeholder="{{ 'action.set' | translate }}"/>
+              @if (geofencingFormGroup.get('perimeterKeyName').touched && geofencingFormGroup.get('perimeterKeyName').hasError('required')) {
+                <mat-icon matSuffix
+                          matTooltipPosition="above"
+                          matTooltipClass="tb-error-tooltip"
+                          [matTooltip]="'calculated-fields.perimeter-attribute-key-required' | translate"
+                          class="tb-error">
+                  warning
+                </mat-icon>
+              } @else if (geofencingFormGroup.get('perimeterKeyName').touched && geofencingFormGroup.get('perimeterKeyName').hasError('pattern')) {
+                <mat-icon matSuffix
+                          matTooltipPosition="above"
+                          matTooltipClass="tb-error-tooltip"
+                          [matTooltip]="'calculated-fields.perimeter-attribute-key-pattern' | translate"
+                          class="tb-error">
+                  warning
+                </mat-icon>
               }
-            </mat-select>
-          </mat-form-field>
+            </mat-form-field>
+          } @else {
+            <tb-entity-key-autocomplete class="flex-1" formControlName="perimeterKeyName"
+                                        [dataKeyType]="DataKeyType.attribute" [entityFilter]="entityFilter"
+                                        [keyScopeType]="AttributeScope.SERVER_SCOPE"/>
+          }
         </div>
-        <div class="tb-form-row" [class.!hidden]="!geofencingFormGroup.get('createRelationsWithMatchedZones').value">
-          <div class="fixed-title-width tb-required">{{ 'calculated-fields.relation-type' | translate }}</div>
-          <tb-string-autocomplete [fetchOptionsFn]="fetchOptions.bind(this)"
-                                  additionalClass="tb-suffix-show-on-hover"
-                                  class="flex-1"
-                                  appearance="outline"
-                                  panelWidth=""
-                                  required
-                                  [errorText]="'calculated-fields.hint.relation-type-required' | translate"
-                                  formControlName="relationType">
-          </tb-string-autocomplete>
+      }
+      <div class="tb-form-row">
+        <div class="fixed-title-width" tb-hint-tooltip-icon="{{'calculated-fields.hint.report-strategy' | translate}}">{{ 'calculated-fields.report-strategy' | translate }}</div>
+        <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
+          <mat-select formControlName="reportStrategy">
+            @for (strategy of GeofencingReportStrategyList; track strategy) {
+              <mat-option [value]="strategy">{{ GeofencingReportStrategyTranslations.get(strategy) | translate }}</mat-option>
+            }
+          </mat-select>
+        </mat-form-field>
+      </div>
+    </ng-container>
+    <div class="tb-form-panel stroked">
+      <mat-slide-toggle class="mat-slide" formControlName="createRelationsWithMatchedZones" (click)="$event.stopPropagation()">
+        <div tb-hint-tooltip-icon="{{ 'calculated-fields.hint.create-relation-with-matched-zones' | translate }}">
+          {{ 'calculated-fields.create-relation-with-matched-zones' | translate }}
         </div>
+      </mat-slide-toggle>
+      <div class="tb-form-row" [class.!hidden]="!geofencingFormGroup.get('createRelationsWithMatchedZones').value">
+        <div class="fixed-title-width">{{ 'calculated-fields.direction' | translate }}</div>
+        <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
+          <mat-select formControlName="direction">
+            @for (direction of GeofencingDirectionList; track direction) {
+              <mat-option [value]="direction">{{ GeofencingDirectionTranslations.get(direction) | translate }}</mat-option>
+            }
+          </mat-select>
+        </mat-form-field>
+      </div>
+      <div class="tb-form-row" [class.!hidden]="!geofencingFormGroup.get('createRelationsWithMatchedZones').value">
+        <div class="fixed-title-width tb-required">{{ 'calculated-fields.relation-type' | translate }}</div>
+        <tb-string-autocomplete [fetchOptionsFn]="fetchOptions.bind(this)"
+                                additionalClass="tb-suffix-show-on-hover"
+                                class="flex-1"
+                                appearance="outline"
+                                panelWidth=""
+                                required
+                                [errorText]="'calculated-fields.hint.relation-type-required' | translate"
+                                formControlName="relationType">
+        </tb-string-autocomplete>
       </div>
     </div>
   </div>
-  <div class="flex justify-end gap-2">
+  <div class="tb-config-panel-buttons">
     <button mat-button
             color="primary"
             type="button"

ui-ngx/src/app/modules/home/components/calculated-fields/components/geofencing-configuration/calculated-field-geofencing-zone-groups-panel.component.scss

@@ -15,20 +15,7 @@
  */
 @import '../../../../../../../scss/constants';
 
-$panel-width: 520px;
-
 :host {
-  display: flex;
-  width: $panel-width;
-  max-width: 100%;
-  max-height: 80vh;
-
-  .fixed-title-width {
-    @media #{$mat-xs} {
-      min-width: 120px;
-    }
-  }
-
   .level-text {
     display: flex;
     justify-content: center;
@@ -58,7 +45,7 @@ $panel-width: 520px;
   }
 
   .limit-field-row {
-    @media screen and (max-width: $panel-width) {
+    @media screen and (max-width: 520px) {
       display: flex;
       flex-direction: column;
 
@@ -71,11 +58,6 @@ $panel-width: 520px;
 }
 
 :host ::ng-deep {
-  .time-interval-field {
-    .advanced-input {
-      flex-direction: column;
-    }
-  }
   tb-entity-autocomplete {
     .mat-mdc-form-field-has-icon-suffix .mat-mdc-text-field-wrapper {
       padding-right: 0 !important;

ui-ngx/src/app/modules/home/components/calculated-fields/components/geofencing-configuration/calculated-field-geofencing-zone-groups-panel.component.ts

@@ -32,14 +32,13 @@ import {
   ArgumentEntityTypeTranslations,
   CalculatedFieldGeofencing,
   CalculatedFieldGeofencingValue,
-  CalculatedFieldType,
   GeofencingDirectionLevelTranslations,
   GeofencingDirectionTranslations,
   GeofencingReportStrategy,
   GeofencingReportStrategyTranslations,
   getCalculatedFieldCurrentEntityFilter
 } from '@shared/models/calculated-field.models';
-import { debounceTime, delay, distinctUntilChanged, map } from 'rxjs/operators';
+import { debounceTime, distinctUntilChanged, map } from 'rxjs/operators';
 import { EntityType } from '@shared/models/entity-type.models';
 import { AttributeScope, DataKeyType } from '@shared/models/telemetry/telemetry.models';
 import { EntityId } from '@shared/models/id/entity-id';
@@ -58,7 +57,7 @@ import { CdkDragDrop } from "@angular/cdk/drag-drop";
 @Component({
   selector: 'tb-calculated-field-geofencing-zone-groups-panel',
   templateUrl: './calculated-field-geofencing-zone-groups-panel.component.html',
-  styleUrls: ['./calculated-field-geofencing-zone-groups-panel.component.scss']
+  styleUrls: ['../common/calculated-field-panel.scss', './calculated-field-geofencing-zone-groups-panel.component.scss']
 })
 export class CalculatedFieldGeofencingZoneGroupsPanelComponent implements OnInit, AfterViewInit {
 
@@ -67,7 +66,6 @@ export class CalculatedFieldGeofencingZoneGroupsPanelComponent implements OnInit
   @Input() entityId: EntityId;
   @Input() tenantId: string;
   @Input() entityName: string;
-  @Input() calculatedFieldType: CalculatedFieldType;
   @Input() usedNames: string[];
 
   @ViewChild('entityAutocomplete') entityAutocomplete: EntityAutocompleteComponent;
@@ -118,7 +116,6 @@ export class CalculatedFieldGeofencingZoneGroupsPanelComponent implements OnInit
 
     this.observeEntityFilterChanges();
     this.observeEntityTypeChanges();
-    this.observeUpdatePosition();
     this.observeCreateRelationZonesChanges();
   }
 
@@ -161,26 +158,12 @@ export class CalculatedFieldGeofencingZoneGroupsPanelComponent implements OnInit
     return of(['Contains', 'Manages']).pipe(map(name => name?.filter(option => option.toLowerCase().includes(search))));
   }
 
-  private observeMaxLevelChanges(): void {
-    this.refDynamicSourceFormGroup.get('maxLevel').valueChanges
-      .pipe(takeUntilDestroyed())
-      .subscribe(value => this.validateFetchLastLevelOnly(value));
-  }
-
   private observeCreateRelationZonesChanges(): void {
     this.geofencingFormGroup.get('createRelationsWithMatchedZones').valueChanges
       .pipe(takeUntilDestroyed())
       .subscribe(value => this.validateDirectionAndRelationType(value));
   }
 
-  private validateFetchLastLevelOnly(maxLevel = 1): void {
-    if (maxLevel > 1) {
-      this.refDynamicSourceFormGroup.get('fetchLastLevelOnly').enable({emitEvent: false});
-    } else {
-      this.refDynamicSourceFormGroup.get('fetchLastLevelOnly').disable({emitEvent: false});
-    }
-  }
-
   private validateDirectionAndRelationType(createRelation = false): void {
     if (createRelation) {
       this.geofencingFormGroup.get('direction').enable({emitEvent: false});
@@ -304,21 +287,11 @@ export class CalculatedFieldGeofencingZoneGroupsPanelComponent implements OnInit
     };
   }
 
-  private observeUpdatePosition(): void {
-    merge(
-      this.refEntityIdFormGroup.get('entityType').valueChanges,
-      this.refEntityIdFormGroup.get('id').valueChanges,
-      this.geofencingFormGroup.get('createRelationsWithMatchedZones').valueChanges
-    )
-      .pipe(delay(50), takeUntilDestroyed())
-      .subscribe(() => this.popover.updatePosition());
-  }
-
   levelsFormArray(): UntypedFormArray {
     return this.refDynamicSourceFormGroup.get('levels') as UntypedFormArray;
   }
 
-  trackByKey(index: number, keyControl: AbstractControl): any {
+  trackByKey(_index: number, keyControl: AbstractControl): any {
     return keyControl;
   }
 

ui-ngx/src/app/modules/home/components/calculated-fields/components/geofencing-configuration/calculated-field-geofencing-zone-groups-table.component.html

@@ -35,7 +35,7 @@
         </mat-cell>
       </ng-container>
       <ng-container [matColumnDef]="'entityType'">
-        <mat-header-cell mat-sort-header *matHeaderCellDef class="entity-type-header w-1/5 xs:hidden">
+        <mat-header-cell mat-sort-header *matHeaderCellDef class="w-1/5 xs:hidden">
           {{ 'entity.entity-type' | translate }}
         </mat-header-cell>
         <mat-cell *matCellDef="let geofenceZone" class="w-1/5 xs:hidden">
@@ -91,7 +91,7 @@
       <ng-container matColumnDef="actions" stickyEnd>
         <mat-header-cell *matHeaderCellDef class="w-20 min-w-20"/>
         <mat-cell *matCellDef="let geofenceZone;">
-          <div class="tb-form-table-row-cell-buttons flex w-20 min-w-20">
+          <div class="tb-form-table-row-cell-buttons min-w-20">
             <button type="button"
                     mat-icon-button
                     #button

ui-ngx/src/app/modules/home/components/calculated-fields/components/geofencing-configuration/calculated-field-geofencing-zone-groups-table.component.scss

@@ -1,76 +0,0 @@
-/**
- * Copyright © 2016-2025 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.
- */
-:host {
-  .arguments-table {
-    min-height: 108px;
-
-    &-with-error {
-      min-height: 150px;
-    }
-
-    .mat-mdc-table {
-      table-layout: fixed;
-    }
-
-    .key-text {
-      font-size: 13px;
-    }
-
-    .copy-argument-name {
-      visibility: hidden;
-      transition: visibility 0.1s;
-    }
-
-    .argument-name-cell:hover {
-      .copy-argument-name {
-        visibility: visible;
-      }
-    }
-  }
-
-  .max-args-warning {
-    .mat-icon {
-      color: #FAA405;
-    }
-  }
-
-  .tb-form-table-row-cell-buttons {
-    --mat-badge-legacy-small-size-container-size: 8px;
-    --mat-badge-small-size-container-overlap-offset: -5px;
-    --mat-badge-small-size-text-size: 0;
-  }
-}
-
-:host ::ng-deep {
-  .arguments-table:not(.arguments-table-with-error) {
-    .mdc-data-table__row:last-child .mat-mdc-cell {
-      border-bottom: none;
-    }
-  }
-
-  .arguments-table {
-    .mat-mdc-header-row.mat-row-select .mat-mdc-header-cell.entity-type-header {
-      padding: 0 28px 0 0;
-    }
-  }
-
-  .copy-argument-name {
-    .mat-icon {
-      font-size: 16px;
-      padding: 4px;
-    }
-  }
-}

ui-ngx/src/app/modules/home/components/calculated-fields/components/geofencing-configuration/calculated-field-geofencing-zone-groups-table.component.ts

@@ -37,7 +37,6 @@ import {
   ArgumentEntityType,
   CalculatedFieldGeofencing,
   CalculatedFieldGeofencingValue,
-  CalculatedFieldType,
   GeofencingReportStrategyTranslations,
 } from '@shared/models/calculated-field.models';
 import { MatButton } from '@angular/material/button';
@@ -63,7 +62,7 @@ import {
 @Component({
   selector: 'tb-calculated-field-geofencing-zone-groups-table',
   templateUrl: './calculated-field-geofencing-zone-groups-table.component.html',
-  styleUrls: [`calculated-field-geofencing-zone-groups-table.component.scss`],
+  styleUrls: [`../calculated-field-arguments/calculated-field-arguments-table.component.scss`],
   providers: [
     {
       provide: NG_VALUE_ACCESSOR,
@@ -157,7 +156,6 @@ export class CalculatedFieldGeofencingZoneGroupsTableComponent implements Contro
         index,
         zone,
         entityId: this.entityId,
-        calculatedFieldType: CalculatedFieldType.GEOFENCING,
         buttonTitle: isExists ? 'action.apply' : 'action.add',
         tenantId: this.tenantId,
         entityName: this.entityName,
@@ -168,7 +166,7 @@ export class CalculatedFieldGeofencingZoneGroupsTableComponent implements Contro
         renderer: this.renderer,
         componentType: CalculatedFieldGeofencingZoneGroupsPanelComponent,
         hostView: this.viewContainerRef,
-        preferredPlacement: isExists ? ['left', 'leftTop', 'leftBottom'] : ['topRight', 'right', 'rightTop'],
+        preferredPlacement: isExists ? ['leftOnly', 'leftTopOnly', 'leftBottomOnly'] : ['rightOnly', 'rightTopOnly', 'rightBottomOnly'],
         context: ctx,
         isModal: true
       });

ui-ngx/src/app/modules/home/components/calculated-fields/components/output/calculated-field-output.component.html

@@ -17,70 +17,74 @@
 -->
 <div class="tb-form-panel" [formGroup]="outputForm">
   <div class="tb-form-panel-title">{{ 'calculated-fields.output' | translate }}</div>
-  <div class="flex items-center gap-3">
-    <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
-      <mat-label>{{ 'calculated-fields.output-type' | translate }}</mat-label>
-      <mat-select formControlName="type">
-        @for (type of outputTypes; track type) {
-          <mat-option [value]="type">{{ OutputTypeTranslations.get(type) | translate }}</mat-option>
-        }
-      </mat-select>
-    </mat-form-field>
-    @if (outputForm.get('type').value === OutputType.Attribute
-    && (entityId.entityType === EntityType.DEVICE || entityId.entityType === EntityType.DEVICE_PROFILE)) {
+  <div class="flex flex-col gap-3">
+    <div class="flex gap-3 xs:flex-col">
       <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
-        <mat-label>{{ 'calculated-fields.attribute-scope' | translate }}</mat-label>
-        <mat-select formControlName="scope" class="w-full">
-          <mat-option [value]="AttributeScope.SERVER_SCOPE">
-            {{ 'calculated-fields.server-attributes' | translate }}
-          </mat-option>
-          <mat-option [value]="AttributeScope.SHARED_SCOPE">
-            {{ 'calculated-fields.shared-attributes' | translate }}
-          </mat-option>
+        <mat-label>{{ 'calculated-fields.output-type' | translate }}</mat-label>
+        <mat-select formControlName="type">
+          @for (type of outputTypes; track type) {
+            <mat-option [value]="type">{{ OutputTypeTranslations.get(type) | translate }}</mat-option>
+          }
         </mat-select>
       </mat-form-field>
+      @if (outputForm.get('type').value === OutputType.Attribute
+      && (entityId.entityType === EntityType.DEVICE || entityId.entityType === EntityType.DEVICE_PROFILE)) {
+        <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
+          <mat-label>{{ 'calculated-fields.attribute-scope' | translate }}</mat-label>
+          <mat-select formControlName="scope" class="w-full">
+            <mat-option [value]="AttributeScope.SERVER_SCOPE">
+              {{ 'calculated-fields.server-attributes' | translate }}
+            </mat-option>
+            <mat-option [value]="AttributeScope.SHARED_SCOPE">
+              {{ 'calculated-fields.shared-attributes' | translate }}
+            </mat-option>
+          </mat-select>
+        </mat-form-field>
+      }
+    </div>
+    @if (simpleMode) {
+      @if (hiddenName) {
+        <div class="grid grid-cols-2 items-start gap-3 xs:grid-cols-1">
+          <ng-container *ngTemplateOutlet="decimalsByDefaultField"></ng-container>
+          <ng-content select=".simpleMode"></ng-content>
+        </div>
+      } @else {
+        <div class="flex items-start gap-3 xs:flex-col xs:items-stretch">
+          <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
+            <mat-label>
+              {{
+                (outputForm.get('type').value === OutputType.Timeseries
+                  ? 'calculated-fields.timeseries-key'
+                  : 'calculated-fields.attribute-key')
+                  | translate
+              }}
+            </mat-label>
+            <input matInput formControlName="name" required>
+            @if (outputForm.get('name').errors && outputForm.get('name').touched) {
+              <mat-error>
+                @if (outputForm.get('name').hasError('required')) {
+                  {{ 'common.hint.key-required' | translate }}
+                } @else if (outputForm.get('name').hasError('pattern')) {
+                  {{ 'common.hint.key-pattern' | translate }}
+                } @else if (outputForm.get('name').hasError('maxlength')) {
+                  {{ 'common.hint.key-max-length' | translate }}
+                }
+              </mat-error>
+            }
+          </mat-form-field>
+          <ng-container *ngTemplateOutlet="decimalsByDefaultField"></ng-container>
+        </div>
+        <ng-content select=".simpleMode"></ng-content>
+      }
     }
   </div>
-  @if (simpleMode) {
-    <div class="flex items-start gap-3">
-      <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
-        <mat-label>
-          {{
-            (outputForm.get('type').value === OutputType.Timeseries
-              ? 'calculated-fields.timeseries-key'
-              : 'calculated-fields.attribute-key')
-              | translate
-          }}
-        </mat-label>
-        <input matInput formControlName="name" required>
-        @if (outputForm.get('name').errors && outputForm.get('name').touched) {
-          <mat-error>
-            @if (outputForm.get('name').hasError('required')) {
-              {{ 'common.hint.key-required' | translate }}
-            } @else if (outputForm.get('name').hasError('pattern')) {
-              {{ 'common.hint.key-pattern' | translate }}
-            } @else if (outputForm.get('name').hasError('maxlength')) {
-              {{ 'common.hint.key-max-length' | translate }}
-            }
-          </mat-error>
-        }
-      </mat-form-field>
-      <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
-        <mat-label>{{ 'calculated-fields.decimals-by-default' | translate }}</mat-label>
-        <input matInput type="number" formControlName="decimalsByDefault">
-        @if (outputForm.get('decimalsByDefault').errors && outputForm.get('decimalsByDefault').touched) {
-          <mat-error>{{ 'calculated-fields.hint.decimals-range' | translate }}</mat-error>
-        }
-      </mat-form-field>
-    </div>
-    <ng-content select=".simpleMode"></ng-content>
-<!--    <div class="tb-form-row" [formGroup]="configFormGroup"-->
-<!--         *ngIf="outputFormGroup.get('type').value === OutputType.Timeseries">-->
-<!--      <mat-slide-toggle class="mat-slide" formControlName="useLatestTs">-->
-<!--        <div tb-hint-tooltip-icon="{{ 'calculated-fields.hint.use-latest-timestamp' | translate }}" translate>-->
-<!--          calculated-fields.use-latest-timestamp-->
-<!--        </div>-->
-<!--      </mat-slide-toggle>-->
-<!--    </div>-->
-  }
 </div>
+<ng-template #decimalsByDefaultField>
+  <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic" [formGroup]="outputForm">
+    <mat-label>{{ 'calculated-fields.decimals-by-default' | translate }}</mat-label>
+    <input matInput type="number" formControlName="decimalsByDefault">
+    @if (outputForm.get('decimalsByDefault').errors && outputForm.get('decimalsByDefault').touched) {
+      <mat-error>{{ 'calculated-fields.hint.decimals-range' | translate }}</mat-error>
+    }
+  </mat-form-field>
+</ng-template>

ui-ngx/src/app/modules/home/components/calculated-fields/components/output/calculated-field-output.component.ts

@@ -35,6 +35,7 @@ import { digitsRegex, oneSpaceInsideRegex } from '@shared/models/regex.constants
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { EntityId } from '@shared/models/id/entity-id';
 import { EntityType } from '@shared/models/entity-type.models';
+import { coerceBoolean } from '@shared/decorators/coercion';
 
 @Component({
   selector: 'tb-calculate-field-output',
@@ -55,8 +56,13 @@ import { EntityType } from '@shared/models/entity-type.models';
 export class CalculatedFieldOutputComponent implements ControlValueAccessor, Validator, OnInit, OnChanges {
 
   @Input()
+  @coerceBoolean()
   simpleMode = false;
 
+  @Input()
+  @coerceBoolean()
+  hiddenName = false;
+
   @Input({required: true})
   entityId: EntityId;
 
@@ -137,11 +143,14 @@ export class CalculatedFieldOutputComponent implements ControlValueAccessor, Val
   }
 
   private updatedFormWithMode(): void {
-    if (this.simpleMode) {
+    if (this.simpleMode && !this.hiddenName) {
       this.outputForm.get('name').enable({emitEvent: false});
-      this.outputForm.get('decimalsByDefault').enable({emitEvent: false});
     } else {
       this.outputForm.get('name').disable({emitEvent: false});
+    }
+    if (this.simpleMode) {
+      this.outputForm.get('decimalsByDefault').enable({emitEvent: false});
+    } else {
       this.outputForm.get('decimalsByDefault').disable({emitEvent: false});
     }
   }

ui-ngx/src/app/modules/home/components/calculated-fields/components/propagation-configuration/propagation-configuration.component.html

@@ -20,7 +20,7 @@
     <div class="tb-form-panel-title" tbTruncateWithTooltip tb-hint-tooltip-icon="{{ 'calculated-fields.hint.propagation-path-related-entities' | translate }}">
       {{ 'calculated-fields.propagation-path-related-entities' | translate }}
     </div>
-    <div class="flex gap-3 xs:flex-col">
+    <div class="flex gap-3 xs:flex-col" formGroupName="relation">
       <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic" hideRequiredMarker>
         <mat-label>{{ 'calculated-fields.direction' | translate }}</mat-label>
         <mat-select formControlName="direction">
@@ -41,11 +41,11 @@
     </div>
   </div>
   <div class="tb-form-panel">
-    <div class="flex flex-row items-center justify-between xs:flex-col xs:items-start xs:gap-3">
+    <div class="flex flex-row items-center justify-between gap-2">
       <div class="tb-form-panel-title" tb-hint-tooltip-icon="{{ 'calculated-fields.hint.data-propagate' | translate }}">
         {{ 'calculated-fields.data-propagate' | translate }}
       </div>
-      <tb-toggle-select formControlName="applyExpressionToResolvedArguments">
+      <tb-toggle-select formControlName="applyExpressionToResolvedArguments" selectMediaBreakpoint="xs" disablePagination>
         <tb-toggle-option [value]="false">{{ 'calculated-fields.propagate-type.arguments-only' | translate }}</tb-toggle-option>
         <tb-toggle-option [value]="true">{{ 'calculated-fields.propagate-type.expression-result' | translate }}</tb-toggle-option>
       </tb-toggle-select>

ui-ngx/src/app/modules/home/components/calculated-fields/components/propagation-configuration/propagation-configuration.component.ts

@@ -76,8 +76,10 @@ export class PropagationConfigurationComponent implements ControlValueAccessor,
   propagateConfiguration = this.fb.group({
     arguments: this.fb.control({}),
     applyExpressionToResolvedArguments: [false],
-    direction: [EntitySearchDirection.TO, Validators.required],
-    relationType: ['Contains', Validators.required],
+    relation: this.fb.group({
+      direction: [EntitySearchDirection.TO, Validators.required],
+      relationType: ['Contains', Validators.required],
+    }),
     expression: [calculatedFieldDefaultScript],
     output: this.fb.control<CalculatedFieldOutput>({
       scope: AttributeScope.SERVER_SCOPE,

ui-ngx/src/app/modules/home/components/calculated-fields/components/related-entities-aggregation-configuration/calculated-field-metrics-panel.component.html

@@ -0,0 +1,175 @@
+<!--
+
+    Copyright © 2016-2025 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.
+
+-->
+<div class="tb-config-panel" [formGroup]="metricForm">
+  <div class="tb-config-panel-title">{{ 'calculated-fields.metrics.metric-settings' | translate }}</div>
+  <div class="tb-config-panel-content tb-form-panel no-border no-padding">
+    <div class="tb-form-row">
+      <div class="fixed-title-width tb-required">{{ 'calculated-fields.metrics.metric-name' | translate }}</div>
+      <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
+        <input matInput autocomplete="new-name" name="value" formControlName="name" maxlength="255"
+               placeholder="{{ 'action.set' | translate }}"/>
+        @if (metricForm.get('name').touched && metricForm.get('name').hasError('required')) {
+          <mat-icon matSuffix
+                    matTooltipPosition="above"
+                    matTooltipClass="tb-error-tooltip"
+                    [matTooltip]="'calculated-fields.hint.name-required' | translate"
+                    class="tb-error">
+            warning
+          </mat-icon>
+        } @else if (metricForm.get('name').touched && metricForm.get('name').hasError('duplicateName')) {
+          <mat-icon matSuffix
+                    matTooltipPosition="above"
+                    matTooltipClass="tb-error-tooltip"
+                    [matTooltip]="'calculated-fields.hint.name-duplicate' | translate"
+                    class="tb-error">
+            warning
+          </mat-icon>
+        } @else if (metricForm.get('name').touched && metricForm.get('name').hasError('pattern')) {
+          <mat-icon matSuffix
+                    matTooltipPosition="above"
+                    matTooltipClass="tb-error-tooltip"
+                    [matTooltip]="'calculated-fields.hint.name-pattern' | translate"
+                    class="tb-error">
+            warning
+          </mat-icon>
+        } @else if (metricForm.get('name').touched && metricForm.get('name').hasError('maxlength')) {
+          <mat-icon matSuffix
+                    matTooltipPosition="above"
+                    matTooltipClass="tb-error-tooltip"
+                    [matTooltip]="'calculated-fields.hint.name-max-length' | translate"
+                    class="tb-error">
+            warning
+          </mat-icon>
+        } @else if (metricForm.get('name').touched && metricForm.get('name').hasError('forbiddenName')) {
+          <mat-icon matSuffix
+                    matTooltipPosition="above"
+                    matTooltipClass="tb-error-tooltip"
+                    [matTooltip]="'calculated-fields.hint.name-forbidden' | translate"
+                    class="tb-error">
+            warning
+          </mat-icon>
+        }
+      </mat-form-field>
+    </div>
+    <div class="tb-form-row">
+      <div class="fixed-title-width">{{ 'calculated-fields.metrics.aggregation' | translate }}</div>
+      <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
+        <mat-select formControlName="function">
+          @for (aggFunction of AggFunctions; track aggFunction) {
+            <mat-option [value]="aggFunction">{{ AggFunctionTranslations.get(aggFunction) | translate }}</mat-option>
+          }
+        </mat-select>
+      </mat-form-field>
+    </div>
+
+    <div class="tb-form-panel stroked tb-slide-toggle">
+      <mat-expansion-panel class="tb-settings" [(expanded)]="filterExpanded"
+                           [disabled]="!metricForm.get('allowFilter').value">
+        <mat-expansion-panel-header class="flex flex-row flex-wrap">
+          <mat-panel-title>
+            <mat-slide-toggle class="mat-slide flex items-stretch justify-center" formControlName="allowFilter"
+                              (click)="$event.stopPropagation()">
+              <div tb-hint-tooltip-icon="{{ 'calculated-fields.metrics.filter-hint' | translate }}">
+                {{ 'calculated-fields.metrics.filter' | translate }}
+              </div>
+            </mat-slide-toggle>
+          </mat-panel-title>
+        </mat-expansion-panel-header>
+        <ng-template matExpansionPanelContent>
+          <tb-js-func required
+                      formControlName="filter"
+                      functionName="filter"
+                      [functionArgs]="functionArgs"
+                      [disableUndefinedCheck]="true"
+                      [scriptLanguage]="ScriptLanguage.TBEL"
+                      [highlightRules]="highlightRules"
+                      [editorCompleter]="editorCompleter"
+                      [helpPopupStyle]="{ width: '1200px' }"
+                      helpId="calculated-field/filter_expression_fn">
+            <div toolbarPrefixButton
+                 class="tb-primary-background tbel-script-lang-chip">{{ 'api-usage.tbel' | translate }}
+            </div>
+          </tb-js-func>
+        </ng-template>
+      </mat-expansion-panel>
+    </div>
+    <ng-container formGroupName="input">
+      <div class="tb-form-row">
+        <div class="fixed-title-width">{{ 'calculated-fields.metrics.value-source' | translate }}</div>
+        <mat-form-field class="tb-flex no-gap" appearance="outline" subscriptSizing="dynamic">
+          <mat-select formControlName="type">
+            @for (inputType of AggInputTypes; track inputType) {
+              <mat-option [value]="inputType">{{ AggInputTypeTranslations.get(inputType) | translate }}</mat-option>
+            }
+          </mat-select>
+        </mat-form-field>
+      </div>
+      @if (this.metricForm.get('input.type').value === AggInputType.key) {
+        <div class="tb-form-row">
+          <div class="fixed-title-width tb-required">{{ 'calculated-fields.argument-name' | translate }}</div>
+          <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic">
+            <mat-select formControlName="key" placeholder="{{ 'action.set' | translate }}">
+              @for (argument of arguments; track argument) {
+                <mat-option [value]="argument">{{ argument }}</mat-option>
+              }
+            </mat-select>
+            @if (metricForm.get('input.key').touched && metricForm.get('input.key').hasError('required')) {
+              <mat-icon matSuffix
+                        matTooltipPosition="above"
+                        matTooltipClass="tb-error-tooltip"
+                        [matTooltip]="'calculated-fields.hint.argument-name-required' | translate"
+                        class="tb-error !block">
+                warning
+              </mat-icon>
+            }
+          </mat-form-field>
+        </div>
+      } @else {
+        <tb-js-func required
+                    formControlName="function"
+                    functionName="filter"
+                    [functionArgs]="functionArgs"
+                    [disableUndefinedCheck]="true"
+                    [scriptLanguage]="ScriptLanguage.TBEL"
+                    [highlightRules]="highlightRules"
+                    [editorCompleter]="editorCompleter"
+                    [helpPopupStyle]="{ width: '1200px' }"
+                    helpId="calculated-field/expression_fn">
+          <div toolbarPrefixButton
+               class="tb-primary-background tbel-script-lang-chip">{{ 'api-usage.tbel' | translate }}
+          </div>
+        </tb-js-func>
+      }
+    </ng-container>
+  </div>
+  <div class="tb-config-panel-buttons">
+    <button mat-button
+            color="primary"
+            type="button"
+            (click)="cancel()">
+      {{ 'action.cancel' | translate }}
+    </button>
+    <button mat-raised-button
+            color="primary"
+            type="button"
+            (click)="saveMetric()"
+            [disabled]="metricForm.invalid || !metricForm.dirty">
+      {{ buttonTitle | translate }}
+    </button>
+  </div>
+</div>

ui-ngx/src/app/modules/home/components/calculated-fields/components/related-entities-aggregation-configuration/calculated-field-metrics-panel.component.ts

@@ -0,0 +1,167 @@
+///
+/// Copyright © 2016-2025 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.
+///
+
+import { Component, Input, OnInit, output } from '@angular/core';
+import { TbPopoverComponent } from '@shared/components/popover.component';
+import { FormBuilder, FormControl, ValidatorFn, Validators } from '@angular/forms';
+import { charsWithNumRegex } from '@shared/models/regex.constants';
+import {
+  AggFunction,
+  AggFunctionTranslations,
+  AggInputType,
+  AggInputTypeTranslations,
+  CalculatedFieldAggMetricValue
+} from '@shared/models/calculated-field.models';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { EntityFilter } from '@shared/models/query/query.models';
+import { ScriptLanguage } from '@shared/models/rule-node.models';
+import { TbEditorCompleter } from '@shared/models/ace/completion.models';
+import { AceHighlightRules } from '@shared/models/ace/ace.models';
+
+interface CalculatedFieldAggMetricValuePanel extends CalculatedFieldAggMetricValue {
+  allowFilter: boolean;
+}
+
+@Component({
+  selector: 'tb-calculated-field-metrics-panel',
+  templateUrl: './calculated-field-metrics-panel.component.html',
+  styleUrl: '../common/calculated-field-panel.scss',
+})
+export class CalculatedFieldMetricsPanelComponent implements OnInit {
+
+  @Input() buttonTitle: string;
+  @Input() metric: CalculatedFieldAggMetricValue;
+  @Input() usedNames: string[];
+  @Input() arguments: Array<string>;
+  @Input() editorCompleter: TbEditorCompleter;
+  @Input() highlightRules: AceHighlightRules;
+
+  metricDataApplied = output<CalculatedFieldAggMetricValue>();
+  filterExpanded = false;
+  functionArgs: Array<string>
+
+  metricForm = this.fb.group({
+    name: ['', [Validators.required, this.uniqNameRequired(), this.forbiddenNameValidator(), Validators.pattern(charsWithNumRegex), Validators.maxLength(255)]],
+    function: [AggFunction.AVG],
+    allowFilter: [false],
+    filter: ['', Validators.required],
+    input: this.fb.group({
+      type: [AggInputType.key],
+      key: ['', Validators.required],
+      function: ['', Validators.required],
+    })
+  });
+
+  entityFilter: EntityFilter;
+
+  readonly AggFunctions = Object.values(AggFunction) as AggFunction[];
+  readonly AggFunctionTranslations = AggFunctionTranslations;
+  readonly ScriptLanguage = ScriptLanguage;
+  readonly AggInputType = AggInputType;
+  readonly AggInputTypes = Object.values(AggInputType) as AggInputType[];
+  readonly AggInputTypeTranslations = AggInputTypeTranslations;
+
+  constructor(
+    private fb: FormBuilder,
+    private popover: TbPopoverComponent<CalculatedFieldMetricsPanelComponent>
+  ) {
+    this.observeFilterAllowChange();
+    this.observeInputTypeChange();
+  }
+
+  ngOnInit(): void {
+    const data: CalculatedFieldAggMetricValuePanel = {
+      ...this.metric,
+      allowFilter: !!this.metric.filter,
+    }
+    this.metricForm.patchValue(data, {emitEvent: false});
+
+    this.validateFilter(data.allowFilter);
+    this.validateInputTypeFilter(data.input?.type ?? AggInputType.key);
+    this.validateInputKey();
+
+    this.functionArgs = ['ctx', ...this.arguments];
+  }
+
+  saveMetric(): void {
+    const value = this.metricForm.value as CalculatedFieldAggMetricValuePanel;
+    if (!value.allowFilter) {
+      delete value.filter;
+    }
+    delete value.allowFilter;
+    this.metricDataApplied.emit(value);
+  }
+
+  cancel(): void {
+    this.popover.hide();
+  }
+
+  private observeFilterAllowChange(): void {
+    this.metricForm.get('allowFilter').valueChanges
+      .pipe(takeUntilDestroyed())
+      .subscribe(value => this.validateFilter(value));
+  }
+
+  private observeInputTypeChange(): void {
+    this.metricForm.get('input.type').valueChanges
+      .pipe(takeUntilDestroyed())
+      .subscribe(value => this.validateInputTypeFilter(value));
+  }
+
+  private validateFilter(allowFilter = false): void {
+    if (allowFilter) {
+      this.metricForm.get('filter').enable({emitEvent: false});
+    } else {
+      this.metricForm.get('filter').disable({emitEvent: false});
+    }
+    this.filterExpanded = allowFilter;
+  }
+
+  private validateInputTypeFilter(value: AggInputType): void {
+    const inputForm = this.metricForm.get('input');
+    if (value === AggInputType.key) {
+      inputForm.get('key').enable({emitEvent: false});
+      inputForm.get('function').disable({emitEvent: false});
+    } else {
+      inputForm.get('key').disable({emitEvent: false});
+      inputForm.get('function').enable({emitEvent: false});
+    }
+  }
+
+  private validateInputKey() {
+    if (this.metric.input?.type === AggInputType.key && !this.arguments.includes(this.metric.input.key)) {
+      this.metricForm.get('input.key').setValue(null);
+      this.metricForm.get('input.key').markAsTouched();
+    }
+  }
+
+  private uniqNameRequired(): ValidatorFn {
+    return (control: FormControl) => {
+      const newName = control.value.trim().toLowerCase();
+      const isDuplicate = this.usedNames?.some(name => name.toLowerCase() === newName);
+
+      return isDuplicate ? { duplicateName: true } : null;
+    };
+  }
+
+  private forbiddenNameValidator(): ValidatorFn {
+    return (control: FormControl) => {
+      const trimmedValue = control.value.trim().toLowerCase();
+      const forbiddenNames = ['ctx', 'e', 'pi'];
+      return forbiddenNames.includes(trimmedValue) ? { forbiddenName: true } : null;
+    };
+  }
+}

ui-ngx/src/app/modules/home/components/calculated-fields/components/related-entities-aggregation-configuration/calculated-field-metrics-table.component.html

@@ -0,0 +1,113 @@
+<!--
+
+    Copyright © 2016-2025 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.
+
+-->
+<div class="flex flex-col gap-3">
+  <div class="tb-form-panel stroked no-padding no-gap arguments-table flex flex-col" [class.arguments-table-with-error]="errorText">
+    <table mat-table [dataSource]="dataSource" class="overflow-hidden bg-transparent" matSort
+           [matSortActive]="sortOrder.property" [matSortDirection]="sortOrder.direction" matSortDisableClear>
+      <ng-container [matColumnDef]="'name'">
+        <mat-header-cell mat-sort-header *matHeaderCellDef class="!w-1/5 xs:!w-full sm:!w-1/2">
+          <div tbTruncateWithTooltip>{{ 'calculated-fields.metrics.metric-name' | translate }}</div>
+        </mat-header-cell>
+        <mat-cell *matCellDef="let metric" class="argument-name-cell w-1/5 xs:w-full sm:w-1/2">
+          <div class="flex items-center">
+            <div tbTruncateWithTooltip class="flex-1">{{ metric.name }}</div>
+            <tb-copy-button class="copy-argument-name"
+                            [copyText]="metric.name"
+                            tooltipText="{{ 'calculated-fields.metrics.copy-metric-name' | translate }}"
+                            tooltipPosition="above"
+                            icon="content_copy"/>
+          </div>
+        </mat-cell>
+      </ng-container>
+      <ng-container [matColumnDef]="'function'">
+        <mat-header-cell mat-sort-header *matHeaderCellDef class="w-1/5 xs:hidden lt-md:w-1/2">
+          {{ 'calculated-fields.metrics.aggregation' | translate }}
+        </mat-header-cell>
+        <mat-cell *matCellDef="let metric" class="w-1/5 xs:hidden lt-md:w-1/2">
+          <div tbTruncateWithTooltip>{{ AggFunctionTranslations.get(metric.function) | translate }}</div>
+        </mat-cell>
+      </ng-container>
+      <ng-container [matColumnDef]="'filter'">
+        <mat-header-cell mat-sort-header *matHeaderCellDef class="w-1/5 lt-md:hidden">
+          {{ 'calculated-fields.metrics.filtered' | translate }}
+        </mat-header-cell>
+        <mat-cell *matCellDef="let metric" class="w-1/5 lt-md:hidden">
+          <div>
+            <mat-icon class="ml-4 align-middle">{{ metric.filter ? 'check_box' : 'check_box_outline_blank' }}</mat-icon>
+          </div>
+        </mat-cell>
+      </ng-container>
+      <ng-container [matColumnDef]="'valueSource'">
+        <mat-header-cell mat-sort-header *matHeaderCellDef class="w-2/5 lt-md:hidden">
+          {{ 'calculated-fields.metrics.value-source' | translate }}
+        </mat-header-cell>
+        <mat-cell *matCellDef="let metric" class="w-2/5 lt-md:hidden">
+          <div tbTruncateWithTooltip>{{ AggInputTypeTranslations.get(metric.input.type) | translate }}</div>
+        </mat-cell>
+      </ng-container>
+
+      <ng-container matColumnDef="actions" stickyEnd>
+        <mat-header-cell *matHeaderCellDef class="w-20 min-w-20"/>
+        <mat-cell *matCellDef="let metric;">
+          <div class="tb-form-table-row-cell-buttons min-w-20">
+            <button type="button"
+                    mat-icon-button
+                    #button
+                    (click)="manageMetrics($event, button, metric)"
+                    [matTooltip]="'action.edit' | translate"
+                    matTooltipPosition="above">
+              <mat-icon>edit</mat-icon>
+            </button>
+            <button type="button"
+                    mat-icon-button
+                    (click)="onDelete($event, metric)"
+                    [matTooltip]="'action.delete' | translate"
+                    matTooltipPosition="above">
+              <mat-icon>delete</mat-icon>
+            </button>
+          </div>
+        </mat-cell>
+      </ng-container>
+      <mat-header-row class="mat-row-select" *matHeaderRowDef=displayColumns></mat-header-row>
+      <mat-row *matRowDef="let argument; columns: displayColumns"></mat-row>
+    </table>
+    <div [class.!hidden]="(dataSource.isEmpty() | async) === false"
+         class="tb-prompt flex flex-1 items-end justify-center">
+      {{ 'calculated-fields.metrics.no-metrics-configured' | translate }}
+    </div>
+    @if (errorText) {
+      <tb-error noMargin [error]="errorText | translate" class="flex h-9 items-center pl-3"/>
+    }
+  </div>
+  <div class="flex h-9 justify-between">
+    <button type="button"
+            mat-stroked-button
+            color="primary"
+            #button
+            (click)="manageMetrics($event, button)"
+            [disabled]="maxArgumentsPerCF > 0 && metricsFormArray.length >= maxArgumentsPerCF">
+      {{ 'calculated-fields.metrics.add-metric' | translate }}
+    </button>
+    @if (maxArgumentsPerCF && metricsFormArray.length >= maxArgumentsPerCF) {
+      <div class="tb-form-hint tb-primary-fill max-args-warning flex items-center gap-2">
+        <mat-icon>warning</mat-icon>
+        <span>{{ 'calculated-fields.metrics.max-metrics' | translate }}</span>
+      </div>
+    }
+  </div>
+</div>

ui-ngx/src/app/modules/home/components/calculated-fields/components/related-entities-aggregation-configuration/calculated-field-metrics-table.component.ts

@@ -0,0 +1,244 @@
+///
+/// Copyright © 2016-2025 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.
+///
+
+import {
+  AfterViewInit,
+  ChangeDetectorRef,
+  Component,
+  DestroyRef,
+  forwardRef,
+  Input,
+  Renderer2,
+  ViewChild,
+  ViewContainerRef,
+} from '@angular/core';
+import {
+  ControlValueAccessor,
+  FormBuilder,
+  NG_VALIDATORS,
+  NG_VALUE_ACCESSOR,
+  ValidationErrors,
+  Validator,
+} from '@angular/forms';
+import {
+  AggFunctionTranslations,
+  AggInputTypeTranslations,
+  CalculatedFieldAggMetric,
+  CalculatedFieldAggMetricValue,
+} from '@shared/models/calculated-field.models';
+import { MatButton } from '@angular/material/button';
+import { TbPopoverService } from '@shared/components/popover.service';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { isDefinedAndNotNull, isEqual } from '@core/utils';
+import { TbPopoverComponent } from '@shared/components/popover.component';
+import { TbTableDatasource } from '@shared/components/table/table-datasource.abstract';
+import { MatSort, SortDirection } from '@angular/material/sort';
+import { getCurrentAuthState } from '@core/auth/auth.selectors';
+import { Store } from '@ngrx/store';
+import { AppState } from '@core/core.state';
+import {
+  CalculatedFieldMetricsPanelComponent
+} from '@home/components/calculated-fields/components/related-entities-aggregation-configuration/calculated-field-metrics-panel.component';
+import { TbEditorCompleter } from '@shared/models/ace/completion.models';
+import { AceHighlightRules } from '@shared/models/ace/ace.models';
+
+@Component({
+  selector: 'tb-calculated-field-metrics-table',
+  templateUrl: './calculated-field-metrics-table.component.html',
+  styleUrls: [`../calculated-field-arguments/calculated-field-arguments-table.component.scss`],
+  providers: [
+    {
+      provide: NG_VALUE_ACCESSOR,
+      useExisting: forwardRef(() => CalculatedFieldMetricsTableComponent),
+      multi: true
+    },
+    {
+      provide: NG_VALIDATORS,
+      useExisting: forwardRef(() => CalculatedFieldMetricsTableComponent),
+      multi: true
+    }
+  ],
+})
+export class CalculatedFieldMetricsTableComponent implements ControlValueAccessor, Validator, AfterViewInit {
+
+  @Input() arguments: Array<string>;
+  @Input() editorCompleter: TbEditorCompleter;
+  @Input() highlightRules: AceHighlightRules;
+
+  @ViewChild(MatSort, { static: true }) sort: MatSort;
+
+  errorText = '';
+  metricsFormArray = this.fb.array<CalculatedFieldAggMetricValue>([]);
+  sortOrder = { direction: 'asc' as SortDirection, property: '' };
+  dataSource = new CalculatedFieldMetricsDatasource();
+
+  displayColumns = ['name', 'function', 'filter', 'valueSource', 'actions']
+
+  readonly AggFunctionTranslations = AggFunctionTranslations;
+  readonly AggInputTypeTranslations = AggInputTypeTranslations;
+  readonly maxArgumentsPerCF = getCurrentAuthState(this.store).maxArgumentsPerCF - 2;
+
+  private popoverComponent: TbPopoverComponent<CalculatedFieldMetricsPanelComponent>;
+  private propagateChange: (zonesObj: Record<string, CalculatedFieldAggMetric>) => void = () => {};
+
+  constructor(
+    private fb: FormBuilder,
+    private popoverService: TbPopoverService,
+    private viewContainerRef: ViewContainerRef,
+    private cd: ChangeDetectorRef,
+    private renderer: Renderer2,
+    private destroyRef: DestroyRef,
+    private store: Store<AppState>
+  ) {
+    this.metricsFormArray.valueChanges.pipe(takeUntilDestroyed()).subscribe(value => {
+      this.updateDataSource(value);
+      this.propagateChange(this.getMetricsObject(value));
+    });
+  }
+
+  ngAfterViewInit(): void {
+    this.sort.sortChange.asObservable().pipe(
+      takeUntilDestroyed(this.destroyRef)
+    ).subscribe(() => {
+      this.sortOrder.property = this.sort.active;
+      this.sortOrder.direction = this.sort.direction;
+      this.updateDataSource(this.metricsFormArray.value);
+    });
+  }
+
+  registerOnChange(fn: (zonesObj: Record<string, CalculatedFieldAggMetric>) => void): void {
+    this.propagateChange = fn;
+  }
+
+  registerOnTouched(_fn: any): void {}
+
+  validate(): ValidationErrors | null {
+    this.updateErrorText();
+    return this.errorText ? { metricsFormArray: false } : null;
+  }
+
+  onDelete($event: Event, metric: CalculatedFieldAggMetricValue): void {
+    $event.stopPropagation();
+    const index = this.metricsFormArray.controls.findIndex(control => isEqual(control.value, metric));
+    this.metricsFormArray.removeAt(index);
+    this.metricsFormArray.markAsDirty();
+  }
+
+  manageMetrics($event: Event, matButton: MatButton, metric = {} as CalculatedFieldAggMetricValue): void {
+    $event?.stopPropagation();
+    if (this.popoverComponent && !this.popoverComponent.tbHidden) {
+      this.popoverComponent.hide();
+    }
+    const trigger = matButton._elementRef.nativeElement;
+    if (this.popoverService.hasPopover(trigger)) {
+      this.popoverService.hidePopover(trigger);
+    } else {
+      const index = this.metricsFormArray.controls.findIndex(control => isEqual(control.value, metric));
+      const isExists = index !== -1;
+      const ctx = {
+        index,
+        metric,
+        buttonTitle: isExists ? 'action.apply' : 'action.add',
+        usedNames: this.metricsFormArray.value.map(({ name }) => name).filter(name => name !== metric.name),
+        arguments: this.arguments,
+        editorCompleter: this.editorCompleter,
+        highlightRules: this.highlightRules
+      };
+      this.popoverComponent = this.popoverService.displayPopover({
+        trigger,
+        renderer: this.renderer,
+        componentType: CalculatedFieldMetricsPanelComponent,
+        hostView: this.viewContainerRef,
+        preferredPlacement: isExists ? ['leftOnly', 'leftTopOnly', 'leftBottomOnly'] : ['rightOnly', 'rightTopOnly', 'rightBottomOnly'],
+        context: ctx,
+        isModal: true
+      });
+      this.popoverComponent.tbComponentRef.instance.metricDataApplied.subscribe((value) => {
+        this.popoverComponent.hide();
+        if (isExists) {
+          this.metricsFormArray.at(index).setValue(value);
+        } else {
+          this.metricsFormArray.push(this.fb.control(value));
+        }
+        this.cd.markForCheck();
+      });
+    }
+  }
+
+  private updateDataSource(value: CalculatedFieldAggMetricValue[]): void {
+    const sortedValue = this.sortData(value);
+    this.dataSource.loadData(sortedValue);
+  }
+
+  private updateErrorText(): void {
+    if (!this.metricsFormArray.controls.length) {
+      this.errorText = 'calculated-fields.metrics.metrics-empty';
+    } else {
+      this.errorText = '';
+    }
+  }
+
+  private getMetricsObject(value: CalculatedFieldAggMetricValue[]): Record<string, CalculatedFieldAggMetric> {
+    return value.reduce((acc, metricValue) => {
+      const { name, ...metric } = metricValue;
+      acc[name] = metric;
+      return acc;
+    }, {} as Record<string, CalculatedFieldAggMetric>);
+  }
+
+  writeValue(metrics: Record<string, CalculatedFieldAggMetric>): void {
+    this.metricsFormArray.clear();
+    this.populateZonesFormArray(metrics);
+  }
+
+  private populateZonesFormArray(metrics: Record<string, CalculatedFieldAggMetric>): void {
+    Object.keys(metrics).forEach(key => {
+      const value: CalculatedFieldAggMetricValue = {
+        ...metrics[key],
+        name: key
+      };
+      this.metricsFormArray.push(this.fb.control(value), { emitEvent: false });
+    });
+    this.metricsFormArray.updateValueAndValidity();
+  }
+
+  private getSortValue(metric: CalculatedFieldAggMetricValue, column: string): string {
+    switch (column) {
+      case 'function':
+        return metric.function;
+      case 'valueSource':
+        return metric.input?.type;
+      case 'filter':
+        return isDefinedAndNotNull(metric.filter).toString();
+      default:
+        return metric.name;
+    }
+  }
+
+  private sortData(data: CalculatedFieldAggMetricValue[]): CalculatedFieldAggMetricValue[] {
+    return data.sort((a, b) => {
+      const valA = this.getSortValue(a, this.sortOrder.property) ?? '';
+      const valB = this.getSortValue(b, this.sortOrder.property) ?? '';
+      return (this.sortOrder.direction === 'asc' ? 1 : -1) * valA.localeCompare(valB);
+    });
+  }
+}
+
+class CalculatedFieldMetricsDatasource extends TbTableDatasource<CalculatedFieldAggMetricValue> {
+  constructor() {
+    super();
+  }
+}

ui-ngx/src/app/modules/home/components/calculated-fields/components/related-entities-aggregation-configuration/related-entities-aggregation-component.component.html

@@ -0,0 +1,80 @@
+<!--
+
+    Copyright © 2016-2025 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.
+
+-->
+<div [formGroup]="relatedAggregationConfiguration" class="tb-form-panel no-border no-padding">
+  <div class="tb-form-panel">
+    <div class="tb-form-panel-title" tbTruncateWithTooltip tb-hint-tooltip-icon="{{ 'calculated-fields.hint.aggregation-path-related-entities' | translate }}">
+      {{ 'calculated-fields.aggregation-path-related-entities' | translate }}
+    </div>
+    <div class="flex gap-3 xs:flex-col" formGroupName="relation">
+      <mat-form-field class="flex-1" appearance="outline" subscriptSizing="dynamic" hideRequiredMarker>
+        <mat-label>{{ 'calculated-fields.direction' | translate }}</mat-label>
+        <mat-select formControlName="direction">
+          @for (direction of Directions; track direction) {
+            <mat-option [value]="direction">{{ PropagationDirectionTranslations.get(direction) | translate }}</mat-option>
+          }
+        </mat-select>
+      </mat-form-field>
+      <tb-string-autocomplete [fetchOptionsFn]="fetchOptions.bind(this)"
+                              class="flex-1"
+                              panelWidth=""
+                              additionalClass=""
+                              required
+                              [label]="'calculated-fields.relation-type' | translate"
+                              [errorText]="'calculated-fields.hint.relation-type-required' | translate"
+                              formControlName="relationType">
+      </tb-string-autocomplete>
+    </div>
+  </div>
+  <div class="tb-form-panel">
+    <div class="tb-form-panel-title" tb-hint-tooltip-icon="{{ 'calculated-fields.hint.arguments-aggregation' | translate }}">
+      {{ 'calculated-fields.arguments' | translate }}
+    </div>
+    <tb-related-aggregation-arguments-table formControlName="arguments"
+                                            [entityId]="entityId"
+                                            [tenantId]="tenantId"
+                                            [entityName]="entityName"/>
+  </div>
+  <div class="tb-form-panel">
+    <div class="tb-form-panel-title" tb-hint-tooltip-icon="{{ 'calculated-fields.hint.metrics' | translate }}">
+      {{ 'calculated-fields.metrics.metrics' | translate }}
+    </div>
+    <tb-calculated-field-metrics-table formControlName="metrics"
+                                       [arguments]="arguments$ | async"
+                                       [highlightRules]="argumentsHighlightRules$ | async"
+                                       [editorCompleter]="argumentsEditorCompleter$ | async"
+    ></tb-calculated-field-metrics-table>
+    <tb-time-unit-input required
+                        appearance="outline"
+                        subscriptSizing="dynamic"
+                        labelText="{{ 'calculated-fields.deduplication-interval' | translate }}"
+                        requiredText="{{ 'calculated-fields.deduplication-interval-required' | translate }}"
+                        minErrorText="{{ 'calculated-fields.deduplication-interval-min' | translate: {sec: minAllowedDeduplicationIntervalInSecForCF} }}"
+                        [minTime]="minAllowedDeduplicationIntervalInSecForCF"
+                        formControlName="deduplicationIntervalInSec">
+    </tb-time-unit-input>
+  </div>
+  <tb-calculate-field-output formControlName="output" [entityId]="entityId" simpleMode hiddenName>
+    <div class="tb-form-row simpleMode flex-1">
+      <mat-slide-toggle class="mat-slide" formControlName="useLatestTs">
+        <div tb-hint-tooltip-icon="{{ 'calculated-fields.hint.use-latest-timestamp' | translate }}">
+          <div translate tbTruncateWithTooltip>calculated-fields.use-latest-timestamp</div>
+        </div>
+      </mat-slide-toggle>
+    </div>
+  </tb-calculate-field-output>
+</div>

ui-ngx/src/app/modules/home/components/calculated-fields/components/related-entities-aggregation-configuration/related-entities-aggregation-component.component.scss

@@ -0,0 +1,32 @@
+/**
+ * Copyright © 2016-2025 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.
+ */
+:host ::ng-deep {
+  .simpleMode {
+    min-width: 0;
+
+    .mat-slide {
+      overflow: hidden;
+
+      .mdc-form-field {
+        width: 100%;
+
+        .mdc-label {
+          min-width: 0;
+        }
+      }
+    }
+  }
+}

ui-ngx/src/app/modules/home/components/calculated-fields/components/related-entities-aggregation-configuration/related-entities-aggregation-component.component.ts

@@ -0,0 +1,156 @@
+///
+/// Copyright © 2016-2025 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.
+///
+
+import { Component, forwardRef, Input } from '@angular/core';
+import {
+  ControlValueAccessor,
+  FormBuilder,
+  NG_VALIDATORS,
+  NG_VALUE_ACCESSOR,
+  ValidationErrors,
+  Validator,
+  Validators
+} from '@angular/forms';
+import { EntityId } from '@shared/models/id/entity-id';
+import { Observable, of } from 'rxjs';
+import {
+  CalculatedFieldOutput,
+  CalculatedFieldRelatedAggregationConfiguration,
+  CalculatedFieldType,
+  getCalculatedFieldArgumentsEditorCompleter,
+  getCalculatedFieldArgumentsHighlights,
+  OutputType,
+  PropagationDirectionTranslations
+} from '@shared/models/calculated-field.models';
+import { AttributeScope } from '@shared/models/telemetry/telemetry.models';
+import { map } from 'rxjs/operators';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ScriptLanguage } from '@app/shared/models/rule-node.models';
+import { EntitySearchDirection } from '@shared/models/relation.models';
+import { getCurrentAuthState } from '@core/auth/auth.selectors';
+import { Store } from '@ngrx/store';
+import { AppState } from '@core/core.state';
+
+@Component({
+  selector: 'tb-related-entities-aggregation-component',
+  templateUrl: './related-entities-aggregation-component.component.html',
+  styleUrl: './related-entities-aggregation-component.component.scss',
+  providers: [
+    {
+      provide: NG_VALUE_ACCESSOR,
+      useExisting: forwardRef(() => RelatedEntitiesAggregationComponentComponent),
+      multi: true
+    },
+    {
+      provide: NG_VALIDATORS,
+      useExisting: forwardRef(() => RelatedEntitiesAggregationComponentComponent),
+      multi: true
+    }
+  ],
+})
+export class RelatedEntitiesAggregationComponentComponent implements ControlValueAccessor, Validator {
+
+  @Input({required: true})
+  entityId: EntityId;
+
+  @Input({required: true})
+  tenantId: string;
+
+  @Input({required: true})
+  entityName: string;
+
+  relatedAggregationConfiguration = this.fb.group({
+    relation: this.fb.group({
+      direction: [EntitySearchDirection.FROM, Validators.required],
+      relationType: ['Contains', Validators.required],
+    }),
+    arguments: this.fb.control({}),
+    metrics: this.fb.control({}),
+    deduplicationIntervalInSec: [],
+    output: this.fb.control<CalculatedFieldOutput>({
+      scope: AttributeScope.SERVER_SCOPE,
+      type: OutputType.Timeseries,
+    }),
+    useLatestTs: [false]
+  });
+
+  readonly ScriptLanguage = ScriptLanguage;
+  readonly CalculatedFieldType = CalculatedFieldType;
+  readonly OutputType = OutputType;
+  readonly Directions = Object.values(EntitySearchDirection) as Array<EntitySearchDirection>;
+  readonly PropagationDirectionTranslations = PropagationDirectionTranslations;
+  readonly minAllowedDeduplicationIntervalInSecForCF = getCurrentAuthState(this.store).minAllowedDeduplicationIntervalInSecForCF;
+
+
+  arguments$ = this.relatedAggregationConfiguration.get('arguments').valueChanges.pipe(
+    map(argumentsObj => Object.keys(argumentsObj))
+  );
+
+  argumentsEditorCompleter$ = this.relatedAggregationConfiguration.get('arguments').valueChanges.pipe(
+    map(argumentsObj => getCalculatedFieldArgumentsEditorCompleter(argumentsObj ?? {}))
+  );
+
+  argumentsHighlightRules$ = this.relatedAggregationConfiguration.get('arguments').valueChanges.pipe(
+    map(argumentsObj => getCalculatedFieldArgumentsHighlights(argumentsObj))
+  );
+
+  private propagateChange: (config: CalculatedFieldRelatedAggregationConfiguration) => void = () => { };
+
+  constructor(private fb: FormBuilder,
+              private store: Store<AppState>) {
+
+    this.relatedAggregationConfiguration.valueChanges.pipe(
+      takeUntilDestroyed()
+    ).subscribe((value: CalculatedFieldRelatedAggregationConfiguration) => {
+      this.updatedModel(value);
+    })
+  }
+
+  validate(): ValidationErrors | null {
+    return this.relatedAggregationConfiguration.valid || this.relatedAggregationConfiguration.status === "DISABLED" ? null : {invalidPropagateConfig: false};
+  }
+
+  writeValue(value: CalculatedFieldRelatedAggregationConfiguration): void {
+    this.relatedAggregationConfiguration.patchValue(value, {emitEvent: false});
+    setTimeout(() => {
+      this.relatedAggregationConfiguration.get('arguments').updateValueAndValidity({onlySelf: true});
+    });
+  }
+
+  registerOnChange(fn: (config: CalculatedFieldRelatedAggregationConfiguration) => void): void {
+    this.propagateChange = fn;
+  }
+
+  registerOnTouched(_: any): void { }
+
+  setDisabledState(isDisabled: boolean): void {
+    if (isDisabled) {
+      this.relatedAggregationConfiguration.disable({emitEvent: false});
+    } else {
+      this.relatedAggregationConfiguration.enable({emitEvent: false});
+    }
+  }
+
+  fetchOptions(searchText: string): Observable<Array<string>> {
+    const search = searchText ? searchText?.toLowerCase() : '';
+    return of(['Contains', 'Manages']).pipe(map(name => name?.filter(option => option.toLowerCase().includes(search))));
+  }
+
+  private updatedModel(value: CalculatedFieldRelatedAggregationConfiguration): void {
+    value.type = CalculatedFieldType.RELATED_ENTITIES_AGGREGATION;
+    this.propagateChange(value);
+  }
+}

ui-ngx/src/app/modules/home/components/calculated-fields/components/related-entities-aggregation-configuration/related-entities-aggregation-component.module.ts

@@ -0,0 +1,53 @@
+///
+/// Copyright © 2016-2025 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.
+///
+
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SharedModule } from '@shared/shared.module';
+import {
+  CalculatedFieldOutputModule
+} from '@home/components/calculated-fields/components/output/calculated-field-output.module';
+import {
+  CalculatedFieldArgumentsTableModule
+} from '@home/components/calculated-fields/components/calculated-field-arguments/calculated-field-arguments-table.module';
+import {
+  RelatedEntitiesAggregationComponentComponent
+} from '@home/components/calculated-fields/components/related-entities-aggregation-configuration/related-entities-aggregation-component.component';
+import {
+  CalculatedFieldMetricsTableComponent
+} from '@home/components/calculated-fields/components/related-entities-aggregation-configuration/calculated-field-metrics-table.component';
+import {
+  CalculatedFieldMetricsPanelComponent
+} from '@home/components/calculated-fields/components/related-entities-aggregation-configuration/calculated-field-metrics-panel.component';
+
+@NgModule({
+  imports: [
+    CommonModule,
+    SharedModule,
+    CalculatedFieldOutputModule,
+    CalculatedFieldArgumentsTableModule,
+  ],
+  declarations: [
+    RelatedEntitiesAggregationComponentComponent,
+    CalculatedFieldMetricsTableComponent,
+    CalculatedFieldMetricsPanelComponent
+  ],
+  exports: [
+    RelatedEntitiesAggregationComponentComponent,
+  ]
+})
+export class RelatedEntitiesAggregationComponentModule {
+}

ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.html

@@ -354,7 +354,19 @@
             </mat-error>
             <mat-hint translate>tenant-profile.relation-search-entity-limit-hint</mat-hint>
           </mat-form-field>
-          <div class="flex-1"></div>
+          <mat-form-field class="mat-block flex-1" appearance="fill" subscriptSizing="dynamic">
+            <mat-label translate>tenant-profile.min-allowed-deduplication-interval</mat-label>
+            <input matInput required min="0" step="1"
+                   formControlName="minAllowedDeduplicationIntervalInSecForCF"
+                   type="number">
+            <mat-error *ngIf="tenantProfileConfigurationForm.get('minAllowedDeduplicationIntervalInSecForCF').hasError('required')">
+              {{ 'tenant-profile.min-allowed-deduplication-interval-required' | translate}}
+            </mat-error>
+            <mat-error *ngIf="tenantProfileConfigurationForm.get('minAllowedDeduplicationIntervalInSecForCF').hasError('min')">
+              {{ 'tenant-profile.min-allowed-deduplication-interval-range' | translate}}
+            </mat-error>
+            <mat-hint></mat-hint>
+          </mat-form-field>
         </div>
       </ng-template>
     </mat-expansion-panel>

ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.ts

@@ -116,6 +116,7 @@ export class DefaultTenantProfileConfigurationComponent implements ControlValueA
       maxCalculatedFieldsPerEntity: [0, [Validators.required, Validators.min(0)]],
       maxArgumentsPerCF: [0, [Validators.required, Validators.min(0)]],
       maxRelationLevelPerCfArgument: [1, [Validators.required, Validators.min(1)]],
+      minAllowedDeduplicationIntervalInSecForCF: [0, [Validators.required, Validators.min(0)]],
       maxRelatedEntitiesToReturnPerCfArgument: [1, [Validators.required, Validators.min(1)]],
       minAllowedScheduledUpdateIntervalInSecForCF: [0, [Validators.required, Validators.min(0)]],
       maxDataPointsPerRollingArg: [0, [Validators.required, Validators.min(0)]],

ui-ngx/src/app/shared/components/time-unit-input.component.html

@@ -18,7 +18,7 @@
 <section [formGroup]="timeInputForm" class="flex gap-4">
   <mat-form-field [class]="{'number': inlineField, 'max-w-66%': !inlineField, 'flex-full': !inlineField}"
                   [appearance]="inlineField ? 'outline' : appearance"
-                  [subscriptSizing]="inlineField ? 'dynamic' : subscriptSizing">
+                  subscriptSizing="dynamic">
     @if (labelText && !inlineField) {
       <mat-label>{{ labelText }}</mat-label>
     }
@@ -41,7 +41,9 @@
       {{ hasError }}
     </mat-error>
   </mat-form-field>
-  <mat-form-field [class.h-fit.max-w-33%.flex-full]="!inlineField"
+  <mat-form-field [class.h-fit]="!inlineField"
+                  [class.max-w-33%]="!inlineField"
+                  [class.flex-full]="!inlineField"
                   [appearance]="inlineField ? 'outline' : appearance"
                   [subscriptSizing]="inlineField ? 'dynamic' : subscriptSizing">
     @if (!inlineField) {

ui-ngx/src/app/shared/models/calculated-field.models.ts

@@ -65,7 +65,8 @@ export enum CalculatedFieldType {
   SIMPLE = 'SIMPLE',
   SCRIPT = 'SCRIPT',
   GEOFENCING = 'GEOFENCING',
-  PROPAGATION = 'PROPAGATION'
+  PROPAGATION = 'PROPAGATION',
+  RELATED_ENTITIES_AGGREGATION = 'RELATED_ENTITIES_AGGREGATION'
 }
 
 export const CalculatedFieldTypeTranslations = new Map<CalculatedFieldType, string>(
@@ -74,6 +75,7 @@ export const CalculatedFieldTypeTranslations = new Map<CalculatedFieldType, stri
     [CalculatedFieldType.SCRIPT, 'calculated-fields.type.script'],
     [CalculatedFieldType.GEOFENCING, 'calculated-fields.type.geofencing'],
     [CalculatedFieldType.PROPAGATION, 'calculated-fields.type.propagation'],
+    [CalculatedFieldType.RELATED_ENTITIES_AGGREGATION, 'calculated-fields.type.related-entities-aggregation'],
   ]
 )
 
@@ -81,12 +83,14 @@ export type CalculatedFieldConfiguration =
   | CalculatedFieldSimpleConfiguration
   | CalculatedFieldScriptConfiguration
   | CalculatedFieldGeofencingConfiguration
-  | CalculatedFieldPropagationConfiguration;
+  | CalculatedFieldPropagationConfiguration
+  | CalculatedFieldRelatedAggregationConfiguration;
 
 export interface CalculatedFieldSimpleConfiguration {
   type: CalculatedFieldType.SIMPLE;
   expression: string;
   arguments: Record<string, CalculatedFieldArgument>;
+  useLatestTs: boolean;
   output: CalculatedFieldSimpleOutput;
 }
 
@@ -105,10 +109,19 @@ export interface CalculatedFieldGeofencingConfiguration {
   output: CalculatedFieldOutput;
 }
 
+export interface CalculatedFieldRelatedAggregationConfiguration {
+  type: CalculatedFieldType.RELATED_ENTITIES_AGGREGATION;
+  relation: RelationPathLevel;
+  arguments: Record<string, CalculatedFieldArgument>;
+  metrics: Record<string, CalculatedFieldAggMetric>;
+  deduplicationIntervalInSec: number;
+  useLatestTs: boolean;
+  output: Omit<CalculatedFieldSimpleOutput, 'name'>;
+}
+
 interface BasePropagationConfiguration {
   type: CalculatedFieldType.PROPAGATION;
-  direction: EntitySearchDirection;
-  relationType: string;
+  relation: RelationPathLevel;
   arguments: Record<string, CalculatedFieldArgument>;
   output: CalculatedFieldOutput;
 }
@@ -238,6 +251,54 @@ export interface CalculatedFieldArgument {
   timeWindow?: number;
 }
 
+export enum AggFunction {
+  AVG='AVG',
+  MIN='MIN',
+  MAX='MAX',
+  SUM='SUM',
+  COUNT='COUNT',
+  COUNT_UNIQUE='COUNT_UNIQUE'
+}
+
+export const AggFunctionTranslations = new Map<AggFunction, string>([
+  [AggFunction.AVG, 'calculated-fields.metrics.aggregation-type.avg'],
+  [AggFunction.MIN, 'calculated-fields.metrics.aggregation-type.min'],
+  [AggFunction.MAX, 'calculated-fields.metrics.aggregation-type.max'],
+  [AggFunction.SUM, 'calculated-fields.metrics.aggregation-type.sum'],
+  [AggFunction.COUNT, 'calculated-fields.metrics.aggregation-type.count'],
+  [AggFunction.COUNT_UNIQUE, 'calculated-fields.metrics.aggregation-type.count-unique'],
+])
+
+export interface CalculatedFieldAggMetric {
+  function: AggFunction;
+  filter?: string;
+  input: AggKeyInput | AggFunctionInput;
+}
+
+export interface CalculatedFieldAggMetricValue extends CalculatedFieldAggMetric {
+  name: string;
+}
+
+export enum AggInputType {
+  key = 'key',
+  function = 'function'
+}
+
+export const AggInputTypeTranslations = new Map<AggInputType, string>([
+  [AggInputType.key, 'calculated-fields.metrics.value-source-type.key'],
+  [AggInputType.function, 'calculated-fields.metrics.value-source-type.function'],
+])
+
+export interface AggKeyInput {
+  type: AggInputType.key;
+  key: string;
+}
+
+export interface AggFunctionInput {
+  type: AggInputType.function;
+  function: string;
+}
+
 export interface CalculatedFieldGeofencing {
   perimeterKeyName: string;
   reportStrategy: GeofencingReportStrategy;
@@ -250,7 +311,7 @@ export interface CalculatedFieldGeofencing {
 
 export interface RefDynamicSourceConfiguration {
   type?: ArgumentEntityType.RelationQuery;
-  levels?: Array<{direction: EntitySearchDirection; relationType: string;}>;
+  levels?: Array<RelationPathLevel>;
 }
 
 export interface CalculatedFieldGeofencingValue extends CalculatedFieldGeofencing {
@@ -317,6 +378,11 @@ export interface CalculatedFieldArgumentValueBase {
   type: ArgumentType;
 }
 
+export interface RelationPathLevel {
+  direction: EntitySearchDirection;
+  relationType: string;
+}
+
 export interface CalculatedFieldAttributeArgumentValue<ValueType = unknown> extends CalculatedFieldArgumentValueBase {
   ts: number;
   value: ValueType;

ui-ngx/src/app/shared/models/tenant.model.ts

@@ -107,6 +107,7 @@ export interface DefaultTenantProfileConfiguration {
   maxCalculatedFieldsPerEntity: number;
   maxArgumentsPerCF: number;
   maxRelationLevelPerCfArgument: number;
+  minAllowedDeduplicationIntervalInSecForCF: number;
   maxRelatedEntitiesToReturnPerCfArgument: number;
   minAllowedScheduledUpdateIntervalInSecForCF: number;
   maxDataPointsPerRollingArg: number;
@@ -174,6 +175,7 @@ export function createTenantProfileConfiguration(type: TenantProfileType): Tenan
           maxArgumentsPerCF: 10,
           maxDataPointsPerRollingArg: 1000,
           maxRelationLevelPerCfArgument: 10,
+          minAllowedDeduplicationIntervalInSecForCF: 3600,
           maxRelatedEntitiesToReturnPerCfArgument: 100,
           minAllowedScheduledUpdateIntervalInSecForCF: 0,
           maxStateSizeInKBytes: 32,

ui-ngx/src/assets/help/en_US/calculated-field/filter_expression_fn.md

@@ -0,0 +1,10 @@
+## Calculated Field TBEL Filter Function
+
+The **filter()** function is a user-defined script that enables custom calculations using [TBEL](${siteBaseUrl}/docs${docPlatformPrefix}/user-guide/tbel/) on telemetry and attribute data.
+It receives arguments configured in the calculated field setup, along with an additional `ctx` object that stores `latestTs` and provides access to all arguments.
+
+### Function Signature
+
+```javascript
+function calculate(ctx, arg1, arg2, ...): boolean
+```

ui-ngx/src/assets/locale/locale.constant-en_US.json

@@ -1056,7 +1056,8 @@
             "simple": "Simple",
             "script": "Script",
             "geofencing" : "Geofencing",
-            "propagation": "Propagation"
+            "propagation": "Propagation",
+            "related-entities-aggregation": "Related entities aggregation"
         },
         "arguments": "Arguments",
         "decimals-by-default": "Decimals by default",
@@ -1090,6 +1091,7 @@
         "shared-attributes": "Shared attributes",
         "attribute-key": "Attribute key",
         "default-value": "Default value",
+        "default-value-required": "Default value is required.",
         "limit": "Max values",
         "time-window": "Time window",
         "customer-name": "Customer name",
@@ -1158,6 +1160,37 @@
         "data-propagate": "Data to propagate",
         "output-key": "Output key",
         "copy-output-key": "Copy output key",
+        "aggregation-path-related-entities": "Aggregation path to related entities",
+        "deduplication-interval": "Deduplication interval",
+        "deduplication-interval-min": "Deduplication interval should be at least {{ sec }} second.",
+        "deduplication-interval-required": "Deduplication interval is required.",
+        "metrics": {
+            "metrics": "Metrics",
+            "metrics-empty": "At least one metric must be configured.",
+            "metric-name": "Metric name",
+            "copy-metric-name": "Copy metric name",
+            "aggregation": "Aggregation",
+            "aggregation-type": {
+                "avg": "Average",
+                "min": "Minimum",
+                "max": "Maximum",
+                "sum": "Sum",
+                "count": "Count",
+                "count-unique": "Count unique"
+            },
+            "filtered": "Filtered",
+            "value-source": "Value source",
+            "value-source-type": {
+                "key": "Key",
+                "function": "Function"
+            },
+            "no-metrics-configured": "No metrics configured",
+            "add-metric": "Add metric",
+            "max-metrics": "Maximum number of metrics reached.",
+            "metric-settings": "Metric settings",
+            "filter": "Filter",
+            "filter-hint": "Enables filtering of entities during aggregation. The filter function must return a boolean value and can use all configured arguments."
+        },
         "hint": {
             "arguments-simple-with-rolling": "Simple type calculated field should not contain keys with time series rolling type.",
             "arguments-propagate-arguments-with-rolling": "'Time series rolling' type is incompatible with 'Arguments only' propagation.",
@@ -1177,7 +1210,7 @@
             "output-key-max-length": "Output key should be less than 256 characters.",
             "output-key-forbidden": "Output key is reserved and cannot be used.",
             "entity-type-required": "Entity type is required",
-            "name-required": "Mame is required.",
+            "name-required": "Name is required.",
             "name-pattern": "Name is invalid.",
             "name-duplicate": "Name with such name already exists.",
             "name-max-length": "Name should be less than 256 characters.",
@@ -1204,7 +1237,11 @@
             "zone-group-refresh-interval-required": "Zone groups refresh interval is required.",
             "zone-group-refresh-interval-min": "Zone group refresh interval should be at least {{ min }} second.",
             "propagation-path-related-entities": "Defines a direct, single-level path to a related entity based on the selected direction and relation type.",
-            "data-propagate": "Defines the data to be propagated from the arguments configured below. 'Arguments only' uses the retrieved data directly, while 'Expression result' calculates a new value from that data."
+            "data-propagate": "Defines the data to be propagated from the arguments configured below. 'Arguments only' uses the retrieved data directly, while 'Expression result' calculates a new value from that data.",
+            "aggregation-path-related-entities": "Defines a single-level aggregation path via direct relations with parent or child entities based on direction and relation type. Only relations between device, asset, customer, and tenant entities are supported.",
+            "arguments-aggregation": "Defines input parameters used for filtering and aggregation.",
+            "setting-arguments-aggregation": "Data will be fetched from related entities configured in aggregation path.",
+            "metrics": "Defines metrics aggregated based on the configured arguments."
         }
     },
     "ai-models": {
@@ -5924,6 +5961,9 @@
         "max-related-level-per-argument-required": "Relation level per 'Related entities' argument max number is required",
         "min-allowed-scheduled-update-interval": "Min allowed update interval for 'Related entities' arguments (seconds)",
         "min-allowed-scheduled-update-interval-range": "Min allowed update interval min number can't be negative",
+        "min-allowed-deduplication-interval": "Min allowed deduplication interval (seconds)",
+        "min-allowed-deduplication-interval-range": "Min allowed deduplication interval value can't be negative",
+        "min-allowed-deduplication-interval-required": "Min allowed deduplication interval is required",
         "min-allowed-scheduled-update-interval-required": "Min allowed update interval min number is required",
         "max-state-size": "State maximum size in KB",
         "max-state-size-range": "State maximum size in KB can't be negative",