[PM-20578] Encrypt Risk Insights report and send it to server

bitwarden_license/bit-common/src/dirt/reports/risk-insights/models/password-health.ts

@@ -167,4 +167,40 @@ export enum DrawerType {
   OrgAtRiskApps = 3,
 }
 
+export interface RiskInsightsReport {
+  organizationId: OrganizationId;
+  date: string;
+  reportData: string;
+  totalMembers: number;
+  totalAtRiskMembers: number;
+  totalApplications: number;
+  totalAtRiskApplications: number;
+  totalCriticalApplications: number;
+}
+
+export interface ReportInsightsReportData {
+  data: string;
+  key: string;
+}
+
+export interface SaveRiskInsightsReportRequest {
+  data: RiskInsightsReport;
+}
+
+export interface SaveRiskInsightsReportResponse {
+  id: string;
+}
+
+export interface GetRiskInsightsReportResponse {
+  id: string;
+  organizationId: OrganizationId;
+  date: string;
+  reportData: string;
+  totalMembers: number;
+  totalAtRiskMembers: number;
+  totalApplications: number;
+  totalAtRiskApplications: number;
+  totalCriticalApplications: number;
+}
+
 export type PasswordHealthReportApplicationId = Opaque<string, "PasswordHealthReportApplicationId">;

bitwarden_license/bit-common/src/dirt/reports/risk-insights/services/index.ts

@@ -4,3 +4,4 @@
 export * from "./critical-apps-api.service";
 export * from "./risk-insights-report.service";
 export * from "./risk-insights-data.service";
+export * from "./risk-insights-api.service";

bitwarden_license/bit-common/src/dirt/reports/risk-insights/services/risk-insights-api.service.spec.ts

@@ -0,0 +1,54 @@
+import { mock } from "jest-mock-extended";
+
+import { ApiService } from "@bitwarden/common/abstractions/api.service";
+import { OrganizationId } from "@bitwarden/common/types/guid";
+
+import { SaveRiskInsightsReportRequest } from "../models/password-health";
+
+import { RiskInsightsApiService } from "./risk-insights-api.service";
+
+describe("RiskInsightsApiService", () => {
+  let service: RiskInsightsApiService;
+  const apiService = mock<ApiService>();
+
+  beforeEach(() => {
+    service = new RiskInsightsApiService(apiService);
+  });
+
+  it("should be created", () => {
+    expect(service).toBeTruthy();
+  });
+
+  it("should call apiService.send with correct parameters for saveRiskInsightsReport", (done) => {
+    const orgId = "org1" as OrganizationId;
+    const request: SaveRiskInsightsReportRequest = {
+      data: {
+        organizationId: orgId,
+        date: new Date().toISOString(),
+        reportData: "test",
+        totalMembers: 10,
+        totalAtRiskMembers: 5,
+        totalApplications: 100,
+        totalAtRiskApplications: 50,
+        totalCriticalApplications: 22,
+      },
+    };
+    const response = {
+      ...request.data,
+    };
+
+    apiService.send.mockReturnValue(Promise.resolve(response));
+
+    service.saveRiskInsightsReport(request).subscribe((result) => {
+      expect(result).toEqual(response);
+      expect(apiService.send).toHaveBeenCalledWith(
+        "POST",
+        `/reports/organization-reports`,
+        request.data,
+        true,
+        true,
+      );
+      done();
+    });
+  });
+});

bitwarden_license/bit-common/src/dirt/reports/risk-insights/services/risk-insights-api.service.ts

@@ -0,0 +1,44 @@
+import { from, Observable, of } from "rxjs";
+
+import { ApiService } from "@bitwarden/common/abstractions/api.service";
+import { OrganizationId } from "@bitwarden/common/types/guid";
+
+import {
+  GetRiskInsightsReportResponse,
+  SaveRiskInsightsReportRequest,
+  SaveRiskInsightsReportResponse,
+} from "../models/password-health";
+
+export class RiskInsightsApiService {
+  constructor(private apiService: ApiService) {}
+
+  saveRiskInsightsReport(
+    request: SaveRiskInsightsReportRequest,
+  ): Observable<SaveRiskInsightsReportResponse> {
+    const dbResponse = this.apiService.send(
+      "POST",
+      `/reports/organization-reports`,
+      request.data,
+      true,
+      true,
+    );
+
+    return from(dbResponse as Promise<SaveRiskInsightsReportResponse>);
+  }
+
+  getRiskInsightsReport(orgId: OrganizationId): Observable<GetRiskInsightsReportResponse | null> {
+    const dbResponse = this.apiService
+      .send("GET", `/reports/organization-reports/latest/${orgId.toString()}`, null, true, true)
+      .catch((error: any): any => {
+        if (error.statusCode === 404) {
+          return null; // Handle 404 by returning null or an appropriate default value
+        }
+        throw error; // Re-throw other errors
+      });
+
+    if (dbResponse instanceof Error) {
+      return of(null);
+    }
+    return from(dbResponse as Promise<GetRiskInsightsReportResponse>);
+  }
+}

bitwarden_license/bit-common/src/dirt/reports/risk-insights/services/risk-insights-data.service.ts

@@ -1,19 +1,30 @@
-import { BehaviorSubject } from "rxjs";
-import { finalize } from "rxjs/operators";
+import { BehaviorSubject, firstValueFrom } from "rxjs";
+import { map, switchMap } from "rxjs/operators";
+
+import { OrganizationId } from "@bitwarden/common/types/guid";
+import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
+import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view";
 
 import {
   AppAtRiskMembersDialogParams,
   ApplicationHealthReportDetail,
+  ApplicationHealthReportSummary,
   AtRiskApplicationDetail,
   AtRiskMemberDetail,
   DrawerType,
 } from "../models/password-health";
 
+import { RiskInsightsApiService } from "./risk-insights-api.service";
+import { RiskInsightsEncryptionService } from "./risk-insights-encryption.service";
 import { RiskInsightsReportService } from "./risk-insights-report.service";
 export class RiskInsightsDataService {
   private applicationsSubject = new BehaviorSubject<ApplicationHealthReportDetail[] | null>(null);
+  private appsSummarySubject = new BehaviorSubject<ApplicationHealthReportSummary | null>(null);
+  private isReportFromArchiveSubject = new BehaviorSubject<boolean>(true); // True by default
 
   applications$ = this.applicationsSubject.asObservable();
+  appsSummary$ = this.appsSummarySubject.asObservable();
+  isReportFromArchive$ = this.isReportFromArchiveSubject.asObservable();
 
   private isLoadingSubject = new BehaviorSubject<boolean>(false);
   isLoading$ = this.isLoadingSubject.asObservable();
@@ -24,50 +35,128 @@
   private errorSubject = new BehaviorSubject<string | null>(null);
   error$ = this.errorSubject.asObservable();
 
-  private dataLastUpdatedSubject = new BehaviorSubject<Date | null>(null);
+  private dataLastUpdatedSubject = new BehaviorSubject<Date>(new Date());
   dataLastUpdated$ = this.dataLastUpdatedSubject.asObservable();
 
+  private cipherViewsForOrganizationSubject = new BehaviorSubject<CipherView[]>([]);
+  cipherViewsForOrganization$ = this.cipherViewsForOrganizationSubject.asObservable();
+
   openDrawer = false;
   drawerInvokerId: string = "";
   activeDrawerType: DrawerType = DrawerType.None;
   atRiskMemberDetails: AtRiskMemberDetail[] = [];
   appAtRiskMembers: AppAtRiskMembersDialogParams | null = null;
   atRiskAppDetails: AtRiskApplicationDetail[] | null = null;
 
-  constructor(private reportService: RiskInsightsReportService) {}
+  constructor(
+    private reportService: RiskInsightsReportService,
+    private riskInsightsApiService: RiskInsightsApiService,
+    private cipherService: CipherService,
+    private riskInsightsEncryptionService: RiskInsightsEncryptionService,
+  ) {}
 
   /**
    * Fetches the applications report and updates the applicationsSubject.
    * @param organizationId The ID of the organization.
    */
   fetchApplicationsReport(organizationId: string, isRefresh?: boolean): void {
-    if (isRefresh) {
-      this.isRefreshingSubject.next(true);
-    } else {
-      this.isLoadingSubject.next(true);
-    }
-    this.reportService
-      .generateApplicationsReport$(organizationId)
+    this.reportService.generateApplicationsReport$(organizationId).subscribe({
+      next: (reports: ApplicationHealthReportDetail[]) => {
+        this.applicationsSubject.next(reports);
+        this.errorSubject.next(null);
+        this.appsSummarySubject.next(this.reportService.generateApplicationsSummary(reports));
+        this.dataLastUpdatedSubject.next(new Date());
+      },
+      error: () => {
+        this.applicationsSubject.next([]);
+      },
+    });
+  }
+
+  fetchApplicationsReportFromCache(organizationId: string, isRefresh: boolean = false) {
+    return this.riskInsightsApiService
+      .getRiskInsightsReport(organizationId as OrganizationId)
       .pipe(
-        finalize(() => {
-          this.isLoadingSubject.next(false);
-          this.isRefreshingSubject.next(false);
-          this.dataLastUpdatedSubject.next(new Date());
+        map((reportFromArchive) => {
+          if (isRefresh) {
+            // we force a refresh if isRefresh is true
+            // ignore all data from the server
+            return null;
+          }
+          return reportFromArchive;
+        }),
+        switchMap(async (reportFromArchive) => {
+          if (!reportFromArchive || !reportFromArchive?.date) {
+            const report = await firstValueFrom(
+              this.reportService.generateApplicationsReport$(organizationId),
+            );
+            const summary = this.reportService.generateApplicationsSummary(report);
+
+            return {
+              report,
+              summary,
+              fromArchive: false,
+              lastUpdated: new Date(),
+            };
+          } else {
+            const [report, summary] =
+              await this.riskInsightsEncryptionService.decryptRiskInsightsReport(
+                organizationId as OrganizationId,
+                reportFromArchive,
+              );
+
+            return {
+              report,
+              summary,
+              fromArchive: true,
+              lastUpdated: new Date(reportFromArchive.date),
+            };
+          }
         }),
       )
       .subscribe({
-        next: (reports: ApplicationHealthReportDetail[]) => {
-          this.applicationsSubject.next(reports);
+        next: ({ report, summary, fromArchive, lastUpdated }) => {
+          this.applicationsSubject.next(report);
           this.errorSubject.next(null);
+          this.appsSummarySubject.next(summary);
+          this.isReportFromArchiveSubject.next(fromArchive);
+          this.dataLastUpdatedSubject.next(lastUpdated);
         },
-        error: () => {
+        error: (error: unknown) => {
+          this.errorSubject.next((error as Error).message);
           this.applicationsSubject.next([]);
         },
       });
   }
 
+  async fetchCipherViewsForOrganization(
+    organizationId: OrganizationId,
+    isRefresh: boolean = false,
+  ): Promise<void> {
+    if (isRefresh) {
+      this.cipherViewsForOrganizationSubject.next([]);
+    }
+
+    if (this.cipherViewsForOrganizationSubject.value) {
+      return;
+    }
+
+    const cipherViews = await this.cipherService.getAllFromApiForOrganization(organizationId);
+    this.cipherViewsForOrganizationSubject.next(cipherViews);
+  }
+
+  isLoadingData(started: boolean): void {
+    this.isLoadingSubject.next(started);
+    this.isRefreshingSubject.next(started);
+  }
+
+  setReportFromArchiveStatus(isFromArchive: boolean): void {
+    this.isReportFromArchiveSubject.next(isFromArchive);
+  }
+
   refreshApplicationsReport(organizationId: string): void {
-    this.fetchApplicationsReport(organizationId, true);
+    this.isLoadingData(true);
+    this.fetchApplicationsReportFromCache(organizationId, true);
   }
 
   isActiveDrawerType = (drawerType: DrawerType): boolean => {