@blackcode_sa/metaestetics-api 1.14.56 → 1.14.57

package/package.json

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

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

@@ -16,6 +16,7 @@ import {
   getCountFromServer,
   doc,
   getDoc,
+  updateDoc,
 } from 'firebase/firestore';
 import { Auth } from 'firebase/auth';
 import { FirebaseApp } from 'firebase/app';
@@ -2296,6 +2297,14 @@ export class AppointmentService extends BaseService {
         finalizationNotes: currentMetadata.finalizationNotes,
       });
 
+      // Convert empty strings to null for proper Firestore storage
+      const normalizedSharedNotes = sharedNotes !== undefined 
+        ? (sharedNotes === '' || sharedNotes === null ? null : sharedNotes)
+        : currentMetadata.finalizationNotesShared;
+      const normalizedInternalNotes = internalNotes !== undefined
+        ? (internalNotes === '' || internalNotes === null ? null : internalNotes)
+        : currentMetadata.finalizationNotesInternal;
+
       const metadataUpdate = {
         selectedZones: currentMetadata.selectedZones,
         zonePhotos: currentMetadata.zonePhotos,
@@ -2304,14 +2313,12 @@ export class AppointmentService extends BaseService {
         extendedProcedures: currentMetadata.extendedProcedures || [],
         recommendedProcedures: currentMetadata.recommendedProcedures || [],
         finalbilling: currentMetadata.finalbilling,
-        finalizationNotesShared:
-          sharedNotes !== undefined ? sharedNotes : currentMetadata.finalizationNotesShared,
-        finalizationNotesInternal:
-          internalNotes !== undefined ? internalNotes : currentMetadata.finalizationNotesInternal,
+        finalizationNotesShared: normalizedSharedNotes,
+        finalizationNotesInternal: normalizedInternalNotes,
         // Keep deprecated field for backward compatibility during migration
         finalizationNotes:
-          sharedNotes !== undefined
-            ? sharedNotes
+          normalizedSharedNotes !== null && normalizedSharedNotes !== undefined
+            ? normalizedSharedNotes
             : currentMetadata.finalizationNotes || currentMetadata.finalizationNotesShared,
       };
 
@@ -2319,14 +2326,39 @@ export class AppointmentService extends BaseService {
         finalizationNotesShared: metadataUpdate.finalizationNotesShared,
         finalizationNotesInternal: metadataUpdate.finalizationNotesInternal,
         finalizationNotes: metadataUpdate.finalizationNotes,
+        normalizedSharedNotes,
+        normalizedInternalNotes,
       });
 
-      const updateData: UpdateAppointmentData = {
-        metadata: metadataUpdate,
+      // Use direct Firestore update with dot notation to ensure fields are saved correctly
+      const appointmentRef = doc(this.db, APPOINTMENTS_COLLECTION, appointmentId);
+      const updateFields: any = {
+        'metadata.finalizationNotesShared': normalizedSharedNotes,
+        'metadata.finalizationNotesInternal': normalizedInternalNotes,
+        'metadata.finalizationNotes': 
+          normalizedSharedNotes !== null && normalizedSharedNotes !== undefined
+            ? normalizedSharedNotes
+            : currentMetadata.finalizationNotes || currentMetadata.finalizationNotesShared,
         updatedAt: serverTimestamp(),
       };
 
-      const result = await this.updateAppointment(appointmentId, updateData);
+      console.log('🔍 [APPOINTMENT_SERVICE] Direct Firestore update with dot notation:', {
+        appointmentId,
+        updateFields: {
+          'metadata.finalizationNotesShared': updateFields['metadata.finalizationNotesShared'],
+          'metadata.finalizationNotesInternal': updateFields['metadata.finalizationNotesInternal'],
+          'metadata.finalizationNotes': updateFields['metadata.finalizationNotes'],
+        },
+      });
+
+      // Update using dot notation to ensure nested fields are saved correctly
+      await updateDoc(appointmentRef, updateFields);
+
+      // Fetch and return the updated appointment
+      const result = await this.getAppointmentById(appointmentId);
+      if (!result) {
+        throw new Error(`Failed to retrieve updated appointment ${appointmentId}`);
+      }
       
       console.log('🔍 [APPOINTMENT_SERVICE] After update, result metadata:', {
         finalizationNotesShared: result.metadata?.finalizationNotesShared,

package/src/services/appointment/utils/extended-procedure.utils.ts

@@ -99,6 +99,7 @@ async function createExtendedProcedureInfo(
     procedureId: procedureId,
     procedureName: data.name,
     procedureDescription: data.description || '',
+    procedurePrice: data.price || 0,
     procedureFamily: data.family, // Use embedded family object
     procedureCategoryId: data.category.id, // Access embedded category
     procedureCategoryName: data.category.name, // Access embedded category

package/src/services/appointment/utils/form-initialization.utils.ts

@@ -218,6 +218,7 @@ export async function initializeFormsForExtendedProcedure(
             sortingOrder: templateRef.sortingOrder,
             status: existingForm.status || FilledDocumentStatus.PENDING,
             path: `${APPOINTMENTS_COLLECTION}/${appointmentId}/${formSubcollectionPath}/${existingForm.id}`,
+            procedureId: procedureId, // Track which procedure this form belongs to
           };
           initializedFormsInfo.push(linkedForm);
           
@@ -288,6 +289,7 @@ export async function initializeFormsForExtendedProcedure(
         sortingOrder: templateRef.sortingOrder,
         status: FilledDocumentStatus.PENDING,
         path: docRef.path,
+        procedureId: procedureId, // Track which procedure this form belongs to
       };
       initializedFormsInfo.push(linkedForm);
 

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

@@ -278,19 +278,45 @@ export async function updateZoneItemUtil(
     throw new Error(`Invalid item index ${itemIndex} for zone ${zoneId}`);
   }
 
+  // Filter out undefined values from updates (Firestore doesn't store undefined)
+  // Keep null values as they're used to explicitly delete/clear fields
+  // Convert empty strings to null for consistency
+  const cleanUpdates = Object.fromEntries(
+    Object.entries(updates)
+      .filter(([_, value]) => value !== undefined)
+      .map(([key, value]) => [
+        key,
+        value === '' ? null : value, // Convert empty strings to null
+      ])
+  ) as Partial<ZoneItemData>;
+
+  console.log(`[updateZoneItemUtil] Updates received:`, {
+    itemIndex,
+    zoneId,
+    rawUpdates: updates,
+    cleanUpdates,
+    hasIonNumber: 'ionNumber' in cleanUpdates,
+    hasExpiryDate: 'expiryDate' in cleanUpdates,
+    ionNumberValue: cleanUpdates.ionNumber,
+    expiryDateValue: cleanUpdates.expiryDate,
+  });
+
   // Update item with updatedAt timestamp
   items[itemIndex] = {
     ...items[itemIndex],
-    ...updates,
+    ...cleanUpdates,
     updatedAt: new Date().toISOString(),
   };
 
-  console.log(`[updateZoneItemUtil] BEFORE recalculation:`, {
+  console.log(`[updateZoneItemUtil] Item after update:`, {
     itemIndex,
+    ionNumber: items[itemIndex].ionNumber,
+    expiryDate: items[itemIndex].expiryDate,
     quantity: items[itemIndex].quantity,
     priceOverrideAmount: items[itemIndex].priceOverrideAmount,
     price: items[itemIndex].price,
     oldSubtotal: items[itemIndex].subtotal,
+    allItemKeys: Object.keys(items[itemIndex]),
   });
 
   // Recalculate subtotal for this item
@@ -304,6 +330,18 @@ export async function updateZoneItemUtil(
   // Recalculate final billing with Swiss tax rate (8.1%)
   const finalbilling = calculateFinalBilling(metadata.zonesData, 0.081);
 
+  // Log what we're about to save to Firestore
+  console.log(`[updateZoneItemUtil] Saving to Firestore:`, {
+    appointmentId,
+    zoneId,
+    itemIndex,
+    itemToSave: items[itemIndex],
+    itemIonNumber: items[itemIndex].ionNumber,
+    itemExpiryDate: items[itemIndex].expiryDate,
+    zonesDataKeys: Object.keys(metadata.zonesData),
+    zoneItemsCount: metadata.zonesData[zoneId]?.length,
+  });
+
   // Update appointment
   const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
   await updateDoc(appointmentRef, {
@@ -312,7 +350,16 @@ export async function updateZoneItemUtil(
     updatedAt: serverTimestamp(),
   });
 
-  return getAppointmentOrThrow(db, appointmentId);
+  // Verify what was actually saved
+  const savedAppointment = await getAppointmentOrThrow(db, appointmentId);
+  const savedItem = savedAppointment.metadata?.zonesData?.[zoneId]?.[itemIndex];
+  console.log(`[updateZoneItemUtil] Verification after save:`, {
+    savedItemIonNumber: savedItem?.ionNumber,
+    savedItemExpiryDate: savedItem?.expiryDate,
+    savedItemKeys: savedItem ? Object.keys(savedItem) : [],
+  });
+
+  return savedAppointment;
 }
 
 /**

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

@@ -206,6 +206,7 @@ export async function getZonePhotoEntryUtil(
 
 /**
  * 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
@@ -223,18 +224,27 @@ export async function updateZonePhotoVisibilityUtil(
   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,
-    { showToPatient },
+    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
@@ -244,6 +254,7 @@ export async function updateZonePhotoVisibilityUtil(
  * @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,
@@ -254,6 +265,33 @@ export async function updateZonePhotoNoteVisibilityUtil(
   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 }

package/src/types/appointment/index.ts

@@ -100,6 +100,7 @@ export interface LinkedFormInfo {
   path: string; // Full Firestore path to the filled document (e.g., appointments/{aid}/user-forms/{fid})
   submittedAt?: Timestamp;
   completedAt?: Timestamp; // When the form reached a final state like 'completed' or 'signed'
+  procedureId?: string; // ID of the procedure this form belongs to (for extended procedure forms)
 }
 
 /**
@@ -168,8 +169,8 @@ export interface ZoneItemData {
   notes?: string;
   notesVisibleToPatient?: boolean; // Whether notes are visible to patient (privacy-first, default false)
   subtotal?: number;
-  ionNumber?: string; // Batch/Lot number
-  expiryDate?: string; // ISO date string (YYYY-MM-DD)
+  ionNumber?: string | null; // Batch/Lot number - can be null to clear/delete
+  expiryDate?: string | null; // ISO date string (YYYY-MM-DD) - can be null to clear/delete
   createdAt?: string; // ISO timestamp
   updatedAt?: string; // ISO timestamp
 }
@@ -226,6 +227,7 @@ export interface ExtendedProcedureInfo {
   procedureId: string;
   procedureName: string;
   procedureDescription?: string;
+  procedurePrice?: number;
   procedureFamily?: ProcedureFamily;
   procedureCategoryId: string;
   procedureCategoryName: string;

package/src/validations/appointment.schema.ts

@@ -227,7 +227,8 @@ export const zoneItemDataSchema = z
     notes: z.string().max(MAX_STRING_LENGTH_LONG, 'Notes too long').optional(),
     notesVisibleToPatient: z.boolean().optional().default(false),
     subtotal: z.number().min(0, 'Subtotal must be non-negative').optional(),
-    ionNumber: z.string().optional(),
+    ionNumber: z.string().nullable().optional(), // Batch/Lot number - can be null to clear/delete
+    expiryDate: z.string().nullable().optional(), // ISO date string (YYYY-MM-DD) - can be null to clear/delete
     createdAt: z.string().optional(),
     updatedAt: z.string().optional(),
   })