@blackcode_sa/metaestetics-api 1.12.36 → 1.12.39

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

@@ -0,0 +1,193 @@
+import { Firestore, updateDoc, serverTimestamp, doc } from 'firebase/firestore';
+import {
+  Appointment,
+  RecommendedProcedure,
+  ExtendedProcedureInfo,
+  APPOINTMENTS_COLLECTION,
+} from '../../../types/appointment';
+import { getAppointmentOrThrow, initializeMetadata } from './zone-management.utils';
+import { PROCEDURES_COLLECTION } from '../../../types/procedure';
+import { getDoc } from 'firebase/firestore';
+
+/**
+ * Creates ExtendedProcedureInfo from procedure document for recommended procedures
+ * @param db Firestore instance
+ * @param procedureId Procedure ID
+ * @returns Extended procedure info
+ */
+async function createExtendedProcedureInfoForRecommended(
+  db: Firestore,
+  procedureId: string
+): Promise<ExtendedProcedureInfo> {
+  const procedureRef = doc(db, PROCEDURES_COLLECTION, procedureId);
+  const procedureSnap = await getDoc(procedureRef);
+
+  if (!procedureSnap.exists()) {
+    throw new Error(`Procedure with ID ${procedureId} not found`);
+  }
+
+  const data = procedureSnap.data();
+
+  return {
+    procedureId: procedureId,
+    procedureName: data.name,
+    procedureFamily: data.family,
+    procedureCategoryId: data.category.id,
+    procedureCategoryName: data.category.name,
+    procedureSubCategoryId: data.subcategory.id,
+    procedureSubCategoryName: data.subcategory.name,
+    procedureTechnologyId: data.technology.id,
+    procedureTechnologyName: data.technology.name,
+    procedureProducts: (data.productsMetadata || []).map((pp: any) => ({
+      productId: pp.product.id,
+      productName: pp.product.name,
+      brandId: pp.product.brandId,
+      brandName: pp.product.brandName,
+    })),
+  };
+}
+
+/**
+ * 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 db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID to recommend
+ * @param note Note explaining the recommendation
+ * @param timeframe Suggested timeframe for the procedure
+ * @returns Updated appointment
+ */
+export async function addRecommendedProcedureUtil(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string,
+  note: string,
+  timeframe: { value: number; unit: 'day' | 'week' | 'month' | 'year' }
+): Promise<Appointment> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  // Create extended procedure info
+  const procedureInfo = await createExtendedProcedureInfoForRecommended(db, procedureId);
+
+  // Create recommended procedure object
+  const recommendedProcedure: RecommendedProcedure = {
+    procedure: procedureInfo,
+    note,
+    timeframe,
+  };
+
+  // Add to recommended procedures array
+  const recommendedProcedures = [...(metadata.recommendedProcedures || []), recommendedProcedure];
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.recommendedProcedures': recommendedProcedures,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Removes a recommended procedure from an appointment by index
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param recommendationIndex Index of the recommendation to remove in the array
+ * @returns Updated appointment
+ */
+export async function removeRecommendedProcedureUtil(
+  db: Firestore,
+  appointmentId: string,
+  recommendationIndex: number
+): Promise<Appointment> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  if (!metadata.recommendedProcedures || metadata.recommendedProcedures.length === 0) {
+    throw new Error('No recommended procedures found for this appointment');
+  }
+
+  // Validate index
+  if (recommendationIndex < 0 || recommendationIndex >= metadata.recommendedProcedures.length) {
+    throw new Error(`Invalid recommendation index ${recommendationIndex}. Must be between 0 and ${metadata.recommendedProcedures.length - 1}`);
+  }
+
+  // Remove recommendation
+  const updatedRecommendedProcedures = [...metadata.recommendedProcedures];
+  updatedRecommendedProcedures.splice(recommendationIndex, 1);
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.recommendedProcedures': updatedRecommendedProcedures,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Updates a recommended procedure in an appointment by index
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param recommendationIndex Index of the recommendation to update
+ * @param updates Partial updates (note and/or timeframe)
+ * @returns Updated appointment
+ */
+export async function updateRecommendedProcedureUtil(
+  db: Firestore,
+  appointmentId: string,
+  recommendationIndex: number,
+  updates: {
+    note?: string;
+    timeframe?: { value: number; unit: 'day' | 'week' | 'month' | 'year' };
+  }
+): Promise<Appointment> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  if (!metadata.recommendedProcedures || metadata.recommendedProcedures.length === 0) {
+    throw new Error('No recommended procedures found for this appointment');
+  }
+
+  // Validate index
+  if (recommendationIndex < 0 || recommendationIndex >= metadata.recommendedProcedures.length) {
+    throw new Error(`Invalid recommendation index ${recommendationIndex}. Must be between 0 and ${metadata.recommendedProcedures.length - 1}`);
+  }
+
+  // Update the recommendation
+  const updatedRecommendedProcedures = [...metadata.recommendedProcedures];
+  const existingRecommendation = updatedRecommendedProcedures[recommendationIndex];
+
+  updatedRecommendedProcedures[recommendationIndex] = {
+    ...existingRecommendation,
+    ...(updates.note !== undefined && { note: updates.note }),
+    ...(updates.timeframe !== undefined && { timeframe: updates.timeframe }),
+  };
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.recommendedProcedures': updatedRecommendedProcedures,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Gets all recommended procedures for an appointment
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @returns Array of recommended procedures
+ */
+export async function getRecommendedProceduresUtil(
+  db: Firestore,
+  appointmentId: string
+): Promise<RecommendedProcedure[]> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  return appointment.metadata?.recommendedProcedures || [];
+}
+

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

@@ -18,7 +18,7 @@ export function validateZoneKeyFormat(zoneKey: string): void {
   const parts = zoneKey.split('.');
   if (parts.length !== 2) {
     throw new Error(
-      `Invalid zone key format: "${zoneKey}". Must be "category.zone" (e.g., "face.forehead")`
+      `Invalid zone key format: "${zoneKey}". Must be "category.zone" (e.g., "face.forehead")`,
     );
   }
 }
@@ -52,7 +52,7 @@ export function calculateItemSubtotal(item: Partial<ZoneItemData>): number {
  */
 export function calculateFinalBilling(
   zonesData: Record<string, ZoneItemData[]>,
-  taxRate: number = 0.20
+  taxRate: number = 0.2,
 ): FinalBilling {
   let subtotalAll = 0;
 
@@ -96,7 +96,7 @@ export function calculateFinalBilling(
  */
 export async function getAppointmentOrThrow(
   db: Firestore,
-  appointmentId: string
+  appointmentId: string,
 ): Promise<Appointment> {
   const appointment = await getAppointmentByIdUtil(db, appointmentId);
   if (!appointment) {
@@ -110,18 +110,19 @@ export async function getAppointmentOrThrow(
  * @param appointment Appointment document
  * @returns Initialized metadata
  */
-export function initializeMetadata(
-  appointment: Appointment
-): AppointmentMetadata {
-  return appointment.metadata || {
-    selectedZones: null,
-    zonePhotos: null,
-    zonesData: null,
-    appointmentProducts: [],
-    extendedProcedures: [],
-    finalbilling: null,
-    finalizationNotes: null,
-  };
+export function initializeMetadata(appointment: Appointment): AppointmentMetadata {
+  return (
+    appointment.metadata || {
+      selectedZones: null,
+      zonePhotos: null,
+      zonesData: null,
+      appointmentProducts: [],
+      extendedProcedures: [],
+      recommendedProcedures: [],
+      finalbilling: null,
+      finalizationNotes: null,
+    }
+  );
 }
 
 /**
@@ -136,7 +137,7 @@ export async function addItemToZoneUtil(
   db: Firestore,
   appointmentId: string,
   zoneId: string,
-  item: Omit<ZoneItemData, 'subtotal' | 'parentZone'>
+  item: Omit<ZoneItemData, 'subtotal' | 'parentZone'>,
 ): Promise<Appointment> {
   // Validate zone key format
   validateZoneKeyFormat(zoneId);
@@ -154,10 +155,13 @@ export async function addItemToZoneUtil(
   }
 
   // Calculate subtotal for the item
+  const now = new Date().toISOString();
   const itemWithSubtotal: ZoneItemData = {
     ...item,
     parentZone: zoneId, // Set parentZone to the zone key
     subtotal: calculateItemSubtotal(item),
+    createdAt: now,
+    updatedAt: now,
   };
 
   // Add item to zone
@@ -190,7 +194,7 @@ export async function removeItemFromZoneUtil(
   db: Firestore,
   appointmentId: string,
   zoneId: string,
-  itemIndex: number
+  itemIndex: number,
 ): Promise<Appointment> {
   validateZoneKeyFormat(zoneId);
 
@@ -242,7 +246,7 @@ export async function updateZoneItemUtil(
   appointmentId: string,
   zoneId: string,
   itemIndex: number,
-  updates: Partial<ZoneItemData>
+  updates: Partial<ZoneItemData>,
 ): Promise<Appointment> {
   validateZoneKeyFormat(zoneId);
 
@@ -258,10 +262,11 @@ export async function updateZoneItemUtil(
     throw new Error(`Invalid item index ${itemIndex} for zone ${zoneId}`);
   }
 
-  // Update item
+  // Update item with updatedAt timestamp
   items[itemIndex] = {
     ...items[itemIndex],
     ...updates,
+    updatedAt: new Date().toISOString(),
   };
 
   // Recalculate subtotal for this item
@@ -295,7 +300,7 @@ export async function overridePriceForZoneItemUtil(
   appointmentId: string,
   zoneId: string,
   itemIndex: number,
-  newPrice: number
+  newPrice: number,
 ): Promise<Appointment> {
   return updateZoneItemUtil(db, appointmentId, zoneId, itemIndex, {
     priceOverrideAmount: newPrice,
@@ -316,14 +321,14 @@ export async function updateSubzonesUtil(
   appointmentId: string,
   zoneId: string,
   itemIndex: number,
-  subzones: string[]
+  subzones: string[],
 ): Promise<Appointment> {
   // Validate subzone format if provided
   subzones.forEach(subzone => {
     const parts = subzone.split('.');
     if (parts.length !== 3) {
       throw new Error(
-        `Invalid subzone format: "${subzone}". Must be "category.zone.subzone" (e.g., "face.forehead.left")`
+        `Invalid subzone format: "${subzone}". Must be "category.zone.subzone" (e.g., "face.forehead.left")`,
       );
     }
   });
@@ -332,4 +337,3 @@ export async function updateSubzonesUtil(
     subzones,
   });
 }
-

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

@@ -0,0 +1,152 @@
+import { Firestore, updateDoc, serverTimestamp, doc } from 'firebase/firestore';
+import {
+  Appointment,
+  BeforeAfterPerZone,
+  APPOINTMENTS_COLLECTION,
+} from '../../../types/appointment';
+import { getAppointmentOrThrow } from './zone-management.utils';
+import { MediaResource } from '../../media/media.service';
+
+/**
+ * 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
+ * @returns Updated appointment
+ */
+export async function updateZonePhotoEntryUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  photoIndex: number,
+  updates: Partial<BeforeAfterPerZone>
+): 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
+  const updatedZonePhotos = { ...zonePhotos };
+  updatedZonePhotos[zoneId] = [...zoneArray];
+  updatedZonePhotos[zoneId][photoIndex] = {
+    ...zoneArray[photoIndex],
+    ...updates,
+  };
+
+  // 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);
+}
+
+/**
+ * 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];
+}
+

package/src/services/procedure/procedure.service.ts

@@ -889,6 +889,8 @@ export class ProcedureService extends BaseService {
     pagination?: number;
     lastDoc?: any;
     isActive?: boolean;
+    practitionerId?: string;
+    clinicId?: string;
   }): Promise<{
     procedures: (Procedure & { distance?: number })[];
     lastDoc: any;
@@ -942,6 +944,12 @@ export class ProcedureService extends BaseService {
         if (filters.procedureTechnology) {
           constraints.push(where('technology.id', '==', filters.procedureTechnology));
         }
+        if (filters.practitionerId) {
+          constraints.push(where('practitionerId', '==', filters.practitionerId));
+        }
+        if (filters.clinicId) {
+          constraints.push(where('clinicBranchId', '==', filters.clinicId));
+        }
         if (filters.minPrice !== undefined) {
           constraints.push(where('price', '>=', filters.minPrice));
         }
@@ -1093,10 +1101,16 @@ export class ProcedureService extends BaseService {
       try {
         console.log('[PROCEDURE_SERVICE] Strategy 4: Minimal query fallback');
         const constraints: QueryConstraint[] = [
-          where('isActive', '==', true),
+          where('isActive', '==', filters.isActive !== undefined ? filters.isActive : true),
           orderBy('createdAt', 'desc'),
-          limit(filters.pagination || 10),
         ];
+        if (filters.practitionerId) {
+          constraints.push(where('practitionerId', '==', filters.practitionerId));
+        }
+        if (filters.clinicId) {
+          constraints.push(where('clinicBranchId', '==', filters.clinicId));
+        }
+        constraints.push(limit(filters.pagination || 10));
 
         const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
         const querySnapshot = await getDocs(q);
@@ -1230,6 +1244,26 @@ export class ProcedureService extends BaseService {
       );
     }
 
+    // Practitioner filtering
+    if (filters.practitionerId) {
+      filteredProcedures = filteredProcedures.filter(
+        procedure => procedure.practitionerId === filters.practitionerId,
+      );
+      console.log(
+        `[PROCEDURE_SERVICE] Applied practitioner filter, results: ${filteredProcedures.length}`,
+      );
+    }
+
+    // Clinic filtering
+    if (filters.clinicId) {
+      filteredProcedures = filteredProcedures.filter(
+        procedure => procedure.clinicBranchId === filters.clinicId,
+      );
+      console.log(
+        `[PROCEDURE_SERVICE] Applied clinic filter, results: ${filteredProcedures.length}`,
+      );
+    }
+
     // Geo-radius filter
     if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
       const location = filters.location;
@@ -1281,6 +1315,12 @@ export class ProcedureService extends BaseService {
           where('clinicInfo.location.geohash', '<=', b[1]),
           where('isActive', '==', filters.isActive !== undefined ? filters.isActive : true),
         ];
+        if (filters.practitionerId) {
+          constraints.push(where('practitionerId', '==', filters.practitionerId));
+        }
+        if (filters.clinicId) {
+          constraints.push(where('clinicBranchId', '==', filters.clinicId));
+        }
         return getDocs(query(collection(this.db, PROCEDURES_COLLECTION), ...constraints));
       });
 

package/src/types/appointment/index.ts

@@ -7,6 +7,7 @@ import { Requirement } from '../../backoffice/types/requirement.types';
 import { FilledDocumentStatus } from '../documentation-templates';
 import type { ContraindicationDynamic, ProcedureFamily } from '../../backoffice';
 import type { MediaResource } from '../../services/media/media.service';
+import { string } from 'zod/v4';
 
 /**
  * Enum defining the possible statuses of an appointment.
@@ -145,6 +146,7 @@ export interface ZoneItemData {
   productBrandName?: string;
   belongingProcedureId: string;
   type: 'item' | 'note';
+  stage?: 'before' | 'after'; // Stage of the note/item: 'before' for planning notes, 'after' for treatment notes
   price?: number;
   currency?: Currency;
   unitOfMeasurement?: PricingMeasure;
@@ -155,6 +157,8 @@ export interface ZoneItemData {
   notes?: string;
   subtotal?: number;
   ionNumber?: string;
+  createdAt?: string; // ISO timestamp
+  updatedAt?: string; // ISO timestamp
 }
 
 /**
@@ -223,18 +227,28 @@ export interface ExtendedProcedureInfo {
   }>;
 }
 
+export interface RecommendedProcedure {
+  procedure: ExtendedProcedureInfo;
+  note: string;
+  timeframe: {
+    value: number;
+    unit: 'day' | 'week' | 'month' | 'year';
+  };
+}
+
 /**
  * Interface for appointment metadata containing zone-specific information
  */
 export interface AppointmentMetadata {
   selectedZones: string[] | null;
-  zonePhotos: Record<string, BeforeAfterPerZone> | null;
+  zonePhotos: Record<string, BeforeAfterPerZone[]> | null;
   zonesData?: Record<string, ZoneItemData[]> | null;
   appointmentProducts?: AppointmentProductMetadata[];
   extendedProcedures?: ExtendedProcedureInfo[];
+  recommendedProcedures: RecommendedProcedure[]
   finalbilling: FinalBilling | null;
   finalizationNotes: string | null;
-  
+
   /**
    * @deprecated Use zonesData instead
    */

package/src/validations/appointment.schema.ts

@@ -185,6 +185,9 @@ export const zoneItemDataSchema = z.object({
   type: z.enum(['item', 'note'], {
     required_error: 'Type must be either "item" or "note"',
   }),
+  stage: z.enum(['before', 'after'], {
+    required_error: 'Stage must be either "before" or "after"',
+  }).optional(),
   price: z.number().min(0, 'Price must be non-negative').optional(),
   currency: z.nativeEnum(Currency).optional(),
   unitOfMeasurement: z.nativeEnum(PricingMeasure).optional(),
@@ -213,6 +216,8 @@ export const zoneItemDataSchema = z.object({
   notes: z.string().max(MAX_STRING_LENGTH_LONG, 'Notes too long').optional(),
   subtotal: z.number().min(0, 'Subtotal must be non-negative').optional(),
   ionNumber: z.string().optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
 }).refine(
   data => {
     if (data.type === 'item') {
@@ -262,15 +267,30 @@ export const extendedProcedureInfoSchema = z.object({
   ),
 });
 
+/**
+ * Schema for recommended procedure within metadata
+ */
+export const recommendedProcedureTimeframeSchema = z.object({
+  value: z.number().int().positive('Timeframe value must be a positive integer'),
+  unit: z.enum(['day', 'week', 'month', 'year']),
+});
+
+export const recommendedProcedureSchema = z.object({
+  procedure: extendedProcedureInfoSchema,
+  note: z.string().min(1, 'Note is required').max(MAX_STRING_LENGTH_LONG, 'Note too long'),
+  timeframe: recommendedProcedureTimeframeSchema,
+});
+
 /**
  * Schema for appointment metadata containing zone-specific information
  */
 export const appointmentMetadataSchema = z.object({
   selectedZones: z.array(z.string()).nullable(),
-  zonePhotos: z.record(z.string(), beforeAfterPerZoneSchema).nullable(),
-  zonesData: z.record(z.string(), z.array(zoneItemDataSchema)).nullable(),
-  appointmentProducts: z.array(appointmentProductMetadataSchema),
-  extendedProcedures: z.array(extendedProcedureInfoSchema),
+  zonePhotos: z.record(z.string(), z.array(beforeAfterPerZoneSchema).max(10)).nullable(),
+  zonesData: z.record(z.string(), z.array(zoneItemDataSchema)).nullable().optional(),
+  appointmentProducts: z.array(appointmentProductMetadataSchema).optional().default([]),
+  extendedProcedures: z.array(extendedProcedureInfoSchema).optional().default([]),
+  recommendedProcedures: z.array(recommendedProcedureSchema).optional().default([]),
   zoneBilling: z.record(z.string(), billingPerZoneSchema).nullable().optional(),
   finalbilling: finalBillingSchema.nullable(),
   finalizationNotes: z.string().nullable(),