@blackcode_sa/metaestetics-api 1.12.36 → 1.12.39

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.12.36",
+  "version": "1.12.39",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/admin/aggregation/appointment/appointment.aggregation.service.ts

@@ -1549,15 +1549,25 @@ export class AppointmentAggregationService {
         return true;
       }
 
-      // Compare before and after photos and notes
-      if (
-        beforeZonePhotos.before !== afterZonePhotos.before ||
-        beforeZonePhotos.after !== afterZonePhotos.after ||
-        beforeZonePhotos.beforeNote !== afterZonePhotos.beforeNote ||
-        beforeZonePhotos.afterNote !== afterZonePhotos.afterNote
-      ) {
+      // Compare before and after photos arrays
+      // If array lengths differ or any entry differs, consider it changed
+      if (beforeZonePhotos.length !== afterZonePhotos.length) {
         return true;
       }
+      
+      // Compare each entry in the arrays
+      for (let i = 0; i < beforeZonePhotos.length; i++) {
+        const beforeEntry = beforeZonePhotos[i];
+        const afterEntry = afterZonePhotos[i];
+        if (
+          beforeEntry.before !== afterEntry.before ||
+          beforeEntry.after !== afterEntry.after ||
+          beforeEntry.beforeNote !== afterEntry.beforeNote ||
+          beforeEntry.afterNote !== afterEntry.afterNote
+        ) {
+          return true;
+        }
+      }
     }
 
     return false;
@@ -1580,27 +1590,48 @@ export class AppointmentAggregationService {
       const newPhotoTypes: { zoneId: string; photoType: 'before' | 'after' }[] = [];
 
       for (const zoneId of Object.keys(afterPhotos)) {
-        const beforeZonePhotos = beforePhotos[zoneId];
-        const afterZonePhotos = afterPhotos[zoneId];
+        const beforeZonePhotos = beforePhotos[zoneId] || [];
+        const afterZonePhotos = afterPhotos[zoneId] || [];
 
-        if (!beforeZonePhotos) {
+        if (beforeZonePhotos.length === 0 && afterZonePhotos.length > 0) {
           // New zone with photos
           updatedZones.push(zoneId);
-          if (afterZonePhotos.before) {
-            newPhotoTypes.push({ zoneId, photoType: 'before' });
-          }
-          if (afterZonePhotos.after) {
-            newPhotoTypes.push({ zoneId, photoType: 'after' });
-          }
+          afterZonePhotos.forEach(entry => {
+            if (entry.before) {
+              newPhotoTypes.push({ zoneId, photoType: 'before' });
+            }
+            if (entry.after) {
+              newPhotoTypes.push({ zoneId, photoType: 'after' });
+            }
+          });
+        } else if (afterZonePhotos.length > beforeZonePhotos.length) {
+          // New photos added to existing zone
+          updatedZones.push(zoneId);
+          const newEntries = afterZonePhotos.slice(beforeZonePhotos.length);
+          newEntries.forEach(entry => {
+            if (entry.before) {
+              newPhotoTypes.push({ zoneId, photoType: 'before' });
+            }
+            if (entry.after) {
+              newPhotoTypes.push({ zoneId, photoType: 'after' });
+            }
+          });
         } else {
-          // Check for new or updated photos
-          if (beforeZonePhotos.before !== afterZonePhotos.before && afterZonePhotos.before) {
-            updatedZones.push(zoneId);
-            newPhotoTypes.push({ zoneId, photoType: 'before' });
-          }
-          if (beforeZonePhotos.after !== afterZonePhotos.after && afterZonePhotos.after) {
-            updatedZones.push(zoneId);
-            newPhotoTypes.push({ zoneId, photoType: 'after' });
+          // Check for updated photos in existing entries
+          for (let i = 0; i < afterZonePhotos.length; i++) {
+            const beforeEntry = beforeZonePhotos[i];
+            const afterEntry = afterZonePhotos[i];
+            
+            if (beforeEntry && afterEntry) {
+              if (beforeEntry.before !== afterEntry.before && afterEntry.before) {
+                updatedZones.push(zoneId);
+                newPhotoTypes.push({ zoneId, photoType: 'before' });
+              }
+              if (beforeEntry.after !== afterEntry.after && afterEntry.after) {
+                updatedZones.push(zoneId);
+                newPhotoTypes.push({ zoneId, photoType: 'after' });
+              }
+            }
           }
         }
       }
@@ -1629,7 +1660,7 @@ export class AppointmentAggregationService {
       if (selectedZones.length > 0) {
         const completedZones = selectedZones.filter(zoneId => {
           const zonePhotos = afterPhotos[zoneId];
-          return zonePhotos && (zonePhotos.before || zonePhotos.after);
+          return zonePhotos && zonePhotos.length > 0 && zonePhotos.some(entry => entry.before || entry.after);
         });
 
         const completionPercentage = (completedZones.length / selectedZones.length) * 100;

package/src/admin/booking/booking.admin.ts

@@ -893,6 +893,7 @@ export class BookingAdmin {
           zonesData: null,
           appointmentProducts: appointmentProducts,
           extendedProcedures: [],
+          recommendedProcedures: [],
           finalbilling: null,
           finalizationNotes: null,
         },

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

@@ -33,6 +33,7 @@ import {
   ZoneItemData,
   ExtendedProcedureInfo,
   AppointmentProductMetadata,
+  RecommendedProcedure,
   APPOINTMENTS_COLLECTION,
 } from '../../types/appointment';
 import {
@@ -48,7 +49,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 { MediaService, MediaAccessLevel, MediaMetadata, MediaResource } from '../media/media.service';
 
 // Import utility functions
 import {
@@ -70,6 +71,18 @@ import {
   getExtendedProceduresUtil,
   getAppointmentProductsUtil,
 } from './utils/extended-procedure.utils';
+import {
+  addRecommendedProcedureUtil,
+  removeRecommendedProcedureUtil,
+  updateRecommendedProcedureUtil,
+  getRecommendedProceduresUtil,
+} from './utils/recommended-procedure.utils';
+import {
+  updateZonePhotoEntryUtil,
+  addAfterPhotoToEntryUtil,
+  updateZonePhotoNotesUtil,
+  getZonePhotoEntryUtil,
+} from './utils/zone-photo.utils';
 
 /**
  * Interface for available booking slot
@@ -1274,35 +1287,34 @@ export class AppointmentService extends BaseService {
         zonesData: null,
         appointmentProducts: [],
         extendedProcedures: [],
+        recommendedProcedures: [],
         zoneBilling: null,
         finalbilling: null,
         finalizationNotes: null,
       };
 
-      // Initialize zonePhotos if it doesn't exist
-      const currentZonePhotos = currentMetadata.zonePhotos || {};
+      // Initialize zonePhotos if it doesn't exist (array model per zone)
+      const currentZonePhotos: Record<string, BeforeAfterPerZone[]> =
+        (currentMetadata.zonePhotos as Record<string, BeforeAfterPerZone[]>) || {};
 
-      // Initialize the zone entry if it doesn't exist
+      // Initialize the zone array if it doesn't exist
       if (!currentZonePhotos[zoneId]) {
-        currentZonePhotos[zoneId] = {
-          before: null,
-          after: null,
-          beforeNote: null,
-          afterNote: null,
-        };
+        currentZonePhotos[zoneId] = [];
       }
 
-      // 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;
-        }
+      // Create a new entry for this uploaded photo with per-photo notes
+      const newEntry: BeforeAfterPerZone = {
+        before: photoType === 'before' ? mediaMetadata.url : null,
+        after: photoType === 'after' ? mediaMetadata.url : null,
+        beforeNote: photoType === 'before' ? (notes || null) : null,
+        afterNote: photoType === 'after' ? (notes || null) : null,
+      };
+
+      // Append to the zone's photo list
+      currentZonePhotos[zoneId] = [...currentZonePhotos[zoneId], newEntry];
+      // Enforce max 10 photos per zone by keeping the most recent 10
+      if (currentZonePhotos[zoneId].length > 10) {
+        currentZonePhotos[zoneId] = currentZonePhotos[zoneId].slice(-10);
       }
 
       // Update the appointment with new metadata
@@ -1313,6 +1325,7 @@ export class AppointmentService extends BaseService {
           zonesData: currentMetadata.zonesData || null,
           appointmentProducts: currentMetadata.appointmentProducts || [],
           extendedProcedures: currentMetadata.extendedProcedures || [],
+          recommendedProcedures: currentMetadata.recommendedProcedures || [],
           // Only include zoneBilling if it exists (avoid undefined values in Firestore)
           ...(currentMetadata.zoneBilling !== undefined && {
             zoneBilling: currentMetadata.zoneBilling,
@@ -1349,7 +1362,7 @@ export class AppointmentService extends BaseService {
   async getZonePhotos(
     appointmentId: string,
     zoneId?: string,
-  ): Promise<Record<string, BeforeAfterPerZone> | BeforeAfterPerZone | null> {
+  ): Promise<Record<string, BeforeAfterPerZone[]> | BeforeAfterPerZone[] | null> {
     try {
       console.log(`[APPOINTMENT_SERVICE] Getting zone photos for appointment ${appointmentId}`);
 
@@ -1358,7 +1371,10 @@ export class AppointmentService extends BaseService {
         throw new Error(`Appointment with ID ${appointmentId} not found`);
       }
 
-      const zonePhotos = appointment.metadata?.zonePhotos;
+      const zonePhotos = appointment.metadata?.zonePhotos as
+        | Record<string, BeforeAfterPerZone[]>
+        | undefined
+        | null;
       if (!zonePhotos) {
         return null;
       }
@@ -1377,21 +1393,21 @@ export class AppointmentService extends BaseService {
   }
 
   /**
-   * Deletes a zone photo and updates appointment metadata
+   * Deletes a zone photo entry (by index) 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')
+   * @param photoIndex Index of the photo entry to delete in the zone array
    * @returns The updated appointment
    */
   async deleteZonePhoto(
     appointmentId: string,
     zoneId: string,
-    photoType: 'before' | 'after',
+    photoIndex: number,
   ): Promise<Appointment> {
     try {
       console.log(
-        `[APPOINTMENT_SERVICE] Deleting ${photoType} photo for zone ${zoneId} in appointment ${appointmentId}`,
+        `[APPOINTMENT_SERVICE] Deleting zone photo index ${photoIndex} for zone ${zoneId} in appointment ${appointmentId}`,
       );
 
       // Get current appointment
@@ -1400,15 +1416,23 @@ export class AppointmentService extends BaseService {
         throw new Error(`Appointment with ID ${appointmentId} not found`);
       }
 
-      const zonePhotos = appointment.metadata?.zonePhotos;
-      if (!zonePhotos || !zonePhotos[zoneId]) {
+      const zonePhotos = appointment.metadata?.zonePhotos as
+        | Record<string, BeforeAfterPerZone[]>
+        | undefined
+        | null;
+      if (!zonePhotos || !zonePhotos[zoneId] || !Array.isArray(zonePhotos[zoneId])) {
         throw new Error(`No photos found for zone ${zoneId} in appointment ${appointmentId}`);
       }
 
-      const photoUrl =
-        photoType === 'before' ? zonePhotos[zoneId].before : zonePhotos[zoneId].after;
+      const zoneArray = [...zonePhotos[zoneId]];
+      if (photoIndex < 0 || photoIndex >= zoneArray.length) {
+        throw new Error(`Invalid photo index ${photoIndex} for zone ${zoneId}`);
+      }
+
+      const entry = zoneArray[photoIndex];
+      const photoUrl = (entry.before || entry.after) as MediaResource | null;
       if (!photoUrl) {
-        throw new Error(`No ${photoType} photo found for zone ${zoneId}`);
+        throw new Error(`No photo URL found for index ${photoIndex} in zone ${zoneId}`);
       }
 
       // Try to find and delete the media from storage
@@ -1429,19 +1453,14 @@ export class AppointmentService extends BaseService {
         // 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) {
+      // Update appointment metadata to remove the photo entry at the specified index
+      const updatedZonePhotos: Record<string, BeforeAfterPerZone[]> = { ...zonePhotos } as any;
+      const updatedZoneArray = [...zoneArray];
+      updatedZoneArray.splice(photoIndex, 1);
+      if (updatedZoneArray.length === 0) {
         delete updatedZonePhotos[zoneId];
+      } else {
+        updatedZonePhotos[zoneId] = updatedZoneArray;
       }
 
       const updateData: UpdateAppointmentData = {
@@ -1451,6 +1470,7 @@ export class AppointmentService extends BaseService {
           zonesData: appointment.metadata?.zonesData || null,
           appointmentProducts: appointment.metadata?.appointmentProducts || [],
           extendedProcedures: appointment.metadata?.extendedProcedures || [],
+          recommendedProcedures: appointment.metadata?.recommendedProcedures || [],
           // Only include zoneBilling if it exists (avoid undefined values in Firestore)
           ...(appointment.metadata?.zoneBilling !== undefined && {
             zoneBilling: appointment.metadata.zoneBilling,
@@ -1464,7 +1484,7 @@ export class AppointmentService extends BaseService {
       const updatedAppointment = await this.updateAppointment(appointmentId, updateData);
 
       console.log(
-        `[APPOINTMENT_SERVICE] Successfully deleted ${photoType} photo for zone ${zoneId}`,
+        `[APPOINTMENT_SERVICE] Successfully deleted photo index ${photoIndex} for zone ${zoneId}`,
       );
 
       return updatedAppointment;
@@ -1714,6 +1734,7 @@ export class AppointmentService extends BaseService {
         zonesData: null,
         appointmentProducts: [],
         extendedProcedures: [],
+        recommendedProcedures: [],
         finalbilling: null,
         finalizationNotes: null,
       };
@@ -1725,6 +1746,7 @@ export class AppointmentService extends BaseService {
           zonesData: currentMetadata.zonesData,
           appointmentProducts: currentMetadata.appointmentProducts || [],
           extendedProcedures: currentMetadata.extendedProcedures || [],
+          recommendedProcedures: currentMetadata.recommendedProcedures || [],
           // Only include zoneBilling if it exists (avoid undefined values in Firestore)
           ...(currentMetadata.zoneBilling !== undefined && {
             zoneBilling: currentMetadata.zoneBilling,
@@ -1741,4 +1763,216 @@ export class AppointmentService extends BaseService {
       throw error;
     }
   }
+
+  /**
+   * Adds a recommended procedure to an appointment
+   * Multiple recommendations of the same procedure are allowed (e.g., touch-up in 2 weeks, full treatment in 3 months)
+   *
+   * @param appointmentId ID of the appointment
+   * @param procedureId ID of the procedure to recommend
+   * @param note Note explaining the recommendation
+   * @param timeframe Suggested timeframe for the procedure
+   * @returns The updated appointment
+   */
+  async addRecommendedProcedure(
+    appointmentId: string,
+    procedureId: string,
+    note: string,
+    timeframe: { value: number; unit: 'day' | 'week' | 'month' | 'year' }
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Adding recommended procedure ${procedureId} to appointment ${appointmentId}`,
+      );
+      return await addRecommendedProcedureUtil(this.db, appointmentId, procedureId, note, timeframe);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error adding recommended procedure:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Removes a recommended procedure from an appointment by index
+   *
+   * @param appointmentId ID of the appointment
+   * @param recommendationIndex Index of the recommendation to remove
+   * @returns The updated appointment
+   */
+  async removeRecommendedProcedure(appointmentId: string, recommendationIndex: number): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Removing recommended procedure at index ${recommendationIndex} from appointment ${appointmentId}`,
+      );
+      return await removeRecommendedProcedureUtil(this.db, appointmentId, recommendationIndex);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error removing recommended procedure:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates a recommended procedure in an appointment by index
+   *
+   * @param appointmentId ID of the appointment
+   * @param recommendationIndex Index of the recommendation to update
+   * @param updates Partial updates (note and/or timeframe)
+   * @returns The updated appointment
+   */
+  async updateRecommendedProcedure(
+    appointmentId: string,
+    recommendationIndex: number,
+    updates: {
+      note?: string;
+      timeframe?: { value: number; unit: 'day' | 'week' | 'month' | 'year' };
+    }
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Updating recommended procedure at index ${recommendationIndex} in appointment ${appointmentId}`,
+      );
+      return await updateRecommendedProcedureUtil(this.db, appointmentId, recommendationIndex, updates);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error updating recommended procedure:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Gets all recommended procedures for an appointment
+   *
+   * @param appointmentId ID of the appointment
+   * @returns Array of recommended procedures
+   */
+  async getRecommendedProcedures(appointmentId: string): Promise<RecommendedProcedure[]> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting recommended procedures for appointment ${appointmentId}`,
+      );
+      return await getRecommendedProceduresUtil(this.db, appointmentId);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error getting recommended procedures:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates a specific photo entry in a zone by index
+   * Can update before/after photos and their notes
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId Zone ID
+   * @param photoIndex Index of the photo entry to update
+   * @param updates Partial updates to apply (before, after, beforeNote, afterNote)
+   * @returns The updated appointment
+   */
+  async updateZonePhotoEntry(
+    appointmentId: string,
+    zoneId: string,
+    photoIndex: number,
+    updates: Partial<BeforeAfterPerZone>
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Updating photo entry at index ${photoIndex} for zone ${zoneId} in appointment ${appointmentId}`,
+      );
+      return await updateZonePhotoEntryUtil(this.db, appointmentId, zoneId, photoIndex, updates);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error updating zone photo entry:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Adds an after photo to an existing before photo entry
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId Zone ID
+   * @param photoIndex Index of the entry to add after photo to
+   * @param afterPhotoUrl URL of the after photo
+   * @param afterNote Optional note for the after photo
+   * @returns The updated appointment
+   */
+  async addAfterPhotoToEntry(
+    appointmentId: string,
+    zoneId: string,
+    photoIndex: number,
+    afterPhotoUrl: MediaResource,
+    afterNote?: string
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Adding after photo to entry at index ${photoIndex} for zone ${zoneId}`,
+      );
+      return await addAfterPhotoToEntryUtil(
+        this.db,
+        appointmentId,
+        zoneId,
+        photoIndex,
+        afterPhotoUrl,
+        afterNote
+      );
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error adding after photo to entry:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates notes for a photo entry
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId Zone ID
+   * @param photoIndex Index of the entry
+   * @param beforeNote Optional note for before photo
+   * @param afterNote Optional note for after photo
+   * @returns The updated appointment
+   */
+  async updateZonePhotoNotes(
+    appointmentId: string,
+    zoneId: string,
+    photoIndex: number,
+    beforeNote?: string,
+    afterNote?: string
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Updating notes for photo entry at index ${photoIndex} for zone ${zoneId}`,
+      );
+      return await updateZonePhotoNotesUtil(
+        this.db,
+        appointmentId,
+        zoneId,
+        photoIndex,
+        beforeNote,
+        afterNote
+      );
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error updating zone photo notes:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Gets a specific photo entry from a zone
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId Zone ID
+   * @param photoIndex Index of the entry
+   * @returns Photo entry
+   */
+  async getZonePhotoEntry(
+    appointmentId: string,
+    zoneId: string,
+    photoIndex: number
+  ): Promise<BeforeAfterPerZone> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting photo entry at index ${photoIndex} for zone ${zoneId}`,
+      );
+      return await getZonePhotoEntryUtil(this.db, appointmentId, zoneId, photoIndex);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error getting zone photo entry:`, error);
+      throw error;
+    }
+  }
 }