@blackcode_sa/metaestetics-api 1.12.20 → 1.12.22

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

@@ -40,6 +40,16 @@ export class ReviewService extends BaseService {
     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);
 
@@ -132,6 +142,13 @@ export class ReviewService extends BaseService {
         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
 
@@ -145,19 +162,80 @@ export class ReviewService extends BaseService {
   }
 
   /**
-   * Gets a review by ID
+   * Gets a review by ID with enhanced entity names
    * @param reviewId The ID of the review to get
-   * @returns The review if found, null otherwise
+   * @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;
     }
 
-    return docSnap.data() as Review;
+    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;
+    }
   }
 
   /**
@@ -206,6 +284,11 @@ export class ReviewService extends BaseService {
               };
             }
 
+            // Add patient name to the main review object
+            if (appointment.patientInfo) {
+              enhancedReview.patientName = appointment.patientInfo.fullName;
+            }
+
             return enhancedReview;
           }
 
@@ -221,45 +304,281 @@ export class ReviewService extends BaseService {
   }
 
   /**
-   * Gets all reviews for a specific clinic
+   * 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
+   * @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);
-    return snapshot.docs.map(doc => doc.data() as Review);
+    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
+   * 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
+   * @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);
-    return snapshot.docs.map(doc => doc.data() as Review);
+    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
+   * 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
+   * @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);
-    return snapshot.docs.map(doc => doc.data() as Review);
+    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;
   }
 
   /**

package/src/types/appointment/index.ts

@@ -120,6 +120,17 @@ export interface BeforeAfterPerZone {
   beforeNote?: string | null;
 }
 
+/**
+ * Interface for zone photo upload data
+ */
+export interface ZonePhotoUploadData {
+  appointmentId: string;
+  zoneId: string;
+  photoType: 'before' | 'after';
+  file: File | Blob;
+  notes?: string;
+}
+
 /**
  * Interface for billing information per zone
  */

package/src/types/reviews/index.ts

@@ -117,6 +117,7 @@ export interface Review {
   id: string;
   appointmentId: string;
   patientId: string;
+  patientName?: string; // Enhanced field: patient name from appointment
   createdAt: Date;
   updatedAt: Date;
   clinicReview?: ClinicReview;
@@ -126,4 +127,4 @@ export interface Review {
   overallRating: number; // Average of all available ratings
 }
 
-export const REVIEWS_COLLECTION = "reviews";
+export const REVIEWS_COLLECTION = 'reviews';

package/src/validations/appointment.schema.ts

@@ -25,7 +25,7 @@ export const appointmentMediaItemSchema = z.object({
   uploadedAt: z
     .any()
     .refine(
-      (val) =>
+      val =>
         val instanceof Date ||
         val?._seconds !== undefined ||
         val?.seconds !== undefined ||
@@ -69,7 +69,7 @@ export const linkedFormInfoSchema = z.object({
   submittedAt: z
     .any()
     .refine(
-      (val) =>
+      val =>
         val === undefined ||
         val instanceof Date ||
         val?._seconds !== undefined ||
@@ -83,7 +83,7 @@ export const linkedFormInfoSchema = z.object({
   completedAt: z
     .any()
     .refine(
-      (val) =>
+      val =>
         val === undefined ||
         val instanceof Date ||
         val?._seconds !== undefined ||
@@ -103,7 +103,7 @@ export const patientReviewInfoSchema = z.object({
   reviewedAt: z
     .any()
     .refine(
-      (val) =>
+      val =>
         val instanceof Date ||
         val?._seconds !== undefined ||
         val?.seconds !== undefined ||
@@ -119,7 +119,7 @@ export const finalizedDetailsSchema = z.object({
   at: z
     .any()
     .refine(
-      (val) =>
+      val =>
         val instanceof Date ||
         val?._seconds !== undefined ||
         val?.seconds !== undefined ||
@@ -194,7 +194,7 @@ export const createAppointmentSchema = z
     appointmentStartTime: z
       .any()
       .refine(
-        (val) =>
+        val =>
           val instanceof Date ||
           val?._seconds !== undefined ||
           val?.seconds !== undefined ||
@@ -206,7 +206,7 @@ export const createAppointmentSchema = z
     appointmentEndTime: z
       .any()
       .refine(
-        (val) =>
+        val =>
           val instanceof Date ||
           val?._seconds !== undefined ||
           val?.seconds !== undefined ||
@@ -222,7 +222,7 @@ export const createAppointmentSchema = z
     initialPaymentStatus: paymentStatusSchema.optional().default(PaymentStatus.UNPAID),
     clinic_tz: z.string().min(1, 'Timezone is required'),
   })
-  .refine((data) => data.appointmentEndTime > data.appointmentStartTime, {
+  .refine(data => data.appointmentEndTime > data.appointmentStartTime, {
     message: 'Appointment end time must be after start time',
     path: ['appointmentEndTime'],
   });
@@ -263,7 +263,7 @@ export const updateAppointmentSchema = z
     appointmentStartTime: z
       .any()
       .refine(
-        (val) =>
+        val =>
           val === undefined ||
           val instanceof Date ||
           val?._seconds !== undefined ||
@@ -277,7 +277,7 @@ export const updateAppointmentSchema = z
     appointmentEndTime: z
       .any()
       .refine(
-        (val) =>
+        val =>
           val === undefined ||
           val instanceof Date ||
           val?._seconds !== undefined ||
@@ -302,7 +302,7 @@ export const updateAppointmentSchema = z
     metadata: appointmentMetadataSchema.optional(),
   })
   .refine(
-    (data) => {
+    data => {
       if (
         data.status === AppointmentStatus.CANCELED_CLINIC ||
         data.status === AppointmentStatus.CANCELED_PATIENT ||
@@ -319,7 +319,7 @@ export const updateAppointmentSchema = z
     },
   )
   .refine(
-    (data) => {
+    data => {
       if (data.appointmentStartTime && data.appointmentEndTime) {
         return data.appointmentEndTime > data.appointmentStartTime;
       }
@@ -342,7 +342,7 @@ export const searchAppointmentsSchema = z
     startDate: z
       .any()
       .refine(
-        (val) =>
+        val =>
           val === undefined ||
           val instanceof Date ||
           val?._seconds !== undefined ||
@@ -356,7 +356,7 @@ export const searchAppointmentsSchema = z
     endDate: z
       .any()
       .refine(
-        (val) =>
+        val =>
           val === undefined ||
           val instanceof Date ||
           val?._seconds !== undefined ||
@@ -374,7 +374,7 @@ export const searchAppointmentsSchema = z
     startAfter: z.any().optional(),
   })
   .refine(
-    (data) => {
+    data => {
       if (!data.startDate && !data.endDate && !data.status) {
         return !!(data.patientId || data.practitionerId || data.clinicBranchId);
       }
@@ -387,7 +387,7 @@ export const searchAppointmentsSchema = z
     },
   )
   .refine(
-    (data) => {
+    data => {
       if (data.startDate && data.endDate) {
         return data.endDate >= data.startDate;
       }
@@ -407,7 +407,7 @@ export const rescheduleAppointmentSchema = z.object({
   newStartTime: z
     .any()
     .refine(
-      (val) =>
+      val =>
         val instanceof Date ||
         val?._seconds !== undefined ||
         val?.seconds !== undefined ||
@@ -419,7 +419,7 @@ export const rescheduleAppointmentSchema = z.object({
   newEndTime: z
     .any()
     .refine(
-      (val) =>
+      val =>
         val instanceof Date ||
         val?._seconds !== undefined ||
         val?.seconds !== undefined ||
@@ -429,3 +429,23 @@ export const rescheduleAppointmentSchema = z.object({
       'New end time must be a valid timestamp, Date object, number, or string',
     ),
 });
+
+/**
+ * Schema for validating zone photo upload data
+ */
+export const zonePhotoUploadSchema = z.object({
+  appointmentId: z.string().min(MIN_STRING_LENGTH, 'Appointment ID is required'),
+  zoneId: z.string().min(MIN_STRING_LENGTH, 'Zone ID is required'),
+  photoType: z.enum(['before', 'after'], {
+    required_error: 'Photo type must be either "before" or "after"',
+  }),
+  file: z.any().refine(file => {
+    // Check if it's a File or Blob object
+    return (
+      file instanceof File ||
+      file instanceof Blob ||
+      (file && typeof file.size === 'number' && typeof file.type === 'string')
+    );
+  }, 'File must be a valid File or Blob object'),
+  notes: z.string().max(MAX_STRING_LENGTH_LONG, 'Notes too long').optional(),
+});