@blackcode_sa/metaestetics-api 1.15.14 → 1.15.17-staging.0

package/src/services/appointment/utils/zone-photo.utils.ts

@@ -1,302 +1,302 @@
-import { Firestore, updateDoc, serverTimestamp, doc, Timestamp } from 'firebase/firestore';
-import {
-  Appointment,
-  BeforeAfterPerZone,
-  APPOINTMENTS_COLLECTION,
-} from '../../../types/appointment';
-import { getAppointmentOrThrow } from './zone-management.utils';
-import { MediaResource } from '../../media/media.service';
-
-/**
- * Updates visibility fields with audit trail
- * Note: We use Timestamp.now() instead of serverTimestamp() because Firestore
- * doesn't support serverTimestamp() inside arrays. The timestamp will be set
- * on the client side, which is acceptable for audit purposes.
- * @param updates Partial updates object
- * @param doctorId ID of the doctor making the change
- */
-function addVisibilityAudit(
-  updates: Partial<BeforeAfterPerZone>,
-  doctorId: string,
-): Partial<BeforeAfterPerZone> {
-  // Only add audit fields if visibility-related fields are being updated
-  if (
-    updates.showToPatient !== undefined ||
-    updates.beforeNoteVisibleToPatient !== undefined ||
-    updates.afterNoteVisibleToPatient !== undefined
-  ) {
-    return {
-      ...updates,
-      visibilityUpdatedAt: Timestamp.now(), // Use client-side timestamp (Firestore limitation)
-      visibilityUpdatedBy: doctorId,
-    };
-  }
-  return updates;
-}
-
-/**
- * Updates a specific photo entry in a zone by index
- * Can update before/after photos and their notes
- * 
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param zoneId Zone ID
- * @param photoIndex Index of the photo entry to update
- * @param updates Partial updates to apply
- * @param doctorId Optional doctor ID for audit trail (required if updating visibility)
- * @returns Updated appointment
- */
-export async function updateZonePhotoEntryUtil(
-  db: Firestore,
-  appointmentId: string,
-  zoneId: string,
-  photoIndex: number,
-  updates: Partial<BeforeAfterPerZone>,
-  doctorId?: string,
-): Promise<Appointment> {
-  const appointment = await getAppointmentOrThrow(db, appointmentId);
-  
-  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 zoneArray = zonePhotos[zoneId];
-  if (photoIndex < 0 || photoIndex >= zoneArray.length) {
-    throw new Error(`Invalid photo index ${photoIndex} for zone ${zoneId}. Must be between 0 and ${zoneArray.length - 1}`);
-  }
-
-  // Update the entry with audit trail if visibility is being changed
-  const updatesWithAudit = doctorId
-    ? addVisibilityAudit(updates, doctorId)
-    : updates;
-
-  const updatedZonePhotos = { ...zonePhotos };
-  updatedZonePhotos[zoneId] = [...zoneArray];
-  updatedZonePhotos[zoneId][photoIndex] = {
-    ...zoneArray[photoIndex],
-    ...updatesWithAudit,
-  };
-
-  // Update appointment
-  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
-  await updateDoc(appointmentRef, {
-    'metadata.zonePhotos': updatedZonePhotos,
-    updatedAt: serverTimestamp(),
-  });
-
-  return getAppointmentOrThrow(db, appointmentId);
-}
-
-/**
- * Adds an after photo to an existing before photo entry
- * 
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @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 Updated appointment
- */
-export async function addAfterPhotoToEntryUtil(
-  db: Firestore,
-  appointmentId: string,
-  zoneId: string,
-  photoIndex: number,
-  afterPhotoUrl: MediaResource,
-  afterNote?: string
-): Promise<Appointment> {
-  return updateZonePhotoEntryUtil(db, appointmentId, zoneId, photoIndex, {
-    after: afterPhotoUrl,
-    afterNote: afterNote || null,
-  });
-}
-
-/**
- * Updates notes for a photo entry
- * 
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @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 Updated appointment
- */
-export async function updateZonePhotoNotesUtil(
-  db: Firestore,
-  appointmentId: string,
-  zoneId: string,
-  photoIndex: number,
-  beforeNote?: string,
-  afterNote?: string
-): Promise<Appointment> {
-  const updates: Partial<BeforeAfterPerZone> = {};
-  
-  if (beforeNote !== undefined) {
-    updates.beforeNote = beforeNote || null;
-  }
-  
-  if (afterNote !== undefined) {
-    updates.afterNote = afterNote || null;
-  }
-
-  return updateZonePhotoEntryUtil(db, appointmentId, zoneId, photoIndex, updates);
-}
-
-/**
- * Removes an after photo from an existing entry (keeps the before photo)
- * 
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param zoneId Zone ID
- * @param photoIndex Index of the entry to remove after photo from
- * @returns Updated appointment
- */
-export async function removeAfterPhotoFromEntryUtil(
-  db: Firestore,
-  appointmentId: string,
-  zoneId: string,
-  photoIndex: number
-): Promise<Appointment> {
-  return updateZonePhotoEntryUtil(db, appointmentId, zoneId, photoIndex, {
-    after: null,
-    afterNote: null,
-  });
-}
-
-/**
- * Gets a specific photo entry from a zone
- * 
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param zoneId Zone ID
- * @param photoIndex Index of the entry
- * @returns Photo entry
- */
-export async function getZonePhotoEntryUtil(
-  db: Firestore,
-  appointmentId: string,
-  zoneId: string,
-  photoIndex: number
-): Promise<BeforeAfterPerZone> {
-  const appointment = await getAppointmentOrThrow(db, appointmentId);
-  
-  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 zoneArray = zonePhotos[zoneId];
-  if (photoIndex < 0 || photoIndex >= zoneArray.length) {
-    throw new Error(`Invalid photo index ${photoIndex} for zone ${zoneId}`);
-  }
-
-  return zoneArray[photoIndex];
-}
-
-/**
- * Updates visibility of a photo pair (before AND after together)
- * Note: If photo pair visibility is disabled, note visibility is automatically disabled as well
- * 
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param zoneId Zone ID
- * @param photoIndex Index of the photo entry
- * @param showToPatient Whether the photo pair should be visible to patient
- * @param doctorId ID of the doctor making the change (for audit trail)
- * @returns Updated appointment
- */
-export async function updateZonePhotoVisibilityUtil(
-  db: Firestore,
-  appointmentId: string,
-  zoneId: string,
-  photoIndex: number,
-  showToPatient: boolean,
-  doctorId: string,
-): Promise<Appointment> {
-  const updates: Partial<BeforeAfterPerZone> = { showToPatient };
-  
-  // If hiding photo pair from patient, also hide notes (notes can't be visible if photos aren't)
-  if (!showToPatient) {
-    updates.beforeNoteVisibleToPatient = false;
-    updates.afterNoteVisibleToPatient = false;
-  }
-  
-  return updateZonePhotoEntryUtil(
-    db,
-    appointmentId,
-    zoneId,
-    photoIndex,
-    updates,
-    doctorId,
-  );
-}
-
-/**
- * Updates visibility of a photo note (before or after)
- * Note: Notes can only be visible to patient if the photo pair itself is visible to patient
- * 
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param zoneId Zone ID
- * @param photoIndex Index of the photo entry
- * @param noteType Type of note ('before' or 'after')
- * @param visibleToPatient Whether the note should be visible to patient
- * @param doctorId ID of the doctor making the change (for audit trail)
- * @returns Updated appointment
- * @throws Error if trying to make note visible when photo pair is not visible
- */
-export async function updateZonePhotoNoteVisibilityUtil(
-  db: Firestore,
-  appointmentId: string,
-  zoneId: string,
-  photoIndex: number,
-  noteType: 'before' | 'after',
-  visibleToPatient: boolean,
-  doctorId: string,
-): Promise<Appointment> {
-  // Get current appointment to check if photo pair is visible
-  const appointment = await getAppointmentOrThrow(db, appointmentId);
-  
-  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 zoneArray = zonePhotos[zoneId];
-  if (photoIndex < 0 || photoIndex >= zoneArray.length) {
-    throw new Error(`Invalid photo index ${photoIndex} for zone ${zoneId}. Must be between 0 and ${zoneArray.length - 1}`);
-  }
-
-  const photoEntry = zoneArray[photoIndex];
-  
-  // Validate: Notes can only be visible if photo pair is visible
-  if (visibleToPatient && !photoEntry.showToPatient) {
-    throw new Error(
-      'Cannot make note visible to patient: The photo pair must be visible to the patient first. ' +
-      'Please enable "Show to Patient" for the photo pair before making notes visible.'
-    );
-  }
-
-  const updates: Partial<BeforeAfterPerZone> =
-    noteType === 'before'
-      ? { beforeNoteVisibleToPatient: visibleToPatient }
-      : { afterNoteVisibleToPatient: visibleToPatient };
-
-  return updateZonePhotoEntryUtil(db, appointmentId, zoneId, photoIndex, updates, doctorId);
-}
-
+import { Firestore, updateDoc, serverTimestamp, doc, Timestamp } from 'firebase/firestore';
+import {
+  Appointment,
+  BeforeAfterPerZone,
+  APPOINTMENTS_COLLECTION,
+} from '../../../types/appointment';
+import { getAppointmentOrThrow } from './zone-management.utils';
+import { MediaResource } from '../../media/media.service';
+
+/**
+ * Updates visibility fields with audit trail
+ * Note: We use Timestamp.now() instead of serverTimestamp() because Firestore
+ * doesn't support serverTimestamp() inside arrays. The timestamp will be set
+ * on the client side, which is acceptable for audit purposes.
+ * @param updates Partial updates object
+ * @param doctorId ID of the doctor making the change
+ */
+function addVisibilityAudit(
+  updates: Partial<BeforeAfterPerZone>,
+  doctorId: string,
+): Partial<BeforeAfterPerZone> {
+  // Only add audit fields if visibility-related fields are being updated
+  if (
+    updates.showToPatient !== undefined ||
+    updates.beforeNoteVisibleToPatient !== undefined ||
+    updates.afterNoteVisibleToPatient !== undefined
+  ) {
+    return {
+      ...updates,
+      visibilityUpdatedAt: Timestamp.now(), // Use client-side timestamp (Firestore limitation)
+      visibilityUpdatedBy: doctorId,
+    };
+  }
+  return updates;
+}
+
+/**
+ * Updates a specific photo entry in a zone by index
+ * Can update before/after photos and their notes
+ * 
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID
+ * @param photoIndex Index of the photo entry to update
+ * @param updates Partial updates to apply
+ * @param doctorId Optional doctor ID for audit trail (required if updating visibility)
+ * @returns Updated appointment
+ */
+export async function updateZonePhotoEntryUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  photoIndex: number,
+  updates: Partial<BeforeAfterPerZone>,
+  doctorId?: string,
+): Promise<Appointment> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  
+  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 zoneArray = zonePhotos[zoneId];
+  if (photoIndex < 0 || photoIndex >= zoneArray.length) {
+    throw new Error(`Invalid photo index ${photoIndex} for zone ${zoneId}. Must be between 0 and ${zoneArray.length - 1}`);
+  }
+
+  // Update the entry with audit trail if visibility is being changed
+  const updatesWithAudit = doctorId
+    ? addVisibilityAudit(updates, doctorId)
+    : updates;
+
+  const updatedZonePhotos = { ...zonePhotos };
+  updatedZonePhotos[zoneId] = [...zoneArray];
+  updatedZonePhotos[zoneId][photoIndex] = {
+    ...zoneArray[photoIndex],
+    ...updatesWithAudit,
+  };
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.zonePhotos': updatedZonePhotos,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Adds an after photo to an existing before photo entry
+ * 
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @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 Updated appointment
+ */
+export async function addAfterPhotoToEntryUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  photoIndex: number,
+  afterPhotoUrl: MediaResource,
+  afterNote?: string
+): Promise<Appointment> {
+  return updateZonePhotoEntryUtil(db, appointmentId, zoneId, photoIndex, {
+    after: afterPhotoUrl,
+    afterNote: afterNote || null,
+  });
+}
+
+/**
+ * Updates notes for a photo entry
+ * 
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @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 Updated appointment
+ */
+export async function updateZonePhotoNotesUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  photoIndex: number,
+  beforeNote?: string,
+  afterNote?: string
+): Promise<Appointment> {
+  const updates: Partial<BeforeAfterPerZone> = {};
+  
+  if (beforeNote !== undefined) {
+    updates.beforeNote = beforeNote || null;
+  }
+  
+  if (afterNote !== undefined) {
+    updates.afterNote = afterNote || null;
+  }
+
+  return updateZonePhotoEntryUtil(db, appointmentId, zoneId, photoIndex, updates);
+}
+
+/**
+ * Removes an after photo from an existing entry (keeps the before photo)
+ * 
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID
+ * @param photoIndex Index of the entry to remove after photo from
+ * @returns Updated appointment
+ */
+export async function removeAfterPhotoFromEntryUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  photoIndex: number
+): Promise<Appointment> {
+  return updateZonePhotoEntryUtil(db, appointmentId, zoneId, photoIndex, {
+    after: null,
+    afterNote: null,
+  });
+}
+
+/**
+ * Gets a specific photo entry from a zone
+ * 
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID
+ * @param photoIndex Index of the entry
+ * @returns Photo entry
+ */
+export async function getZonePhotoEntryUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  photoIndex: number
+): Promise<BeforeAfterPerZone> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  
+  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 zoneArray = zonePhotos[zoneId];
+  if (photoIndex < 0 || photoIndex >= zoneArray.length) {
+    throw new Error(`Invalid photo index ${photoIndex} for zone ${zoneId}`);
+  }
+
+  return zoneArray[photoIndex];
+}
+
+/**
+ * Updates visibility of a photo pair (before AND after together)
+ * Note: If photo pair visibility is disabled, note visibility is automatically disabled as well
+ * 
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID
+ * @param photoIndex Index of the photo entry
+ * @param showToPatient Whether the photo pair should be visible to patient
+ * @param doctorId ID of the doctor making the change (for audit trail)
+ * @returns Updated appointment
+ */
+export async function updateZonePhotoVisibilityUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  photoIndex: number,
+  showToPatient: boolean,
+  doctorId: string,
+): Promise<Appointment> {
+  const updates: Partial<BeforeAfterPerZone> = { showToPatient };
+  
+  // If hiding photo pair from patient, also hide notes (notes can't be visible if photos aren't)
+  if (!showToPatient) {
+    updates.beforeNoteVisibleToPatient = false;
+    updates.afterNoteVisibleToPatient = false;
+  }
+  
+  return updateZonePhotoEntryUtil(
+    db,
+    appointmentId,
+    zoneId,
+    photoIndex,
+    updates,
+    doctorId,
+  );
+}
+
+/**
+ * Updates visibility of a photo note (before or after)
+ * Note: Notes can only be visible to patient if the photo pair itself is visible to patient
+ * 
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID
+ * @param photoIndex Index of the photo entry
+ * @param noteType Type of note ('before' or 'after')
+ * @param visibleToPatient Whether the note should be visible to patient
+ * @param doctorId ID of the doctor making the change (for audit trail)
+ * @returns Updated appointment
+ * @throws Error if trying to make note visible when photo pair is not visible
+ */
+export async function updateZonePhotoNoteVisibilityUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  photoIndex: number,
+  noteType: 'before' | 'after',
+  visibleToPatient: boolean,
+  doctorId: string,
+): Promise<Appointment> {
+  // Get current appointment to check if photo pair is visible
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  
+  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 zoneArray = zonePhotos[zoneId];
+  if (photoIndex < 0 || photoIndex >= zoneArray.length) {
+    throw new Error(`Invalid photo index ${photoIndex} for zone ${zoneId}. Must be between 0 and ${zoneArray.length - 1}`);
+  }
+
+  const photoEntry = zoneArray[photoIndex];
+  
+  // Validate: Notes can only be visible if photo pair is visible
+  if (visibleToPatient && !photoEntry.showToPatient) {
+    throw new Error(
+      'Cannot make note visible to patient: The photo pair must be visible to the patient first. ' +
+      'Please enable "Show to Patient" for the photo pair before making notes visible.'
+    );
+  }
+
+  const updates: Partial<BeforeAfterPerZone> =
+    noteType === 'before'
+      ? { beforeNoteVisibleToPatient: visibleToPatient }
+      : { afterNoteVisibleToPatient: visibleToPatient };
+
+  return updateZonePhotoEntryUtil(db, appointmentId, zoneId, photoIndex, updates, doctorId);
+}
+