@blackcode_sa/metaestetics-api 1.12.20 → 1.12.22

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

@@ -28,12 +28,15 @@ import {
   AppointmentMediaItem,
   PatientReviewInfo,
   type CreateAppointmentHttpData,
+  type ZonePhotoUploadData,
+  BeforeAfterPerZone,
   APPOINTMENTS_COLLECTION,
 } from '../../types/appointment';
 import {
   updateAppointmentSchema,
   searchAppointmentsSchema,
   rescheduleAppointmentSchema,
+  zonePhotoUploadSchema,
 } from '../../validations/appointment.schema';
 
 // Import other services needed (dependency injection pattern)
@@ -42,6 +45,7 @@ import { PatientService } from '../patient/patient.service';
 import { PractitionerService } from '../practitioner/practitioner.service';
 import { ClinicService } from '../clinic/clinic.service';
 import { FilledDocumentService } from '../documentation-templates/filled-document.service';
+import { MediaService, MediaAccessLevel, MediaMetadata } from '../media/media.service';
 
 // Import utility functions
 import {
@@ -68,6 +72,7 @@ export class AppointmentService extends BaseService {
   private practitionerService: PractitionerService;
   private clinicService: ClinicService;
   private filledDocumentService: FilledDocumentService;
+  private mediaService: MediaService;
   private functions: Functions;
 
   /**
@@ -80,6 +85,7 @@ export class AppointmentService extends BaseService {
    * @param patientService Patient service instance
    * @param practitionerService Practitioner service instance
    * @param clinicService Clinic service instance
+   * @param filledDocumentService Filled document service instance
    */
   constructor(
     db: Firestore,
@@ -97,6 +103,7 @@ export class AppointmentService extends BaseService {
     this.practitionerService = practitionerService;
     this.clinicService = clinicService;
     this.filledDocumentService = filledDocumentService;
+    this.mediaService = new MediaService(db, auth, app);
     this.functions = getFunctions(app, 'europe-west6'); // Initialize Firebase Functions with the correct region
   }
 
@@ -1144,4 +1151,294 @@ export class AppointmentService extends BaseService {
       throw error;
     }
   }
+
+  /**
+   * Uploads a zone photo and updates appointment metadata
+   *
+   * @param uploadData Zone photo upload data containing appointment ID, zone ID, photo type, file, and optional notes
+   * @returns The uploaded media metadata
+   */
+  async uploadZonePhoto(uploadData: ZonePhotoUploadData): Promise<MediaMetadata> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Uploading ${uploadData.photoType} photo for zone ${uploadData.zoneId} in appointment ${uploadData.appointmentId}`,
+      );
+
+      // Validate input data
+      const validatedData = await zonePhotoUploadSchema.parseAsync(uploadData);
+
+      // Check if user is authenticated
+      const currentUser = this.auth.currentUser;
+      if (!currentUser) {
+        throw new Error('User must be authenticated to upload zone photos');
+      }
+
+      // Get the appointment to verify it exists and user has access
+      const appointment = await this.getAppointmentById(validatedData.appointmentId);
+      if (!appointment) {
+        throw new Error(`Appointment with ID ${validatedData.appointmentId} not found`);
+      }
+
+      // Generate collection name for the media
+      const collectionName = `appointment_${validatedData.appointmentId}_zone_photos`;
+
+      // Generate filename with zone and photo type info
+      const timestamp = Date.now();
+      const fileExtension = validatedData.file.type?.split('/')[1] || 'jpg';
+      const fileName = `${validatedData.photoType}_${validatedData.zoneId}_${timestamp}.${fileExtension}`;
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Uploading file: ${fileName} to collection: ${collectionName}`,
+      );
+
+      // Upload the media file using MediaService
+      const uploadedMedia = await this.mediaService.uploadMedia(
+        validatedData.file,
+        validatedData.appointmentId, // ownerId is the appointment ID
+        MediaAccessLevel.PRIVATE, // Zone photos are private
+        collectionName,
+        fileName,
+      );
+
+      console.log(`[APPOINTMENT_SERVICE] Media uploaded successfully with ID: ${uploadedMedia.id}`);
+
+      // Update appointment metadata with the new photo
+      await this.updateAppointmentZonePhoto(
+        validatedData.appointmentId,
+        validatedData.zoneId,
+        validatedData.photoType,
+        uploadedMedia,
+        validatedData.notes,
+      );
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Successfully uploaded and linked ${validatedData.photoType} photo for zone ${validatedData.zoneId}`,
+      );
+
+      return uploadedMedia;
+    } catch (error) {
+      console.error('[APPOINTMENT_SERVICE] Error uploading zone photo:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates appointment metadata with zone photo information
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId ID of the zone
+   * @param photoType Type of photo ('before' or 'after')
+   * @param mediaMetadata Uploaded media metadata
+   * @param notes Optional notes for the photo
+   * @returns The updated appointment
+   */
+  private async updateAppointmentZonePhoto(
+    appointmentId: string,
+    zoneId: string,
+    photoType: 'before' | 'after',
+    mediaMetadata: MediaMetadata,
+    notes?: string,
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Updating appointment metadata for ${photoType} photo in zone ${zoneId}`,
+      );
+
+      // Get current appointment
+      const appointment = await this.getAppointmentById(appointmentId);
+      if (!appointment) {
+        throw new Error(`Appointment with ID ${appointmentId} not found`);
+      }
+
+      // Initialize metadata if it doesn't exist
+      const currentMetadata = appointment.metadata || {
+        selectedZones: null,
+        zonePhotos: null,
+        zoneBilling: null,
+        finalbilling: null,
+        finalizationNotes: null,
+      };
+
+      // Initialize zonePhotos if it doesn't exist
+      const currentZonePhotos = currentMetadata.zonePhotos || {};
+
+      // Initialize the zone entry if it doesn't exist
+      if (!currentZonePhotos[zoneId]) {
+        currentZonePhotos[zoneId] = {
+          before: null,
+          after: null,
+          beforeNote: null,
+          afterNote: null,
+        };
+      }
+
+      // Update the specific photo type
+      if (photoType === 'before') {
+        currentZonePhotos[zoneId].before = mediaMetadata.url;
+        if (notes) {
+          currentZonePhotos[zoneId].beforeNote = notes;
+        }
+      } else {
+        currentZonePhotos[zoneId].after = mediaMetadata.url;
+        if (notes) {
+          currentZonePhotos[zoneId].afterNote = notes;
+        }
+      }
+
+      // Update the appointment with new metadata
+      const updateData: UpdateAppointmentData = {
+        metadata: {
+          selectedZones: currentMetadata.selectedZones,
+          zonePhotos: currentZonePhotos,
+          zoneBilling: currentMetadata.zoneBilling,
+          finalbilling: currentMetadata.finalbilling,
+          finalizationNotes: currentMetadata.finalizationNotes,
+        },
+        updatedAt: serverTimestamp(),
+      };
+
+      const updatedAppointment = await this.updateAppointment(appointmentId, updateData);
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Successfully updated appointment metadata for ${photoType} photo in zone ${zoneId}`,
+      );
+
+      return updatedAppointment;
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error updating appointment metadata for zone photo:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Gets zone photos for a specific appointment and zone
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId ID of the zone (optional - if not provided, returns all zones)
+   * @returns Zone photos data
+   */
+  async getZonePhotos(
+    appointmentId: string,
+    zoneId?: string,
+  ): Promise<Record<string, BeforeAfterPerZone> | BeforeAfterPerZone | null> {
+    try {
+      console.log(`[APPOINTMENT_SERVICE] Getting zone photos for appointment ${appointmentId}`);
+
+      const appointment = await this.getAppointmentById(appointmentId);
+      if (!appointment) {
+        throw new Error(`Appointment with ID ${appointmentId} not found`);
+      }
+
+      const zonePhotos = appointment.metadata?.zonePhotos;
+      if (!zonePhotos) {
+        return null;
+      }
+
+      // If specific zone requested, return only that zone's photos
+      if (zoneId) {
+        return zonePhotos[zoneId] || null;
+      }
+
+      // Return all zone photos
+      return zonePhotos;
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error getting zone photos:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Deletes a zone photo and updates appointment metadata
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId ID of the zone
+   * @param photoType Type of photo to delete ('before' or 'after')
+   * @returns The updated appointment
+   */
+  async deleteZonePhoto(
+    appointmentId: string,
+    zoneId: string,
+    photoType: 'before' | 'after',
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Deleting ${photoType} photo for zone ${zoneId} in appointment ${appointmentId}`,
+      );
+
+      // Get current appointment
+      const appointment = await this.getAppointmentById(appointmentId);
+      if (!appointment) {
+        throw new Error(`Appointment with ID ${appointmentId} not found`);
+      }
+
+      const zonePhotos = appointment.metadata?.zonePhotos;
+      if (!zonePhotos || !zonePhotos[zoneId]) {
+        throw new Error(`No photos found for zone ${zoneId} in appointment ${appointmentId}`);
+      }
+
+      const photoUrl =
+        photoType === 'before' ? zonePhotos[zoneId].before : zonePhotos[zoneId].after;
+      if (!photoUrl) {
+        throw new Error(`No ${photoType} photo found for zone ${zoneId}`);
+      }
+
+      // Try to find and delete the media from storage
+      try {
+        // Only try to delete if photoUrl is a string (URL)
+        if (typeof photoUrl === 'string') {
+          const mediaMetadata = await this.mediaService.getMediaMetadataByUrl(photoUrl);
+          if (mediaMetadata) {
+            await this.mediaService.deleteMedia(mediaMetadata.id);
+            console.log(`[APPOINTMENT_SERVICE] Deleted media file with ID: ${mediaMetadata.id}`);
+          }
+        }
+      } catch (mediaError) {
+        console.warn(
+          `[APPOINTMENT_SERVICE] Could not delete media file for URL ${photoUrl}:`,
+          mediaError,
+        );
+        // Continue with metadata update even if media deletion fails
+      }
+
+      // Update appointment metadata to remove the photo reference
+      const updatedZonePhotos = { ...zonePhotos };
+      if (photoType === 'before') {
+        updatedZonePhotos[zoneId].before = null;
+        updatedZonePhotos[zoneId].beforeNote = null;
+      } else {
+        updatedZonePhotos[zoneId].after = null;
+        updatedZonePhotos[zoneId].afterNote = null;
+      }
+
+      // If both photos are null, we could optionally remove the zone entry entirely
+      if (!updatedZonePhotos[zoneId].before && !updatedZonePhotos[zoneId].after) {
+        delete updatedZonePhotos[zoneId];
+      }
+
+      const updateData: UpdateAppointmentData = {
+        metadata: {
+          selectedZones: appointment.metadata?.selectedZones || null,
+          zonePhotos: updatedZonePhotos,
+          zoneBilling: appointment.metadata?.zoneBilling || null,
+          finalbilling: appointment.metadata?.finalbilling || null,
+          finalizationNotes: appointment.metadata?.finalizationNotes || null,
+        },
+        updatedAt: serverTimestamp(),
+      };
+
+      const updatedAppointment = await this.updateAppointment(appointmentId, updateData);
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Successfully deleted ${photoType} photo for zone ${zoneId}`,
+      );
+
+      return updatedAppointment;
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error deleting zone photo:`, error);
+      throw error;
+    }
+  }
 }

package/src/services/reviews/README.md

@@ -0,0 +1,129 @@
+# Reviews Service - Enhanced with Entity Names
+
+## Overview
+
+The Reviews Service has been enhanced to automatically include entity names (clinic, practitioner, procedure, and patient names) in all review responses. This eliminates the need for frontend applications to make additional API calls to fetch entity details.
+
+## Enhanced Methods
+
+All review retrieval methods now include entity names from associated appointments:
+
+### 1. `getReview(reviewId: string)`
+- **Enhanced**: ✅ Returns single review with entity names
+- **Entity Names**: Clinic name, practitioner name, procedure name, patient name
+- **Source**: Fetched from associated appointment data
+
+### 2. `getReviewsByPatient(patientId: string)`
+- **Enhanced**: ✅ Returns patient reviews with entity names
+- **Entity Names**: Clinic name, practitioner name, procedure name, patient name
+- **Use Case**: Patient app - "My Reviews" screen
+
+### 3. `getReviewsByPractitioner(practitionerId: string)`
+- **Enhanced**: ✅ Returns practitioner reviews with entity names
+- **Entity Names**: Clinic name, practitioner name, procedure name, patient name
+- **Use Case**: Doctor app - "Reviews" screen
+
+### 4. `getReviewsByClinic(clinicId: string)`
+- **Enhanced**: ✅ Returns clinic reviews with entity names
+- **Entity Names**: Clinic name, practitioner name, procedure name, patient name
+- **Use Case**: Clinic dashboard - "Reviews" section
+
+### 5. `getReviewsByProcedure(procedureId: string)`
+- **Enhanced**: ✅ Returns procedure reviews with entity names
+- **Entity Names**: Clinic name, practitioner name, procedure name, patient name
+- **Use Case**: Procedure analytics and reporting
+
+## Enhanced Review Structure
+
+```typescript
+interface Review {
+  id: string;
+  appointmentId: string;
+  patientId: string;
+  patientName?: string; // 🆕 Enhanced field
+  createdAt: Date;
+  updatedAt: Date;
+  clinicReview?: {
+    // ... existing fields
+    clinicName?: string; // 🆕 Enhanced field
+  };
+  practitionerReview?: {
+    // ... existing fields
+    practitionerName?: string; // 🆕 Enhanced field
+  };
+  procedureReview?: {
+    // ... existing fields
+    procedureName?: string; // 🆕 Enhanced field
+  };
+  overallComment: string;
+  overallRating: number;
+}
+```
+
+## Data Sources
+
+Entity names are fetched from the associated appointment's aggregated information:
+
+- **Clinic Name**: `appointment.clinicInfo.name`
+- **Practitioner Name**: `appointment.practitionerInfo.name`
+- **Procedure Name**: `appointment.procedureInfo.name`
+- **Patient Name**: `appointment.patientInfo.fullName`
+
+## Error Handling
+
+- If appointment is not found, review is returned without enhancement
+- Individual enhancement failures are logged but don't break the entire operation
+- Graceful fallback ensures API reliability
+
+## Logging
+
+Enhanced logging provides detailed information about:
+- Query parameters
+- Number of reviews found
+- Enhancement success/failure
+- Entity names availability
+
+## Performance Considerations
+
+- Each review requires one additional Firestore read for appointment data
+- Enhancement is performed in parallel for multiple reviews
+- Consider caching strategies for high-volume applications
+
+## Migration Notes
+
+- **Backward Compatible**: Existing code continues to work
+- **Optional Fields**: All enhanced fields are optional
+- **No Breaking Changes**: API signature remains the same
+
+## Usage Examples
+
+### Doctor App - Reviews Screen
+```typescript
+const reviews = await reviewService.getReviewsByPractitioner(practitionerId);
+// Now includes practitioner names, clinic names, procedure names, and patient names
+```
+
+### Patient App - My Reviews
+```typescript
+const reviews = await reviewService.getReviewsByPatient(patientId);
+// Now includes all entity names for better UX
+```
+
+### Clinic Dashboard
+```typescript
+const reviews = await reviewService.getReviewsByClinic(clinicId);
+// Now includes practitioner and procedure names for each review
+```
+
+## Testing
+
+All enhanced methods include comprehensive logging for debugging:
+- Input parameters
+- Query results
+- Enhancement status
+- Entity name availability
+
+Monitor logs with:
+```bash
+firebase functions:log --only reviewService
+```