Refactoring for updating alarm rule arguments

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

@@ -87,16 +87,15 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
 
             if (existingEntry == null || newEntry.isForceResetPrevious()) {
                 validateNewEntry(key, newEntry);
-                if (existingEntry instanceof RelatedEntitiesArgumentEntry relatedEntitiesArgumentEntry) {
-                    relatedEntitiesArgumentEntry.updateEntry(newEntry);
-                } else if (existingEntry instanceof EntityAggregationArgumentEntry entityAggArgumentEntry) {
-                    entityAggArgumentEntry.updateEntry(newEntry);
+                if (existingEntry instanceof RelatedEntitiesArgumentEntry ||
+                    existingEntry instanceof EntityAggregationArgumentEntry) {
+                    updateEntry(existingEntry, newEntry);
                 } else {
                     arguments.put(key, newEntry);
                 }
                 entryUpdated = true;
             } else {
-                entryUpdated = existingEntry.updateEntry(newEntry);
+                entryUpdated = updateEntry(existingEntry, newEntry);
             }
 
             if (entryUpdated) {
@@ -116,6 +115,10 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
         return updatedArguments;
     }
 
+    protected boolean updateEntry(ArgumentEntry existingEntry, ArgumentEntry newEntry) {
+        return existingEntry.updateEntry(newEntry);
+    }
+
     @Override
     public void reset() { // must reset everything dependent on arguments
         requiredArguments = null;

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

@@ -162,9 +162,7 @@ public class SingleValueArgumentEntry implements ArgumentEntry {
     public boolean updateEntry(ArgumentEntry entry) {
         if (entry instanceof SingleValueArgumentEntry singleValueEntry) {
             if (singleValueEntry.getTs() < this.ts) {
-                if (!isDefaultValue()) {
-                    return false;
-                }
+                return false;
             }
 
             Long newVersion = singleValueEntry.getVersion();

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

@@ -225,6 +225,20 @@ public class AlarmCalculatedFieldState extends BaseCalculatedFieldState {
                 .build());
     }
 
+    @Override
+    protected boolean updateEntry(ArgumentEntry existingArgumentEntry, ArgumentEntry newArgumentEntry) {
+        if (!(existingArgumentEntry instanceof SingleValueArgumentEntry existingEntry) ||
+            !(newArgumentEntry instanceof SingleValueArgumentEntry newEntry)) {
+            return super.updateEntry(existingArgumentEntry, newArgumentEntry);
+        }
+        if (newEntry.getTs() < existingEntry.getTs()) {
+            if (existingEntry.isDefaultValue()) {
+                existingEntry.setTs(newEntry.getTs());
+            }
+        }
+        return super.updateEntry(existingEntry, newEntry);
+    }
+
     public void processAlarmAction(Alarm alarm, ActionType action) {
         switch (action) {
             case ALARM_ACK -> processAlarmAck(alarm);

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

@@ -157,7 +157,7 @@ public class AlarmRuleState {
     private AlarmEvalResult evalDuration(CalculatedFieldCtx ctx) {
         if (eval(condition.getExpression(), ctx)) {
             long ts = System.currentTimeMillis();
-            if (firstEventTs == 0) {
+            if (firstEventTs <= 0) {
                 firstEventTs = state.getLatestTimestamp();
             }
             lastCheckTs = ts;

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

@@ -194,6 +194,30 @@ public class AlarmRulesTest extends AbstractControllerTest {
         });
     }
 
+    @Test
+    public void testCreateAlarm_eventBeforeDefaultTs() throws Exception {
+        Argument temperatureArgument = new Argument();
+        temperatureArgument.setRefEntityKey(new ReferencedEntityKey("temperature", ArgumentType.TS_LATEST, null));
+        temperatureArgument.setDefaultValue("0");
+        Map<String, Argument> arguments = Map.of(
+                "temperature", temperatureArgument
+        );
+
+        Map<AlarmSeverity, Condition> createRules = Map.of(
+                AlarmSeverity.CRITICAL, new Condition("return temperature >= 50;", null, null)
+        );
+
+        CalculatedField calculatedField = createAlarmCf(deviceId, "High Temperature Alarm",
+                arguments, createRules, null);
+
+        postTelemetry(deviceId, "{\"values\": {\"temperature\": 50}, \"ts\": " + (System.currentTimeMillis() - TimeUnit.DAYS.toMillis(30) + "}"));
+        checkAlarmResult(calculatedField, alarmResult -> {
+            assertThat(alarmResult.isCreated()).isTrue();
+            assertThat(alarmResult.getAlarm().getSeverity()).isEqualTo(AlarmSeverity.CRITICAL);
+            assertThat(alarmResult.getAlarm().getStatus()).isEqualTo(AlarmStatus.ACTIVE_UNACK);
+        });
+    }
+
     @Test
     public void testCreateAlarm_repeatingCondition() throws Exception {
         Argument temperatureArgument = new Argument();
@@ -350,6 +374,32 @@ public class AlarmRulesTest extends AbstractControllerTest {
         });
     }
 
+    @Test
+    public void testCreateAlarm_durationCondition_defaultValue() {
+        Argument powerConsumptionArgument = new Argument();
+        powerConsumptionArgument.setRefEntityKey(new ReferencedEntityKey("powerConsumption", ArgumentType.TS_LATEST, null));
+        powerConsumptionArgument.setDefaultValue("3500");
+        Map<String, Argument> arguments = Map.of(
+                "powerConsumption", powerConsumptionArgument
+        );
+
+        long createDurationMs = 2000L;
+        Map<AlarmSeverity, Condition> createRules = Map.of(
+                AlarmSeverity.CRITICAL, new Condition("return powerConsumption >= 3000;", null, null,
+                        new AlarmConditionValue<Long>(2000L, null), null)
+        );
+
+        CalculatedField calculatedField = createAlarmCf(deviceId, "High power consumption during 2 seconds",
+                arguments, createRules, null);
+
+        checkAlarmResult(calculatedField, alarmResult -> {
+            assertThat(alarmResult.isCreated()).isTrue();
+            assertThat(alarmResult.getAlarm().getSeverity()).isEqualTo(AlarmSeverity.CRITICAL);
+            assertThat(alarmResult.getAlarm().getStatus()).isEqualTo(AlarmStatus.ACTIVE_UNACK);
+            assertThat(alarmResult.getConditionDuration()).isBetween(createDurationMs, createDurationMs + 2000);
+        });
+    }
+
     @Test
     public void testCreateAlarm_currentOwnerArgument() throws Exception {
         Argument temperatureArgument = new Argument();