@blackcode_sa/metaestetics-api 1.13.0 → 1.13.1

package/src/services/analytics/utils/cost-calculation.utils.ts

@@ -67,7 +67,11 @@ export function calculateAppointmentCost(appointment: Appointment): {
 /**
  * Calculates total revenue from an array of appointments
  *
- * @param appointments - Array of appointments
+ * IMPORTANT: This function should only be called with COMPLETED appointments.
+ * Only completed procedures generate revenue. Confirmed, pending, canceled, and no-show
+ * appointments should be filtered out before calling this function.
+ *
+ * @param appointments - Array of appointments (should be filtered to COMPLETED only)
  * @returns Total revenue and currency
  */
 export function calculateTotalRevenue(appointments: Appointment[]): {
@@ -96,8 +100,19 @@ export function calculateTotalRevenue(appointments: Appointment[]): {
 /**
  * Extracts product usage from appointment metadata
  *
- * @param appointment - The appointment to extract products from
- * @returns Array of product usage data
+ * IMPORTANT: This function should only be called with COMPLETED appointments.
+ * Products are only considered "used" when the procedure has been completed.
+ * Only completed procedures generate product usage and revenue.
+ *
+ * NOTE ON PRICING:
+ * - Price overrides (priceOverrideAmount) are always applied if available
+ * - Subtotal is recalculated to ensure price overrides are reflected
+ * - Product revenue shows SUBTOTAL (before tax) - tax is applied at appointment level
+ * - Tax is included in appointment revenue (finalbilling.finalPrice) but not in product revenue
+ * - Product subtotals should sum to finalbilling.subtotalAll (before tax)
+ *
+ * @param appointment - The appointment to extract products from (should be COMPLETED)
+ * @returns Array of product usage data with subtotal (before tax)
  */
 export function extractProductUsage(appointment: Appointment): Array<{
   productId: string;
@@ -131,9 +146,22 @@ export function extractProductUsage(appointment: Appointment): Array<{
   Object.values(zonesData).forEach(items => {
     items.forEach(item => {
       if (item.type === 'item' && item.productId) {
+        // Always use priceOverrideAmount if available, otherwise use price
+        // This ensures price overrides are properly applied to product calculations
         const price = item.priceOverrideAmount || item.price || 0;
         const quantity = item.quantity || 1;
-        const subtotal = item.subtotal || price * quantity;
+        
+        // Always recalculate subtotal based on the actual price (with override)
+        // This ensures price overrides are reflected in product revenue
+        // Use stored subtotal only if it matches the calculated value (to handle rounding)
+        const calculatedSubtotal = price * quantity;
+        const storedSubtotal = item.subtotal || 0;
+        
+        // Use stored subtotal if it's close to calculated (within 0.01 for rounding differences)
+        // Otherwise recalculate to ensure price override is applied correctly
+        const subtotal = Math.abs(storedSubtotal - calculatedSubtotal) < 0.01 
+          ? storedSubtotal 
+          : calculatedSubtotal;
 
         products.push({
           productId: item.productId,

package/src/services/analytics/utils/grouping.utils.ts

@@ -101,6 +101,9 @@ export function groupAppointmentsByEntity(
 
 /**
  * Calculates grouped revenue metrics
+ * 
+ * IMPORTANT: Only COMPLETED appointments are included in revenue calculations.
+ * Confirmed, pending, canceled, and no-show appointments are excluded from financial metrics.
  */
 export function calculateGroupedRevenueMetrics(
   appointments: Appointment[],
@@ -139,6 +142,15 @@ export function calculateGroupedRevenueMetrics(
       }
     });
 
+    // Get practitioner info when grouping by procedure
+    let practitionerId: string | undefined;
+    let practitionerName: string | undefined;
+    if (entityType === 'procedure' && entityAppointments.length > 0) {
+      const firstAppointment = entityAppointments[0];
+      practitionerId = firstAppointment.practitionerId;
+      practitionerName = firstAppointment.practitionerInfo?.name;
+    }
+
     return {
       entityId,
       entityName: data.name,
@@ -153,12 +165,18 @@ export function calculateGroupedRevenueMetrics(
       refundedRevenue,
       totalTax,
       totalSubtotal,
+      ...(practitionerId && { practitionerId }),
+      ...(practitionerName && { practitionerName }),
     };
   });
 }
 
 /**
  * Calculates grouped product usage metrics
+ * 
+ * IMPORTANT: Only COMPLETED appointments are included in product usage calculations.
+ * Products are only considered "used" when the procedure has been completed.
+ * Confirmed, pending, canceled, and no-show appointments are excluded from product metrics.
  */
 export function calculateGroupedProductUsageMetrics(
   appointments: Appointment[],
@@ -220,6 +238,15 @@ export function calculateGroupedProductUsageMetrics(
     const totalProductRevenue = topProducts.reduce((sum, p) => sum + p.totalRevenue, 0);
     const totalProductQuantity = topProducts.reduce((sum, p) => sum + p.totalQuantity, 0);
 
+    // Get practitioner info when grouping by procedure
+    let practitionerId: string | undefined;
+    let practitionerName: string | undefined;
+    if (entityType === 'procedure' && entityAppointments.length > 0) {
+      const firstAppointment = entityAppointments[0];
+      practitionerId = firstAppointment.practitionerId;
+      practitionerName = firstAppointment.practitionerInfo?.name;
+    }
+
     return {
       entityId,
       entityName: data.name,
@@ -231,6 +258,8 @@ export function calculateGroupedProductUsageMetrics(
       averageProductsPerAppointment:
         entityCompleted.length > 0 ? productMap.size / entityCompleted.length : 0,
       topProducts,
+      ...(practitionerId && { practitionerId }),
+      ...(practitionerName && { practitionerName }),
     };
   });
 }
@@ -253,6 +282,15 @@ export function calculateGroupedTimeEfficiencyMetrics(
 
     const timeMetrics = calculateAverageTimeMetrics(entityCompleted);
 
+    // Get practitioner info when grouping by procedure
+    let practitionerId: string | undefined;
+    let practitionerName: string | undefined;
+    if (entityType === 'procedure' && entityAppointments.length > 0) {
+      const firstAppointment = entityAppointments[0];
+      practitionerId = firstAppointment.practitionerId;
+      practitionerName = firstAppointment.practitionerInfo?.name;
+    }
+
     return {
       entityId,
       entityName: data.name,
@@ -266,6 +304,8 @@ export function calculateGroupedTimeEfficiencyMetrics(
       totalUnderutilization: timeMetrics.totalUnderutilization,
       averageOverrun: timeMetrics.averageOverrun,
       averageUnderutilization: timeMetrics.averageUnderutilization,
+      ...(practitionerId && { practitionerId }),
+      ...(practitionerName && { practitionerName }),
     };
   });
 }

package/src/services/analytics/utils/trend-calculation.utils.ts

@@ -0,0 +1,200 @@
+import { Appointment } from '../../../types/appointment';
+import { Timestamp } from 'firebase/firestore';
+
+/**
+ * Trend period type
+ */
+export type TrendPeriod = 'week' | 'month' | 'quarter' | 'year';
+
+/**
+ * Period information for trend grouping
+ */
+export interface PeriodInfo {
+  period: string; // e.g., "2024-W01", "2024-01", "2024-Q1", "2024"
+  startDate: Date;
+  endDate: Date;
+}
+
+/**
+ * Calculates the start and end dates for a given period
+ */
+export function getPeriodDates(date: Date, period: TrendPeriod): PeriodInfo {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const day = date.getDate();
+
+  let startDate: Date;
+  let endDate: Date;
+  let periodString: string;
+
+  switch (period) {
+    case 'week': {
+      // Get Monday of the week
+      const dayOfWeek = date.getDay();
+      const diff = date.getDate() - dayOfWeek + (dayOfWeek === 0 ? -6 : 1); // Adjust when day is Sunday
+      startDate = new Date(year, month, diff);
+      startDate.setHours(0, 0, 0, 0);
+      
+      endDate = new Date(startDate);
+      endDate.setDate(endDate.getDate() + 6);
+      endDate.setHours(23, 59, 59, 999);
+
+      // ISO week format: YYYY-Www
+      const weekNumber = getWeekNumber(date);
+      periodString = `${year}-W${weekNumber.toString().padStart(2, '0')}`;
+      break;
+    }
+
+    case 'month': {
+      startDate = new Date(year, month, 1);
+      startDate.setHours(0, 0, 0, 0);
+      
+      endDate = new Date(year, month + 1, 0);
+      endDate.setHours(23, 59, 59, 999);
+
+      periodString = `${year}-${(month + 1).toString().padStart(2, '0')}`;
+      break;
+    }
+
+    case 'quarter': {
+      const quarter = Math.floor(month / 3);
+      const quarterStartMonth = quarter * 3;
+      
+      startDate = new Date(year, quarterStartMonth, 1);
+      startDate.setHours(0, 0, 0, 0);
+      
+      endDate = new Date(year, quarterStartMonth + 3, 0);
+      endDate.setHours(23, 59, 59, 999);
+
+      periodString = `${year}-Q${quarter + 1}`;
+      break;
+    }
+
+    case 'year': {
+      startDate = new Date(year, 0, 1);
+      startDate.setHours(0, 0, 0, 0);
+      
+      endDate = new Date(year, 11, 31);
+      endDate.setHours(23, 59, 59, 999);
+
+      periodString = `${year}`;
+      break;
+    }
+  }
+
+  return {
+    period: periodString,
+    startDate,
+    endDate,
+  };
+}
+
+/**
+ * Gets ISO week number for a date
+ */
+function getWeekNumber(date: Date): number {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  return Math.ceil(((d.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+}
+
+/**
+ * Groups appointments by trend period
+ */
+export function groupAppointmentsByPeriod(
+  appointments: Appointment[],
+  period: TrendPeriod,
+): Map<string, Appointment[]> {
+  const periodMap = new Map<string, Appointment[]>();
+
+  appointments.forEach(appointment => {
+    const appointmentDate = appointment.appointmentStartTime.toDate();
+    const periodInfo = getPeriodDates(appointmentDate, period);
+    const periodKey = periodInfo.period;
+
+    if (!periodMap.has(periodKey)) {
+      periodMap.set(periodKey, []);
+    }
+    periodMap.get(periodKey)!.push(appointment);
+  });
+
+  return periodMap;
+}
+
+/**
+ * Generates all periods between start and end date for a given period type
+ */
+export function generatePeriods(
+  startDate: Date,
+  endDate: Date,
+  period: TrendPeriod,
+): PeriodInfo[] {
+  const periods: PeriodInfo[] = [];
+  const current = new Date(startDate);
+
+  while (current <= endDate) {
+    const periodInfo = getPeriodDates(current, period);
+    
+    // Only add if period overlaps with our date range
+    if (periodInfo.endDate >= startDate && periodInfo.startDate <= endDate) {
+      periods.push(periodInfo);
+    }
+
+    // Move to next period
+    switch (period) {
+      case 'week':
+        current.setDate(current.getDate() + 7);
+        break;
+      case 'month':
+        current.setMonth(current.getMonth() + 1);
+        break;
+      case 'quarter':
+        current.setMonth(current.getMonth() + 3);
+        break;
+      case 'year':
+        current.setFullYear(current.getFullYear() + 1);
+        break;
+    }
+  }
+
+  return periods.sort((a, b) => a.startDate.getTime() - b.startDate.getTime());
+}
+
+/**
+ * Calculates percentage change between two values
+ * @param current - Current value
+ * @param previous - Previous value
+ * @returns Percentage change (positive = increase, negative = decrease)
+ */
+export function calculatePercentageChange(current: number, previous: number): number {
+  if (previous === 0) {
+    return current > 0 ? 100 : 0;
+  }
+  return ((current - previous) / previous) * 100;
+}
+
+/**
+ * Gets trend direction and percentage change
+ */
+export interface TrendChange {
+  value: number;
+  previousValue: number;
+  percentageChange: number;
+  direction: 'up' | 'down' | 'stable';
+}
+
+export function getTrendChange(current: number, previous: number): TrendChange {
+  const percentageChange = calculatePercentageChange(current, previous);
+  const direction: 'up' | 'down' | 'stable' =
+    percentageChange > 0.01 ? 'up' : percentageChange < -0.01 ? 'down' : 'stable';
+
+  return {
+    value: current,
+    previousValue: previous,
+    percentageChange: Math.abs(percentageChange),
+    direction,
+  };
+}
+

package/src/services/appointment/appointment.service.ts

@@ -1833,6 +1833,12 @@ export class AppointmentService extends BaseService {
         finalizationNotes: null,
       };
 
+      // Update payment status if billing data exists but status is NOT_APPLICABLE
+      // This handles cases where appointment was created with price 0 but billing was added later
+      const shouldUpdatePaymentStatus =
+        finalbilling.finalPrice > 0 &&
+        appointment.paymentStatus === PaymentStatus.NOT_APPLICABLE;
+
       const updateData: UpdateAppointmentData = {
         metadata: {
           selectedZones: currentMetadata.selectedZones,
@@ -1848,6 +1854,9 @@ export class AppointmentService extends BaseService {
           finalbilling,
           finalizationNotes: currentMetadata.finalizationNotes,
         },
+        ...(shouldUpdatePaymentStatus && {
+          paymentStatus: PaymentStatus.UNPAID,
+        }),
         updatedAt: serverTimestamp(),
       };
 

package/src/services/procedure/procedure.service.ts

@@ -1088,6 +1088,14 @@ export class ProcedureService extends BaseService {
           console.log('[PROCEDURE_SERVICE] Strategy 1: Trying nameLower search');
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
+          
+          // Check if we have nested field filters that might conflict with orderBy
+          const hasNestedFilters = !!(filters.procedureTechnology || filters.procedureCategory || filters.procedureSubcategory);
+          
+          if (hasNestedFilters) {
+            console.log('[PROCEDURE_SERVICE] Strategy 1: Has nested filters, will apply client-side after query');
+          }
+          
           constraints.push(where('nameLower', '>=', searchTerm));
           constraints.push(where('nameLower', '<=', searchTerm + '\uf8ff'));
           constraints.push(orderBy('nameLower'));
@@ -1105,9 +1113,15 @@ export class ProcedureService extends BaseService {
 
           const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs(q);
-          const procedures = querySnapshot.docs.map(
+          let procedures = querySnapshot.docs.map(
             doc => ({ ...doc.data(), id: doc.id } as Procedure),
           );
+          
+          // Apply client-side filters for nested fields if needed
+          if (hasNestedFilters) {
+            procedures = this.applyInMemoryFilters(procedures, filters);
+          }
+          
           const lastDoc =
             querySnapshot.docs.length > 0
               ? querySnapshot.docs[querySnapshot.docs.length - 1]
@@ -1131,6 +1145,14 @@ export class ProcedureService extends BaseService {
           console.log('[PROCEDURE_SERVICE] Strategy 2: Trying name field search');
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
+          
+          // Check if we have nested field filters that might conflict with orderBy
+          const hasNestedFilters = !!(filters.procedureTechnology || filters.procedureCategory || filters.procedureSubcategory);
+          
+          if (hasNestedFilters) {
+            console.log('[PROCEDURE_SERVICE] Strategy 2: Has nested filters, will apply client-side after query');
+          }
+          
           constraints.push(where('name', '>=', searchTerm));
           constraints.push(where('name', '<=', searchTerm + '\uf8ff'));
           constraints.push(orderBy('name'));
@@ -1148,9 +1170,15 @@ export class ProcedureService extends BaseService {
 
           const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs(q);
-          const procedures = querySnapshot.docs.map(
+          let procedures = querySnapshot.docs.map(
             doc => ({ ...doc.data(), id: doc.id } as Procedure),
           );
+          
+          // Apply client-side filters for nested fields if needed
+          if (hasNestedFilters) {
+            procedures = this.applyInMemoryFilters(procedures, filters);
+          }
+          
           const lastDoc =
             querySnapshot.docs.length > 0
               ? querySnapshot.docs[querySnapshot.docs.length - 1]
@@ -1169,11 +1197,66 @@ export class ProcedureService extends BaseService {
       }
 
       // Strategy 3: orderBy createdAt with client-side filtering
+      // NOTE: This strategy excludes nested field filters (technology.id, category.id, subcategory.id)
+      // from Firestore query because Firestore doesn't support orderBy on different field
+      // when using where on nested fields without a composite index.
+      // These filters are applied client-side instead.
       try {
         console.log(
           '[PROCEDURE_SERVICE] Strategy 3: Using createdAt orderBy with client-side filtering',
+          {
+            procedureTechnology: filters.procedureTechnology,
+            hasTechnologyFilter: !!filters.procedureTechnology,
+          },
+        );
+        
+        // Build constraints WITHOUT nested field filters (these will be applied client-side)
+        const constraints: QueryConstraint[] = [];
+        
+        // Active status filter
+        if (filters.isActive !== undefined) {
+          constraints.push(where('isActive', '==', filters.isActive));
+        } else {
+          constraints.push(where('isActive', '==', true));
+        }
+        
+        // Only include non-nested field filters in Firestore query
+        if (filters.procedureFamily) {
+          constraints.push(where('family', '==', filters.procedureFamily));
+        }
+        if (filters.practitionerId) {
+          constraints.push(where('practitionerId', '==', filters.practitionerId));
+        }
+        if (filters.clinicId) {
+          constraints.push(where('clinicBranchId', '==', filters.clinicId));
+        }
+        if (filters.minPrice !== undefined) {
+          constraints.push(where('price', '>=', filters.minPrice));
+        }
+        if (filters.maxPrice !== undefined) {
+          constraints.push(where('price', '<=', filters.maxPrice));
+        }
+        if (filters.minRating !== undefined) {
+          constraints.push(where('reviewInfo.averageRating', '>=', filters.minRating));
+        }
+        if (filters.maxRating !== undefined) {
+          constraints.push(where('reviewInfo.averageRating', '<=', filters.maxRating));
+        }
+        if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
+          const benefitIdsToMatch = filters.treatmentBenefits;
+          constraints.push(where('treatmentBenefitIds', 'array-contains-any', benefitIdsToMatch));
+        }
+        
+        // NOTE: We intentionally EXCLUDE these nested field filters from Firestore query:
+        // - filters.procedureTechnology (technology.id)
+        // - filters.procedureCategory (category.id)
+        // - filters.procedureSubcategory (subcategory.id)
+        // These will be applied client-side in applyInMemoryFilters
+        
+        console.log(
+          '[PROCEDURE_SERVICE] Strategy 3 Firestore constraints (nested filters excluded):',
+          constraints.map(c => (c as any).fieldPath || 'unknown'),
         );
-        const constraints = getBaseConstraints();
         constraints.push(orderBy('createdAt', 'desc'));
 
         if (filters.lastDoc) {
@@ -1194,7 +1277,20 @@ export class ProcedureService extends BaseService {
         );
 
         // Apply all client-side filters using centralized function
+        console.log('[PROCEDURE_SERVICE] Before applyInMemoryFilters (Strategy 3):', {
+          procedureCount: procedures.length,
+          procedureTechnology: filters.procedureTechnology,
+          filtersObject: {
+            procedureTechnology: filters.procedureTechnology,
+            procedureFamily: filters.procedureFamily,
+            procedureCategory: filters.procedureCategory,
+            procedureSubcategory: filters.procedureSubcategory,
+          },
+        });
         procedures = this.applyInMemoryFilters(procedures, filters);
+        console.log('[PROCEDURE_SERVICE] After applyInMemoryFilters (Strategy 3):', {
+          procedureCount: procedures.length,
+        });
 
         const lastDoc =
           querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
@@ -1265,6 +1361,14 @@ export class ProcedureService extends BaseService {
   ): (Procedure & { distance?: number })[] {
     let filteredProcedures = [...procedures]; // Create copy to avoid mutating original
 
+    // Debug: Log what filters we received
+    console.log('[PROCEDURE_SERVICE] applyInMemoryFilters called:', {
+      procedureCount: procedures.length,
+      procedureTechnology: filters.procedureTechnology,
+      hasTechnologyFilter: !!filters.procedureTechnology,
+      allFilterKeys: Object.keys(filters).filter(k => filters[k] !== undefined && filters[k] !== null),
+    });
+
     // Name search filter
     if (filters.nameSearch && filters.nameSearch.trim()) {
       const searchTerm = filters.nameSearch.trim().toLowerCase();
@@ -1348,12 +1452,21 @@ export class ProcedureService extends BaseService {
 
     // Technology filtering
     if (filters.procedureTechnology) {
+      const beforeCount = filteredProcedures.length;
       filteredProcedures = filteredProcedures.filter(
         procedure => procedure.technology?.id === filters.procedureTechnology,
       );
       console.log(
-        `[PROCEDURE_SERVICE] Applied technology filter, results: ${filteredProcedures.length}`,
+        `[PROCEDURE_SERVICE] Applied technology filter (${filters.procedureTechnology}), before: ${beforeCount}, after: ${filteredProcedures.length}`,
       );
+      // Log sample technology IDs for debugging
+      if (beforeCount > filteredProcedures.length) {
+        const filteredOut = procedures
+          .filter(p => p.technology?.id !== filters.procedureTechnology)
+          .slice(0, 3)
+          .map(p => ({ id: p.id, techId: p.technology?.id, name: p.name }));
+        console.log('[PROCEDURE_SERVICE] Filtered out sample procedures:', filteredOut);
+      }
     }
 
     // Practitioner filtering

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

@@ -29,6 +29,57 @@ export class ReviewService extends BaseService {
     super(db, auth, app);
   }
 
+  /**
+   * Helper function to convert Firestore Timestamps to Date objects
+   * @param timestamp The timestamp to convert
+   * @returns A JavaScript Date object or null
+   */
+  private convertTimestamp(timestamp: any): Date {
+    if (!timestamp) {
+      return new Date();
+    }
+
+    // Firebase Timestamp object with __isTimestamp
+    if (timestamp && timestamp.__isTimestamp === true && typeof timestamp.seconds === 'number') {
+      return new Date(timestamp.seconds * 1000 + (timestamp.nanoseconds || 0) / 1000000);
+    }
+
+    // Firebase Firestore Timestamp with toDate method
+    if (timestamp && timestamp.toDate && typeof timestamp.toDate === 'function') {
+      return timestamp.toDate();
+    }
+
+    // Already a Date object
+    if (timestamp instanceof Date) {
+      return timestamp;
+    }
+
+    // String or number
+    if (typeof timestamp === 'string' || typeof timestamp === 'number') {
+      const date = new Date(timestamp);
+      if (!isNaN(date.getTime())) {
+        return date;
+      }
+    }
+
+    return new Date();
+  }
+
+  /**
+   * Converts a Firestore document to a Review object with proper date handling
+   * @param docData The raw Firestore document data
+   * @returns A Review object with properly converted dates
+   */
+  private convertDocToReview(docData: any): Review {
+    const review = docData as Review;
+    
+    // Convert main review timestamps (all sub-reviews share the same creation date)
+    review.createdAt = this.convertTimestamp(docData.createdAt);
+    review.updatedAt = this.convertTimestamp(docData.updatedAt);
+
+    return review;
+  }
+
   /**
    * Creates a new review
    * @param data - The review data to create
@@ -206,7 +257,7 @@ export class ReviewService extends BaseService {
       return null;
     }
 
-    const review = { ...docSnap.data(), id: reviewId } as Review;
+    const review = { ...this.convertDocToReview(docSnap.data()), id: reviewId };
 
     try {
       // Fetch the associated appointment to enhance with entity names
@@ -293,7 +344,7 @@ export class ReviewService extends BaseService {
   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);
+    const reviews = snapshot.docs.map(doc => this.convertDocToReview(doc.data()));
 
     // Enhance reviews with entity names from appointments
     const enhancedReviews = await Promise.all(
@@ -364,8 +415,8 @@ export class ReviewService extends BaseService {
     );
     const snapshot = await getDocs(q);
     const reviews = snapshot.docs.map(doc => {
-      const data = doc.data() as Review;
-      return { ...data, id: doc.id };
+      const review = this.convertDocToReview(doc.data());
+      return { ...review, id: doc.id };
     });
 
     console.log('🔍 ReviewService.getReviewsByClinic - Found reviews before enhancement:', {
@@ -459,8 +510,8 @@ export class ReviewService extends BaseService {
     );
     const snapshot = await getDocs(q);
     const reviews = snapshot.docs.map(doc => {
-      const data = doc.data() as Review;
-      return { ...data, id: doc.id };
+      const review = this.convertDocToReview(doc.data());
+      return { ...review, id: doc.id };
     });
 
     console.log('🔍 ReviewService.getReviewsByPractitioner - Found reviews before enhancement:', {
@@ -644,7 +695,7 @@ export class ReviewService extends BaseService {
       return null;
     }
 
-    return snapshot.docs[0].data() as Review;
+    return this.convertDocToReview(snapshot.docs[0].data());
   }
 
   /**