@blackcode_sa/metaestetics-api 1.12.61 → 1.12.62

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

@@ -1,636 +1,683 @@
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  query,
-  where,
-  setDoc,
-  deleteDoc,
-  serverTimestamp,
-} from 'firebase/firestore';
-import { BaseService } from '../base.service';
-import {
-  Review,
-  ClinicReview,
-  PractitionerReview,
-  ProcedureReview,
-  REVIEWS_COLLECTION,
-} 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 { Appointment, APPOINTMENTS_COLLECTION } from '../../types/appointment';
-
-export class ReviewService extends BaseService {
-  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
-    super(db, auth, app);
-  }
-
-  /**
-   * Creates a new review
-   * @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 {
-      console.log('🔍 ReviewService.createReview - Input data:', {
-        appointmentId,
-        hasClinicReview: !!data.clinicReview,
-        hasPractitionerReview: !!data.practitionerReview,
-        hasProcedureReview: !!data.procedureReview,
-        practitionerId: data.practitionerReview?.practitionerId,
-        clinicId: data.clinicReview?.clinicId,
-        procedureId: data.procedureReview?.procedureId,
-      });
-
-      // 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(),
-      });
-
-      console.log('✅ ReviewService.createReview - Review saved to Firestore:', {
-        reviewId,
-        practitionerId: review.practitionerReview?.practitionerId,
-        clinicId: review.clinicReview?.clinicId,
-        procedureId: review.procedureReview?.procedureId,
-      });
-
-      // Note: Related entity updates (clinic, practitioner, procedure) are now handled
-      // by cloud functions through the ReviewsAggregationService
-
-      return review;
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        throw new Error(`Invalid review data: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Gets a review by ID with enhanced entity names
-   * @param reviewId The ID of the review to get
-   * @returns The review with entity names if found, null otherwise
-   */
-  async getReview(reviewId: string): Promise<Review | null> {
-    console.log('🔍 ReviewService.getReview - Getting review:', reviewId);
-
-    const docRef = doc(this.db, REVIEWS_COLLECTION, reviewId);
-    const docSnap = await getDoc(docRef);
-
-    if (!docSnap.exists()) {
-      console.log('❌ ReviewService.getReview - Review not found:', reviewId);
-      return null;
-    }
-
-    const review = { ...docSnap.data(), id: reviewId } as Review;
-
-    try {
-      // Fetch the associated appointment to enhance with entity names
-      const appointmentDoc = await getDoc(
-        doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
-      );
-
-      if (appointmentDoc.exists()) {
-        const appointment = appointmentDoc.data() as Appointment;
-
-        // Create enhanced review with entity names
-        const enhancedReview = { ...review };
-
-        if (enhancedReview.clinicReview && appointment.clinicInfo) {
-          enhancedReview.clinicReview = {
-            ...enhancedReview.clinicReview,
-            clinicName: appointment.clinicInfo.name,
-          };
-        }
-
-        if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
-          enhancedReview.practitionerReview = {
-            ...enhancedReview.practitionerReview,
-            practitionerName: appointment.practitionerInfo.name,
-          };
-        }
-
-        if (enhancedReview.procedureReview && appointment.procedureInfo) {
-          enhancedReview.procedureReview = {
-            ...enhancedReview.procedureReview,
-            procedureName: appointment.procedureInfo.name,
-          };
-        }
-
-        // Add patient name to the main review object
-        if (appointment.patientInfo) {
-          enhancedReview.patientName = appointment.patientInfo.fullName;
-        }
-
-        console.log('✅ ReviewService.getReview - Enhanced review:', {
-          reviewId,
-          hasEntityNames: !!(
-            enhancedReview.clinicReview?.clinicName ||
-            enhancedReview.practitionerReview?.practitionerName ||
-            enhancedReview.procedureReview?.procedureName ||
-            enhancedReview.patientName
-          ),
-        });
-
-        return enhancedReview;
-      }
-
-      console.log('⚠️ ReviewService.getReview - Appointment not found for review:', reviewId);
-      return review;
-    } catch (error) {
-      console.warn(`Failed to enhance review ${reviewId} with entity names:`, error);
-      return review;
-    }
-  }
-
-  /**
-   * Gets all reviews for a specific patient with enhanced entity names
-   * @param patientId The ID of the patient
-   * @returns Array of reviews for the patient with clinic, practitioner, and procedure names
-   */
-  async getReviewsByPatient(patientId: string): Promise<Review[]> {
-    const q = query(collection(this.db, REVIEWS_COLLECTION), where('patientId', '==', patientId));
-    const snapshot = await getDocs(q);
-    const reviews = snapshot.docs.map(doc => doc.data() as Review);
-
-    // Enhance reviews with entity names from appointments
-    const enhancedReviews = await Promise.all(
-      reviews.map(async review => {
-        try {
-          // Fetch the associated appointment
-          const appointmentDoc = await getDoc(
-            doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
-          );
-
-          if (appointmentDoc.exists()) {
-            const appointment = appointmentDoc.data() as Appointment;
-
-            // Create enhanced review with entity names
-            const enhancedReview = { ...review };
-
-            if (enhancedReview.clinicReview && appointment.clinicInfo) {
-              enhancedReview.clinicReview = {
-                ...enhancedReview.clinicReview,
-                clinicName: appointment.clinicInfo.name,
-              };
-            }
-
-            if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
-              enhancedReview.practitionerReview = {
-                ...enhancedReview.practitionerReview,
-                practitionerName: appointment.practitionerInfo.name,
-              };
-            }
-
-            if (enhancedReview.procedureReview && appointment.procedureInfo) {
-              enhancedReview.procedureReview = {
-                ...enhancedReview.procedureReview,
-                procedureName: appointment.procedureInfo.name,
-              };
-            }
-
-            // Add patient name to the main review object
-            if (appointment.patientInfo) {
-              enhancedReview.patientName = appointment.patientInfo.fullName;
-            }
-
-            return enhancedReview;
-          }
-
-          return review;
-        } catch (error) {
-          console.warn(`Failed to enhance review ${review.id} with entity names:`, error);
-          return review;
-        }
-      }),
-    );
-
-    return enhancedReviews;
-  }
-
-  /**
-   * Gets all reviews for a specific clinic with enhanced entity names
-   * @param clinicId The ID of the clinic
-   * @returns Array of reviews containing clinic reviews with clinic, practitioner, and procedure names
-   */
-  async getReviewsByClinic(clinicId: string): Promise<Review[]> {
-    console.log('🔍 ReviewService.getReviewsByClinic - Querying for clinic:', clinicId);
-
-    const q = query(
-      collection(this.db, REVIEWS_COLLECTION),
-      where('clinicReview.clinicId', '==', clinicId),
-    );
-    const snapshot = await getDocs(q);
-    const reviews = snapshot.docs.map(doc => {
-      const data = doc.data() as Review;
-      return { ...data, id: doc.id };
-    });
-
-    console.log('🔍 ReviewService.getReviewsByClinic - Found reviews before enhancement:', {
-      clinicId,
-      reviewCount: reviews.length,
-      reviewIds: reviews.map(r => r.id),
-    });
-
-    // Enhance reviews with entity names from appointments
-    const enhancedReviews = await Promise.all(
-      reviews.map(async review => {
-        try {
-          // Fetch the associated appointment
-          const appointmentDoc = await getDoc(
-            doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
-          );
-
-          if (appointmentDoc.exists()) {
-            const appointment = appointmentDoc.data() as Appointment;
-
-            // Create enhanced review with entity names
-            const enhancedReview = { ...review };
-
-            if (enhancedReview.clinicReview && appointment.clinicInfo) {
-              enhancedReview.clinicReview = {
-                ...enhancedReview.clinicReview,
-                clinicName: appointment.clinicInfo.name,
-              };
-            }
-
-            if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
-              enhancedReview.practitionerReview = {
-                ...enhancedReview.practitionerReview,
-                practitionerName: appointment.practitionerInfo.name,
-              };
-            }
-
-            if (enhancedReview.procedureReview && appointment.procedureInfo) {
-              enhancedReview.procedureReview = {
-                ...enhancedReview.procedureReview,
-                procedureName: appointment.procedureInfo.name,
-              };
-            }
-
-            // Add patient name to the main review object
-            if (appointment.patientInfo) {
-              enhancedReview.patientName = appointment.patientInfo.fullName;
-            }
-
-            return enhancedReview;
-          }
-
-          return review;
-        } catch (error) {
-          console.warn(`Failed to enhance review ${review.id} with entity names:`, error);
-          return review;
-        }
-      }),
-    );
-
-    console.log('✅ ReviewService.getReviewsByClinic - Enhanced reviews:', {
-      clinicId,
-      reviewCount: enhancedReviews.length,
-      reviewIds: enhancedReviews.map(r => r.id),
-      hasEntityNames: enhancedReviews.some(
-        r =>
-          r.clinicReview?.clinicName ||
-          r.practitionerReview?.practitionerName ||
-          r.procedureReview?.procedureName ||
-          r.patientName,
-      ),
-    });
-
-    return enhancedReviews;
-  }
-
-  /**
-   * Gets all reviews for a specific practitioner with enhanced entity names
-   * @param practitionerId The ID of the practitioner
-   * @returns Array of reviews containing practitioner reviews with clinic, practitioner, and procedure names
-   */
-  async getReviewsByPractitioner(practitionerId: string): Promise<Review[]> {
-    console.log(
-      '🔍 ReviewService.getReviewsByPractitioner - Querying for practitioner:',
-      practitionerId,
-    );
-
-    const q = query(
-      collection(this.db, REVIEWS_COLLECTION),
-      where('practitionerReview.practitionerId', '==', practitionerId),
-    );
-    const snapshot = await getDocs(q);
-    const reviews = snapshot.docs.map(doc => {
-      const data = doc.data() as Review;
-      return { ...data, id: doc.id };
-    });
-
-    console.log('🔍 ReviewService.getReviewsByPractitioner - Found reviews before enhancement:', {
-      practitionerId,
-      reviewCount: reviews.length,
-      reviewIds: reviews.map(r => r.id),
-    });
-
-    // Enhance reviews with entity names from appointments
-    const enhancedReviews = await Promise.all(
-      reviews.map(async review => {
-        try {
-          // Fetch the associated appointment
-          const appointmentDoc = await getDoc(
-            doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
-          );
-
-          if (appointmentDoc.exists()) {
-            const appointment = appointmentDoc.data() as Appointment;
-
-            // Create enhanced review with entity names
-            const enhancedReview = { ...review };
-
-            if (enhancedReview.clinicReview && appointment.clinicInfo) {
-              enhancedReview.clinicReview = {
-                ...enhancedReview.clinicReview,
-                clinicName: appointment.clinicInfo.name,
-              };
-            }
-
-            if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
-              enhancedReview.practitionerReview = {
-                ...enhancedReview.practitionerReview,
-                practitionerName: appointment.practitionerInfo.name,
-              };
-            }
-
-            if (enhancedReview.procedureReview && appointment.procedureInfo) {
-              enhancedReview.procedureReview = {
-                ...enhancedReview.procedureReview,
-                procedureName: appointment.procedureInfo.name,
-              };
-            }
-
-            // Add patient name to the main review object
-            if (appointment.patientInfo) {
-              enhancedReview.patientName = appointment.patientInfo.fullName;
-            }
-
-            return enhancedReview;
-          }
-
-          return review;
-        } catch (error) {
-          console.warn(`Failed to enhance review ${review.id} with entity names:`, error);
-          return review;
-        }
-      }),
-    );
-
-    console.log('✅ ReviewService.getReviewsByPractitioner - Enhanced reviews:', {
-      practitionerId,
-      reviewCount: enhancedReviews.length,
-      reviewIds: enhancedReviews.map(r => r.id),
-      hasEntityNames: enhancedReviews.some(
-        r =>
-          r.clinicReview?.clinicName ||
-          r.practitionerReview?.practitionerName ||
-          r.procedureReview?.procedureName,
-      ),
-    });
-
-    return enhancedReviews;
-  }
-
-  /**
-   * Gets all reviews for a specific procedure with enhanced entity names
-   * @param procedureId The ID of the procedure
-   * @returns Array of reviews containing procedure reviews with clinic, practitioner, and procedure names
-   */
-  async getReviewsByProcedure(procedureId: string): Promise<Review[]> {
-    console.log('🔍 ReviewService.getReviewsByProcedure - Querying for procedure:', procedureId);
-
-    const q = query(
-      collection(this.db, REVIEWS_COLLECTION),
-      where('procedureReview.procedureId', '==', procedureId),
-    );
-    const snapshot = await getDocs(q);
-    const reviews = snapshot.docs.map(doc => {
-      const data = doc.data() as Review;
-      return { ...data, id: doc.id };
-    });
-
-    console.log('🔍 ReviewService.getReviewsByProcedure - Found reviews before enhancement:', {
-      procedureId,
-      reviewCount: reviews.length,
-      reviewIds: reviews.map(r => r.id),
-    });
-
-    // Enhance reviews with entity names from appointments
-    const enhancedReviews = await Promise.all(
-      reviews.map(async review => {
-        try {
-          // Fetch the associated appointment
-          const appointmentDoc = await getDoc(
-            doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
-          );
-
-          if (appointmentDoc.exists()) {
-            const appointment = appointmentDoc.data() as Appointment;
-
-            // Create enhanced review with entity names
-            const enhancedReview = { ...review };
-
-            if (enhancedReview.clinicReview && appointment.clinicInfo) {
-              enhancedReview.clinicReview = {
-                ...enhancedReview.clinicReview,
-                clinicName: appointment.clinicInfo.name,
-              };
-            }
-
-            if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
-              enhancedReview.practitionerReview = {
-                ...enhancedReview.practitionerReview,
-                practitionerName: appointment.practitionerInfo.name,
-              };
-            }
-
-            if (enhancedReview.procedureReview && appointment.procedureInfo) {
-              enhancedReview.procedureReview = {
-                ...enhancedReview.procedureReview,
-                procedureName: appointment.procedureInfo.name,
-              };
-            }
-
-            // Add patient name to the main review object
-            if (appointment.patientInfo) {
-              enhancedReview.patientName = appointment.patientInfo.fullName;
-            }
-
-            return enhancedReview;
-          }
-
-          return review;
-        } catch (error) {
-          console.warn(`Failed to enhance review ${review.id} with entity names:`, error);
-          return review;
-        }
-      }),
-    );
-
-    console.log('✅ ReviewService.getReviewsByProcedure - Enhanced reviews:', {
-      procedureId,
-      reviewCount: enhancedReviews.length,
-      reviewIds: enhancedReviews.map(r => r.id),
-      hasEntityNames: enhancedReviews.some(
-        r =>
-          r.clinicReview?.clinicName ||
-          r.practitionerReview?.practitionerName ||
-          r.procedureReview?.procedureName ||
-          r.patientName,
-      ),
-    });
-
-    return enhancedReviews;
-  }
-
-  /**
-   * 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
-   * @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));
-
-    // Note: Updates to related entities after deletion are now handled
-    // by cloud functions through the ReviewsAggregationService
-  }
-
-  /**
-   * 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;
-  }
-}
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  setDoc,
+  deleteDoc,
+  serverTimestamp,
+} from 'firebase/firestore';
+import { BaseService } from '../base.service';
+import {
+  Review,
+  ClinicReview,
+  PractitionerReview,
+  ProcedureReview,
+  REVIEWS_COLLECTION,
+} 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 { Appointment, APPOINTMENTS_COLLECTION } from '../../types/appointment';
+
+export class ReviewService extends BaseService {
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+    super(db, auth, app);
+  }
+
+  /**
+   * Creates a new review
+   * @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 {
+      console.log('🔍 ReviewService.createReview - Input data:', {
+        appointmentId,
+        hasClinicReview: !!data.clinicReview,
+        hasPractitionerReview: !!data.practitionerReview,
+        hasProcedureReview: !!data.procedureReview,
+        extendedProcedureReviewsCount: data.extendedProcedureReviews?.length || 0,
+        practitionerId: data.practitionerReview?.practitionerId,
+        clinicId: data.clinicReview?.clinicId,
+        procedureId: data.procedureReview?.procedureId,
+      });
+
+      // 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);
+      }
+
+      // Process extended procedure reviews
+      if (data.extendedProcedureReviews && data.extendedProcedureReviews.length > 0) {
+        data.extendedProcedureReviews.forEach((extendedReview) => {
+          const extendedRatings = [
+            extendedReview.effectivenessOfTreatment,
+            extendedReview.outcomeExplanation,
+            extendedReview.painManagement,
+            extendedReview.followUpCare,
+            extendedReview.valueForMoney,
+          ];
+          const extendedAverage = this.calculateAverage(extendedRatings);
+          extendedReview.overallRating = extendedAverage;
+          ratings.push(extendedAverage);
+        });
+      }
+
+      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();
+
+      // Add IDs to extended procedure reviews
+      if (data.extendedProcedureReviews && data.extendedProcedureReviews.length > 0) {
+        data.extendedProcedureReviews.forEach((extendedReview) => {
+          extendedReview.id = this.generateId();
+          extendedReview.fullReviewId = reviewId;
+          extendedReview.createdAt = now;
+          extendedReview.updatedAt = now;
+        });
+      }
+      const review: Review = {
+        id: reviewId,
+        appointmentId,
+        patientId: data.patientId,
+        clinicReview: data.clinicReview,
+        practitionerReview: data.practitionerReview,
+        procedureReview: data.procedureReview,
+        extendedProcedureReviews: data.extendedProcedureReviews,
+        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(),
+      });
+
+      console.log('✅ ReviewService.createReview - Review saved to Firestore:', {
+        reviewId,
+        practitionerId: review.practitionerReview?.practitionerId,
+        clinicId: review.clinicReview?.clinicId,
+        procedureId: review.procedureReview?.procedureId,
+        extendedProcedureReviewsCount: review.extendedProcedureReviews?.length || 0,
+      });
+
+      // Note: Related entity updates (clinic, practitioner, procedure) are now handled
+      // by cloud functions through the ReviewsAggregationService
+
+      return review;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error(`Invalid review data: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Gets a review by ID with enhanced entity names
+   * @param reviewId The ID of the review to get
+   * @returns The review with entity names if found, null otherwise
+   */
+  async getReview(reviewId: string): Promise<Review | null> {
+    console.log('🔍 ReviewService.getReview - Getting review:', reviewId);
+
+    const docRef = doc(this.db, REVIEWS_COLLECTION, reviewId);
+    const docSnap = await getDoc(docRef);
+
+    if (!docSnap.exists()) {
+      console.log('❌ ReviewService.getReview - Review not found:', reviewId);
+      return null;
+    }
+
+    const review = { ...docSnap.data(), id: reviewId } as Review;
+
+    try {
+      // Fetch the associated appointment to enhance with entity names
+      const appointmentDoc = await getDoc(
+        doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
+      );
+
+      if (appointmentDoc.exists()) {
+        const appointment = appointmentDoc.data() as Appointment;
+
+        // Create enhanced review with entity names
+        const enhancedReview = { ...review };
+
+        if (enhancedReview.clinicReview && appointment.clinicInfo) {
+          enhancedReview.clinicReview = {
+            ...enhancedReview.clinicReview,
+            clinicName: appointment.clinicInfo.name,
+          };
+        }
+
+        if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
+          enhancedReview.practitionerReview = {
+            ...enhancedReview.practitionerReview,
+            practitionerName: appointment.practitionerInfo.name,
+          };
+        }
+
+        if (enhancedReview.procedureReview && appointment.procedureInfo) {
+          enhancedReview.procedureReview = {
+            ...enhancedReview.procedureReview,
+            procedureName: appointment.procedureInfo.name,
+          };
+        }
+
+        // Enhance extended procedure reviews with names
+        if (enhancedReview.extendedProcedureReviews && enhancedReview.extendedProcedureReviews.length > 0) {
+          const extendedProcedures = appointment.metadata?.extendedProcedures || [];
+          enhancedReview.extendedProcedureReviews = enhancedReview.extendedProcedureReviews.map((extendedReview) => {
+            const procedureInfo = extendedProcedures.find(
+              (ep) => ep.procedureId === extendedReview.procedureId
+            );
+            if (procedureInfo) {
+              return {
+                ...extendedReview,
+                procedureName: procedureInfo.procedureName,
+              };
+            }
+            return extendedReview;
+          });
+        }
+
+        // Add patient name to the main review object
+        if (appointment.patientInfo) {
+          enhancedReview.patientName = appointment.patientInfo.fullName;
+        }
+
+        console.log('✅ ReviewService.getReview - Enhanced review:', {
+          reviewId,
+          hasEntityNames: !!(
+            enhancedReview.clinicReview?.clinicName ||
+            enhancedReview.practitionerReview?.practitionerName ||
+            enhancedReview.procedureReview?.procedureName ||
+            enhancedReview.patientName ||
+            enhancedReview.extendedProcedureReviews?.some(epr => epr.procedureName)
+          ),
+        });
+
+        return enhancedReview;
+      }
+
+      console.log('⚠️ ReviewService.getReview - Appointment not found for review:', reviewId);
+      return review;
+    } catch (error) {
+      console.warn(`Failed to enhance review ${reviewId} with entity names:`, error);
+      return review;
+    }
+  }
+
+  /**
+   * Gets all reviews for a specific patient with enhanced entity names
+   * @param patientId The ID of the patient
+   * @returns Array of reviews for the patient with clinic, practitioner, and procedure names
+   */
+  async getReviewsByPatient(patientId: string): Promise<Review[]> {
+    const q = query(collection(this.db, REVIEWS_COLLECTION), where('patientId', '==', patientId));
+    const snapshot = await getDocs(q);
+    const reviews = snapshot.docs.map(doc => doc.data() as Review);
+
+    // Enhance reviews with entity names from appointments
+    const enhancedReviews = await Promise.all(
+      reviews.map(async review => {
+        try {
+          // Fetch the associated appointment
+          const appointmentDoc = await getDoc(
+            doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
+          );
+
+          if (appointmentDoc.exists()) {
+            const appointment = appointmentDoc.data() as Appointment;
+
+            // Create enhanced review with entity names
+            const enhancedReview = { ...review };
+
+            if (enhancedReview.clinicReview && appointment.clinicInfo) {
+              enhancedReview.clinicReview = {
+                ...enhancedReview.clinicReview,
+                clinicName: appointment.clinicInfo.name,
+              };
+            }
+
+            if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
+              enhancedReview.practitionerReview = {
+                ...enhancedReview.practitionerReview,
+                practitionerName: appointment.practitionerInfo.name,
+              };
+            }
+
+            if (enhancedReview.procedureReview && appointment.procedureInfo) {
+              enhancedReview.procedureReview = {
+                ...enhancedReview.procedureReview,
+                procedureName: appointment.procedureInfo.name,
+              };
+            }
+
+            // Add patient name to the main review object
+            if (appointment.patientInfo) {
+              enhancedReview.patientName = appointment.patientInfo.fullName;
+            }
+
+            return enhancedReview;
+          }
+
+          return review;
+        } catch (error) {
+          console.warn(`Failed to enhance review ${review.id} with entity names:`, error);
+          return review;
+        }
+      }),
+    );
+
+    return enhancedReviews;
+  }
+
+  /**
+   * Gets all reviews for a specific clinic with enhanced entity names
+   * @param clinicId The ID of the clinic
+   * @returns Array of reviews containing clinic reviews with clinic, practitioner, and procedure names
+   */
+  async getReviewsByClinic(clinicId: string): Promise<Review[]> {
+    console.log('🔍 ReviewService.getReviewsByClinic - Querying for clinic:', clinicId);
+
+    const q = query(
+      collection(this.db, REVIEWS_COLLECTION),
+      where('clinicReview.clinicId', '==', clinicId),
+    );
+    const snapshot = await getDocs(q);
+    const reviews = snapshot.docs.map(doc => {
+      const data = doc.data() as Review;
+      return { ...data, id: doc.id };
+    });
+
+    console.log('🔍 ReviewService.getReviewsByClinic - Found reviews before enhancement:', {
+      clinicId,
+      reviewCount: reviews.length,
+      reviewIds: reviews.map(r => r.id),
+    });
+
+    // Enhance reviews with entity names from appointments
+    const enhancedReviews = await Promise.all(
+      reviews.map(async review => {
+        try {
+          // Fetch the associated appointment
+          const appointmentDoc = await getDoc(
+            doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
+          );
+
+          if (appointmentDoc.exists()) {
+            const appointment = appointmentDoc.data() as Appointment;
+
+            // Create enhanced review with entity names
+            const enhancedReview = { ...review };
+
+            if (enhancedReview.clinicReview && appointment.clinicInfo) {
+              enhancedReview.clinicReview = {
+                ...enhancedReview.clinicReview,
+                clinicName: appointment.clinicInfo.name,
+              };
+            }
+
+            if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
+              enhancedReview.practitionerReview = {
+                ...enhancedReview.practitionerReview,
+                practitionerName: appointment.practitionerInfo.name,
+              };
+            }
+
+            if (enhancedReview.procedureReview && appointment.procedureInfo) {
+              enhancedReview.procedureReview = {
+                ...enhancedReview.procedureReview,
+                procedureName: appointment.procedureInfo.name,
+              };
+            }
+
+            // Add patient name to the main review object
+            if (appointment.patientInfo) {
+              enhancedReview.patientName = appointment.patientInfo.fullName;
+            }
+
+            return enhancedReview;
+          }
+
+          return review;
+        } catch (error) {
+          console.warn(`Failed to enhance review ${review.id} with entity names:`, error);
+          return review;
+        }
+      }),
+    );
+
+    console.log('✅ ReviewService.getReviewsByClinic - Enhanced reviews:', {
+      clinicId,
+      reviewCount: enhancedReviews.length,
+      reviewIds: enhancedReviews.map(r => r.id),
+      hasEntityNames: enhancedReviews.some(
+        r =>
+          r.clinicReview?.clinicName ||
+          r.practitionerReview?.practitionerName ||
+          r.procedureReview?.procedureName ||
+          r.patientName,
+      ),
+    });
+
+    return enhancedReviews;
+  }
+
+  /**
+   * Gets all reviews for a specific practitioner with enhanced entity names
+   * @param practitionerId The ID of the practitioner
+   * @returns Array of reviews containing practitioner reviews with clinic, practitioner, and procedure names
+   */
+  async getReviewsByPractitioner(practitionerId: string): Promise<Review[]> {
+    console.log(
+      '🔍 ReviewService.getReviewsByPractitioner - Querying for practitioner:',
+      practitionerId,
+    );
+
+    const q = query(
+      collection(this.db, REVIEWS_COLLECTION),
+      where('practitionerReview.practitionerId', '==', practitionerId),
+    );
+    const snapshot = await getDocs(q);
+    const reviews = snapshot.docs.map(doc => {
+      const data = doc.data() as Review;
+      return { ...data, id: doc.id };
+    });
+
+    console.log('🔍 ReviewService.getReviewsByPractitioner - Found reviews before enhancement:', {
+      practitionerId,
+      reviewCount: reviews.length,
+      reviewIds: reviews.map(r => r.id),
+    });
+
+    // Enhance reviews with entity names from appointments
+    const enhancedReviews = await Promise.all(
+      reviews.map(async review => {
+        try {
+          // Fetch the associated appointment
+          const appointmentDoc = await getDoc(
+            doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
+          );
+
+          if (appointmentDoc.exists()) {
+            const appointment = appointmentDoc.data() as Appointment;
+
+            // Create enhanced review with entity names
+            const enhancedReview = { ...review };
+
+            if (enhancedReview.clinicReview && appointment.clinicInfo) {
+              enhancedReview.clinicReview = {
+                ...enhancedReview.clinicReview,
+                clinicName: appointment.clinicInfo.name,
+              };
+            }
+
+            if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
+              enhancedReview.practitionerReview = {
+                ...enhancedReview.practitionerReview,
+                practitionerName: appointment.practitionerInfo.name,
+              };
+            }
+
+            if (enhancedReview.procedureReview && appointment.procedureInfo) {
+              enhancedReview.procedureReview = {
+                ...enhancedReview.procedureReview,
+                procedureName: appointment.procedureInfo.name,
+              };
+            }
+
+            // Add patient name to the main review object
+            if (appointment.patientInfo) {
+              enhancedReview.patientName = appointment.patientInfo.fullName;
+            }
+
+            return enhancedReview;
+          }
+
+          return review;
+        } catch (error) {
+          console.warn(`Failed to enhance review ${review.id} with entity names:`, error);
+          return review;
+        }
+      }),
+    );
+
+    console.log('✅ ReviewService.getReviewsByPractitioner - Enhanced reviews:', {
+      practitionerId,
+      reviewCount: enhancedReviews.length,
+      reviewIds: enhancedReviews.map(r => r.id),
+      hasEntityNames: enhancedReviews.some(
+        r =>
+          r.clinicReview?.clinicName ||
+          r.practitionerReview?.practitionerName ||
+          r.procedureReview?.procedureName,
+      ),
+    });
+
+    return enhancedReviews;
+  }
+
+  /**
+   * Gets all reviews for a specific procedure with enhanced entity names
+   * @param procedureId The ID of the procedure
+   * @returns Array of reviews containing procedure reviews with clinic, practitioner, and procedure names
+   */
+  async getReviewsByProcedure(procedureId: string): Promise<Review[]> {
+    console.log('🔍 ReviewService.getReviewsByProcedure - Querying for procedure:', procedureId);
+
+    const q = query(
+      collection(this.db, REVIEWS_COLLECTION),
+      where('procedureReview.procedureId', '==', procedureId),
+    );
+    const snapshot = await getDocs(q);
+    const reviews = snapshot.docs.map(doc => {
+      const data = doc.data() as Review;
+      return { ...data, id: doc.id };
+    });
+
+    console.log('🔍 ReviewService.getReviewsByProcedure - Found reviews before enhancement:', {
+      procedureId,
+      reviewCount: reviews.length,
+      reviewIds: reviews.map(r => r.id),
+    });
+
+    // Enhance reviews with entity names from appointments
+    const enhancedReviews = await Promise.all(
+      reviews.map(async review => {
+        try {
+          // Fetch the associated appointment
+          const appointmentDoc = await getDoc(
+            doc(this.db, APPOINTMENTS_COLLECTION, review.appointmentId),
+          );
+
+          if (appointmentDoc.exists()) {
+            const appointment = appointmentDoc.data() as Appointment;
+
+            // Create enhanced review with entity names
+            const enhancedReview = { ...review };
+
+            if (enhancedReview.clinicReview && appointment.clinicInfo) {
+              enhancedReview.clinicReview = {
+                ...enhancedReview.clinicReview,
+                clinicName: appointment.clinicInfo.name,
+              };
+            }
+
+            if (enhancedReview.practitionerReview && appointment.practitionerInfo) {
+              enhancedReview.practitionerReview = {
+                ...enhancedReview.practitionerReview,
+                practitionerName: appointment.practitionerInfo.name,
+              };
+            }
+
+            if (enhancedReview.procedureReview && appointment.procedureInfo) {
+              enhancedReview.procedureReview = {
+                ...enhancedReview.procedureReview,
+                procedureName: appointment.procedureInfo.name,
+              };
+            }
+
+            // Add patient name to the main review object
+            if (appointment.patientInfo) {
+              enhancedReview.patientName = appointment.patientInfo.fullName;
+            }
+
+            return enhancedReview;
+          }
+
+          return review;
+        } catch (error) {
+          console.warn(`Failed to enhance review ${review.id} with entity names:`, error);
+          return review;
+        }
+      }),
+    );
+
+    console.log('✅ ReviewService.getReviewsByProcedure - Enhanced reviews:', {
+      procedureId,
+      reviewCount: enhancedReviews.length,
+      reviewIds: enhancedReviews.map(r => r.id),
+      hasEntityNames: enhancedReviews.some(
+        r =>
+          r.clinicReview?.clinicName ||
+          r.practitionerReview?.practitionerName ||
+          r.procedureReview?.procedureName ||
+          r.patientName,
+      ),
+    });
+
+    return enhancedReviews;
+  }
+
+  /**
+   * 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
+   * @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));
+
+    // Note: Updates to related entities after deletion are now handled
+    // by cloud functions through the ReviewsAggregationService
+  }
+
+  /**
+   * 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;
+  }
+}