@blackcode_sa/metaestetics-api 1.12.20 → 1.12.21

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/reviews.service.ts

@@ -8,21 +8,23 @@ import {
   setDoc,
   deleteDoc,
   serverTimestamp,
-} from 'firebase/firestore';
-import { BaseService } from '../base.service';
+} 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';
+} 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";
 
 export class ReviewService extends BaseService {
   constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
@@ -36,8 +38,11 @@ export class ReviewService extends BaseService {
    * @returns The created review
    */
   async createReview(
-    data: Omit<Review, 'id' | 'createdAt' | 'updatedAt' | 'appointmentId' | 'overallRating'>,
-    appointmentId: string,
+    data: Omit<
+      Review,
+      "id" | "createdAt" | "updatedAt" | "appointmentId" | "overallRating"
+    >,
+    appointmentId: string
   ): Promise<Review> {
     try {
       // Validate input data
@@ -161,63 +166,17 @@ export class ReviewService extends BaseService {
   }
 
   /**
-   * Gets all reviews for a specific patient with enhanced entity names
+   * Gets all reviews for a specific patient
    * @param patientId The ID of the patient
-   * @returns Array of reviews for the patient with clinic, practitioner, and procedure names
+   * @returns Array of reviews for the patient
    */
   async getReviewsByPatient(patientId: string): Promise<Review[]> {
-    const q = query(collection(this.db, REVIEWS_COLLECTION), where('patientId', '==', patientId));
-    const snapshot = await getDocs(q);
-    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,
-              };
-            }
-
-            return enhancedReview;
-          }
-
-          return review;
-        } catch (error) {
-          console.warn(`Failed to enhance review ${review.id} with entity names:`, error);
-          return review;
-        }
-      }),
+    const q = query(
+      collection(this.db, REVIEWS_COLLECTION),
+      where("patientId", "==", patientId)
     );
-
-    return enhancedReviews;
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map((doc) => doc.data() as Review);
   }
 
   /**
@@ -228,10 +187,10 @@ export class ReviewService extends BaseService {
   async getReviewsByClinic(clinicId: string): Promise<Review[]> {
     const q = query(
       collection(this.db, REVIEWS_COLLECTION),
-      where('clinicReview.clinicId', '==', clinicId),
+      where("clinicReview.clinicId", "==", clinicId)
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(doc => doc.data() as Review);
+    return snapshot.docs.map((doc) => doc.data() as Review);
   }
 
   /**
@@ -242,10 +201,10 @@ export class ReviewService extends BaseService {
   async getReviewsByPractitioner(practitionerId: string): Promise<Review[]> {
     const q = query(
       collection(this.db, REVIEWS_COLLECTION),
-      where('practitionerReview.practitionerId', '==', practitionerId),
+      where("practitionerReview.practitionerId", "==", practitionerId)
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(doc => doc.data() as Review);
+    return snapshot.docs.map((doc) => doc.data() as Review);
   }
 
   /**
@@ -256,10 +215,10 @@ export class ReviewService extends BaseService {
   async getReviewsByProcedure(procedureId: string): Promise<Review[]> {
     const q = query(
       collection(this.db, REVIEWS_COLLECTION),
-      where('procedureReview.procedureId', '==', procedureId),
+      where("procedureReview.procedureId", "==", procedureId)
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(doc => doc.data() as Review);
+    return snapshot.docs.map((doc) => doc.data() as Review);
   }
 
   /**
@@ -270,7 +229,7 @@ export class ReviewService extends BaseService {
   async getReviewByAppointment(appointmentId: string): Promise<Review | null> {
     const q = query(
       collection(this.db, REVIEWS_COLLECTION),
-      where('appointmentId', '==', appointmentId),
+      where("appointmentId", "==", appointmentId)
     );
     const snapshot = await getDocs(q);
 

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

@@ -22,7 +22,6 @@ interface BaseReview {
  */
 export interface ClinicReview extends BaseReview {
   clinicId: string;
-  clinicName?: string; // Enhanced field: clinic name from appointment
   cleanliness: number; // 1-5 stars
   facilities: number; // 1-5 stars
   staffFriendliness: number; // 1-5 stars
@@ -38,7 +37,6 @@ export interface ClinicReview extends BaseReview {
  */
 export interface PractitionerReview extends BaseReview {
   practitionerId: string;
-  practitionerName?: string; // Enhanced field: practitioner name from appointment
   knowledgeAndExpertise: number; // 1-5 stars
   communicationSkills: number; // 1-5 stars
   bedSideManner: number; // 1-5 stars
@@ -54,7 +52,6 @@ export interface PractitionerReview extends BaseReview {
  */
 export interface ProcedureReview extends BaseReview {
   procedureId: string;
-  procedureName?: string; // Enhanced field: procedure name from appointment
   effectivenessOfTreatment: number; // 1-5 stars
   outcomeExplanation: number; // 1-5 stars
   painManagement: number; // 1-5 stars