Create Alarm Rule Node - option to owerride alarm details for alarm from message.

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

@@ -23,6 +23,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.EnumUtils;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.rule.engine.api.RuleNode;
 import org.thingsboard.rule.engine.api.TbContext;
 import org.thingsboard.rule.engine.api.TbNodeConfiguration;
@@ -122,40 +123,66 @@ public class TbCreateAlarmNode extends TbAbstractAlarmNode<TbCreateAlarmNodeConf
     }
 
     private ListenableFuture<TbAlarmResult> createNewAlarm(TbContext ctx, TbMsg msg, Alarm msgAlarm) {
-        ListenableFuture<Alarm> asyncAlarm;
+        ListenableFuture<JsonNode> asyncDetails;
-        if (msgAlarm != null) {
+        boolean buildDetails = !config.isUseMessageAlarmData() || config.isOverwriteAlarmDetails();
-            asyncAlarm = Futures.immediateFuture(msgAlarm);
+        if (buildDetails) {
-        } else {
             ctx.logJsEvalRequest();
-            asyncAlarm = Futures.transform(buildAlarmDetails(ctx, msg, null),
+            asyncDetails = buildAlarmDetails(ctx, msg, null);
-                    details -> {
+        } else {
-                        ctx.logJsEvalResponse();
+            asyncDetails = Futures.immediateFuture(null);
-                        return buildAlarm(msg, details, ctx.getTenantId());
-                    }, MoreExecutors.directExecutor());
         }
+        ListenableFuture<Alarm> asyncAlarm =  Futures.transform(asyncDetails, details -> {
+            if (buildDetails) {
+                ctx.logJsEvalResponse();
+            }
+            Alarm newAlarm;
+            if (msgAlarm != null) {
+                newAlarm = msgAlarm;
+                if (buildDetails) {
+                    newAlarm.setDetails(details);
+                }
+            } else {
+                newAlarm = buildAlarm(msg, details, ctx.getTenantId());
+            }
+            return newAlarm;
+        }, MoreExecutors.directExecutor());
         ListenableFuture<Alarm> asyncCreated = Futures.transform(asyncAlarm,
                 alarm -> ctx.getAlarmService().createOrUpdateAlarm(alarm), ctx.getDbCallbackExecutor());
         return Futures.transform(asyncCreated, alarm -> new TbAlarmResult(true, false, false, alarm), MoreExecutors.directExecutor());
     }
 
     private ListenableFuture<TbAlarmResult> updateAlarm(TbContext ctx, TbMsg msg, Alarm existingAlarm, Alarm msgAlarm) {
-        ctx.logJsEvalRequest();
+        ListenableFuture<JsonNode> asyncDetails;
-        ListenableFuture<Alarm> asyncUpdated = Futures.transform(buildAlarmDetails(ctx, msg, existingAlarm.getDetails()), (Function<JsonNode, Alarm>) details -> {
+        boolean buildDetails = !config.isUseMessageAlarmData() || config.isOverwriteAlarmDetails();
-            ctx.logJsEvalResponse();
+        if (buildDetails) {
+            ctx.logJsEvalRequest();
+            asyncDetails = buildAlarmDetails(ctx, msg, existingAlarm.getDetails());
+        } else {
+            asyncDetails = Futures.immediateFuture(null);
+        }
+        ListenableFuture<Alarm> asyncUpdated = Futures.transform(asyncDetails, (Function<JsonNode, Alarm>) details -> {
+            if (buildDetails) {
+                ctx.logJsEvalResponse();
+            }
             if (msgAlarm != null) {
                 existingAlarm.setSeverity(msgAlarm.getSeverity());
                 existingAlarm.setPropagate(msgAlarm.isPropagate());
                 existingAlarm.setPropagateToOwner(msgAlarm.isPropagateToOwner());
                 existingAlarm.setPropagateToTenant(msgAlarm.isPropagateToTenant());
                 existingAlarm.setPropagateRelationTypes(msgAlarm.getPropagateRelationTypes());
+                if (buildDetails) {
+                    existingAlarm.setDetails(details);
+                } else {
+                    existingAlarm.setDetails(msgAlarm.getDetails());
+                }
             } else {
                 existingAlarm.setSeverity(processAlarmSeverity(msg));
                 existingAlarm.setPropagate(config.isPropagate());
                 existingAlarm.setPropagateToOwner(config.isPropagateToOwner());
                 existingAlarm.setPropagateToTenant(config.isPropagateToTenant());
                 existingAlarm.setPropagateRelationTypes(relationTypes);
+                existingAlarm.setDetails(details);
             }
-            existingAlarm.setDetails(details);
             existingAlarm.setEndTs(System.currentTimeMillis());
             return ctx.getAlarmService().createOrUpdateAlarm(existingAlarm);
         }, ctx.getDbCallbackExecutor());

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

@@ -30,6 +30,7 @@ public class TbCreateAlarmNodeConfiguration extends TbAbstractAlarmNodeConfigura
     private boolean propagateToOwner;
     private boolean propagateToTenant;
     private boolean useMessageAlarmData;
+    private boolean overwriteAlarmDetails = true;
     private boolean dynamicSeverity;
 
     private List<String> relationTypes;
@@ -44,8 +45,10 @@ public class TbCreateAlarmNodeConfiguration extends TbAbstractAlarmNodeConfigura
         configuration.setPropagateToOwner(false);
         configuration.setPropagateToTenant(false);
         configuration.setUseMessageAlarmData(false);
+        configuration.setOverwriteAlarmDetails(false);
         configuration.setRelationTypes(Collections.emptyList());
         configuration.setDynamicSeverity(false);
         return configuration;
     }
+
 }