Feature/651 show notification usage (#657)

#651 show notification usage (#657)

Author: jozefbakus

src/main/scala/za/co/absa/hyperdrive/trigger/api/rest/controllers/NotificationRuleController.scala

@@ -59,4 +59,9 @@ class NotificationRuleController @Inject()(notificationRuleService: Notification
   def searchNotificationRules(@RequestBody searchRequest: TableSearchRequest): CompletableFuture[TableSearchResponse[NotificationRule]] = {
     notificationRuleService.searchNotificationRules(searchRequest).toJava.toCompletableFuture
   }
+
+  @GetMapping(path = Array("/notificationRules/{id}/workflows"))
+  def getMatchingWorkflows(@PathVariable id: Long): CompletableFuture[Seq[Workflow]] = {
+    notificationRuleService.getMatchingWorkflows(id).toJava.toCompletableFuture
+  }
 }

src/main/scala/za/co/absa/hyperdrive/trigger/api/rest/services/NotificationRuleService.scala

@@ -42,6 +42,7 @@ trait NotificationRuleService {
 
   def getMatchingNotificationRules(workflowId: Long, status: DagInstanceStatus)(implicit ec: ExecutionContext): Future[Option[(Seq[NotificationRule], Workflow)]]
 
+  def getMatchingWorkflows(id: Long)(implicit ec: ExecutionContext): Future[Seq[Workflow]]
 }
 
 @Service
@@ -84,4 +85,8 @@ class NotificationRuleServiceImpl(override val notificationRuleRepository: Notif
   override def getMatchingNotificationRules(workflowId: Long, status: DagInstanceStatus)(implicit ec: ExecutionContext): Future[Option[(Seq[NotificationRule], Workflow)]] = {
     notificationRuleRepository.getMatchingNotificationRules(workflowId, status, LocalDateTime.now())
   }
+
+  override def getMatchingWorkflows(id: Long)(implicit ec: ExecutionContext): Future[Seq[Workflow]] = {
+    notificationRuleRepository.getMatchingWorkflows(id)
+  }
 }

src/main/scala/za/co/absa/hyperdrive/trigger/persistance/NotificationRuleRepository.scala

@@ -45,6 +45,8 @@ trait NotificationRuleRepository extends Repository {
 
   def getMatchingNotificationRules(workflowId: Long, status: DagInstanceStatus, currentTime: LocalDateTime)(implicit ec: ExecutionContext): Future[Option[(Seq[NotificationRule], Workflow)]]
 
+  def getMatchingWorkflows(id: Long)(implicit ec: ExecutionContext): Future[Seq[Workflow]]
+
 }
 
 @stereotype.Repository
@@ -136,6 +138,24 @@ class NotificationRuleRepositoryImpl @Inject()(
     )
   }
 
+  override def getMatchingWorkflows(id: Long)(implicit ec: ExecutionContext): Future[Seq[Workflow]] = {
+    db.run(
+      getNotificationRuleInternal(id).flatMap { notificationRule =>
+        workflowTable
+          .filter { workflow =>
+            val workflowPrefix = notificationRule.workflowPrefix.getOrElse("")
+            LiteralColumn[Boolean](workflowPrefix.isEmpty) ||
+              workflow.name.toLowerCase.like(workflowPrefix.toLowerCase ++ "%")
+          }
+          .filter { workflow =>
+            val project = notificationRule.project.getOrElse("")
+            LiteralColumn[Boolean](project.isEmpty) ||
+              workflow.project.toLowerCase === project.toLowerCase
+          }.result
+      }
+    )
+  }
+
   private def insertNotificationRuleInternal(notificationRule: NotificationRule, user: String)(implicit ec: ExecutionContext) = {
     val notificationRuleToInsert = notificationRule.copy(created = LocalDateTime.now())
     for {

src/test/scala/za/co/absa/hyperdrive/trigger/api/rest/services/NotificationRuleServiceTest.scala

@@ -178,4 +178,16 @@ class NotificationRuleServiceTest extends AsyncFlatSpec with Matchers with Mocki
     result.value shouldBe matchingRules
   }
 
+  "getMatchingWorkflows" should "return matching workflows" in {
+    // given
+    val notificationRuleId: Long = 1
+    val workflows = Seq(Workflow("workflow1", isActive = true, "project1", LocalDateTime.now(), None, 1, None, 42L))
+    when(notificationRuleRepository.getMatchingWorkflows(eqTo(notificationRuleId))(any[ExecutionContext])).thenReturn(Future(workflows))
+
+    // when
+    val result = await(underTest.getMatchingWorkflows(notificationRuleId))
+
+    // then
+    result shouldBe workflows
+  }
 }

src/test/scala/za/co/absa/hyperdrive/trigger/persistance/NotificationRuleRepositoryPostgresTest.scala

@@ -162,6 +162,67 @@ class NotificationRuleRepositoryPostgresTest extends FlatSpec with Matchers with
     result.value._2 shouldBe w1
   }
 
+  "getMatchingWorkflows" should "return matching workflows" in {
+    val w1 = Workflow(name = "workflow1", project = "project1", isActive = true, created = LocalDateTime.now(), updated = None, version = 1, id = 0)
+    val w2 = Workflow(name = "workflow2", project = "project1", isActive = true, created = LocalDateTime.now(), updated = None, version = 1, id = 1)
+    val w3 = Workflow(name = "workflow3", project = "project2", isActive = true, created = LocalDateTime.now(), updated = None, version = 1, id = 2)
+    val w4 = Workflow(name = "workflow14", project = "project3", isActive = true, created = LocalDateTime.now(), updated = None, version = 1, id = 3)
+
+    val nr = createDummyNotificationRule()
+    val nr1 = nr.copy(workflowPrefix = None, project = Some("project2"), id = 1)
+    val nr2 = nr.copy(workflowPrefix = None, project = Some("PROJECT1"), id = 2)
+    val nr3 = nr.copy(workflowPrefix = None, project = Some(""), id = 3)
+    val nr4 = nr.copy(workflowPrefix = None, project = None, id = 4)
+    val nr5 = nr.copy(workflowPrefix = None, project = Some("project"), id = 5)
+
+    val nr6 = nr.copy(workflowPrefix = Some("WORKFLOW"), project = None, id = 6)
+    val nr7 = nr.copy(workflowPrefix = Some("WoRkFlOw1"), project = None, id = 7)
+    val nr8 = nr.copy(workflowPrefix = Some(""), project = None, id = 8)
+    val nr9 = nr.copy(workflowPrefix = None, project = None, id = 9)
+    val nr10 = nr.copy(workflowPrefix = Some("xyz"), project = None, id = 10)
+
+    val nr11 = nr.copy(workflowPrefix = Some("wor"), project = Some("PROJECT1"), id = 11)
+
+    await(db.run(workflowTable.forceInsertAll(Seq(w1, w2, w3, w4))))
+    await(db.run(notificationRuleTable.forceInsertAll(Seq(nr1, nr2, nr3, nr4, nr5, nr6, nr7, nr8, nr9, nr10, nr11))))
+
+    //Match on project
+    val result1 = await(notificationRuleRepository.getMatchingWorkflows(nr1.id))
+    result1 should contain theSameElementsAs Seq(w3)
+    //Match on project only, ignoring case
+    val result2 = await(notificationRuleRepository.getMatchingWorkflows(nr2.id))
+    result2 should contain theSameElementsAs Seq(w1, w2)
+    //Match on project only - empty string
+    val result3 = await(notificationRuleRepository.getMatchingWorkflows(nr3.id))
+    result3 should contain theSameElementsAs Seq(w1, w2, w3, w4)
+    //Match on project only - none
+    val result4 = await(notificationRuleRepository.getMatchingWorkflows(nr4.id))
+    result4 should contain theSameElementsAs Seq(w1, w2, w3, w4)
+    //Match on project only - no matching workflow
+    val result5 = await(notificationRuleRepository.getMatchingWorkflows(nr5.id))
+    result5 should contain theSameElementsAs Seq()
+
+    //Match on workflow prefix only, ignoring case - match all
+    val result6 = await(notificationRuleRepository.getMatchingWorkflows(nr6.id))
+    result6 should contain theSameElementsAs Seq(w1, w2, w3, w4)
+    //Match on workflow prefix only - partial match
+    val result7 = await(notificationRuleRepository.getMatchingWorkflows(nr7.id))
+    result7 should contain theSameElementsAs Seq(w1, w4)
+    //Match on workflow prefix only - empty string
+    val result8 = await(notificationRuleRepository.getMatchingWorkflows(nr8.id))
+    result8 should contain theSameElementsAs Seq(w1, w2, w3, w4)
+    //Match on workflow prefix only - none
+    val result9 = await(notificationRuleRepository.getMatchingWorkflows(nr9.id))
+    result9 should contain theSameElementsAs Seq(w1, w2, w3, w4)
+    //Match on workflow prefix only - no matching workflow
+    val result10 = await(notificationRuleRepository.getMatchingWorkflows(nr10.id))
+    result10 should contain theSameElementsAs Seq()
+
+    //Match on workflow prefix and project
+    val result11 = await(notificationRuleRepository.getMatchingWorkflows(nr11.id))
+    result11 should contain theSameElementsAs Seq(w1, w2)
+  }
+
   private def createDummyNotificationRule() = {
     NotificationRule(isActive = true, None, None, None, Seq(DagInstanceStatuses.Failed), Seq("[email protected]"),
       created = LocalDateTime.now(), updated = None, id = -1L)

ui/src/app/app.module.ts

@@ -101,6 +101,7 @@ import { JobTemplateHistoryComponent } from './components/admin/job-templates/jo
 import { JobTemplateComparisonComponent } from './components/admin/job-templates/job-template-history/job-template-comparison/job-template-comparison.component';
 import { JobTemplateUsageComponent } from './components/admin/job-templates/job-templates-home/job-template-usage/job-template-usage.component';
 import { LengthValidator } from './components/workflows/workflow-form/dynamic-parts/string-sequence-part/validator/length.validator';
+import { NotificationRuleUsageComponent } from './components/admin/notification-rules/notification-rules-home/notification-rule-usage/notification-rule-usage.component';
 
 @NgModule({
   declarations: [
@@ -160,6 +161,7 @@ import { LengthValidator } from './components/workflows/workflow-form/dynamic-pa
     NotificationRuleComponent,
     NotificationRulesComponent,
     NotificationRulesHomeComponent,
+    NotificationRuleUsageComponent,
     NotificationRulesFormComponent,
     NotificationRuleComparisonComponent,
     NotificationRuleHistoryComponent,

ui/src/app/components/admin/notification-rules/notification-rules-home/notification-rule-usage/notification-rule-usage.component.html

@@ -0,0 +1,38 @@
+<!--
+  ~ Copyright 2018 ABSA Group Limited
+  ~
+  ~ 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.
+  -->
+
+<clr-datagrid [clrDgLoading]="loading">
+  <clr-dg-column>Workflow Name</clr-dg-column>
+  <clr-dg-column>Project Name</clr-dg-column>
+  <clr-dg-column>Is Active</clr-dg-column>
+
+  <clr-dg-placeholder>Notification rule has not matched any workflow!</clr-dg-placeholder>
+
+  <clr-dg-row *ngFor="let workflow of workflows">
+    <clr-dg-action-overflow>
+      <button type="button" class="action-item" (click)="showWorkflow(workflow.id)">
+        <clr-icon shape="eye"></clr-icon>
+        Show
+      </button>
+    </clr-dg-action-overflow>
+    <clr-dg-cell (dblclick)="showWorkflow(workflow.id)">{{workflow.name}}</clr-dg-cell>
+    <clr-dg-cell (dblclick)="showWorkflow(workflow.id)">{{workflow.project}}</clr-dg-cell>
+    <clr-dg-cell (dblclick)="showWorkflow(workflow.id)" [ngSwitch]="workflow.isActive">
+      <clr-icon *ngSwitchCase="true" shape="circle" class="is-solid" style="color: green"></clr-icon>
+      <clr-icon *ngSwitchCase="false" shape="circle" class="is-solid" style="color: red"></clr-icon>
+      {{workflow.isActive ? 'Yes' : 'No'}}
+    </clr-dg-cell>
+  </clr-dg-row>
+</clr-datagrid>

ui/src/app/components/admin/notification-rules/notification-rules-home/notification-rule-usage/notification-rule-usage.component.scss

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2018 ABSA Group Limited
+ *
+ * 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.
+ */
+

ui/src/app/components/admin/notification-rules/notification-rules-home/notification-rule-usage/notification-rule-usage.component.spec.ts

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2018 ABSA Group Limited
+ *
+ * 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 { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+
+import { provideMockStore } from '@ngrx/store/testing';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { Store } from '@ngrx/store';
+import { Subject } from 'rxjs';
+import { AppState } from '../../../../../stores/app.reducers';
+import { Router } from '@angular/router';
+import { RouterTestingModule } from '@angular/router/testing';
+import { absoluteRoutes } from '../../../../../constants/routes.constants';
+import { NotificationRuleUsageComponent } from './notification-rule-usage.component';
+import { GetNotificationRuleUsage } from '../../../../../stores/notification-rules/notification-rules.actions';
+
+describe('NotificationRuleUsageComponent', () => {
+  let underTest: NotificationRuleUsageComponent;
+  let fixture: ComponentFixture<NotificationRuleUsageComponent>;
+  let store: Store<AppState>;
+  let router: Router;
+
+  const initialAppState = {
+    notificationRules: {
+      usage: {
+        loading: true,
+        workflows: [],
+      },
+    },
+  };
+
+  beforeEach(
+    waitForAsync(() => {
+      TestBed.configureTestingModule({
+        providers: [provideMockStore({ initialState: initialAppState })],
+        declarations: [NotificationRuleUsageComponent],
+        imports: [HttpClientTestingModule, RouterTestingModule.withRoutes([])],
+      }).compileComponents();
+      store = TestBed.inject(Store);
+      router = TestBed.inject(Router);
+    }),
+  );
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(NotificationRuleUsageComponent);
+    underTest = fixture.componentInstance;
+  });
+
+  it('should create', () => {
+    expect(underTest).toBeTruthy();
+  });
+
+  it(
+    'onInit should set component properties',
+    waitForAsync(() => {
+      fixture.detectChanges();
+      fixture.whenStable().then(() => {
+        expect(underTest.loading).toBe(initialAppState.notificationRules.usage.loading);
+        expect(underTest.workflows).toBe(initialAppState.notificationRules.usage.workflows);
+      });
+    }),
+  );
+
+  it(
+    'onRefresh() should dispatch GetNotificationRuleUsage',
+    waitForAsync(() => {
+      underTest.notificationId = 42;
+      underTest.refreshSubject = new Subject<boolean>();
+      const subject = new Subject<boolean>();
+      const storeSpy = spyOn(store, 'dispatch');
+
+      underTest.onRefresh();
+      subject.next(true);
+
+      fixture.detectChanges();
+      fixture.whenStable().then(() => {
+        expect(storeSpy).toHaveBeenCalled();
+        expect(storeSpy).toHaveBeenCalledWith(new GetNotificationRuleUsage(underTest.notificationId));
+      });
+    }),
+  );
+
+  it(
+    'showWorkflow() should navigate to show workflow page',
+    waitForAsync(() => {
+      const id = 42;
+      const routerSpy = spyOn(router, 'navigate');
+
+      underTest.showWorkflow(id);
+
+      expect(routerSpy).toHaveBeenCalledTimes(1);
+      expect(routerSpy).toHaveBeenCalledWith([absoluteRoutes.SHOW_WORKFLOW, id]);
+    }),
+  );
+});

ui/src/app/components/admin/notification-rules/notification-rules-home/notification-rule-usage/notification-rule-usage.component.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2018 ABSA Group Limited
+ *
+ * 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, OnDestroy, OnInit } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { Subject, Subscription } from 'rxjs';
+import { WorkflowModel } from '../../../../../models/workflow.model';
+import { AppState, selectNotificationRulesState } from '../../../../../stores/app.reducers';
+import { Router } from '@angular/router';
+import { absoluteRoutes } from '../../../../../constants/routes.constants';
+import { GetNotificationRuleUsage } from '../../../../../stores/notification-rules/notification-rules.actions';
+
+@Component({
+  selector: 'app-notification-rule-usage',
+  templateUrl: './notification-rule-usage.component.html',
+  styleUrls: ['./notification-rule-usage.component.scss'],
+})
+export class NotificationRuleUsageComponent implements OnInit, OnDestroy {
+  @Input('notificationId') notificationId: number;
+  @Input() refreshSubject: Subject<boolean> = new Subject<boolean>();
+  workflows: WorkflowModel[];
+  loading = true;
+
+  notificationsSubscription: Subscription;
+  refreshSubscription: Subscription;
+
+  constructor(private store: Store<AppState>, private router: Router) {}
+
+  ngOnInit() {
+    this.store.dispatch(new GetNotificationRuleUsage(this.notificationId));
+    this.notificationsSubscription = this.store.select(selectNotificationRulesState).subscribe((state) => {
+      this.loading = state.usage.loading;
+      this.workflows = state.usage.workflows;
+    });
+
+    this.refreshSubscription = this.refreshSubject.subscribe((response) => {
+      if (response) {
+        this.onRefresh();
+      }
+    });
+  }
+
+  onRefresh() {
+    this.store.dispatch(new GetNotificationRuleUsage(this.notificationId));
+  }
+
+  showWorkflow(id: number) {
+    this.router.navigate([absoluteRoutes.SHOW_WORKFLOW, id]);
+  }
+
+  ngOnDestroy(): void {
+    !!this.notificationsSubscription && this.notificationsSubscription.unsubscribe();
+    !!this.refreshSubscription && this.refreshSubscription.unsubscribe();
+  }
+}