@blackcode_sa/metaestetics-api 1.12.62 → 1.12.64

package/src/admin/aggregation/reviews/reviews.aggregation.service.ts

@@ -1,689 +1,641 @@
-import * as admin from "firebase-admin";
-import {
-  Review,
-  ClinicReview,
-  PractitionerReview,
-  ProcedureReview,
-  REVIEWS_COLLECTION,
-  ClinicReviewInfo,
-  PractitionerReviewInfo,
-  ProcedureReviewInfo,
-} from "../../../types/reviews";
-import { CLINICS_COLLECTION } from "../../../types/clinic";
-import { PRACTITIONERS_COLLECTION } from "../../../types/practitioner";
-import { PROCEDURES_COLLECTION } from "../../../types/procedure";
-
-/**
- * @class ReviewsAggregationService
- * @description Handles aggregation tasks related to review data updates.
- * This service is intended to be used primarily by background functions (e.g., Cloud Functions)
- * triggered by changes in the reviews collection.
- */
-export class ReviewsAggregationService {
-  private db: admin.firestore.Firestore;
-
-  /**
-   * Constructor for ReviewsAggregationService.
-   * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
-   */
-  constructor(firestore?: admin.firestore.Firestore) {
-    this.db = firestore || admin.firestore();
-  }
-
-  /**
-   * Process a newly created review and update all related entities
-   * @param review The newly created review
-   * @returns Promise resolving when all updates are complete
-   */
-  async processNewReview(review: Review): Promise<void> {
-    console.log(
-      `[ReviewsAggregationService] Processing new review: ${review.id}`
-    );
-
-    const updatePromises: Promise<any>[] = [];
-
-    // Update clinic if clinic review exists
-    if (review.clinicReview) {
-      updatePromises.push(
-        this.updateClinicReviewInfo(review.clinicReview.clinicId)
-      );
-    }
-
-    // Update practitioner if practitioner review exists
-    if (review.practitionerReview) {
-      updatePromises.push(
-        this.updatePractitionerReviewInfo(
-          review.practitionerReview.practitionerId
-        )
-      );
-    }
-
-    // Update procedure if procedure review exists
-    if (review.procedureReview) {
-      updatePromises.push(
-        this.updateProcedureReviewInfo(review.procedureReview.procedureId)
-      );
-    }
-
-    // Update extended procedures if they exist
-    if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
-      console.log(
-        `[ReviewsAggregationService] Processing ${review.extendedProcedureReviews.length} extended procedure reviews`
-      );
-      review.extendedProcedureReviews.forEach((extendedReview) => {
-        updatePromises.push(
-          this.updateProcedureReviewInfo(extendedReview.procedureId)
-        );
-      });
-    }
-
-    // Wait for all updates to complete
-    await Promise.all(updatePromises);
-    console.log(
-      `[ReviewsAggregationService] Successfully processed review: ${review.id}`
-    );
-  }
-
-  /**
-   * Process a deleted review and update all related entities
-   * @param review The deleted review
-   * @returns Promise resolving when all updates are complete
-   */
-  async processDeletedReview(review: Review): Promise<void> {
-    console.log(
-      `[ReviewsAggregationService] Processing deleted review: ${review.id}`
-    );
-
-    const updatePromises: Promise<any>[] = [];
-
-    // Update clinic if clinic review exists
-    if (review.clinicReview) {
-      updatePromises.push(
-        this.updateClinicReviewInfo(
-          review.clinicReview.clinicId,
-          review.clinicReview,
-          true
-        )
-      );
-    }
-
-    // Update practitioner if practitioner review exists
-    if (review.practitionerReview) {
-      updatePromises.push(
-        this.updatePractitionerReviewInfo(
-          review.practitionerReview.practitionerId,
-          review.practitionerReview,
-          true
-        )
-      );
-    }
-
-    // Update procedure if procedure review exists
-    if (review.procedureReview) {
-      updatePromises.push(
-        this.updateProcedureReviewInfo(
-          review.procedureReview.procedureId,
-          review.procedureReview,
-          true
-        )
-      );
-    }
-
-    // Update extended procedures if they exist
-    if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
-      console.log(
-        `[ReviewsAggregationService] Processing deletion of ${review.extendedProcedureReviews.length} extended procedure reviews`
-      );
-      review.extendedProcedureReviews.forEach((extendedReview) => {
-        updatePromises.push(
-          this.updateProcedureReviewInfo(
-            extendedReview.procedureId,
-            extendedReview,
-            true
-          )
-        );
-      });
-    }
-
-    // Wait for all updates to complete
-    await Promise.all(updatePromises);
-    console.log(
-      `[ReviewsAggregationService] Successfully processed deleted review: ${review.id}`
-    );
-  }
-
-  /**
-   * Updates the review info for a clinic
-   * @param clinicId The ID of the clinic to update
-   * @param removedReview Optional review being removed
-   * @param isRemoval Whether this update is for a review removal
-   * @returns The updated clinic review info
-   */
-  async updateClinicReviewInfo(
-    clinicId: string,
-    removedReview?: ClinicReview,
-    isRemoval: boolean = false
-  ): Promise<ClinicReviewInfo> {
-    console.log(
-      `[ReviewsAggregationService] Updating review info for clinic: ${clinicId}`
-    );
-
-    // Get the current clinic document
-    const clinicDoc = await this.db
-      .collection(CLINICS_COLLECTION)
-      .doc(clinicId)
-      .get();
-
-    if (!clinicDoc.exists) {
-      console.error(
-        `[ReviewsAggregationService] Clinic with ID ${clinicId} not found`
-      );
-      throw new Error(`Clinic with ID ${clinicId} not found`);
-    }
-
-    const clinicData = clinicDoc.data();
-    const currentReviewInfo = (clinicData?.reviewInfo as ClinicReviewInfo) || {
-      totalReviews: 0,
-      averageRating: 0,
-      cleanliness: 0,
-      facilities: 0,
-      staffFriendliness: 0,
-      waitingTime: 0,
-      accessibility: 0,
-      recommendationPercentage: 0,
-    };
-
-    // Get all reviews for this clinic
-    const reviewsQuery = await this.db
-      .collection(REVIEWS_COLLECTION)
-      .where("clinicReview.clinicId", "==", clinicId)
-      .get();
-
-    // If we're removing the last review or there are no reviews, set default values
-    if ((isRemoval && reviewsQuery.size <= 1) || reviewsQuery.empty) {
-      const updatedReviewInfo: ClinicReviewInfo = {
-        totalReviews: 0,
-        averageRating: 0,
-        cleanliness: 0,
-        facilities: 0,
-        staffFriendliness: 0,
-        waitingTime: 0,
-        accessibility: 0,
-        recommendationPercentage: 0,
-      };
-
-      await this.db.collection(CLINICS_COLLECTION).doc(clinicId).update({
-        reviewInfo: updatedReviewInfo,
-        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-      });
-
-      console.log(
-        `[ReviewsAggregationService] Reset review info for clinic: ${clinicId}`
-      );
-      return updatedReviewInfo;
-    }
-
-    // Calculate new averages from all reviews
-    const reviews = reviewsQuery.docs.map((doc) => doc.data() as Review);
-    const clinicReviews = reviews
-      .map((review) => review.clinicReview)
-      .filter((review): review is ClinicReview => review !== undefined);
-
-    // Calculate averages
-    let totalRating = 0;
-    let totalCleanliness = 0;
-    let totalFacilities = 0;
-    let totalStaffFriendliness = 0;
-    let totalWaitingTime = 0;
-    let totalAccessibility = 0;
-    let totalRecommendations = 0;
-
-    clinicReviews.forEach((review) => {
-      totalRating += review.overallRating;
-      totalCleanliness += review.cleanliness;
-      totalFacilities += review.facilities;
-      totalStaffFriendliness += review.staffFriendliness;
-      totalWaitingTime += review.waitingTime;
-      totalAccessibility += review.accessibility;
-      if (review.wouldRecommend) totalRecommendations++;
-    });
-
-    const count = clinicReviews.length;
-    const roundToOneDecimal = (value: number): number =>
-      Math.round((value / count) * 10) / 10;
-
-    const updatedReviewInfo: ClinicReviewInfo = {
-      totalReviews: count,
-      averageRating: roundToOneDecimal(totalRating),
-      cleanliness: roundToOneDecimal(totalCleanliness),
-      facilities: roundToOneDecimal(totalFacilities),
-      staffFriendliness: roundToOneDecimal(totalStaffFriendliness),
-      waitingTime: roundToOneDecimal(totalWaitingTime),
-      accessibility: roundToOneDecimal(totalAccessibility),
-      recommendationPercentage:
-        Math.round((totalRecommendations / count) * 1000) / 10,
-    };
-
-    // Update the clinic with the new review info
-    await this.db.collection(CLINICS_COLLECTION).doc(clinicId).update({
-      reviewInfo: updatedReviewInfo,
-      updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-    });
-
-    console.log(
-      `[ReviewsAggregationService] Updated review info for clinic: ${clinicId}`
-    );
-    return updatedReviewInfo;
-  }
-
-  /**
-   * Updates the review info for a practitioner
-   * @param practitionerId The ID of the practitioner to update
-   * @param removedReview Optional review being removed
-   * @param isRemoval Whether this update is for a review removal
-   * @returns The updated practitioner review info
-   */
-  async updatePractitionerReviewInfo(
-    practitionerId: string,
-    removedReview?: PractitionerReview,
-    isRemoval: boolean = false
-  ): Promise<PractitionerReviewInfo> {
-    console.log(
-      `[ReviewsAggregationService] Updating review info for practitioner: ${practitionerId}`
-    );
-
-    // Get the current practitioner document
-    const practitionerDoc = await this.db
-      .collection(PRACTITIONERS_COLLECTION)
-      .doc(practitionerId)
-      .get();
-
-    if (!practitionerDoc.exists) {
-      console.error(
-        `[ReviewsAggregationService] Practitioner with ID ${practitionerId} not found`
-      );
-      throw new Error(`Practitioner with ID ${practitionerId} not found`);
-    }
-
-    const practitionerData = practitionerDoc.data();
-    const currentReviewInfo =
-      (practitionerData?.reviewInfo as PractitionerReviewInfo) || {
-        totalReviews: 0,
-        averageRating: 0,
-        knowledgeAndExpertise: 0,
-        communicationSkills: 0,
-        bedSideManner: 0,
-        thoroughness: 0,
-        trustworthiness: 0,
-        recommendationPercentage: 0,
-      };
-
-    // Get all reviews for this practitioner
-    const reviewsQuery = await this.db
-      .collection(REVIEWS_COLLECTION)
-      .where("practitionerReview.practitionerId", "==", practitionerId)
-      .get();
-
-    // If we're removing the last review or there are no reviews, set default values
-    if ((isRemoval && reviewsQuery.size <= 1) || reviewsQuery.empty) {
-      const updatedReviewInfo: PractitionerReviewInfo = {
-        totalReviews: 0,
-        averageRating: 0,
-        knowledgeAndExpertise: 0,
-        communicationSkills: 0,
-        bedSideManner: 0,
-        thoroughness: 0,
-        trustworthiness: 0,
-        recommendationPercentage: 0,
-      };
-
-      await this.db
-        .collection(PRACTITIONERS_COLLECTION)
-        .doc(practitionerId)
-        .update({
-          reviewInfo: updatedReviewInfo,
-          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-        });
-
-      // Also update doctor info in procedures with the new rating
-      await this.updateDoctorInfoInProcedures(practitionerId, 0);
-
-      console.log(
-        `[ReviewsAggregationService] Reset review info for practitioner: ${practitionerId}`
-      );
-      return updatedReviewInfo;
-    }
-
-    // Calculate new averages from all reviews
-    const reviews = reviewsQuery.docs.map((doc) => doc.data() as Review);
-    const practitionerReviews = reviews
-      .map((review) => review.practitionerReview)
-      .filter((review): review is PractitionerReview => review !== undefined);
-
-    // Calculate averages
-    let totalRating = 0;
-    let totalKnowledgeAndExpertise = 0;
-    let totalCommunicationSkills = 0;
-    let totalBedSideManner = 0;
-    let totalThoroughness = 0;
-    let totalTrustworthiness = 0;
-    let totalRecommendations = 0;
-
-    practitionerReviews.forEach((review) => {
-      totalRating += review.overallRating;
-      totalKnowledgeAndExpertise += review.knowledgeAndExpertise;
-      totalCommunicationSkills += review.communicationSkills;
-      totalBedSideManner += review.bedSideManner;
-      totalThoroughness += review.thoroughness;
-      totalTrustworthiness += review.trustworthiness;
-      if (review.wouldRecommend) totalRecommendations++;
-    });
-
-    const count = practitionerReviews.length;
-    const roundToOneDecimal = (value: number): number =>
-      Math.round((value / count) * 10) / 10;
-
-    const updatedReviewInfo: PractitionerReviewInfo = {
-      totalReviews: count,
-      averageRating: roundToOneDecimal(totalRating),
-      knowledgeAndExpertise: roundToOneDecimal(totalKnowledgeAndExpertise),
-      communicationSkills: roundToOneDecimal(totalCommunicationSkills),
-      bedSideManner: roundToOneDecimal(totalBedSideManner),
-      thoroughness: roundToOneDecimal(totalThoroughness),
-      trustworthiness: roundToOneDecimal(totalTrustworthiness),
-      recommendationPercentage:
-        Math.round((totalRecommendations / count) * 1000) / 10,
-    };
-
-    // Update the practitioner with the new review info
-    await this.db
-      .collection(PRACTITIONERS_COLLECTION)
-      .doc(practitionerId)
-      .update({
-        reviewInfo: updatedReviewInfo,
-        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-      });
-
-    // Also update doctor info in procedures with the new rating
-    await this.updateDoctorInfoInProcedures(
-      practitionerId,
-      updatedReviewInfo.averageRating
-    );
-
-    console.log(
-      `[ReviewsAggregationService] Updated review info for practitioner: ${practitionerId}`
-    );
-    return updatedReviewInfo;
-  }
-
-  /**
-   * Updates the review info for a procedure
-   * @param procedureId The ID of the procedure to update
-   * @param removedReview Optional review being removed
-   * @param isRemoval Whether this update is for a review removal
-   * @returns The updated procedure review info
-   */
-  async updateProcedureReviewInfo(
-    procedureId: string,
-    removedReview?: ProcedureReview,
-    isRemoval: boolean = false
-  ): Promise<ProcedureReviewInfo> {
-    console.log(
-      `[ReviewsAggregationService] Updating review info for procedure: ${procedureId}`
-    );
-
-    // Get the current procedure document
-    const procedureDoc = await this.db
-      .collection(PROCEDURES_COLLECTION)
-      .doc(procedureId)
-      .get();
-
-    if (!procedureDoc.exists) {
-      console.error(
-        `[ReviewsAggregationService] Procedure with ID ${procedureId} not found`
-      );
-      throw new Error(`Procedure with ID ${procedureId} not found`);
-    }
-
-    const procedureData = procedureDoc.data();
-    const currentReviewInfo =
-      (procedureData?.reviewInfo as ProcedureReviewInfo) || {
-        totalReviews: 0,
-        averageRating: 0,
-        effectivenessOfTreatment: 0,
-        outcomeExplanation: 0,
-        painManagement: 0,
-        followUpCare: 0,
-        valueForMoney: 0,
-        recommendationPercentage: 0,
-      };
-
-    // Get all reviews for this procedure (both main and extended)
-    // We need to check both procedureReview.procedureId and extendedProcedureReviews array
-    const allReviewsQuery = await this.db
-      .collection(REVIEWS_COLLECTION)
-      .get();
-
-    // Filter reviews that contain this procedure (either as main or extended)
-    const reviews = allReviewsQuery.docs.map((doc) => doc.data() as Review);
-    const procedureReviews: ProcedureReview[] = [];
-
-    reviews.forEach((review) => {
-      // Check if this is the main procedure
-      if (review.procedureReview && review.procedureReview.procedureId === procedureId) {
-        procedureReviews.push(review.procedureReview);
-      }
-      // Check if this is in extended procedures
-      if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
-        const matchingExtended = review.extendedProcedureReviews.filter(
-          (extReview) => extReview.procedureId === procedureId
-        );
-        procedureReviews.push(...matchingExtended);
-      }
-    });
-
-    // If there are no reviews, set default values
-    if (procedureReviews.length === 0) {
-      const updatedReviewInfo: ProcedureReviewInfo = {
-        totalReviews: 0,
-        averageRating: 0,
-        effectivenessOfTreatment: 0,
-        outcomeExplanation: 0,
-        painManagement: 0,
-        followUpCare: 0,
-        valueForMoney: 0,
-        recommendationPercentage: 0,
-      };
-
-      await this.db.collection(PROCEDURES_COLLECTION).doc(procedureId).update({
-        reviewInfo: updatedReviewInfo,
-        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-      });
-
-      console.log(
-        `[ReviewsAggregationService] Reset review info for procedure: ${procedureId}`
-      );
-      return updatedReviewInfo;
-    }
-
-    // Calculate averages
-    let totalRating = 0;
-    let totalEffectivenessOfTreatment = 0;
-    let totalOutcomeExplanation = 0;
-    let totalPainManagement = 0;
-    let totalFollowUpCare = 0;
-    let totalValueForMoney = 0;
-    let totalRecommendations = 0;
-
-    procedureReviews.forEach((review) => {
-      totalRating += review.overallRating;
-      totalEffectivenessOfTreatment += review.effectivenessOfTreatment;
-      totalOutcomeExplanation += review.outcomeExplanation;
-      totalPainManagement += review.painManagement;
-      totalFollowUpCare += review.followUpCare;
-      totalValueForMoney += review.valueForMoney;
-      if (review.wouldRecommend) totalRecommendations++;
-    });
-
-    const count = procedureReviews.length;
-    const roundToOneDecimal = (value: number): number =>
-      Math.round((value / count) * 10) / 10;
-
-    const updatedReviewInfo: ProcedureReviewInfo = {
-      totalReviews: count,
-      averageRating: roundToOneDecimal(totalRating),
-      effectivenessOfTreatment: roundToOneDecimal(
-        totalEffectivenessOfTreatment
-      ),
-      outcomeExplanation: roundToOneDecimal(totalOutcomeExplanation),
-      painManagement: roundToOneDecimal(totalPainManagement),
-      followUpCare: roundToOneDecimal(totalFollowUpCare),
-      valueForMoney: roundToOneDecimal(totalValueForMoney),
-      recommendationPercentage:
-        Math.round((totalRecommendations / count) * 1000) / 10,
-    };
-
-    // Update the procedure with the new review info
-    await this.db.collection(PROCEDURES_COLLECTION).doc(procedureId).update({
-      reviewInfo: updatedReviewInfo,
-      updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-    });
-
-    console.log(
-      `[ReviewsAggregationService] Updated review info for procedure: ${procedureId}`
-    );
-    return updatedReviewInfo;
-  }
-
-  /**
-   * Updates doctorInfo rating in all procedures for a practitioner
-   * @param practitionerId The ID of the practitioner
-   * @param rating The new rating to set
-   */
-  private async updateDoctorInfoInProcedures(
-    practitionerId: string,
-    rating: number
-  ): Promise<void> {
-    console.log(
-      `[ReviewsAggregationService] Updating doctor info in procedures for practitioner: ${practitionerId}`
-    );
-
-    // Find all procedures for this practitioner
-    const proceduresQuery = await this.db
-      .collection(PROCEDURES_COLLECTION)
-      .where("practitionerId", "==", practitionerId)
-      .get();
-
-    if (proceduresQuery.empty) {
-      console.log(
-        `[ReviewsAggregationService] No procedures found for practitioner: ${practitionerId}`
-      );
-      return;
-    }
-
-    // Batch update all procedures
-    const batch = this.db.batch();
-
-    proceduresQuery.docs.forEach((docSnapshot) => {
-      const procedureRef = this.db
-        .collection(PROCEDURES_COLLECTION)
-        .doc(docSnapshot.id);
-      batch.update(procedureRef, {
-        "doctorInfo.rating": rating,
-        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-      });
-    });
-
-    await batch.commit();
-    console.log(
-      `[ReviewsAggregationService] Updated doctor info in ${proceduresQuery.size} procedures for practitioner: ${practitionerId}`
-    );
-  }
-
-  /**
-   * Verifies a review as checked by admin/staff
-   * @param reviewId The ID of the review to verify
-   */
-  async verifyReview(reviewId: string): Promise<void> {
-    console.log(`[ReviewsAggregationService] Verifying review: ${reviewId}`);
-
-    // Get the review
-    const reviewDoc = await this.db
-      .collection(REVIEWS_COLLECTION)
-      .doc(reviewId)
-      .get();
-
-    if (!reviewDoc.exists) {
-      console.error(
-        `[ReviewsAggregationService] Review with ID ${reviewId} not found`
-      );
-      throw new Error(`Review with ID ${reviewId} not found`);
-    }
-
-    const review = reviewDoc.data() as Review;
-    const batch = this.db.batch();
-    const reviewRef = this.db.collection(REVIEWS_COLLECTION).doc(reviewId);
-
-    // Update clinic review if it exists
-    if (review.clinicReview) {
-      review.clinicReview.isVerified = true;
-    }
-
-    // Update practitioner review if it exists
-    if (review.practitionerReview) {
-      review.practitionerReview.isVerified = true;
-    }
-
-    // Update procedure review if it exists
-    if (review.procedureReview) {
-      review.procedureReview.isVerified = true;
-    }
-
-    // Update extended procedure reviews if they exist
-    if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
-      review.extendedProcedureReviews.forEach((extReview) => {
-        extReview.isVerified = true;
-      });
-    }
-
-    // Update the review
-    batch.update(reviewRef, {
-      clinicReview: review.clinicReview,
-      practitionerReview: review.practitionerReview,
-      procedureReview: review.procedureReview,
-      extendedProcedureReviews: review.extendedProcedureReviews,
-      updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-    });
-
-    await batch.commit();
-    console.log(
-      `[ReviewsAggregationService] Successfully verified review: ${reviewId}`
-    );
-  }
-
-  /**
-   * Calculate the average of all reviews for an entity
-   * @param entityId The entity ID
-   * @param entityType The type of entity ('clinic', 'practitioner', or 'procedure')
-   * @returns Promise that resolves to the calculated review info
-   */
-  async calculateEntityReviewInfo(
-    entityId: string,
-    entityType: "clinic" | "practitioner" | "procedure"
-  ): Promise<ClinicReviewInfo | PractitionerReviewInfo | ProcedureReviewInfo> {
-    console.log(
-      `[ReviewsAggregationService] Calculating review info for ${entityType}: ${entityId}`
-    );
-
-    switch (entityType) {
-      case "clinic":
-        return this.updateClinicReviewInfo(entityId);
-      case "practitioner":
-        return this.updatePractitionerReviewInfo(entityId);
-      case "procedure":
-        return this.updateProcedureReviewInfo(entityId);
-      default:
-        throw new Error(`Invalid entity type: ${entityType}`);
-    }
-  }
-}
+import * as admin from "firebase-admin";
+import {
+  Review,
+  ClinicReview,
+  PractitionerReview,
+  ProcedureReview,
+  REVIEWS_COLLECTION,
+  ClinicReviewInfo,
+  PractitionerReviewInfo,
+  ProcedureReviewInfo,
+} from "../../../types/reviews";
+import { CLINICS_COLLECTION } from "../../../types/clinic";
+import { PRACTITIONERS_COLLECTION } from "../../../types/practitioner";
+import { PROCEDURES_COLLECTION } from "../../../types/procedure";
+
+/**
+ * @class ReviewsAggregationService
+ * @description Handles aggregation tasks related to review data updates.
+ * This service is intended to be used primarily by background functions (e.g., Cloud Functions)
+ * triggered by changes in the reviews collection.
+ */
+export class ReviewsAggregationService {
+  private db: admin.firestore.Firestore;
+
+  /**
+   * Constructor for ReviewsAggregationService.
+   * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
+   */
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.firestore();
+  }
+
+  /**
+   * Process a newly created review and update all related entities
+   * @param review The newly created review
+   * @returns Promise resolving when all updates are complete
+   */
+  async processNewReview(review: Review): Promise<void> {
+    console.log(
+      `[ReviewsAggregationService] Processing new review: ${review.id}`
+    );
+
+    const updatePromises: Promise<any>[] = [];
+
+    // Update clinic if clinic review exists
+    if (review.clinicReview) {
+      updatePromises.push(
+        this.updateClinicReviewInfo(review.clinicReview.clinicId)
+      );
+    }
+
+    // Update practitioner if practitioner review exists
+    if (review.practitionerReview) {
+      updatePromises.push(
+        this.updatePractitionerReviewInfo(
+          review.practitionerReview.practitionerId
+        )
+      );
+    }
+
+    // Update procedure if procedure review exists
+    if (review.procedureReview) {
+      updatePromises.push(
+        this.updateProcedureReviewInfo(review.procedureReview.procedureId)
+      );
+    }
+
+    // Wait for all updates to complete
+    await Promise.all(updatePromises);
+    console.log(
+      `[ReviewsAggregationService] Successfully processed review: ${review.id}`
+    );
+  }
+
+  /**
+   * Process a deleted review and update all related entities
+   * @param review The deleted review
+   * @returns Promise resolving when all updates are complete
+   */
+  async processDeletedReview(review: Review): Promise<void> {
+    console.log(
+      `[ReviewsAggregationService] Processing deleted review: ${review.id}`
+    );
+
+    const updatePromises: Promise<any>[] = [];
+
+    // Update clinic if clinic review exists
+    if (review.clinicReview) {
+      updatePromises.push(
+        this.updateClinicReviewInfo(
+          review.clinicReview.clinicId,
+          review.clinicReview,
+          true
+        )
+      );
+    }
+
+    // Update practitioner if practitioner review exists
+    if (review.practitionerReview) {
+      updatePromises.push(
+        this.updatePractitionerReviewInfo(
+          review.practitionerReview.practitionerId,
+          review.practitionerReview,
+          true
+        )
+      );
+    }
+
+    // Update procedure if procedure review exists
+    if (review.procedureReview) {
+      updatePromises.push(
+        this.updateProcedureReviewInfo(
+          review.procedureReview.procedureId,
+          review.procedureReview,
+          true
+        )
+      );
+    }
+
+    // Wait for all updates to complete
+    await Promise.all(updatePromises);
+    console.log(
+      `[ReviewsAggregationService] Successfully processed deleted review: ${review.id}`
+    );
+  }
+
+  /**
+   * Updates the review info for a clinic
+   * @param clinicId The ID of the clinic to update
+   * @param removedReview Optional review being removed
+   * @param isRemoval Whether this update is for a review removal
+   * @returns The updated clinic review info
+   */
+  async updateClinicReviewInfo(
+    clinicId: string,
+    removedReview?: ClinicReview,
+    isRemoval: boolean = false
+  ): Promise<ClinicReviewInfo> {
+    console.log(
+      `[ReviewsAggregationService] Updating review info for clinic: ${clinicId}`
+    );
+
+    // Get the current clinic document
+    const clinicDoc = await this.db
+      .collection(CLINICS_COLLECTION)
+      .doc(clinicId)
+      .get();
+
+    if (!clinicDoc.exists) {
+      console.error(
+        `[ReviewsAggregationService] Clinic with ID ${clinicId} not found`
+      );
+      throw new Error(`Clinic with ID ${clinicId} not found`);
+    }
+
+    const clinicData = clinicDoc.data();
+    const currentReviewInfo = (clinicData?.reviewInfo as ClinicReviewInfo) || {
+      totalReviews: 0,
+      averageRating: 0,
+      cleanliness: 0,
+      facilities: 0,
+      staffFriendliness: 0,
+      waitingTime: 0,
+      accessibility: 0,
+      recommendationPercentage: 0,
+    };
+
+    // Get all reviews for this clinic
+    const reviewsQuery = await this.db
+      .collection(REVIEWS_COLLECTION)
+      .where("clinicReview.clinicId", "==", clinicId)
+      .get();
+
+    // If we're removing the last review or there are no reviews, set default values
+    if ((isRemoval && reviewsQuery.size <= 1) || reviewsQuery.empty) {
+      const updatedReviewInfo: ClinicReviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        cleanliness: 0,
+        facilities: 0,
+        staffFriendliness: 0,
+        waitingTime: 0,
+        accessibility: 0,
+        recommendationPercentage: 0,
+      };
+
+      await this.db.collection(CLINICS_COLLECTION).doc(clinicId).update({
+        reviewInfo: updatedReviewInfo,
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+      console.log(
+        `[ReviewsAggregationService] Reset review info for clinic: ${clinicId}`
+      );
+      return updatedReviewInfo;
+    }
+
+    // Calculate new averages from all reviews
+    const reviews = reviewsQuery.docs.map((doc) => doc.data() as Review);
+    const clinicReviews = reviews
+      .map((review) => review.clinicReview)
+      .filter((review): review is ClinicReview => review !== undefined);
+
+    // Calculate averages
+    let totalRating = 0;
+    let totalCleanliness = 0;
+    let totalFacilities = 0;
+    let totalStaffFriendliness = 0;
+    let totalWaitingTime = 0;
+    let totalAccessibility = 0;
+    let totalRecommendations = 0;
+
+    clinicReviews.forEach((review) => {
+      totalRating += review.overallRating;
+      totalCleanliness += review.cleanliness;
+      totalFacilities += review.facilities;
+      totalStaffFriendliness += review.staffFriendliness;
+      totalWaitingTime += review.waitingTime;
+      totalAccessibility += review.accessibility;
+      if (review.wouldRecommend) totalRecommendations++;
+    });
+
+    const count = clinicReviews.length;
+    const roundToOneDecimal = (value: number): number =>
+      Math.round((value / count) * 10) / 10;
+
+    const updatedReviewInfo: ClinicReviewInfo = {
+      totalReviews: count,
+      averageRating: roundToOneDecimal(totalRating),
+      cleanliness: roundToOneDecimal(totalCleanliness),
+      facilities: roundToOneDecimal(totalFacilities),
+      staffFriendliness: roundToOneDecimal(totalStaffFriendliness),
+      waitingTime: roundToOneDecimal(totalWaitingTime),
+      accessibility: roundToOneDecimal(totalAccessibility),
+      recommendationPercentage:
+        Math.round((totalRecommendations / count) * 1000) / 10,
+    };
+
+    // Update the clinic with the new review info
+    await this.db.collection(CLINICS_COLLECTION).doc(clinicId).update({
+      reviewInfo: updatedReviewInfo,
+      updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+    });
+
+    console.log(
+      `[ReviewsAggregationService] Updated review info for clinic: ${clinicId}`
+    );
+    return updatedReviewInfo;
+  }
+
+  /**
+   * Updates the review info for a practitioner
+   * @param practitionerId The ID of the practitioner to update
+   * @param removedReview Optional review being removed
+   * @param isRemoval Whether this update is for a review removal
+   * @returns The updated practitioner review info
+   */
+  async updatePractitionerReviewInfo(
+    practitionerId: string,
+    removedReview?: PractitionerReview,
+    isRemoval: boolean = false
+  ): Promise<PractitionerReviewInfo> {
+    console.log(
+      `[ReviewsAggregationService] Updating review info for practitioner: ${practitionerId}`
+    );
+
+    // Get the current practitioner document
+    const practitionerDoc = await this.db
+      .collection(PRACTITIONERS_COLLECTION)
+      .doc(practitionerId)
+      .get();
+
+    if (!practitionerDoc.exists) {
+      console.error(
+        `[ReviewsAggregationService] Practitioner with ID ${practitionerId} not found`
+      );
+      throw new Error(`Practitioner with ID ${practitionerId} not found`);
+    }
+
+    const practitionerData = practitionerDoc.data();
+    const currentReviewInfo =
+      (practitionerData?.reviewInfo as PractitionerReviewInfo) || {
+        totalReviews: 0,
+        averageRating: 0,
+        knowledgeAndExpertise: 0,
+        communicationSkills: 0,
+        bedSideManner: 0,
+        thoroughness: 0,
+        trustworthiness: 0,
+        recommendationPercentage: 0,
+      };
+
+    // Get all reviews for this practitioner
+    const reviewsQuery = await this.db
+      .collection(REVIEWS_COLLECTION)
+      .where("practitionerReview.practitionerId", "==", practitionerId)
+      .get();
+
+    // If we're removing the last review or there are no reviews, set default values
+    if ((isRemoval && reviewsQuery.size <= 1) || reviewsQuery.empty) {
+      const updatedReviewInfo: PractitionerReviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        knowledgeAndExpertise: 0,
+        communicationSkills: 0,
+        bedSideManner: 0,
+        thoroughness: 0,
+        trustworthiness: 0,
+        recommendationPercentage: 0,
+      };
+
+      await this.db
+        .collection(PRACTITIONERS_COLLECTION)
+        .doc(practitionerId)
+        .update({
+          reviewInfo: updatedReviewInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+
+      // Also update doctor info in procedures with the new rating
+      await this.updateDoctorInfoInProcedures(practitionerId, 0);
+
+      console.log(
+        `[ReviewsAggregationService] Reset review info for practitioner: ${practitionerId}`
+      );
+      return updatedReviewInfo;
+    }
+
+    // Calculate new averages from all reviews
+    const reviews = reviewsQuery.docs.map((doc) => doc.data() as Review);
+    const practitionerReviews = reviews
+      .map((review) => review.practitionerReview)
+      .filter((review): review is PractitionerReview => review !== undefined);
+
+    // Calculate averages
+    let totalRating = 0;
+    let totalKnowledgeAndExpertise = 0;
+    let totalCommunicationSkills = 0;
+    let totalBedSideManner = 0;
+    let totalThoroughness = 0;
+    let totalTrustworthiness = 0;
+    let totalRecommendations = 0;
+
+    practitionerReviews.forEach((review) => {
+      totalRating += review.overallRating;
+      totalKnowledgeAndExpertise += review.knowledgeAndExpertise;
+      totalCommunicationSkills += review.communicationSkills;
+      totalBedSideManner += review.bedSideManner;
+      totalThoroughness += review.thoroughness;
+      totalTrustworthiness += review.trustworthiness;
+      if (review.wouldRecommend) totalRecommendations++;
+    });
+
+    const count = practitionerReviews.length;
+    const roundToOneDecimal = (value: number): number =>
+      Math.round((value / count) * 10) / 10;
+
+    const updatedReviewInfo: PractitionerReviewInfo = {
+      totalReviews: count,
+      averageRating: roundToOneDecimal(totalRating),
+      knowledgeAndExpertise: roundToOneDecimal(totalKnowledgeAndExpertise),
+      communicationSkills: roundToOneDecimal(totalCommunicationSkills),
+      bedSideManner: roundToOneDecimal(totalBedSideManner),
+      thoroughness: roundToOneDecimal(totalThoroughness),
+      trustworthiness: roundToOneDecimal(totalTrustworthiness),
+      recommendationPercentage:
+        Math.round((totalRecommendations / count) * 1000) / 10,
+    };
+
+    // Update the practitioner with the new review info
+    await this.db
+      .collection(PRACTITIONERS_COLLECTION)
+      .doc(practitionerId)
+      .update({
+        reviewInfo: updatedReviewInfo,
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+    // Also update doctor info in procedures with the new rating
+    await this.updateDoctorInfoInProcedures(
+      practitionerId,
+      updatedReviewInfo.averageRating
+    );
+
+    console.log(
+      `[ReviewsAggregationService] Updated review info for practitioner: ${practitionerId}`
+    );
+    return updatedReviewInfo;
+  }
+
+  /**
+   * Updates the review info for a procedure
+   * @param procedureId The ID of the procedure to update
+   * @param removedReview Optional review being removed
+   * @param isRemoval Whether this update is for a review removal
+   * @returns The updated procedure review info
+   */
+  async updateProcedureReviewInfo(
+    procedureId: string,
+    removedReview?: ProcedureReview,
+    isRemoval: boolean = false
+  ): Promise<ProcedureReviewInfo> {
+    console.log(
+      `[ReviewsAggregationService] Updating review info for procedure: ${procedureId}`
+    );
+
+    // Get the current procedure document
+    const procedureDoc = await this.db
+      .collection(PROCEDURES_COLLECTION)
+      .doc(procedureId)
+      .get();
+
+    if (!procedureDoc.exists) {
+      console.error(
+        `[ReviewsAggregationService] Procedure with ID ${procedureId} not found`
+      );
+      throw new Error(`Procedure with ID ${procedureId} not found`);
+    }
+
+    const procedureData = procedureDoc.data();
+    const currentReviewInfo =
+      (procedureData?.reviewInfo as ProcedureReviewInfo) || {
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0,
+      };
+
+    // Get all reviews for this procedure
+    const reviewsQuery = await this.db
+      .collection(REVIEWS_COLLECTION)
+      .where("procedureReview.procedureId", "==", procedureId)
+      .get();
+
+    // If we're removing the last review or there are no reviews, set default values
+    if ((isRemoval && reviewsQuery.size <= 1) || reviewsQuery.empty) {
+      const updatedReviewInfo: ProcedureReviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0,
+      };
+
+      await this.db.collection(PROCEDURES_COLLECTION).doc(procedureId).update({
+        reviewInfo: updatedReviewInfo,
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+      console.log(
+        `[ReviewsAggregationService] Reset review info for procedure: ${procedureId}`
+      );
+      return updatedReviewInfo;
+    }
+
+    // Calculate new averages from all reviews
+    const reviews = reviewsQuery.docs.map((doc) => doc.data() as Review);
+    const procedureReviews = reviews
+      .map((review) => review.procedureReview)
+      .filter((review): review is ProcedureReview => review !== undefined);
+
+    // Calculate averages
+    let totalRating = 0;
+    let totalEffectivenessOfTreatment = 0;
+    let totalOutcomeExplanation = 0;
+    let totalPainManagement = 0;
+    let totalFollowUpCare = 0;
+    let totalValueForMoney = 0;
+    let totalRecommendations = 0;
+
+    procedureReviews.forEach((review) => {
+      totalRating += review.overallRating;
+      totalEffectivenessOfTreatment += review.effectivenessOfTreatment;
+      totalOutcomeExplanation += review.outcomeExplanation;
+      totalPainManagement += review.painManagement;
+      totalFollowUpCare += review.followUpCare;
+      totalValueForMoney += review.valueForMoney;
+      if (review.wouldRecommend) totalRecommendations++;
+    });
+
+    const count = procedureReviews.length;
+    const roundToOneDecimal = (value: number): number =>
+      Math.round((value / count) * 10) / 10;
+
+    const updatedReviewInfo: ProcedureReviewInfo = {
+      totalReviews: count,
+      averageRating: roundToOneDecimal(totalRating),
+      effectivenessOfTreatment: roundToOneDecimal(
+        totalEffectivenessOfTreatment
+      ),
+      outcomeExplanation: roundToOneDecimal(totalOutcomeExplanation),
+      painManagement: roundToOneDecimal(totalPainManagement),
+      followUpCare: roundToOneDecimal(totalFollowUpCare),
+      valueForMoney: roundToOneDecimal(totalValueForMoney),
+      recommendationPercentage:
+        Math.round((totalRecommendations / count) * 1000) / 10,
+    };
+
+    // Update the procedure with the new review info
+    await this.db.collection(PROCEDURES_COLLECTION).doc(procedureId).update({
+      reviewInfo: updatedReviewInfo,
+      updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+    });
+
+    console.log(
+      `[ReviewsAggregationService] Updated review info for procedure: ${procedureId}`
+    );
+    return updatedReviewInfo;
+  }
+
+  /**
+   * Updates doctorInfo rating in all procedures for a practitioner
+   * @param practitionerId The ID of the practitioner
+   * @param rating The new rating to set
+   */
+  private async updateDoctorInfoInProcedures(
+    practitionerId: string,
+    rating: number
+  ): Promise<void> {
+    console.log(
+      `[ReviewsAggregationService] Updating doctor info in procedures for practitioner: ${practitionerId}`
+    );
+
+    // Find all procedures for this practitioner
+    const proceduresQuery = await this.db
+      .collection(PROCEDURES_COLLECTION)
+      .where("practitionerId", "==", practitionerId)
+      .get();
+
+    if (proceduresQuery.empty) {
+      console.log(
+        `[ReviewsAggregationService] No procedures found for practitioner: ${practitionerId}`
+      );
+      return;
+    }
+
+    // Batch update all procedures
+    const batch = this.db.batch();
+
+    proceduresQuery.docs.forEach((docSnapshot) => {
+      const procedureRef = this.db
+        .collection(PROCEDURES_COLLECTION)
+        .doc(docSnapshot.id);
+      batch.update(procedureRef, {
+        "doctorInfo.rating": rating,
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+    });
+
+    await batch.commit();
+    console.log(
+      `[ReviewsAggregationService] Updated doctor info in ${proceduresQuery.size} procedures for practitioner: ${practitionerId}`
+    );
+  }
+
+  /**
+   * Verifies a review as checked by admin/staff
+   * @param reviewId The ID of the review to verify
+   */
+  async verifyReview(reviewId: string): Promise<void> {
+    console.log(`[ReviewsAggregationService] Verifying review: ${reviewId}`);
+
+    // Get the review
+    const reviewDoc = await this.db
+      .collection(REVIEWS_COLLECTION)
+      .doc(reviewId)
+      .get();
+
+    if (!reviewDoc.exists) {
+      console.error(
+        `[ReviewsAggregationService] Review with ID ${reviewId} not found`
+      );
+      throw new Error(`Review with ID ${reviewId} not found`);
+    }
+
+    const review = reviewDoc.data() as Review;
+    const batch = this.db.batch();
+    const reviewRef = this.db.collection(REVIEWS_COLLECTION).doc(reviewId);
+
+    // Update clinic review if it exists
+    if (review.clinicReview) {
+      review.clinicReview.isVerified = true;
+    }
+
+    // Update practitioner review if it exists
+    if (review.practitionerReview) {
+      review.practitionerReview.isVerified = true;
+    }
+
+    // Update procedure review if it exists
+    if (review.procedureReview) {
+      review.procedureReview.isVerified = true;
+    }
+
+    // Update the review
+    batch.update(reviewRef, {
+      clinicReview: review.clinicReview,
+      practitionerReview: review.practitionerReview,
+      procedureReview: review.procedureReview,
+      updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+    });
+
+    await batch.commit();
+    console.log(
+      `[ReviewsAggregationService] Successfully verified review: ${reviewId}`
+    );
+  }
+
+  /**
+   * Calculate the average of all reviews for an entity
+   * @param entityId The entity ID
+   * @param entityType The type of entity ('clinic', 'practitioner', or 'procedure')
+   * @returns Promise that resolves to the calculated review info
+   */
+  async calculateEntityReviewInfo(
+    entityId: string,
+    entityType: "clinic" | "practitioner" | "procedure"
+  ): Promise<ClinicReviewInfo | PractitionerReviewInfo | ProcedureReviewInfo> {
+    console.log(
+      `[ReviewsAggregationService] Calculating review info for ${entityType}: ${entityId}`
+    );
+
+    switch (entityType) {
+      case "clinic":
+        return this.updateClinicReviewInfo(entityId);
+      case "practitioner":
+        return this.updatePractitionerReviewInfo(entityId);
+      case "procedure":
+        return this.updateProcedureReviewInfo(entityId);
+      default:
+        throw new Error(`Invalid entity type: ${entityType}`);
+    }
+  }
+}