@blackcode_sa/metaestetics-api 1.5.28 → 1.5.30

package/src/services/reviews/reviews.service.ts

@@ -0,0 +1,842 @@
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  setDoc,
+  deleteDoc,
+  Timestamp,
+  serverTimestamp,
+  DocumentData,
+  writeBatch,
+} from "firebase/firestore";
+import { BaseService } from "../base.service";
+import {
+  Review,
+  ClinicReview,
+  PractitionerReview,
+  ProcedureReview,
+  REVIEWS_COLLECTION,
+  ClinicReviewInfo,
+  PractitionerReviewInfo,
+  ProcedureReviewInfo,
+} from "../../types/reviews";
+import {
+  createReviewSchema,
+  reviewSchema,
+} from "../../validations/reviews.schema";
+import { z } from "zod";
+import { Auth } from "firebase/auth";
+import { Firestore } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import { CLINICS_COLLECTION } from "../../types/clinic";
+import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
+import { PROCEDURES_COLLECTION } from "../../types/procedure";
+
+export class ReviewService extends BaseService {
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+    super(db, auth, app);
+  }
+
+  /**
+   * Creates a new review and updates related entities
+   * @param data - The review data to create
+   * @param appointmentId - ID of the completed appointment
+   * @returns The created review
+   */
+  async createReview(
+    data: Omit<
+      Review,
+      "id" | "createdAt" | "updatedAt" | "appointmentId" | "overallRating"
+    >,
+    appointmentId: string
+  ): Promise<Review> {
+    try {
+      // Validate input data
+      const validatedData = createReviewSchema.parse(data);
+
+      // Calculate overall rating based on all provided reviews
+      const ratings: number[] = [];
+
+      if (data.clinicReview) {
+        const clinicRatings = [
+          data.clinicReview.cleanliness,
+          data.clinicReview.facilities,
+          data.clinicReview.staffFriendliness,
+          data.clinicReview.waitingTime,
+          data.clinicReview.accessibility,
+        ];
+        const clinicAverage = this.calculateAverage(clinicRatings);
+        data.clinicReview.overallRating = clinicAverage;
+        ratings.push(clinicAverage);
+      }
+
+      if (data.practitionerReview) {
+        const practitionerRatings = [
+          data.practitionerReview.knowledgeAndExpertise,
+          data.practitionerReview.communicationSkills,
+          data.practitionerReview.bedSideManner,
+          data.practitionerReview.thoroughness,
+          data.practitionerReview.trustworthiness,
+        ];
+        const practitionerAverage = this.calculateAverage(practitionerRatings);
+        data.practitionerReview.overallRating = practitionerAverage;
+        ratings.push(practitionerAverage);
+      }
+
+      if (data.procedureReview) {
+        const procedureRatings = [
+          data.procedureReview.effectivenessOfTreatment,
+          data.procedureReview.outcomeExplanation,
+          data.procedureReview.painManagement,
+          data.procedureReview.followUpCare,
+          data.procedureReview.valueForMoney,
+        ];
+        const procedureAverage = this.calculateAverage(procedureRatings);
+        data.procedureReview.overallRating = procedureAverage;
+        ratings.push(procedureAverage);
+      }
+
+      const overallRating = this.calculateAverage(ratings);
+
+      // Generate a unique ID for the main review
+      const reviewId = this.generateId();
+
+      // Add IDs to each review component
+      if (data.clinicReview) {
+        data.clinicReview.id = this.generateId();
+        data.clinicReview.fullReviewId = reviewId;
+      }
+
+      if (data.practitionerReview) {
+        data.practitionerReview.id = this.generateId();
+        data.practitionerReview.fullReviewId = reviewId;
+      }
+
+      if (data.procedureReview) {
+        data.procedureReview.id = this.generateId();
+        data.procedureReview.fullReviewId = reviewId;
+      }
+
+      // Create the review object with timestamps
+      const now = new Date();
+      const review: Review = {
+        id: reviewId,
+        appointmentId,
+        patientId: data.patientId,
+        clinicReview: data.clinicReview,
+        practitionerReview: data.practitionerReview,
+        procedureReview: data.procedureReview,
+        overallComment: data.overallComment,
+        overallRating,
+        createdAt: now,
+        updatedAt: now,
+      };
+
+      // Validate complete review object
+      reviewSchema.parse(review);
+
+      // Save the review to Firestore
+      const docRef = doc(this.db, REVIEWS_COLLECTION, reviewId);
+      await setDoc(docRef, {
+        ...review,
+        createdAt: serverTimestamp(),
+        updatedAt: serverTimestamp(),
+      });
+
+      // Update related entities
+      const updatePromises: Promise<any>[] = [];
+
+      // Update clinic if clinic review exists
+      if (data.clinicReview) {
+        updatePromises.push(
+          this.updateClinicReviewInfo(data.clinicReview.clinicId)
+        );
+      }
+
+      // Update practitioner if practitioner review exists
+      if (data.practitionerReview) {
+        updatePromises.push(
+          this.updatePractitionerReviewInfo(
+            data.practitionerReview.practitionerId
+          )
+        );
+      }
+
+      // Update procedure if procedure review exists
+      if (data.procedureReview) {
+        updatePromises.push(
+          this.updateProcedureReviewInfo(data.procedureReview.procedureId)
+        );
+      }
+
+      // Wait for all updates to complete
+      await Promise.all(updatePromises);
+
+      return review;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error(`Invalid review data: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Gets a review by ID
+   * @param reviewId The ID of the review to get
+   * @returns The review if found, null otherwise
+   */
+  async getReview(reviewId: string): Promise<Review | null> {
+    const docRef = doc(this.db, REVIEWS_COLLECTION, reviewId);
+    const docSnap = await getDoc(docRef);
+
+    if (!docSnap.exists()) {
+      return null;
+    }
+
+    return docSnap.data() as Review;
+  }
+
+  /**
+   * Gets all reviews for a specific patient
+   * @param patientId The ID of the patient
+   * @returns Array of reviews for the patient
+   */
+  async getReviewsByPatient(patientId: string): Promise<Review[]> {
+    const q = query(
+      collection(this.db, REVIEWS_COLLECTION),
+      where("patientId", "==", patientId)
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map((doc) => doc.data() as Review);
+  }
+
+  /**
+   * Gets all reviews for a specific clinic
+   * @param clinicId The ID of the clinic
+   * @returns Array of reviews containing clinic reviews
+   */
+  async getReviewsByClinic(clinicId: string): Promise<Review[]> {
+    const q = query(
+      collection(this.db, REVIEWS_COLLECTION),
+      where("clinicReview.clinicId", "==", clinicId)
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map((doc) => doc.data() as Review);
+  }
+
+  /**
+   * Gets all reviews for a specific practitioner
+   * @param practitionerId The ID of the practitioner
+   * @returns Array of reviews containing practitioner reviews
+   */
+  async getReviewsByPractitioner(practitionerId: string): Promise<Review[]> {
+    const q = query(
+      collection(this.db, REVIEWS_COLLECTION),
+      where("practitionerReview.practitionerId", "==", practitionerId)
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map((doc) => doc.data() as Review);
+  }
+
+  /**
+   * Gets all reviews for a specific procedure
+   * @param procedureId The ID of the procedure
+   * @returns Array of reviews containing procedure reviews
+   */
+  async getReviewsByProcedure(procedureId: string): Promise<Review[]> {
+    const q = query(
+      collection(this.db, REVIEWS_COLLECTION),
+      where("procedureReview.procedureId", "==", procedureId)
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map((doc) => doc.data() as Review);
+  }
+
+  /**
+   * Gets all reviews for a specific appointment
+   * @param appointmentId The ID of the appointment
+   * @returns The review for the appointment if found, null otherwise
+   */
+  async getReviewByAppointment(appointmentId: string): Promise<Review | null> {
+    const q = query(
+      collection(this.db, REVIEWS_COLLECTION),
+      where("appointmentId", "==", appointmentId)
+    );
+    const snapshot = await getDocs(q);
+
+    if (snapshot.empty) {
+      return null;
+    }
+
+    return snapshot.docs[0].data() as Review;
+  }
+
+  /**
+   * Deletes a review and updates related entities
+   * @param reviewId The ID of the review to delete
+   */
+  async deleteReview(reviewId: string): Promise<void> {
+    const review = await this.getReview(reviewId);
+    if (!review) {
+      throw new Error(`Review with ID ${reviewId} not found`);
+    }
+
+    // Delete the review
+    await deleteDoc(doc(this.db, REVIEWS_COLLECTION, reviewId));
+
+    // Update related entities after deletion
+    const updatePromises: Promise<any>[] = [];
+
+    if (review.clinicReview) {
+      updatePromises.push(
+        this.updateClinicReviewInfo(
+          review.clinicReview.clinicId,
+          review.clinicReview,
+          true
+        )
+      );
+    }
+
+    if (review.practitionerReview) {
+      updatePromises.push(
+        this.updatePractitionerReviewInfo(
+          review.practitionerReview.practitionerId,
+          review.practitionerReview,
+          true
+        )
+      );
+    }
+
+    if (review.procedureReview) {
+      updatePromises.push(
+        this.updateProcedureReviewInfo(
+          review.procedureReview.procedureId,
+          review.procedureReview,
+          true
+        )
+      );
+    }
+
+    // Wait for all updates to complete
+    await Promise.all(updatePromises);
+  }
+
+  /**
+   * Updates the review info for a clinic
+   * @param clinicId The ID of the clinic to update
+   * @param newReview Optional new review being added or removed
+   * @param isRemoval Whether this update is for a review removal
+   * @returns The updated clinic review info
+   */
+  async updateClinicReviewInfo(
+    clinicId: string,
+    newReview?: ClinicReview,
+    isRemoval: boolean = false
+  ): Promise<ClinicReviewInfo> {
+    // Get the current clinic document
+    const clinicDoc = await getDoc(doc(this.db, CLINICS_COLLECTION, clinicId));
+
+    if (!clinicDoc.exists()) {
+      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,
+    };
+
+    // If we have no reviews and aren't adding a new one, return default values
+    if (currentReviewInfo.totalReviews === 0 && !newReview) {
+      await updateDoc(doc(this.db, CLINICS_COLLECTION, clinicId), {
+        reviewInfo: currentReviewInfo,
+        updatedAt: serverTimestamp(),
+      });
+      return currentReviewInfo;
+    }
+
+    let updatedReviewInfo: ClinicReviewInfo;
+
+    if (newReview) {
+      // Calculate new values based on existing averages and the new review
+      const oldTotal = currentReviewInfo.totalReviews;
+      const newTotal = isRemoval ? oldTotal - 1 : oldTotal + 1;
+
+      // If removing the last review, set all values to 0
+      if (newTotal === 0) {
+        updatedReviewInfo = {
+          totalReviews: 0,
+          averageRating: 0,
+          cleanliness: 0,
+          facilities: 0,
+          staffFriendliness: 0,
+          waitingTime: 0,
+          accessibility: 0,
+          recommendationPercentage: 0,
+        };
+      } else {
+        // Calculate new averages
+        const updateAverage = (
+          currentAvg: number,
+          newValue: number
+        ): number => {
+          const currentSum = currentAvg * oldTotal;
+          const newSum = isRemoval
+            ? currentSum - newValue
+            : currentSum + newValue;
+          const newAvg = newSum / newTotal;
+          return Math.round(newAvg * 10) / 10; // Round to 1 decimal
+        };
+
+        // Update recommendation percentage
+        const currentRecommendations =
+          (currentReviewInfo.recommendationPercentage / 100) * oldTotal;
+        const newRecommendations = isRemoval
+          ? newReview.wouldRecommend
+            ? currentRecommendations - 1
+            : currentRecommendations
+          : newReview.wouldRecommend
+          ? currentRecommendations + 1
+          : currentRecommendations;
+        const newRecommendationPercentage =
+          (newRecommendations / newTotal) * 100;
+
+        updatedReviewInfo = {
+          totalReviews: newTotal,
+          averageRating: updateAverage(
+            currentReviewInfo.averageRating,
+            newReview.overallRating
+          ),
+          cleanliness: updateAverage(
+            currentReviewInfo.cleanliness,
+            newReview.cleanliness
+          ),
+          facilities: updateAverage(
+            currentReviewInfo.facilities,
+            newReview.facilities
+          ),
+          staffFriendliness: updateAverage(
+            currentReviewInfo.staffFriendliness,
+            newReview.staffFriendliness
+          ),
+          waitingTime: updateAverage(
+            currentReviewInfo.waitingTime,
+            newReview.waitingTime
+          ),
+          accessibility: updateAverage(
+            currentReviewInfo.accessibility,
+            newReview.accessibility
+          ),
+          recommendationPercentage:
+            Math.round(newRecommendationPercentage * 10) / 10,
+        };
+      }
+    } else {
+      // If no new review provided, keep the current info
+      updatedReviewInfo = { ...currentReviewInfo };
+    }
+
+    // Update the clinic with the new review info
+    await updateDoc(doc(this.db, CLINICS_COLLECTION, clinicId), {
+      reviewInfo: updatedReviewInfo,
+      updatedAt: serverTimestamp(),
+    });
+
+    return updatedReviewInfo;
+  }
+
+  /**
+   * Updates the review info for a practitioner
+   * @param practitionerId The ID of the practitioner to update
+   * @param newReview Optional new review being added or removed
+   * @param isRemoval Whether this update is for a review removal
+   * @returns The updated practitioner review info
+   */
+  async updatePractitionerReviewInfo(
+    practitionerId: string,
+    newReview?: PractitionerReview,
+    isRemoval: boolean = false
+  ): Promise<PractitionerReviewInfo> {
+    // Get the current practitioner document
+    const practitionerDoc = await getDoc(
+      doc(this.db, PRACTITIONERS_COLLECTION, practitionerId)
+    );
+
+    if (!practitionerDoc.exists()) {
+      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,
+      };
+
+    // If we have no reviews and aren't adding a new one, return default values
+    if (currentReviewInfo.totalReviews === 0 && !newReview) {
+      await updateDoc(doc(this.db, PRACTITIONERS_COLLECTION, practitionerId), {
+        reviewInfo: currentReviewInfo,
+        updatedAt: serverTimestamp(),
+      });
+      return currentReviewInfo;
+    }
+
+    let updatedReviewInfo: PractitionerReviewInfo;
+
+    if (newReview) {
+      // Calculate new values based on existing averages and the new review
+      const oldTotal = currentReviewInfo.totalReviews;
+      const newTotal = isRemoval ? oldTotal - 1 : oldTotal + 1;
+
+      // If removing the last review, set all values to 0
+      if (newTotal === 0) {
+        updatedReviewInfo = {
+          totalReviews: 0,
+          averageRating: 0,
+          knowledgeAndExpertise: 0,
+          communicationSkills: 0,
+          bedSideManner: 0,
+          thoroughness: 0,
+          trustworthiness: 0,
+          recommendationPercentage: 0,
+        };
+      } else {
+        // Calculate new averages
+        const updateAverage = (
+          currentAvg: number,
+          newValue: number
+        ): number => {
+          const currentSum = currentAvg * oldTotal;
+          const newSum = isRemoval
+            ? currentSum - newValue
+            : currentSum + newValue;
+          const newAvg = newSum / newTotal;
+          return Math.round(newAvg * 10) / 10; // Round to 1 decimal
+        };
+
+        // Update recommendation percentage
+        const currentRecommendations =
+          (currentReviewInfo.recommendationPercentage / 100) * oldTotal;
+        const newRecommendations = isRemoval
+          ? newReview.wouldRecommend
+            ? currentRecommendations - 1
+            : currentRecommendations
+          : newReview.wouldRecommend
+          ? currentRecommendations + 1
+          : currentRecommendations;
+        const newRecommendationPercentage =
+          (newRecommendations / newTotal) * 100;
+
+        updatedReviewInfo = {
+          totalReviews: newTotal,
+          averageRating: updateAverage(
+            currentReviewInfo.averageRating,
+            newReview.overallRating
+          ),
+          knowledgeAndExpertise: updateAverage(
+            currentReviewInfo.knowledgeAndExpertise,
+            newReview.knowledgeAndExpertise
+          ),
+          communicationSkills: updateAverage(
+            currentReviewInfo.communicationSkills,
+            newReview.communicationSkills
+          ),
+          bedSideManner: updateAverage(
+            currentReviewInfo.bedSideManner,
+            newReview.bedSideManner
+          ),
+          thoroughness: updateAverage(
+            currentReviewInfo.thoroughness,
+            newReview.thoroughness
+          ),
+          trustworthiness: updateAverage(
+            currentReviewInfo.trustworthiness,
+            newReview.trustworthiness
+          ),
+          recommendationPercentage:
+            Math.round(newRecommendationPercentage * 10) / 10,
+        };
+      }
+    } else {
+      // If no new review provided, keep the current info
+      updatedReviewInfo = { ...currentReviewInfo };
+    }
+
+    // Update the practitioner with the new review info
+    await updateDoc(doc(this.db, PRACTITIONERS_COLLECTION, practitionerId), {
+      reviewInfo: updatedReviewInfo,
+      updatedAt: serverTimestamp(),
+    });
+
+    // Also update doctor info in procedures with the new rating
+    await this.updateDoctorInfoInProcedures(
+      practitionerId,
+      updatedReviewInfo.averageRating
+    );
+
+    return updatedReviewInfo;
+  }
+
+  /**
+   * Updates the review info for a procedure
+   * @param procedureId The ID of the procedure to update
+   * @param newReview Optional new review being added or removed
+   * @param isRemoval Whether this update is for a review removal
+   * @returns The updated procedure review info
+   */
+  async updateProcedureReviewInfo(
+    procedureId: string,
+    newReview?: ProcedureReview,
+    isRemoval: boolean = false
+  ): Promise<ProcedureReviewInfo> {
+    // Get the current procedure document
+    const procedureDoc = await getDoc(
+      doc(this.db, PROCEDURES_COLLECTION, procedureId)
+    );
+
+    if (!procedureDoc.exists()) {
+      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,
+      };
+
+    // If we have no reviews and aren't adding a new one, return default values
+    if (currentReviewInfo.totalReviews === 0 && !newReview) {
+      await updateDoc(doc(this.db, PROCEDURES_COLLECTION, procedureId), {
+        reviewInfo: currentReviewInfo,
+        updatedAt: serverTimestamp(),
+      });
+      return currentReviewInfo;
+    }
+
+    let updatedReviewInfo: ProcedureReviewInfo;
+
+    if (newReview) {
+      // Calculate new values based on existing averages and the new review
+      const oldTotal = currentReviewInfo.totalReviews;
+      const newTotal = isRemoval ? oldTotal - 1 : oldTotal + 1;
+
+      // If removing the last review, set all values to 0
+      if (newTotal === 0) {
+        updatedReviewInfo = {
+          totalReviews: 0,
+          averageRating: 0,
+          effectivenessOfTreatment: 0,
+          outcomeExplanation: 0,
+          painManagement: 0,
+          followUpCare: 0,
+          valueForMoney: 0,
+          recommendationPercentage: 0,
+        };
+      } else {
+        // Calculate new averages
+        const updateAverage = (
+          currentAvg: number,
+          newValue: number
+        ): number => {
+          const currentSum = currentAvg * oldTotal;
+          const newSum = isRemoval
+            ? currentSum - newValue
+            : currentSum + newValue;
+          const newAvg = newSum / newTotal;
+          return Math.round(newAvg * 10) / 10; // Round to 1 decimal
+        };
+
+        // Update recommendation percentage
+        const currentRecommendations =
+          (currentReviewInfo.recommendationPercentage / 100) * oldTotal;
+        const newRecommendations = isRemoval
+          ? newReview.wouldRecommend
+            ? currentRecommendations - 1
+            : currentRecommendations
+          : newReview.wouldRecommend
+          ? currentRecommendations + 1
+          : currentRecommendations;
+        const newRecommendationPercentage =
+          (newRecommendations / newTotal) * 100;
+
+        updatedReviewInfo = {
+          totalReviews: newTotal,
+          averageRating: updateAverage(
+            currentReviewInfo.averageRating,
+            newReview.overallRating
+          ),
+          effectivenessOfTreatment: updateAverage(
+            currentReviewInfo.effectivenessOfTreatment,
+            newReview.effectivenessOfTreatment
+          ),
+          outcomeExplanation: updateAverage(
+            currentReviewInfo.outcomeExplanation,
+            newReview.outcomeExplanation
+          ),
+          painManagement: updateAverage(
+            currentReviewInfo.painManagement,
+            newReview.painManagement
+          ),
+          followUpCare: updateAverage(
+            currentReviewInfo.followUpCare,
+            newReview.followUpCare
+          ),
+          valueForMoney: updateAverage(
+            currentReviewInfo.valueForMoney,
+            newReview.valueForMoney
+          ),
+          recommendationPercentage:
+            Math.round(newRecommendationPercentage * 10) / 10,
+        };
+      }
+    } else {
+      // If no new review provided, keep the current info
+      updatedReviewInfo = { ...currentReviewInfo };
+    }
+
+    // Update the procedure with the new review info
+    await updateDoc(doc(this.db, PROCEDURES_COLLECTION, procedureId), {
+      reviewInfo: updatedReviewInfo,
+      updatedAt: serverTimestamp(),
+    });
+
+    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> {
+    // Find all procedures for this practitioner
+    const q = query(
+      collection(this.db, PROCEDURES_COLLECTION),
+      where("practitionerId", "==", practitionerId)
+    );
+
+    const snapshot = await getDocs(q);
+
+    if (snapshot.empty) {
+      return;
+    }
+
+    // Batch update all procedures
+    const batch = writeBatch(this.db);
+
+    snapshot.docs.forEach((docSnapshot) => {
+      const procedureRef = doc(this.db, PROCEDURES_COLLECTION, docSnapshot.id);
+      batch.update(procedureRef, {
+        "doctorInfo.rating": rating,
+        updatedAt: serverTimestamp(),
+      });
+    });
+
+    await batch.commit();
+  }
+
+  /**
+   * Verifies a review as checked by admin/staff
+   * @param reviewId The ID of the review to verify
+   */
+  async verifyReview(reviewId: string): Promise<void> {
+    const review = await this.getReview(reviewId);
+    if (!review) {
+      throw new Error(`Review with ID ${reviewId} not found`);
+    }
+
+    const batch = writeBatch(this.db);
+
+    // Update main review document
+    batch.update(doc(this.db, REVIEWS_COLLECTION, reviewId), {
+      updatedAt: serverTimestamp(),
+    });
+
+    // 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;
+    }
+
+    await batch.commit();
+
+    // Update all related entities
+    const updatePromises: Promise<any>[] = [];
+
+    if (review.clinicReview) {
+      updatePromises.push(
+        this.updateClinicReviewInfo(review.clinicReview.clinicId)
+      );
+    }
+
+    if (review.practitionerReview) {
+      updatePromises.push(
+        this.updatePractitionerReviewInfo(
+          review.practitionerReview.practitionerId
+        )
+      );
+    }
+
+    if (review.procedureReview) {
+      updatePromises.push(
+        this.updateProcedureReviewInfo(review.procedureReview.procedureId)
+      );
+    }
+
+    await Promise.all(updatePromises);
+  }
+
+  /**
+   * Calculates the average of an array of numbers
+   * @param numbers Array of numbers to average
+   * @returns The average, or 0 if the array is empty
+   */
+  private calculateAverage(numbers: number[]): number {
+    if (numbers.length === 0) {
+      return 0;
+    }
+
+    const sum = numbers.reduce((a, b) => a + b, 0);
+    const avg = sum / numbers.length;
+
+    // Round to 1 decimal place
+    return Math.round(avg * 10) / 10;
+  }
+}