refactoring & added alarmCanBeClearedWithAlarmOriginator test

@@ -57,38 +57,15 @@ public class TbClearAlarmNode extends TbAbstractAlarmNode<TbClearAlarmNodeConfig
     @Override
     protected ListenableFuture<AlarmResult> processAlarm(TbContext ctx, TbMsg msg) {
         String alarmType = TbNodeUtils.processPattern(this.config.getAlarmType(), msg.getMetaData());
+        ListenableFuture<Alarm> alarmFuture;
         if (msg.getOriginator().getEntityType().equals(EntityType.ALARM)) {
-            return clearAlarmByAlarmOriginator(ctx, msg);
+            alarmFuture = ctx.getAlarmService().findAlarmByIdAsync(ctx.getTenantId(), new AlarmId(msg.getOriginator().getId()));
         } else {
-            ListenableFuture<Alarm> latest = ctx.getAlarmService().findLatestByOriginatorAndType(ctx.getTenantId(), msg.getOriginator(), alarmType);
-            return Futures.transformAsync(latest, a -> {
-                if (a != null && !a.getStatus().isCleared()) {
-                    return clearAlarm(ctx, msg, a);
-                }
-                return Futures.immediateFuture(new AlarmResult(false, false, false, null));
-            }, ctx.getDbCallbackExecutor());
+            alarmFuture = ctx.getAlarmService().findLatestByOriginatorAndType(ctx.getTenantId(), msg.getOriginator(), alarmType);
         }
-    }
-
-    private ListenableFuture<AlarmResult> clearAlarmByAlarmOriginator(TbContext ctx, TbMsg msg) {
-        ListenableFuture<Alarm> alarmByIdAsync = ctx.getAlarmService().findAlarmByIdAsync(ctx.getTenantId(), new AlarmId(msg.getOriginator().getId()));
-        return Futures.transformAsync(alarmByIdAsync, alarm -> {
-            if (alarm != null && !alarm.getStatus().isCleared()) {
-                ctx.logJsEvalRequest();
-                ListenableFuture<JsonNode> asyncDetails = buildAlarmDetails(ctx, msg, alarm.getDetails());
-                return Futures.transformAsync(asyncDetails, details -> {
-                    ctx.logJsEvalRequest();
-                    long clearTs = System.currentTimeMillis();
-                    ListenableFuture<Boolean> clearAlarmFuture = ctx.getAlarmService().clearAlarm(ctx.getTenantId(), alarm.getId(), details, clearTs);
-                    return Futures.transformAsync(clearAlarmFuture, cleared -> {
-                        if (cleared) {
-                            alarm.setClearTs(clearTs);
-                            alarm.setDetails(details);
-                        }
-                        alarm.setStatus(alarm.getStatus().isAck() ? AlarmStatus.CLEARED_ACK : AlarmStatus.CLEARED_UNACK);
-                        return Futures.immediateFuture(new AlarmResult(false, false, true, alarm));
-                    }, ctx.getDbCallbackExecutor());
-                }, ctx.getDbCallbackExecutor());
+        return Futures.transformAsync(alarmFuture, a -> {
+            if (a != null && !a.getStatus().isCleared()) {
+                return clearAlarm(ctx, msg, a);
             }
             return Futures.immediateFuture(new AlarmResult(false, false, false, null));
         }, ctx.getDbCallbackExecutor());

@@ -35,6 +35,7 @@ import org.thingsboard.rule.engine.api.TbContext;
 import org.thingsboard.rule.engine.api.TbNodeConfiguration;
 import org.thingsboard.rule.engine.api.TbNodeException;
 import org.thingsboard.server.common.data.alarm.Alarm;
+import org.thingsboard.server.common.data.id.AlarmId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.RuleChainId;
@@ -95,6 +96,7 @@ public class TbAlarmNodeTest {
     private ListeningExecutor dbExecutor;
 
     private EntityId originator = new DeviceId(UUIDs.timeBased());
+    private EntityId alarmOriginator = new AlarmId(UUIDs.timeBased());
     private TenantId tenantId = new TenantId(UUIDs.timeBased());
     private TbMsgMetaData metaData = new TbMsgMetaData();
     private String rawJson = "{\"name\": \"Vit\", \"passed\": 5}";
@@ -325,6 +327,55 @@ public class TbAlarmNodeTest {
         assertEquals(expectedAlarm, actualAlarm);
     }
 
+    @Test
+    public void alarmCanBeClearedWithAlarmOriginator() throws ScriptException, IOException {
+        initWithClearAlarmScript();
+        metaData.putValue("key", "value");
+        TbMsg msg = TbMsg.newMsg( "USER", alarmOriginator, metaData, TbMsgDataType.JSON, rawJson, ruleChainId, ruleNodeId);
+
+        long oldEndDate = System.currentTimeMillis();
+        AlarmId id = new AlarmId(alarmOriginator.getId());
+        Alarm activeAlarm = Alarm.builder().type("SomeType").tenantId(tenantId).originator(originator).status(ACTIVE_UNACK).severity(WARNING).endTs(oldEndDate).build();
+        activeAlarm.setId(id);
+
+        when(detailsJs.executeJsonAsync(msg)).thenReturn(Futures.immediateFuture(null));
+        when(alarmService.findAlarmByIdAsync(tenantId, id)).thenReturn(Futures.immediateFuture(activeAlarm));
+        when(alarmService.clearAlarm(eq(activeAlarm.getTenantId()), eq(activeAlarm.getId()), org.mockito.Mockito.any(JsonNode.class), anyLong())).thenReturn(Futures.immediateFuture(true));
+//        doAnswer((Answer<Alarm>) invocationOnMock -> (Alarm) (invocationOnMock.getArguments())[0]).when(alarmService).createOrUpdateAlarm(activeAlarm);
+
+        node.onMsg(ctx, msg);
+
+        verify(ctx).tellNext(any(), eq("Cleared"));
+
+        ArgumentCaptor<TbMsg> msgCaptor = ArgumentCaptor.forClass(TbMsg.class);
+        ArgumentCaptor<String> typeCaptor = ArgumentCaptor.forClass(String.class);
+        ArgumentCaptor<EntityId> originatorCaptor = ArgumentCaptor.forClass(EntityId.class);
+        ArgumentCaptor<TbMsgMetaData> metadataCaptor = ArgumentCaptor.forClass(TbMsgMetaData.class);
+        ArgumentCaptor<String> dataCaptor = ArgumentCaptor.forClass(String.class);
+        verify(ctx).transformMsg(msgCaptor.capture(), typeCaptor.capture(), originatorCaptor.capture(), metadataCaptor.capture(), dataCaptor.capture());
+
+        assertEquals("ALARM", typeCaptor.getValue());
+        assertEquals(alarmOriginator, originatorCaptor.getValue());
+        assertEquals("value", metadataCaptor.getValue().getValue("key"));
+        assertEquals(Boolean.TRUE.toString(), metadataCaptor.getValue().getValue(IS_CLEARED_ALARM));
+        assertNotSame(metaData, metadataCaptor.getValue());
+
+        Alarm actualAlarm = new ObjectMapper().readValue(dataCaptor.getValue().getBytes(), Alarm.class);
+        Alarm expectedAlarm = Alarm.builder()
+                .tenantId(tenantId)
+                .originator(originator)
+                .status(CLEARED_UNACK)
+                .severity(WARNING)
+                .propagate(false)
+                .type("SomeType")
+                .details(null)
+                .endTs(oldEndDate)
+                .build();
+        expectedAlarm.setId(id);
+
+        assertEquals(expectedAlarm, actualAlarm);
+    }
+
     private void initWithCreateAlarmScript() {
         try {
             TbCreateAlarmNodeConfiguration config = new TbCreateAlarmNodeConfiguration();