[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.service";
 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 { takeUntilDestroyed } from "@angular/core/rxjs-interop";
 import { BehaviorSubject } from "rxjs";
-import { finalize } from "rxjs/operators";
+import { 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 { 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();
@@ -27,45 +38,117 @@ export class RiskInsightsDataService {
   private dataLastUpdatedSubject = new BehaviorSubject<Date | null>(null);
   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,
+  ) {}
 
   /**
    * 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)
-      .pipe(
-        finalize(() => {
-          this.isLoadingSubject.next(false);
-          this.isRefreshingSubject.next(false);
-          this.dataLastUpdatedSubject.next(new Date());
-        }),
-      )
+      .pipe(takeUntilDestroyed())
       .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) {
+    return this.riskInsightsApiService
+      .getRiskInsightsReport(organizationId as OrganizationId)
+      .pipe(
+        switchMap(async (reportFromArchive) => {
+          if (!reportFromArchive || !reportFromArchive?.date) {
+            this.fetchApplicationsReport(organizationId);
+
+            return {
+              report: [],
+              summary: null,
+              fromArchive: false,
+              lastUpdated: new Date(),
+            };
+          } else {
+            const [report, summary] = await this.reportService.decryptRiskInsightsReport(
+              organizationId as OrganizationId,
+              reportFromArchive,
+            );
+
+            return {
+              report,
+              summary,
+              fromArchive: true,
+              lastUpdated: new Date(reportFromArchive.date),
+            };
+          }
+        }),
+      )
+      .subscribe({
+        next: ({ report, summary, fromArchive, lastUpdated }) => {
+          // in this block, only set the applicationsSubject and appsSummarySubject if the report is from archive
+          // the fetchApplicationsReport will set them if the report is not from archive
+          if (fromArchive) {
+            this.applicationsSubject.next(report);
+            this.errorSubject.next(null);
+            this.appsSummarySubject.next(summary);
+          }
+
+          this.isReportFromArchiveSubject.next(fromArchive);
+          this.dataLastUpdatedSubject.next(lastUpdated);
+        },
+        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);
   }

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

@@ -3,10 +3,14 @@ import { firstValueFrom } from "rxjs";
 import { ZXCVBNResult } from "zxcvbn";
 
 import { AuditService } from "@bitwarden/common/abstractions/audit.service";
+import { EncryptService } from "@bitwarden/common/key-management/crypto/abstractions/encrypt.service";
+import { KeyGenerationService } from "@bitwarden/common/platform/abstractions/key-generation.service";
 import { PasswordStrengthServiceAbstraction } from "@bitwarden/common/tools/password-strength";
 import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
+import { KeyService } from "@bitwarden/key-management";
 
 import { mockCiphers } from "./ciphers.mock";
+import { CriticalAppsService } from "./critical-apps.service";
 import { MemberCipherDetailsApiService } from "./member-cipher-details-api.service";
 import { mockMemberCipherDetails } from "./member-cipher-details-api.service.spec";
 import { RiskInsightsReportService } from "./risk-insights-report.service";
@@ -17,6 +21,10 @@ describe("RiskInsightsReportService", () => {
   const auditService = mock<AuditService>();
   const cipherService = mock<CipherService>();
   const memberCipherDetailsService = mock<MemberCipherDetailsApiService>();
+  const keyService = mock<KeyService>();
+  const encryptService = mock<EncryptService>();
+  const criticalAppsService = mock<CriticalAppsService>();
+  const keyGenerationService = mock<KeyGenerationService>();
 
   beforeEach(() => {
     pwdStrengthService.getPasswordStrength.mockImplementation((password: string) => {
@@ -37,6 +45,10 @@ describe("RiskInsightsReportService", () => {
       auditService,
       cipherService,
       memberCipherDetailsService,
+      keyService,
+      encryptService,
+      criticalAppsService,
+      keyGenerationService,
     );
   });