Merge pull request #40 from DigitalProductInnovationAndDevelopment/feat/recommendationFilter

Feat/recommendationFilter

Author: ishworgiri1999

dashboard/src/app/components/findings-input-filter-dialog/findings-input-filter-dialog.component.ts

@@ -55,16 +55,16 @@ export class FindingsInputFilterDialogComponent {
     const priMaxValue = this.rangeFilters.priorities.maxValue;
     this.dialogRef.close({
       ...((sevMinValue !== 0 || sevMaxValue !== 100) && {
-        severity: [
-          this.rangeFilters.severities.minValue,
-          this.rangeFilters.severities.maxValue,
-        ],
+        severity: {
+          minValue: this.rangeFilters.severities.minValue,
+          maxValue: this.rangeFilters.severities.maxValue,
+        },
       }),
       ...((priMinValue !== 0 || priMaxValue !== 100) && {
-        priority: [
-          this.rangeFilters.priorities.minValue,
-          this.rangeFilters.priorities.maxValue,
-        ],
+        priority: {
+          minValue: this.rangeFilters.priorities.minValue,
+          maxValue: this.rangeFilters.priorities.maxValue,
+        },
       }),
       ...(source && source.length > 0 && { source }),
       ...(cve_ids && cve_ids.length > 0 && { cve_ids }),

dashboard/src/app/pages/results/results.component.html

@@ -18,10 +18,20 @@ <h2>Recommendations</h2>
         <span *ngIf="fileName$ | async as fileName">{{ fileName }}</span>
       </div>
     </div>
-    <div class="info-container__numberFindings">
-      <span>{{ findings?.length }}</span>
-      <p>Vulnerabilities</p>
-      <i class="bi bi-shield-exclamation"></i>
+    <div class="info-container__right">
+      <div class="slider">
+        <span>{{ severityMinValue }}</span>
+        <mat-slider min="0" max="100" step="1" (input)="filterRecommendations()">
+          <input matSliderStartThumb [(ngModel)]="severityMinValue" />
+          <input matSliderEndThumb [(ngModel)]="severityMaxValue" />
+        </mat-slider>
+        <span>{{ severityMaxValue }}</span>
+      </div>
+      <div class="info-container__numberFindings">
+        <span>{{ findings?.length }}</span>
+        <p>Vulnerabilities</p>
+        <i class="bi bi-shield-exclamation"></i>
+      </div>
     </div>
   </div>
 

dashboard/src/app/pages/results/results.component.scss

@@ -28,6 +28,25 @@
     justify-content: space-between;
     margin-bottom: 20px;
 
+    &__right {
+      display: flex;
+      gap: 20px;
+      align-items: center;
+      .slider {
+        color: #ffffff;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        ::ng-deep {
+          &.mat-mdc-slider {
+            .mdc-slider__thumb-knob,
+            .mdc-slider__track--active_fill {
+              border-color: var(--textColorSecondary) !important;
+            }
+          }
+        }
+      }
+    }
     &__selectedFile {
       display: flex;
       flex-direction: column;

dashboard/src/app/pages/results/results.component.ts

@@ -1,11 +1,11 @@
 import { Component, OnDestroy, OnInit } from '@angular/core';
 import { Router } from '@angular/router';
 import { Select, Store } from '@ngxs/store';
-import { Observable, Subscription } from 'rxjs';
+import { Observable } from 'rxjs';
 import { IFinding } from 'src/app/interfaces/IFinding';
-import { RecommendationsService } from 'src/app/services/recommendations.service';
 import {
   clearFindings,
+  filterRecs,
   loadRecommendations,
 } from 'src/app/states/recommendations.actions';
 import { RecommendationsState } from 'src/app/states/recommendations.state';
@@ -31,13 +31,10 @@ export class ResultsComponent implements OnInit, OnDestroy {
   @Select(RecommendationsState.exampleProcess)
   exampleProcess$!: Observable<boolean>;
   public loading: boolean = false;
-  private subscription!: Subscription;
+  public severityMinValue = 0;
+  public severityMaxValue = 100;
 
-  constructor(
-    private router: Router,
-    private recommendationService: RecommendationsService,
-    private store: Store
-  ) {}
+  constructor(private router: Router, private store: Store) {}
 
   ngOnInit(): void {
     this.getRecommendations();
@@ -57,7 +54,16 @@ export class ResultsComponent implements OnInit, OnDestroy {
     if (!fileName) {
       this.router.navigate(['home']);
     } else if (!exampleProcess) {
-      this.store.dispatch(new loadRecommendations()).subscribe();
+      this.store.dispatch(new loadRecommendations({})).subscribe();
     }
   }
+
+  public filterRecommendations(): void {
+    console.log(this.severityMinValue, this.severityMaxValue);
+    this.store.dispatch(
+      new filterRecs({
+        severity: [this.severityMinValue, this.severityMaxValue],
+      })
+    );
+  }
 }

dashboard/src/app/services/recommendations.service.ts

@@ -14,9 +14,12 @@ export class RecommendationsService {
     return this.http.get<void>(environment.apiUrl + '/');
   }
 
-  public uploadFindings(inputData: string, filter: any): Observable<number> {
+  public uploadFindings(
+    inputData: string,
+    filter: any
+  ): Observable<{ task_id: number }> {
     return this.http
-      .post<number>(environment.apiUrl + '/upload', {
+      .post<any>(environment.apiUrl + '/upload', {
         data: inputData,
         user_id: 1,
         filter,
@@ -28,25 +31,38 @@ export class RecommendationsService {
             error.error.detail ===
               'Recommendation task already exists for today'
           ) {
-            return new Observable<number>((observer) => {
-              observer.next(100);
+            return new Observable<{ task_id: number }>((observer) => {
+              observer.next({ task_id: 100 });
               observer.complete();
             });
           } else {
-            return of(-1);
+            return of({ task_id: -1 });
           }
         })
       );
   }
 
-  public getRecommendations(): Observable<ReceivedRecommendations> {
+  public getRecommendations(
+    taskId?: number,
+    severity?: number[]
+  ): Observable<ReceivedRecommendations> {
+    const body: any = {};
+    if (taskId !== undefined) {
+      body.taskId = taskId;
+    }
+    if (severity !== undefined) {
+      body.severity = { minValue: severity[0], maxValue: severity[1] };
+    }
+
     return this.http.post<ReceivedRecommendations>(
       environment.apiUrl + '/recommendations',
-      {}
+      body
     );
   }
 
-  public getUploadStatus(): Observable<{ status: string }> {
-    return this.http.get<{ status: string }>(environment.apiUrl + '/status');
+  public getUploadStatus(taskId: number): Observable<{ status: string }> {
+    return this.http.get<{ status: string }>(
+      environment.apiUrl + `/tasks/${taskId}/status`
+    );
   }
 }

dashboard/src/app/states/recommendations.actions.ts

@@ -27,4 +27,20 @@ export class clearFindings {
 
 export class loadRecommendations {
   static readonly type = '[] load recommendations';
+
+  constructor(
+    public readonly payload: {
+      severity?: number[];
+    }
+  ) {}
+}
+
+export class filterRecs {
+  static readonly type = '[severity] filter recommendations';
+
+  constructor(
+    public readonly payload: {
+      severity: number[];
+    }
+  ) {}
 }

dashboard/src/app/states/recommendations.state.ts

@@ -14,6 +14,7 @@ import { IFinding } from 'src/app/interfaces/IFinding';
 import { RecommendationsService } from '../services/recommendations.service';
 import {
   clearFindings,
+  filterRecs,
   loadRecommendations,
   setInformation,
   UploadFile,
@@ -25,6 +26,7 @@ export interface RecommendationsStateModel {
   findings: IFinding[];
   fileName: string | undefined;
   exampleProcess: boolean;
+  taskId: number | undefined;
 }
 
 @State<RecommendationsStateModel>({
@@ -35,6 +37,7 @@ export interface RecommendationsStateModel {
     findings: [],
     fileName: undefined,
     exampleProcess: false,
+    taskId: undefined,
   },
 })
 @Injectable()
@@ -82,12 +85,12 @@ export class RecommendationsState {
     context: StateContext<RecommendationsStateModel>,
     { payload }: UploadFile
   ): Observable<number> {
-    console.log(payload.filter);
     return this.recommendationService
       .uploadFindings(payload.data, payload.filter)
       .pipe(
-        filter((response) => response !== -1),
-        map((response) => response),
+        filter((response) => response.task_id !== -1),
+        tap((response) => context.patchState({ taskId: response.task_id })),
+        map((response) => response.task_id),
         finalize(() => void context.patchState({ isLoading: false }))
       );
   }
@@ -102,16 +105,40 @@ export class RecommendationsState {
   }
 
   @Action(loadRecommendations)
-  loadRecommendations(context: StateContext<RecommendationsStateModel>): void {
-    interval(10000)
-      .pipe(
-        switchMap(() => this.recommendationService.getUploadStatus()),
-        takeWhile((response) => response.status !== 'completed', true),
-        filter((response) => response.status === 'completed'),
-        switchMap(() => this.recommendationService.getRecommendations()),
-        tap((findings) => context.patchState({ findings: findings.items }))
-      )
-      .subscribe();
+  loadRecommendations(
+    context: StateContext<RecommendationsStateModel>,
+    { payload }: loadRecommendations
+  ): void {
+    const taskId = context.getState().taskId;
+    if (typeof taskId === 'number') {
+      interval(10000)
+        .pipe(
+          filter(() => taskId !== undefined),
+          switchMap(() => this.recommendationService.getUploadStatus(taskId)),
+          takeWhile((response) => response.status !== 'completed', true),
+          filter((response) => response.status === 'completed'),
+          switchMap(() =>
+            this.recommendationService.getRecommendations(
+              taskId,
+              payload.severity
+            )
+          ),
+          tap((findings) => context.patchState({ findings: findings.items }))
+        )
+        .subscribe();
+    }
+  }
+  @Action(filterRecs)
+  filterRecs(
+    context: StateContext<RecommendationsStateModel>,
+    { payload }: filterRecs
+  ) {
+    let findings = context.getState().findings;
+    findings = findings.filter(
+      (finding) =>
+        finding.severity >= payload.severity[0] &&
+        finding.severity <= payload.severity[1]
+    );
+    context.patchState({ findings });
   }
 }
-

src/app.py

@@ -29,12 +29,13 @@ def run_migrations():
 async def lifespan(app_: FastAPI):
     log.info("Starting up...")
     log.info("run alembic upgrade head...")
-    run_migrations()
+    # run_migrations()
+    log.info("alembic upgrade head done")
     yield
     log.info("Shutting down...")
 
 
-app = FastAPI()
+app = FastAPI(lifespan=lifespan)
 
 
 app.add_middleware(

src/data/apischema.py

@@ -1,30 +1,24 @@
-from typing import List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
 
 from pydantic import BaseModel, validator
 
+from data.Categories import Category
 from data.Finding import Finding
 from data.pagination import Pagination, PaginationInput
+from data.Solution import Solution
 from data.types import InputData
 from db.models import TaskStatus
 
 
+class SeverityFilter(BaseModel):
+    minValue: int
+    maxValue: int
 class FindingInputFilter(BaseModel):
-    severity: Optional[List[int]] = None # ['low', 'high']
-    priority: Optional[List[int]] = None # ['low', 'high']
+    severity: Optional[SeverityFilter] = None # ['low', 'high']
+    priority: Optional[SeverityFilter] = None # ['low', 'high']
     cve_ids: Optional[List[str]] = None
     cwe_ids: Optional[List[str]] = None
     source: Optional[List[str]] = None
-
-    @validator('severity', pre=True, always=True)
-    def check_severity(cls, value):
-        if value is not None and len(value) != 2:
-            raise ValueError('severity must be an array with exactly 2 elements')
-        return value
-    @validator('priority', pre=True, always=True)
-    def check_priority(cls, value):
-        if value is not None and len(value) != 2:
-            raise ValueError('priority must be an array with exactly 2 elements')
-        return value  
 
 class StartRecommendationTaskRequest(BaseModel):
     user_id: Optional[int] = None
@@ -42,7 +36,7 @@ class GetRecommendationFilter(BaseModel):
     task_id: Optional[int] = None
     date: Optional[str] = None
     location: Optional[str] = None
-    severity: Optional[str] = None
+    severity: Optional[SeverityFilter] = None # ['low', 'high']
     cve_id: Optional[str] = None
     source: Optional[str] = None
 

src/data/helper.py

@@ -27,10 +27,10 @@ def matches(content: Content) -> bool:
         if filter.source and not any(title.source in filter.source for title in content.title_list):
             return False
 
-        if filter.severity and not (filter.severity[0] <= content.severity <= filter.severity[1]):
+        if filter.severity and not (filter.severity.minValue <= content.severity <= filter.severity.maxValue):
             return False
 
-        if filter.priority and not (filter.priority[0] <= content.priority <= filter.priority[1]):
+        if filter.priority and not (filter.priority.minValue <= content.priority <= filter.priority.maxValue):
             return False
 
         if filter.cve_ids and not any(cve.element in filter.cve_ids for cve in content.cve_id_list):