@blackcode_sa/metaestetics-api 1.12.19 → 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/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/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(),
+});