@blackcode_sa/metaestetics-api 1.12.20 → 1.12.21

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

@@ -1,43 +1,40 @@
-import * as admin from "firebase-admin";
+import * as admin from 'firebase-admin';
 import {
   Appointment,
   AppointmentStatus,
   // APPOINTMENTS_COLLECTION, // Not directly used in this file after refactor
-} from "../../../types/appointment";
+} from '../../../types/appointment';
 import {
   PatientRequirementInstance,
   PatientRequirementOverallStatus,
   PatientInstructionStatus,
   PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME,
   PatientRequirementInstruction, // Added import
-} from "../../../types/patient/patient-requirements";
+} from '../../../types/patient/patient-requirements';
 import {
   Requirement as RequirementTemplate,
   // REQUIREMENTS_COLLECTION as REQUIREMENTS_TEMPLATES_COLLECTION, // Not used directly after refactor
   RequirementType,
   TimeUnit, // Added import
-} from "../../../backoffice/types/requirement.types";
+} from '../../../backoffice/types/requirement.types';
 import {
   PATIENTS_COLLECTION,
   PatientProfile,
   PatientSensitiveInfo,
   PATIENT_SENSITIVE_INFO_COLLECTION,
-} from "../../../types/patient";
-import {
-  Practitioner,
-  PRACTITIONERS_COLLECTION,
-} from "../../../types/practitioner";
-import { Clinic, CLINICS_COLLECTION } from "../../../types/clinic";
+} from '../../../types/patient';
+import { Practitioner, PRACTITIONERS_COLLECTION } from '../../../types/practitioner';
+import { Clinic, CLINICS_COLLECTION } from '../../../types/clinic';
 // import { UserRole } from "../../../types"; // Not directly used
 
 // Dependent Admin Services
-import { PatientRequirementsAdminService } from "../../requirements/patient-requirements.admin.service";
-import { NotificationsAdmin } from "../../notifications/notifications.admin";
-import { CalendarAdminService } from "../../calendar/calendar.admin.service";
-import { AppointmentMailingService } from "../../mailing/appointment/appointment.mailing.service";
-import { Logger } from "../../logger";
-import { UserRole } from "../../../types";
-import { CalendarEventStatus } from "../../../types/calendar";
+import { PatientRequirementsAdminService } from '../../requirements/patient-requirements.admin.service';
+import { NotificationsAdmin } from '../../notifications/notifications.admin';
+import { CalendarAdminService } from '../../calendar/calendar.admin.service';
+import { AppointmentMailingService } from '../../mailing/appointment/appointment.mailing.service';
+import { Logger } from '../../logger';
+import { UserRole } from '../../../types';
+import { CalendarEventStatus } from '../../../types/calendar';
 
 // Mailgun client will be injected via constructor
 
@@ -61,19 +58,17 @@ export class AppointmentAggregationService {
    */
   constructor(
     mailgunClient: any, // Type as 'any' for now, to be provided by the calling Cloud Function
-    firestore?: admin.firestore.Firestore
+    firestore?: admin.firestore.Firestore,
   ) {
     this.db = firestore || admin.firestore();
     this.appointmentMailingService = new AppointmentMailingService(
       this.db,
-      mailgunClient // Pass the injected client
+      mailgunClient, // Pass the injected client
     );
     this.notificationsAdmin = new NotificationsAdmin(this.db);
     this.calendarAdminService = new CalendarAdminService(this.db);
-    this.patientRequirementsAdminService = new PatientRequirementsAdminService(
-      this.db
-    );
-    Logger.info("[AppointmentAggregationService] Initialized.");
+    this.patientRequirementsAdminService = new PatientRequirementsAdminService(this.db);
+    Logger.info('[AppointmentAggregationService] Initialized.');
   }
 
   /**
@@ -84,23 +79,19 @@ export class AppointmentAggregationService {
    */
   async handleAppointmentCreate(appointment: Appointment): Promise<void> {
     Logger.info(
-      `[AggService] Handling CREATE for appointment: ${appointment.id}, patient: ${appointment.patientId}, status: ${appointment.status}`
+      `[AggService] Handling CREATE for appointment: ${appointment.id}, patient: ${appointment.patientId}, status: ${appointment.status}`,
     );
 
     try {
       // 1. Fetch necessary profiles for notifications and context
       // These can be fetched in parallel
-      const [
-        patientProfile,
-        patientSensitiveInfo,
-        practitionerProfile,
-        clinicInfo,
-      ] = await Promise.all([
-        this.fetchPatientProfile(appointment.patientId),
-        this.fetchPatientSensitiveInfo(appointment.patientId),
-        this.fetchPractitionerProfile(appointment.practitionerId), // Needed for practitioner notifications
-        this.fetchClinicInfo(appointment.clinicBranchId), // Needed for clinic admin notifications
-      ]);
+      const [patientProfile, patientSensitiveInfo, practitionerProfile, clinicInfo] =
+        await Promise.all([
+          this.fetchPatientProfile(appointment.patientId),
+          this.fetchPatientSensitiveInfo(appointment.patientId),
+          this.fetchPractitionerProfile(appointment.practitionerId), // Needed for practitioner notifications
+          this.fetchClinicInfo(appointment.clinicBranchId), // Needed for clinic admin notifications
+        ]);
 
       // 2. Manage Patient-Clinic-Practitioner Links (moved from beginning to here)
       // Now we can pass the already fetched patient profile
@@ -109,67 +100,62 @@ export class AppointmentAggregationService {
           patientProfile,
           appointment.practitionerId,
           appointment.clinicBranchId,
-          "create"
+          'create',
         );
       }
 
       // 3. Initial State Handling based on appointment status
       if (appointment.status === AppointmentStatus.CONFIRMED) {
-        Logger.info(
-          `[AggService] Appt ${appointment.id} created as CONFIRMED.`
-        );
+        Logger.info(`[AggService] Appt ${appointment.id} created as CONFIRMED.`);
         // Create pre-appointment requirements for confirmed appointments
         await this.createPreAppointmentRequirementInstances(appointment);
 
         // Send confirmation notifications
         if (patientSensitiveInfo?.email && patientProfile) {
           Logger.info(
-            `[AggService] Sending appointment confirmed email to patient ${patientSensitiveInfo.email}`
+            `[AggService] Sending appointment confirmed email to patient ${patientSensitiveInfo.email}`,
           );
           // Construct the data object for the mailing service
           const emailData = {
             appointment: appointment,
             recipientProfile: appointment.patientInfo,
-            recipientRole: "patient" as const, // Use 'as const' for literal type
+            recipientRole: 'patient' as const, // Use 'as const' for literal type
           };
           // The type cast here might still be an issue if PatientProfileInfo is not imported.
           // However, the structure should be compatible enough for the call.
           await this.appointmentMailingService.sendAppointmentConfirmedEmail(
-            emailData as any // Using 'as any' temporarily to bypass strict type checking if PatientProfileInfo is not imported
+            emailData as any, // Using 'as any' temporarily to bypass strict type checking if PatientProfileInfo is not imported
             // TODO: Properly import PatientProfileInfo and ensure type compatibility
           );
         } else {
           Logger.warn(
-            `[AggService] Cannot send confirmation email to patient ${appointment.patientId}: email missing.`
+            `[AggService] Cannot send confirmation email to patient ${appointment.patientId}: email missing.`,
           );
         }
 
-        if (
-          patientProfile?.expoTokens &&
-          patientProfile.expoTokens.length > 0
-        ) {
+        if (patientProfile?.expoTokens && patientProfile.expoTokens.length > 0) {
           Logger.info(
-            `[AggService] TODO: Send appointment confirmed push to patient ${appointment.patientId}`
+            `[AggService] TODO: Send appointment confirmed push to patient ${appointment.patientId}`,
           );
           await this.notificationsAdmin.sendAppointmentConfirmedPush(
             appointment,
             appointment.patientId,
             patientProfile.expoTokens,
-            UserRole.PATIENT
+            UserRole.PATIENT,
           );
         }
 
         if (practitionerProfile?.basicInfo?.email) {
           Logger.info(
-            `[AggService] Sending appointment confirmation email to practitioner ${practitionerProfile.basicInfo.email}`
+            `[AggService] Sending appointment confirmation email to practitioner ${practitionerProfile.basicInfo.email}`,
           );
           const practitionerEmailData = {
             appointment: appointment,
             recipientProfile: appointment.practitionerInfo,
-            recipientRole: "practitioner" as const,
+            recipientRole: 'practitioner' as const,
           };
           await this.appointmentMailingService.sendAppointmentConfirmedEmail(
-            practitionerEmailData // TODO: Properly import PractitionerProfileInfo and ensure type compatibility
+            practitionerEmailData, // TODO: Properly import PractitionerProfileInfo and ensure type compatibility
           );
         }
         // TODO: Add push notification for practitioner if they have expoTokens
@@ -178,31 +164,29 @@ export class AppointmentAggregationService {
         // Notify clinic admin about the pending appointment
         if (clinicInfo?.contactInfo?.email) {
           Logger.info(
-            `[AggService] TODO: Send pending appointment notification email to clinic admin ${clinicInfo.contactInfo.email}`
+            `[AggService] TODO: Send pending appointment notification email to clinic admin ${clinicInfo.contactInfo.email}`,
           );
           const clinicEmailData = {
             appointment: appointment,
             clinicProfile: appointment.clinicInfo, // clinicInfo should be compatible with ClinicInfo type
           };
           await this.appointmentMailingService.sendAppointmentRequestedEmailToClinic(
-            clinicEmailData // TODO: Properly import ClinicInfo if stricter typing is needed here and ensure compatibility
+            clinicEmailData, // TODO: Properly import ClinicInfo if stricter typing is needed here and ensure compatibility
           );
         } else {
           Logger.warn(
-            `[AggService] Cannot send pending appointment email to clinic ${appointment.clinicBranchId}: email missing.`
+            `[AggService] Cannot send pending appointment email to clinic ${appointment.clinicBranchId}: email missing.`,
           );
         }
         // TODO: Push notification for clinic admin if applicable (they usually don't have tokens)
       }
 
       // Calendar events are noted as being handled by BookingAdmin.orchestrateAppointmentCreation during the booking process itself.
-      Logger.info(
-        `[AggService] Successfully processed CREATE for appointment: ${appointment.id}`
-      );
+      Logger.info(`[AggService] Successfully processed CREATE for appointment: ${appointment.id}`);
     } catch (error) {
       Logger.error(
         `[AggService] Critical error in handleAppointmentCreate for appointment ${appointment.id}:`,
-        error
+        error,
       );
       // Depending on the error, you might want to re-throw or handle specific cases
       // (e.g., update appointment status to an error state if a critical part failed)
@@ -216,41 +200,33 @@ export class AppointmentAggregationService {
    * @param {Appointment} after - The Appointment object after the update.
    * @returns {Promise<void>}
    */
-  async handleAppointmentUpdate(
-    before: Appointment,
-    after: Appointment
-  ): Promise<void> {
+  async handleAppointmentUpdate(before: Appointment, after: Appointment): Promise<void> {
     Logger.info(
-      `[AggService] Handling UPDATE for appointment: ${after.id}. Status ${before.status} -> ${after.status}`
+      `[AggService] Handling UPDATE for appointment: ${after.id}. Status ${before.status} -> ${after.status}`,
     );
 
     try {
       const statusChanged = before.status !== after.status;
       const timeChanged =
-        before.appointmentStartTime.toMillis() !==
-          after.appointmentStartTime.toMillis() ||
-        before.appointmentEndTime.toMillis() !==
-          after.appointmentEndTime.toMillis();
+        before.appointmentStartTime.toMillis() !== after.appointmentStartTime.toMillis() ||
+        before.appointmentEndTime.toMillis() !== after.appointmentEndTime.toMillis();
+      const zonePhotosChanged = this.hasZonePhotosChanged(before, after);
       // const paymentStatusChanged = before.paymentStatus !== after.paymentStatus; // TODO: Handle later
       // const reviewAdded = !before.reviewInfo && after.reviewInfo; // TODO: Handle later
 
       // Fetch profiles for notifications - could be conditional based on changes
       // For simplicity, fetching upfront, but optimize if performance is an issue.
-      const [
-        patientProfile,
-        patientSensitiveInfo,
-        practitionerProfile,
-        clinicInfo,
-      ] = await Promise.all([
-        this.fetchPatientProfile(after.patientId),
-        this.fetchPatientSensitiveInfo(after.patientId),
-        this.fetchPractitionerProfile(after.practitionerId),
-        this.fetchClinicInfo(after.clinicBranchId),
-      ]);
+      const [patientProfile, patientSensitiveInfo, practitionerProfile, clinicInfo] =
+        await Promise.all([
+          this.fetchPatientProfile(after.patientId),
+          this.fetchPatientSensitiveInfo(after.patientId),
+          this.fetchPractitionerProfile(after.practitionerId),
+          this.fetchClinicInfo(after.clinicBranchId),
+        ]);
 
       if (statusChanged) {
         Logger.info(
-          `[AggService] Status changed for ${after.id}: ${before.status} -> ${after.status}`
+          `[AggService] Status changed for ${after.id}: ${before.status} -> ${after.status}`,
         );
 
         // --- PENDING -> CONFIRMED ---
@@ -264,54 +240,49 @@ export class AppointmentAggregationService {
           // Update calendar events to CONFIRMED status
           await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
             after,
-            CalendarEventStatus.CONFIRMED
+            CalendarEventStatus.CONFIRMED,
           );
 
           // Send confirmation notifications
           if (patientSensitiveInfo?.email && patientProfile) {
             Logger.info(
-              `[AggService] Sending appointment confirmed email to patient ${patientSensitiveInfo.email}`
+              `[AggService] Sending appointment confirmed email to patient ${patientSensitiveInfo.email}`,
             );
             const emailData = {
               appointment: after,
               recipientProfile: after.patientInfo,
-              recipientRole: "patient" as const,
+              recipientRole: 'patient' as const,
             };
-            await this.appointmentMailingService.sendAppointmentConfirmedEmail(
-              emailData as any
-            );
+            await this.appointmentMailingService.sendAppointmentConfirmedEmail(emailData as any);
           } else {
             Logger.warn(
-              `[AggService] Cannot send confirmation email to patient ${after.patientId}: email missing.`
+              `[AggService] Cannot send confirmation email to patient ${after.patientId}: email missing.`,
             );
           }
 
-          if (
-            patientProfile?.expoTokens &&
-            patientProfile.expoTokens.length > 0
-          ) {
+          if (patientProfile?.expoTokens && patientProfile.expoTokens.length > 0) {
             Logger.info(
-              `[AggService] TODO: Send appointment confirmed push to patient ${after.patientId}`
+              `[AggService] TODO: Send appointment confirmed push to patient ${after.patientId}`,
             );
             await this.notificationsAdmin.sendAppointmentConfirmedPush(
               after,
               after.patientId,
               patientProfile.expoTokens,
-              UserRole.PATIENT
+              UserRole.PATIENT,
             );
           }
 
           if (practitionerProfile?.basicInfo?.email) {
             Logger.info(
-              `[AggService] Sending appointment confirmation email to practitioner ${practitionerProfile.basicInfo.email}`
+              `[AggService] Sending appointment confirmation email to practitioner ${practitionerProfile.basicInfo.email}`,
             );
             const practitionerEmailData = {
               appointment: after,
               recipientProfile: after.practitionerInfo,
-              recipientRole: "practitioner" as const,
+              recipientRole: 'practitioner' as const,
             };
             await this.appointmentMailingService.sendAppointmentConfirmedEmail(
-              practitionerEmailData as any
+              practitionerEmailData as any,
             );
           }
         }
@@ -320,61 +291,54 @@ export class AppointmentAggregationService {
           before.status === AppointmentStatus.RESCHEDULED_BY_CLINIC &&
           after.status === AppointmentStatus.CONFIRMED
         ) {
-          Logger.info(
-            `[AggService] Appt ${after.id} RESCHEDULED_BY_CLINIC -> CONFIRMED.`
-          );
+          Logger.info(`[AggService] Appt ${after.id} RESCHEDULED_BY_CLINIC -> CONFIRMED.`);
 
           // Update existing requirements as superseded and create new ones
           await this.updateRelatedPatientRequirementInstances(
             before,
-            PatientRequirementOverallStatus.SUPERSEDED_RESCHEDULE
+            PatientRequirementOverallStatus.SUPERSEDED_RESCHEDULE,
           );
           await this.createPreAppointmentRequirementInstances(after);
 
           // Update calendar events to CONFIRMED status and update times
           await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
             after,
-            CalendarEventStatus.CONFIRMED
+            CalendarEventStatus.CONFIRMED,
           );
 
           // Send confirmation notifications (similar to PENDING -> CONFIRMED)
           if (patientSensitiveInfo?.email && patientProfile) {
             Logger.info(
-              `[AggService] Sending appointment confirmed email to patient ${patientSensitiveInfo.email}`
+              `[AggService] Sending appointment confirmed email to patient ${patientSensitiveInfo.email}`,
             );
             const emailData = {
               appointment: after,
               recipientProfile: after.patientInfo,
-              recipientRole: "patient" as const,
+              recipientRole: 'patient' as const,
             };
-            await this.appointmentMailingService.sendAppointmentConfirmedEmail(
-              emailData as any
-            );
+            await this.appointmentMailingService.sendAppointmentConfirmedEmail(emailData as any);
           }
 
-          if (
-            patientProfile?.expoTokens &&
-            patientProfile.expoTokens.length > 0
-          ) {
+          if (patientProfile?.expoTokens && patientProfile.expoTokens.length > 0) {
             await this.notificationsAdmin.sendAppointmentConfirmedPush(
               after,
               after.patientId,
               patientProfile.expoTokens,
-              UserRole.PATIENT
+              UserRole.PATIENT,
             );
           }
 
           if (practitionerProfile?.basicInfo?.email) {
             Logger.info(
-              `[AggService] Sending appointment confirmation email to practitioner ${practitionerProfile.basicInfo.email}`
+              `[AggService] Sending appointment confirmation email to practitioner ${practitionerProfile.basicInfo.email}`,
             );
             const practitionerEmailData = {
               appointment: after,
               recipientProfile: after.practitionerInfo,
-              recipientRole: "practitioner" as const,
+              recipientRole: 'practitioner' as const,
             };
             await this.appointmentMailingService.sendAppointmentConfirmedEmail(
-              practitionerEmailData as any
+              practitionerEmailData as any,
             );
           }
         }
@@ -386,11 +350,11 @@ export class AppointmentAggregationService {
           after.status === AppointmentStatus.NO_SHOW
         ) {
           Logger.info(
-            `[AggService] Appt ${after.id} status -> ${after.status}. Processing as cancellation.`
+            `[AggService] Appt ${after.id} status -> ${after.status}. Processing as cancellation.`,
           );
           await this.updateRelatedPatientRequirementInstances(
             after,
-            PatientRequirementOverallStatus.CANCELLED_APPOINTMENT
+            PatientRequirementOverallStatus.CANCELLED_APPOINTMENT,
           );
 
           // Update patient-clinic-practitioner links if patient profile exists
@@ -399,8 +363,8 @@ export class AppointmentAggregationService {
               patientProfile,
               after.practitionerId,
               after.clinicBranchId,
-              "cancel",
-              after.status
+              'cancel',
+              after.status,
             );
           }
 
@@ -421,38 +385,38 @@ export class AppointmentAggregationService {
 
           await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
             after,
-            calendarStatus(after.status)
+            calendarStatus(after.status),
           );
 
           // Send cancellation email to Patient
           if (patientSensitiveInfo?.email && patientProfile) {
             Logger.info(
-              `[AggService] Sending appointment cancellation email to patient ${patientSensitiveInfo.email}`
+              `[AggService] Sending appointment cancellation email to patient ${patientSensitiveInfo.email}`,
             );
             const patientCancellationData = {
               appointment: after,
               recipientProfile: after.patientInfo,
-              recipientRole: "patient" as const,
+              recipientRole: 'patient' as const,
               // cancellationReason: after.cancellationReason, // TODO: Add if cancellationReason is available on 'after' Appointment
             };
             await this.appointmentMailingService.sendAppointmentCancelledEmail(
-              patientCancellationData as any // TODO: Properly import types
+              patientCancellationData as any, // TODO: Properly import types
             );
           }
 
           // Send cancellation email to Practitioner
           if (practitionerProfile?.basicInfo?.email) {
             Logger.info(
-              `[AggService] Sending appointment cancellation email to practitioner ${practitionerProfile.basicInfo.email}`
+              `[AggService] Sending appointment cancellation email to practitioner ${practitionerProfile.basicInfo.email}`,
             );
             const practitionerCancellationData = {
               appointment: after,
               recipientProfile: after.practitionerInfo,
-              recipientRole: "practitioner" as const,
+              recipientRole: 'practitioner' as const,
               // cancellationReason: after.cancellationReason, // TODO: Add if cancellationReason is available on 'after' Appointment
             };
             await this.appointmentMailingService.sendAppointmentCancelledEmail(
-              practitionerCancellationData as any // TODO: Properly import types
+              practitionerCancellationData as any, // TODO: Properly import types
             );
           }
 
@@ -467,54 +431,49 @@ export class AppointmentAggregationService {
           // Update calendar events to COMPLETED status
           await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
             after,
-            CalendarEventStatus.COMPLETED
+            CalendarEventStatus.COMPLETED,
           );
 
           // Send review request email to patient
           if (patientSensitiveInfo?.email && patientProfile) {
             Logger.info(
-              `[AggService] Sending review request email to patient ${patientSensitiveInfo.email}`
+              `[AggService] Sending review request email to patient ${patientSensitiveInfo.email}`,
             );
             const reviewRequestData = {
               appointment: after,
               patientProfile: after.patientInfo,
-              reviewLink: "TODO: Generate actual review link", // Placeholder
+              reviewLink: 'TODO: Generate actual review link', // Placeholder
             };
             await this.appointmentMailingService.sendReviewRequestEmail(
-              reviewRequestData as any // TODO: Properly import PatientProfileInfo and define reviewLink generation
+              reviewRequestData as any, // TODO: Properly import PatientProfileInfo and define reviewLink generation
             );
           }
           // TODO: Send review request push notification to patient
         }
         // --- RESCHEDULE Scenarios (e.g., PENDING/CONFIRMED -> RESCHEDULED_BY_CLINIC) ---
         else if (after.status === AppointmentStatus.RESCHEDULED_BY_CLINIC) {
-          Logger.info(
-            `[AggService] Appt ${after.id} status -> RESCHEDULED_BY_CLINIC.`
-          );
+          Logger.info(`[AggService] Appt ${after.id} status -> RESCHEDULED_BY_CLINIC.`);
           await this.updateRelatedPatientRequirementInstances(
             before, // Pass the 'before' state for old requirements
-            PatientRequirementOverallStatus.SUPERSEDED_RESCHEDULE
+            PatientRequirementOverallStatus.SUPERSEDED_RESCHEDULE,
           );
 
           // First update the calendar event times with new proposed times
-          await this.calendarAdminService.updateAppointmentCalendarEventsTime(
-            after,
-            {
-              start: after.appointmentStartTime,
-              end: after.appointmentEndTime,
-            }
-          );
+          await this.calendarAdminService.updateAppointmentCalendarEventsTime(after, {
+            start: after.appointmentStartTime,
+            end: after.appointmentEndTime,
+          });
 
           // Then update calendar events to PENDING status (waiting for patient confirmation)
           await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
             after,
-            CalendarEventStatus.PENDING
+            CalendarEventStatus.PENDING,
           );
 
           // Send reschedule proposal email to patient
           if (patientSensitiveInfo?.email && patientProfile) {
             Logger.info(
-              `[AggService] Sending reschedule proposal email to patient ${patientSensitiveInfo.email}`
+              `[AggService] Sending reschedule proposal email to patient ${patientSensitiveInfo.email}`,
             );
             const rescheduleEmailData = {
               appointment: after, // The new state of the appointment
@@ -523,12 +482,12 @@ export class AppointmentAggregationService {
               previousEndTime: before.appointmentEndTime,
             };
             await this.appointmentMailingService.sendAppointmentRescheduledProposalEmail(
-              rescheduleEmailData as any // TODO: Properly import PatientProfileInfo and types
+              rescheduleEmailData as any, // TODO: Properly import PatientProfileInfo and types
             );
           }
 
           Logger.info(
-            `[AggService] TODO: Send reschedule proposal notifications to practitioner as well.`
+            `[AggService] TODO: Send reschedule proposal notifications to practitioner as well.`,
           );
           // TODO: Update calendar event to reflect proposed new time via calendarAdminService.
         }
@@ -545,21 +504,18 @@ export class AppointmentAggregationService {
           // Update existing requirements as superseded and create new ones
           await this.updateRelatedPatientRequirementInstances(
             before,
-            PatientRequirementOverallStatus.SUPERSEDED_RESCHEDULE
+            PatientRequirementOverallStatus.SUPERSEDED_RESCHEDULE,
           );
           await this.createPreAppointmentRequirementInstances(after);
 
           // Update calendar event times with new times
-          await this.calendarAdminService.updateAppointmentCalendarEventsTime(
-            after,
-            {
-              start: after.appointmentStartTime,
-              end: after.appointmentEndTime,
-            }
-          );
+          await this.calendarAdminService.updateAppointmentCalendarEventsTime(after, {
+            start: after.appointmentStartTime,
+            end: after.appointmentEndTime,
+          });
         } else {
           Logger.warn(
-            `[AggService] Independent time change detected for ${after.id} with status ${after.status}. Review implications for requirements and calendar.`
+            `[AggService] Independent time change detected for ${after.id} with status ${after.status}. Review implications for requirements and calendar.`,
           );
         }
       }
@@ -568,17 +524,21 @@ export class AppointmentAggregationService {
       // const paymentStatusChanged = before.paymentStatus !== after.paymentStatus;
       // if (paymentStatusChanged && after.paymentStatus === PaymentStatus.PAID) { ... }
 
+      // Handle Zone Photos Changes
+      if (zonePhotosChanged) {
+        Logger.info(`[AggService] Zone photos changed for appointment ${after.id}`);
+        await this.handleZonePhotosUpdate(before, after);
+      }
+
       // TODO: Handle Review Added
       // const reviewAdded = !before.reviewInfo && after.reviewInfo;
       // if (reviewAdded) { ... }
 
-      Logger.info(
-        `[AggService] Successfully processed UPDATE for appointment: ${after.id}`
-      );
+      Logger.info(`[AggService] Successfully processed UPDATE for appointment: ${after.id}`);
     } catch (error) {
       Logger.error(
         `[AggService] Critical error in handleAppointmentUpdate for appointment ${after.id}:`,
-        error
+        error,
       );
     }
   }
@@ -588,22 +548,16 @@ export class AppointmentAggregationService {
    * @param deletedAppointment - The Appointment object that was deleted.
    * @returns {Promise<void>}
    */
-  async handleAppointmentDelete(
-    deletedAppointment: Appointment
-  ): Promise<void> {
-    Logger.info(
-      `[AggService] Handling DELETE for appointment: ${deletedAppointment.id}`
-    );
+  async handleAppointmentDelete(deletedAppointment: Appointment): Promise<void> {
+    Logger.info(`[AggService] Handling DELETE for appointment: ${deletedAppointment.id}`);
     // Similar to cancellation
     await this.updateRelatedPatientRequirementInstances(
       deletedAppointment,
-      PatientRequirementOverallStatus.CANCELLED_APPOINTMENT
+      PatientRequirementOverallStatus.CANCELLED_APPOINTMENT,
     );
 
     // Fetch patient profile first
-    const patientProfile = await this.fetchPatientProfile(
-      deletedAppointment.patientId
-    );
+    const patientProfile = await this.fetchPatientProfile(deletedAppointment.patientId);
 
     // Update relationship links if patient profile exists
     if (patientProfile) {
@@ -611,14 +565,12 @@ export class AppointmentAggregationService {
         patientProfile,
         deletedAppointment.practitionerId,
         deletedAppointment.clinicBranchId,
-        "cancel"
+        'cancel',
       );
     }
 
     // Delete all associated calendar events
-    await this.calendarAdminService.deleteAppointmentCalendarEvents(
-      deletedAppointment
-    );
+    await this.calendarAdminService.deleteAppointmentCalendarEvents(deletedAppointment);
 
     // TODO: Send cancellation/deletion notifications if appropriate (though data is gone)
   }
@@ -634,16 +586,14 @@ export class AppointmentAggregationService {
    * @param {Appointment} appointment - The appointment for which to create pre-requirement instances.
    * @returns {Promise<void>} A promise that resolves when the operation is complete.
    */
-  private async createPreAppointmentRequirementInstances(
-    appointment: Appointment
-  ): Promise<void> {
+  private async createPreAppointmentRequirementInstances(appointment: Appointment): Promise<void> {
     Logger.info(
-      `[AggService] Creating PRE-appointment requirement instances for appt: ${appointment.id}, patient: ${appointment.patientId}`
+      `[AggService] Creating PRE-appointment requirement instances for appt: ${appointment.id}, patient: ${appointment.patientId}`,
     );
 
     if (!appointment.procedureId) {
       Logger.warn(
-        `[AggService] Appointment ${appointment.id} has no procedureId. Cannot create pre-requirement instances.`
+        `[AggService] Appointment ${appointment.id} has no procedureId. Cannot create pre-requirement instances.`,
       );
       return;
     }
@@ -653,7 +603,7 @@ export class AppointmentAggregationService {
       appointment.preProcedureRequirements.length === 0
     ) {
       Logger.info(
-        `[AggService] No preProcedureRequirements found on appointment ${appointment.id}. Nothing to create.`
+        `[AggService] No preProcedureRequirements found on appointment ${appointment.id}. Nothing to create.`,
       );
       return;
     }
@@ -669,21 +619,21 @@ export class AppointmentAggregationService {
         `[AggService] Found ${
           appointment.preProcedureRequirements.length
         } pre-requirements to process: ${JSON.stringify(
-          appointment.preProcedureRequirements.map((r) => ({
+          appointment.preProcedureRequirements.map(r => ({
             id: r.id,
             name: r.name,
             type: r.type,
             isActive: r.isActive,
             hasTimeframe: !!r.timeframe,
             notifyAtLength: r.timeframe?.notifyAt?.length || 0,
-          }))
-        )}`
+          })),
+        )}`,
       );
 
       for (const template of appointment.preProcedureRequirements) {
         if (!template) {
           Logger.warn(
-            `[AggService] Found null/undefined template in preProcedureRequirements array`
+            `[AggService] Found null/undefined template in preProcedureRequirements array`,
           );
           continue;
         }
@@ -691,7 +641,7 @@ export class AppointmentAggregationService {
         // Ensure it's an active, PRE-type requirement
         if (template.type !== RequirementType.PRE || !template.isActive) {
           Logger.debug(
-            `[AggService] Skipping template ${template.id} (${template.name}): not an active PRE requirement.`
+            `[AggService] Skipping template ${template.id} (${template.name}): not an active PRE requirement.`,
           );
           continue;
         }
@@ -702,12 +652,12 @@ export class AppointmentAggregationService {
           template.timeframe.notifyAt.length === 0
         ) {
           Logger.warn(
-            `[AggService] Template ${template.id} (${template.name}) has no timeframe.notifyAt values. Creating with empty instructions.`
+            `[AggService] Template ${template.id} (${template.name}) has no timeframe.notifyAt values. Creating with empty instructions.`,
           );
         }
 
         Logger.debug(
-          `[AggService] Processing template ${template.id} (${template.name}) for appt ${appointment.id}`
+          `[AggService] Processing template ${template.id} (${template.name}) for appt ${appointment.id}`,
         );
 
         const newInstanceRef = this.db
@@ -717,18 +667,14 @@ export class AppointmentAggregationService {
           .doc(); // Auto-generate ID for the new instance
 
         // Log the path for debugging
-        Logger.debug(
-          `[AggService] Created doc reference: ${newInstanceRef.path}`
-        );
+        Logger.debug(`[AggService] Created doc reference: ${newInstanceRef.path}`);
 
         const instructions: PatientRequirementInstruction[] = (
           template.timeframe?.notifyAt || []
-        ).map((notifyAtValue) => {
+        ).map(notifyAtValue => {
           let dueTime: any = appointment.appointmentStartTime;
-          if (template.timeframe && typeof notifyAtValue === "number") {
-            const dueDateTime = new Date(
-              appointment.appointmentStartTime.toMillis()
-            );
+          if (template.timeframe && typeof notifyAtValue === 'number') {
+            const dueDateTime = new Date(appointment.appointmentStartTime.toMillis());
             if (template.timeframe.unit === TimeUnit.DAYS) {
               dueDateTime.setDate(dueDateTime.getDate() - notifyAtValue);
             } else if (template.timeframe.unit === TimeUnit.HOURS) {
@@ -739,18 +685,13 @@ export class AppointmentAggregationService {
 
           // TODO: Determine source or default for 'actionableWindow' - consult requirements for PatientRequirementInstruction
           const actionableWindowHours =
-            template.importance === "high"
-              ? 1
-              : template.importance === "medium"
-              ? 4
-              : 15; // Default to 15 hours for low importance; // Placeholder default, TODO: Define source
+            template.importance === 'high' ? 1 : template.importance === 'medium' ? 4 : 15; // Default to 15 hours for low importance; // Placeholder default, TODO: Define source
 
           const instructionObject: PatientRequirementInstruction = {
-            instructionId:
-              `${template.id}_${notifyAtValue}_${newInstanceRef.id}`.replace(
-                /[^a-zA-Z0-9_]/g,
-                "_"
-              ),
+            instructionId: `${template.id}_${notifyAtValue}_${newInstanceRef.id}`.replace(
+              /[^a-zA-Z0-9_]/g,
+              '_',
+            ),
             instructionText: template.description || template.name,
             dueTime: dueTime as any,
             actionableWindow: actionableWindowHours, // Directly assigning the placeholder default value
@@ -786,7 +727,7 @@ export class AppointmentAggregationService {
             appointmentId: newInstanceData.appointmentId,
             requirementName: newInstanceData.requirementName,
             instructionsCount: newInstanceData.instructions.length,
-          })}`
+          })}`,
         );
 
         batch.set(newInstanceRef, newInstanceData);
@@ -798,7 +739,7 @@ export class AppointmentAggregationService {
 
         instancesCreatedCount++;
         Logger.debug(
-          `[AggService] Added PatientRequirementInstance ${newInstanceRef.id} to batch for template ${template.id}.`
+          `[AggService] Added PatientRequirementInstance ${newInstanceRef.id} to batch for template ${template.id}.`,
         );
       }
 
@@ -806,7 +747,7 @@ export class AppointmentAggregationService {
         try {
           await batch.commit();
           Logger.info(
-            `[AggService] Successfully created ${instancesCreatedCount} PRE_APPOINTMENT requirement instances for appointment ${appointment.id}.`
+            `[AggService] Successfully created ${instancesCreatedCount} PRE_APPOINTMENT requirement instances for appointment ${appointment.id}.`,
           );
 
           // Verify creation success
@@ -815,116 +756,106 @@ export class AppointmentAggregationService {
               .collection(PATIENTS_COLLECTION)
               .doc(appointment.patientId)
               .collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME)
-              .where("appointmentId", "==", appointment.id)
+              .where('appointmentId', '==', appointment.id)
               .get();
 
             if (verifySnapshot.empty) {
               Logger.warn(
-                `[AggService] Batch commit reported success but documents not found! Attempting direct creation as fallback...`
+                `[AggService] Batch commit reported success but documents not found! Attempting direct creation as fallback...`,
               );
 
               // Fallback to direct creation if batch worked but docs aren't there
-              const fallbackPromises = createdInstances.map(
-                async ({ ref, data }) => {
-                  try {
-                    await ref.set(data);
-                    Logger.info(
-                      `[AggService] Fallback direct creation success for ${ref.id}`
-                    );
-                    return true;
-                  } catch (fallbackError) {
-                    Logger.error(
-                      `[AggService] Fallback direct creation failed for ${ref.id}:`,
-                      fallbackError
-                    );
-                    return false;
-                  }
+              const fallbackPromises = createdInstances.map(async ({ ref, data }) => {
+                try {
+                  await ref.set(data);
+                  Logger.info(`[AggService] Fallback direct creation success for ${ref.id}`);
+                  return true;
+                } catch (fallbackError) {
+                  Logger.error(
+                    `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                    fallbackError,
+                  );
+                  return false;
                 }
-              );
+              });
 
-              const fallbackResults = await Promise.allSettled(
-                fallbackPromises
-              );
+              const fallbackResults = await Promise.allSettled(fallbackPromises);
               const successCount = fallbackResults.filter(
-                (r) => r.status === "fulfilled" && r.value === true
+                r => r.status === 'fulfilled' && r.value === true,
               ).length;
 
               if (successCount > 0) {
                 Logger.info(
-                  `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+                  `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`,
                 );
               } else {
                 Logger.error(
-                  `[AggService] Both batch and fallback mechanisms failed to create requirements`
+                  `[AggService] Both batch and fallback mechanisms failed to create requirements`,
                 );
                 throw new Error(
-                  "Failed to create patient requirements through both batch and direct methods"
+                  'Failed to create patient requirements through both batch and direct methods',
                 );
               }
             } else {
               Logger.info(
-                `[AggService] Verification confirmed ${verifySnapshot.size} requirement documents created`
+                `[AggService] Verification confirmed ${verifySnapshot.size} requirement documents created`,
               );
             }
           } catch (verifyError) {
             Logger.error(
               `[AggService] Error during verification of created requirements:`,
-              verifyError
+              verifyError,
             );
           }
         } catch (commitError) {
           Logger.error(
             `[AggService] Error committing batch for PRE_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
-            commitError
+            commitError,
           );
 
           // Try direct creation as fallback
           Logger.info(`[AggService] Attempting direct creation as fallback...`);
-          const fallbackPromises = createdInstances.map(
-            async ({ ref, data }) => {
-              try {
-                await ref.set(data);
-                Logger.info(
-                  `[AggService] Fallback direct creation success for ${ref.id}`
-                );
-                return true;
-              } catch (fallbackError) {
-                Logger.error(
-                  `[AggService] Fallback direct creation failed for ${ref.id}:`,
-                  fallbackError
-                );
-                return false;
-              }
+          const fallbackPromises = createdInstances.map(async ({ ref, data }) => {
+            try {
+              await ref.set(data);
+              Logger.info(`[AggService] Fallback direct creation success for ${ref.id}`);
+              return true;
+            } catch (fallbackError) {
+              Logger.error(
+                `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                fallbackError,
+              );
+              return false;
             }
-          );
+          });
 
           const fallbackResults = await Promise.allSettled(fallbackPromises);
           const successCount = fallbackResults.filter(
-            (r) => r.status === "fulfilled" && r.value === true
+            r => r.status === 'fulfilled' && r.value === true,
           ).length;
 
           if (successCount > 0) {
             Logger.info(
-              `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+              `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`,
             );
           } else {
             Logger.error(
-              `[AggService] Both batch and fallback mechanisms failed to create requirements`
+              `[AggService] Both batch and fallback mechanisms failed to create requirements`,
             );
             throw new Error(
-              "Failed to create patient requirements through both batch and direct methods"
+              'Failed to create patient requirements through both batch and direct methods',
             );
           }
         }
       } else {
         Logger.info(
-          `[AggService] No new PRE_APPOINTMENT requirement instances were prepared for batch commit for appointment ${appointment.id}.`
+          `[AggService] No new PRE_APPOINTMENT requirement instances were prepared for batch commit for appointment ${appointment.id}.`,
         );
       }
     } catch (error) {
       Logger.error(
         `[AggService] Error creating PRE_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
-        error
+        error,
       );
       throw error; // Re-throw to ensure the caller knows there was a problem
     }
@@ -939,16 +870,14 @@ export class AppointmentAggregationService {
    * @param {Appointment} appointment - The appointment for which to create post-requirement instances.
    * @returns {Promise<void>} A promise that resolves when the operation is complete.
    */
-  private async createPostAppointmentRequirementInstances(
-    appointment: Appointment
-  ): Promise<void> {
+  private async createPostAppointmentRequirementInstances(appointment: Appointment): Promise<void> {
     Logger.info(
-      `[AggService] Creating POST-appointment requirement instances for appt: ${appointment.id}, patient: ${appointment.patientId}`
+      `[AggService] Creating POST-appointment requirement instances for appt: ${appointment.id}, patient: ${appointment.patientId}`,
     );
 
     if (!appointment.procedureId) {
       Logger.warn(
-        `[AggService] Appointment ${appointment.id} has no procedureId. Cannot create post-requirement instances.`
+        `[AggService] Appointment ${appointment.id} has no procedureId. Cannot create post-requirement instances.`,
       );
       return;
     }
@@ -958,7 +887,7 @@ export class AppointmentAggregationService {
       appointment.postProcedureRequirements.length === 0
     ) {
       Logger.info(
-        `[AggService] No postProcedureRequirements found on appointment ${appointment.id}. Nothing to create.`
+        `[AggService] No postProcedureRequirements found on appointment ${appointment.id}. Nothing to create.`,
       );
       return;
     }
@@ -974,21 +903,21 @@ export class AppointmentAggregationService {
         `[AggService] Found ${
           appointment.postProcedureRequirements.length
         } post-requirements to process: ${JSON.stringify(
-          appointment.postProcedureRequirements.map((r) => ({
+          appointment.postProcedureRequirements.map(r => ({
             id: r.id,
             name: r.name,
             type: r.type,
             isActive: r.isActive,
             hasTimeframe: !!r.timeframe,
             notifyAtLength: r.timeframe?.notifyAt?.length || 0,
-          }))
-        )}`
+          })),
+        )}`,
       );
 
       for (const template of appointment.postProcedureRequirements) {
         if (!template) {
           Logger.warn(
-            `[AggService] Found null/undefined template in postProcedureRequirements array`
+            `[AggService] Found null/undefined template in postProcedureRequirements array`,
           );
           continue;
         }
@@ -996,7 +925,7 @@ export class AppointmentAggregationService {
         // Ensure it's an active, POST-type requirement
         if (template.type !== RequirementType.POST || !template.isActive) {
           Logger.debug(
-            `[AggService] Skipping template ${template.id} (${template.name}): not an active POST requirement.`
+            `[AggService] Skipping template ${template.id} (${template.name}): not an active POST requirement.`,
           );
           continue;
         }
@@ -1007,12 +936,12 @@ export class AppointmentAggregationService {
           template.timeframe.notifyAt.length === 0
         ) {
           Logger.warn(
-            `[AggService] Template ${template.id} (${template.name}) has no timeframe.notifyAt values. Creating with empty instructions.`
+            `[AggService] Template ${template.id} (${template.name}) has no timeframe.notifyAt values. Creating with empty instructions.`,
           );
         }
 
         Logger.debug(
-          `[AggService] Processing template ${template.id} (${template.name}) for appt ${appointment.id}`
+          `[AggService] Processing template ${template.id} (${template.name}) for appt ${appointment.id}`,
         );
 
         const newInstanceRef = this.db
@@ -1022,18 +951,14 @@ export class AppointmentAggregationService {
           .doc(); // Auto-generate ID for the new instance
 
         // Log the path for debugging
-        Logger.debug(
-          `[AggService] Created doc reference: ${newInstanceRef.path}`
-        );
+        Logger.debug(`[AggService] Created doc reference: ${newInstanceRef.path}`);
 
         const instructions: PatientRequirementInstruction[] = (
           template.timeframe?.notifyAt || []
-        ).map((notifyAtValue) => {
+        ).map(notifyAtValue => {
           let dueTime: any = appointment.appointmentEndTime;
-          if (template.timeframe && typeof notifyAtValue === "number") {
-            const dueDateTime = new Date(
-              appointment.appointmentEndTime.toMillis()
-            );
+          if (template.timeframe && typeof notifyAtValue === 'number') {
+            const dueDateTime = new Date(appointment.appointmentEndTime.toMillis());
             // For POST requirements, notifyAtValue means AFTER the event
             if (template.timeframe.unit === TimeUnit.DAYS) {
               dueDateTime.setDate(dueDateTime.getDate() + notifyAtValue);
@@ -1044,18 +969,13 @@ export class AppointmentAggregationService {
           }
 
           const actionableWindowHours =
-            template.importance === "high"
-              ? 1
-              : template.importance === "medium"
-              ? 4
-              : 15; // Default to 15 hours for low importance
+            template.importance === 'high' ? 1 : template.importance === 'medium' ? 4 : 15; // Default to 15 hours for low importance
 
           const instructionObject: PatientRequirementInstruction = {
-            instructionId:
-              `${template.id}_${notifyAtValue}_${newInstanceRef.id}`.replace(
-                /[^a-zA-Z0-9_]/g,
-                "_"
-              ),
+            instructionId: `${template.id}_${notifyAtValue}_${newInstanceRef.id}`.replace(
+              /[^a-zA-Z0-9_]/g,
+              '_',
+            ),
             instructionText: template.description || template.name,
             dueTime: dueTime as any,
             actionableWindow: actionableWindowHours,
@@ -1092,7 +1012,7 @@ export class AppointmentAggregationService {
             appointmentId: newInstanceData.appointmentId,
             requirementName: newInstanceData.requirementName,
             instructionsCount: newInstanceData.instructions.length,
-          })}`
+          })}`,
         );
 
         batch.set(newInstanceRef, newInstanceData);
@@ -1104,7 +1024,7 @@ export class AppointmentAggregationService {
 
         instancesCreatedCount++;
         Logger.debug(
-          `[AggService] Added PatientRequirementInstance ${newInstanceRef.id} to batch for template ${template.id}.`
+          `[AggService] Added PatientRequirementInstance ${newInstanceRef.id} to batch for template ${template.id}.`,
         );
       }
 
@@ -1112,7 +1032,7 @@ export class AppointmentAggregationService {
         try {
           await batch.commit();
           Logger.info(
-            `[AggService] Successfully created ${instancesCreatedCount} POST_APPOINTMENT requirement instances for appointment ${appointment.id}.`
+            `[AggService] Successfully created ${instancesCreatedCount} POST_APPOINTMENT requirement instances for appointment ${appointment.id}.`,
           );
 
           // Verify creation success
@@ -1121,116 +1041,106 @@ export class AppointmentAggregationService {
               .collection(PATIENTS_COLLECTION)
               .doc(appointment.patientId)
               .collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME)
-              .where("appointmentId", "==", appointment.id)
+              .where('appointmentId', '==', appointment.id)
               .get();
 
             if (verifySnapshot.empty) {
               Logger.warn(
-                `[AggService] Batch commit reported success but documents not found! Attempting direct creation as fallback...`
+                `[AggService] Batch commit reported success but documents not found! Attempting direct creation as fallback...`,
               );
 
               // Fallback to direct creation if batch worked but docs aren't there
-              const fallbackPromises = createdInstances.map(
-                async ({ ref, data }) => {
-                  try {
-                    await ref.set(data);
-                    Logger.info(
-                      `[AggService] Fallback direct creation success for ${ref.id}`
-                    );
-                    return true;
-                  } catch (fallbackError) {
-                    Logger.error(
-                      `[AggService] Fallback direct creation failed for ${ref.id}:`,
-                      fallbackError
-                    );
-                    return false;
-                  }
+              const fallbackPromises = createdInstances.map(async ({ ref, data }) => {
+                try {
+                  await ref.set(data);
+                  Logger.info(`[AggService] Fallback direct creation success for ${ref.id}`);
+                  return true;
+                } catch (fallbackError) {
+                  Logger.error(
+                    `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                    fallbackError,
+                  );
+                  return false;
                 }
-              );
+              });
 
-              const fallbackResults = await Promise.allSettled(
-                fallbackPromises
-              );
+              const fallbackResults = await Promise.allSettled(fallbackPromises);
               const successCount = fallbackResults.filter(
-                (r) => r.status === "fulfilled" && r.value === true
+                r => r.status === 'fulfilled' && r.value === true,
               ).length;
 
               if (successCount > 0) {
                 Logger.info(
-                  `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+                  `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`,
                 );
               } else {
                 Logger.error(
-                  `[AggService] Both batch and fallback mechanisms failed to create requirements`
+                  `[AggService] Both batch and fallback mechanisms failed to create requirements`,
                 );
                 throw new Error(
-                  "Failed to create patient requirements through both batch and direct methods"
+                  'Failed to create patient requirements through both batch and direct methods',
                 );
               }
             } else {
               Logger.info(
-                `[AggService] Verification confirmed ${verifySnapshot.size} requirement documents created`
+                `[AggService] Verification confirmed ${verifySnapshot.size} requirement documents created`,
               );
             }
           } catch (verifyError) {
             Logger.error(
               `[AggService] Error during verification of created requirements:`,
-              verifyError
+              verifyError,
             );
           }
         } catch (commitError) {
           Logger.error(
             `[AggService] Error committing batch for POST_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
-            commitError
+            commitError,
           );
 
           // Try direct creation as fallback
           Logger.info(`[AggService] Attempting direct creation as fallback...`);
-          const fallbackPromises = createdInstances.map(
-            async ({ ref, data }) => {
-              try {
-                await ref.set(data);
-                Logger.info(
-                  `[AggService] Fallback direct creation success for ${ref.id}`
-                );
-                return true;
-              } catch (fallbackError) {
-                Logger.error(
-                  `[AggService] Fallback direct creation failed for ${ref.id}:`,
-                  fallbackError
-                );
-                return false;
-              }
+          const fallbackPromises = createdInstances.map(async ({ ref, data }) => {
+            try {
+              await ref.set(data);
+              Logger.info(`[AggService] Fallback direct creation success for ${ref.id}`);
+              return true;
+            } catch (fallbackError) {
+              Logger.error(
+                `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                fallbackError,
+              );
+              return false;
             }
-          );
+          });
 
           const fallbackResults = await Promise.allSettled(fallbackPromises);
           const successCount = fallbackResults.filter(
-            (r) => r.status === "fulfilled" && r.value === true
+            r => r.status === 'fulfilled' && r.value === true,
           ).length;
 
           if (successCount > 0) {
             Logger.info(
-              `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+              `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`,
             );
           } else {
             Logger.error(
-              `[AggService] Both batch and fallback mechanisms failed to create requirements`
+              `[AggService] Both batch and fallback mechanisms failed to create requirements`,
             );
             throw new Error(
-              "Failed to create patient requirements through both batch and direct methods"
+              'Failed to create patient requirements through both batch and direct methods',
             );
           }
         }
       } else {
         Logger.info(
-          `[AggService] No new POST_APPOINTMENT requirement instances were prepared for batch commit for appointment ${appointment.id}.`
+          `[AggService] No new POST_APPOINTMENT requirement instances were prepared for batch commit for appointment ${appointment.id}.`,
         );
       }
     } catch (error) {
       Logger.error(
         `[AggService] Error creating POST_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
-        error
+        error,
       );
       throw error; // Re-throw to ensure the caller knows there was a problem
     }
@@ -1247,16 +1157,16 @@ export class AppointmentAggregationService {
   private async updateRelatedPatientRequirementInstances(
     appointment: Appointment,
     newOverallStatus: PatientRequirementOverallStatus,
-    _previousAppointmentData?: Appointment // Not used in this basic implementation, but kept for signature consistency
+    _previousAppointmentData?: Appointment, // Not used in this basic implementation, but kept for signature consistency
   ): Promise<void> {
     Logger.info(
-      `[AggService] Updating related patient req instances for appt ${appointment.id} (patient: ${appointment.patientId}) to ${newOverallStatus}`
+      `[AggService] Updating related patient req instances for appt ${appointment.id} (patient: ${appointment.patientId}) to ${newOverallStatus}`,
     );
 
     if (!appointment.id || !appointment.patientId) {
       Logger.error(
-        "[AggService] updateRelatedPatientRequirementInstances called with missing appointmentId or patientId.",
-        { appointmentId: appointment.id, patientId: appointment.patientId }
+        '[AggService] updateRelatedPatientRequirementInstances called with missing appointmentId or patientId.',
+        { appointmentId: appointment.id, patientId: appointment.patientId },
       );
       return;
     }
@@ -1266,12 +1176,12 @@ export class AppointmentAggregationService {
         .collection(PATIENTS_COLLECTION)
         .doc(appointment.patientId)
         .collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME)
-        .where("appointmentId", "==", appointment.id)
+        .where('appointmentId', '==', appointment.id)
         .get();
 
       if (instancesSnapshot.empty) {
         Logger.info(
-          `[AggService] No patient requirement instances found for appointment ${appointment.id} to update.`
+          `[AggService] No patient requirement instances found for appointment ${appointment.id} to update.`,
         );
         return;
       }
@@ -1279,13 +1189,12 @@ export class AppointmentAggregationService {
       const batch = this.db.batch();
       let instancesUpdatedCount = 0;
 
-      instancesSnapshot.docs.forEach((doc) => {
+      instancesSnapshot.docs.forEach(doc => {
         const instance = doc.data() as PatientRequirementInstance;
         // Update only if the status is actually different and not already in a terminal state like FAILED_TO_PROCESS
         if (
           instance.overallStatus !== newOverallStatus &&
-          instance.overallStatus !==
-            PatientRequirementOverallStatus.FAILED_TO_PROCESS
+          instance.overallStatus !== PatientRequirementOverallStatus.FAILED_TO_PROCESS
         ) {
           batch.update(doc.ref, {
             overallStatus: newOverallStatus,
@@ -1295,7 +1204,7 @@ export class AppointmentAggregationService {
           });
           instancesUpdatedCount++;
           Logger.debug(
-            `[AggService] Added update for PatientRequirementInstance ${doc.id} to batch. New status: ${newOverallStatus}`
+            `[AggService] Added update for PatientRequirementInstance ${doc.id} to batch. New status: ${newOverallStatus}`,
           );
         }
       });
@@ -1303,17 +1212,17 @@ export class AppointmentAggregationService {
       if (instancesUpdatedCount > 0) {
         await batch.commit();
         Logger.info(
-          `[AggService] Successfully updated ${instancesUpdatedCount} patient requirement instances for appointment ${appointment.id} to status ${newOverallStatus}.`
+          `[AggService] Successfully updated ${instancesUpdatedCount} patient requirement instances for appointment ${appointment.id} to status ${newOverallStatus}.`,
         );
       } else {
         Logger.info(
-          `[AggService] No patient requirement instances needed an update for appointment ${appointment.id}.`
+          `[AggService] No patient requirement instances needed an update for appointment ${appointment.id}.`,
         );
       }
     } catch (error) {
       Logger.error(
         `[AggService] Error updating patient requirement instances for appointment ${appointment.id}:`,
-        error
+        error,
       );
     }
   }
@@ -1333,27 +1242,27 @@ export class AppointmentAggregationService {
     patientProfile: PatientProfile,
     practitionerId: string,
     clinicId: string,
-    action: "create" | "cancel",
-    cancelStatus?: AppointmentStatus
+    action: 'create' | 'cancel',
+    cancelStatus?: AppointmentStatus,
   ): Promise<void> {
     Logger.info(
-      `[AggService] Managing patient-clinic-practitioner links for patient ${patientProfile.id}, action: ${action}`
+      `[AggService] Managing patient-clinic-practitioner links for patient ${patientProfile.id}, action: ${action}`,
     );
 
     try {
-      if (action === "create") {
+      if (action === 'create') {
         await this.addPatientLinks(patientProfile, practitionerId, clinicId);
-      } else if (action === "cancel") {
+      } else if (action === 'cancel') {
         await this.removePatientLinksIfNoActiveAppointments(
           patientProfile,
           practitionerId,
-          clinicId
+          clinicId,
         );
       }
     } catch (error) {
       Logger.error(
         `[AggService] Error managing patient-clinic-practitioner links for patient ${patientProfile.id}:`,
-        error
+        error,
       );
     }
   }
@@ -1369,52 +1278,45 @@ export class AppointmentAggregationService {
   private async addPatientLinks(
     patientProfile: PatientProfile,
     practitionerId: string,
-    clinicId: string
+    clinicId: string,
   ): Promise<void> {
     try {
       // Check if the IDs already exist in the arrays
-      const hasDoctor =
-        patientProfile.doctorIds?.includes(practitionerId) || false;
+      const hasDoctor = patientProfile.doctorIds?.includes(practitionerId) || false;
       const hasClinic = patientProfile.clinicIds?.includes(clinicId) || false;
 
       // Only update if necessary
       if (!hasDoctor || !hasClinic) {
-        const patientRef = this.db
-          .collection(PATIENTS_COLLECTION)
-          .doc(patientProfile.id);
+        const patientRef = this.db.collection(PATIENTS_COLLECTION).doc(patientProfile.id);
         const updateData: Record<string, any> = {
           updatedAt: admin.firestore.FieldValue.serverTimestamp(),
         };
 
         if (!hasDoctor) {
           Logger.debug(
-            `[AggService] Adding practitioner ${practitionerId} to patient ${patientProfile.id}`
+            `[AggService] Adding practitioner ${practitionerId} to patient ${patientProfile.id}`,
           );
-          updateData.doctorIds =
-            admin.firestore.FieldValue.arrayUnion(practitionerId);
+          updateData.doctorIds = admin.firestore.FieldValue.arrayUnion(practitionerId);
         }
 
         if (!hasClinic) {
-          Logger.debug(
-            `[AggService] Adding clinic ${clinicId} to patient ${patientProfile.id}`
-          );
-          updateData.clinicIds =
-            admin.firestore.FieldValue.arrayUnion(clinicId);
+          Logger.debug(`[AggService] Adding clinic ${clinicId} to patient ${patientProfile.id}`);
+          updateData.clinicIds = admin.firestore.FieldValue.arrayUnion(clinicId);
         }
 
         await patientRef.update(updateData);
         Logger.info(
-          `[AggService] Successfully updated patient ${patientProfile.id} with new links.`
+          `[AggService] Successfully updated patient ${patientProfile.id} with new links.`,
         );
       } else {
         Logger.info(
-          `[AggService] Patient ${patientProfile.id} already has links to both practitioner ${practitionerId} and clinic ${clinicId}.`
+          `[AggService] Patient ${patientProfile.id} already has links to both practitioner ${practitionerId} and clinic ${clinicId}.`,
         );
       }
     } catch (error) {
       Logger.error(
         `[AggService] Error updating patient ${patientProfile.id} with new links:`,
-        error
+        error,
       );
       throw error;
     }
@@ -1431,30 +1333,28 @@ export class AppointmentAggregationService {
   private async removePatientLinksIfNoActiveAppointments(
     patientProfile: PatientProfile,
     practitionerId: string,
-    clinicId: string
+    clinicId: string,
   ): Promise<void> {
     try {
       // Check for active appointments with this practitioner and clinic
       const activePractitionerAppointments = await this.checkActiveAppointments(
         patientProfile.id,
-        "practitionerId",
-        practitionerId
+        'practitionerId',
+        practitionerId,
       );
 
       const activeClinicAppointments = await this.checkActiveAppointments(
         patientProfile.id,
-        "clinicBranchId",
-        clinicId
+        'clinicBranchId',
+        clinicId,
       );
 
       Logger.info(
-        `[AggService] Active appointment count for patient ${patientProfile.id}: With practitioner ${practitionerId}: ${activePractitionerAppointments}, With clinic ${clinicId}: ${activeClinicAppointments}`
+        `[AggService] Active appointment count for patient ${patientProfile.id}: With practitioner ${practitionerId}: ${activePractitionerAppointments}, With clinic ${clinicId}: ${activeClinicAppointments}`,
       );
 
       // Only update if there are no active appointments
-      const patientRef = this.db
-        .collection(PATIENTS_COLLECTION)
-        .doc(patientProfile.id);
+      const patientRef = this.db.collection(PATIENTS_COLLECTION).doc(patientProfile.id);
       const updateData: Record<string, any> = {};
       let updateNeeded = false;
 
@@ -1463,20 +1363,14 @@ export class AppointmentAggregationService {
         patientProfile.doctorIds?.includes(practitionerId)
       ) {
         Logger.debug(
-          `[AggService] Removing practitioner ${practitionerId} from patient ${patientProfile.id}`
+          `[AggService] Removing practitioner ${practitionerId} from patient ${patientProfile.id}`,
         );
-        updateData.doctorIds =
-          admin.firestore.FieldValue.arrayRemove(practitionerId);
+        updateData.doctorIds = admin.firestore.FieldValue.arrayRemove(practitionerId);
         updateNeeded = true;
       }
 
-      if (
-        activeClinicAppointments === 0 &&
-        patientProfile.clinicIds?.includes(clinicId)
-      ) {
-        Logger.debug(
-          `[AggService] Removing clinic ${clinicId} from patient ${patientProfile.id}`
-        );
+      if (activeClinicAppointments === 0 && patientProfile.clinicIds?.includes(clinicId)) {
+        Logger.debug(`[AggService] Removing clinic ${clinicId} from patient ${patientProfile.id}`);
         updateData.clinicIds = admin.firestore.FieldValue.arrayRemove(clinicId);
         updateNeeded = true;
       }
@@ -1484,19 +1378,12 @@ export class AppointmentAggregationService {
       if (updateNeeded) {
         updateData.updatedAt = admin.firestore.FieldValue.serverTimestamp();
         await patientRef.update(updateData);
-        Logger.info(
-          `[AggService] Successfully removed links from patient ${patientProfile.id}`
-        );
+        Logger.info(`[AggService] Successfully removed links from patient ${patientProfile.id}`);
       } else {
-        Logger.info(
-          `[AggService] No links need to be removed from patient ${patientProfile.id}`
-        );
+        Logger.info(`[AggService] No links need to be removed from patient ${patientProfile.id}`);
       }
     } catch (error) {
-      Logger.error(
-        `[AggService] Error removing links from patient profile:`,
-        error
-      );
+      Logger.error(`[AggService] Error removing links from patient profile:`, error);
       throw error;
     }
   }
@@ -1511,8 +1398,8 @@ export class AppointmentAggregationService {
    */
   private async checkActiveAppointments(
     patientId: string,
-    entityField: "practitionerId" | "clinicBranchId",
-    entityId: string
+    entityField: 'practitionerId' | 'clinicBranchId',
+    entityId: string,
   ): Promise<number> {
     try {
       // Define all cancelled/inactive appointment statuses
@@ -1524,10 +1411,10 @@ export class AppointmentAggregationService {
       ];
 
       const snapshot = await this.db
-        .collection("appointments")
-        .where("patientId", "==", patientId)
-        .where(entityField, "==", entityId)
-        .where("status", "not-in", inactiveStatuses)
+        .collection('appointments')
+        .where('patientId', '==', patientId)
+        .where(entityField, '==', entityId)
+        .where('status', 'not-in', inactiveStatuses)
         .get();
 
       return snapshot.size;
@@ -1538,20 +1425,12 @@ export class AppointmentAggregationService {
   }
 
   // --- Data Fetching Helpers (Consider moving to a data access layer or using existing services if available) ---
-  private async fetchPatientProfile(
-    patientId: string
-  ): Promise<PatientProfile | null> {
+  private async fetchPatientProfile(patientId: string): Promise<PatientProfile | null> {
     try {
-      const doc = await this.db
-        .collection(PATIENTS_COLLECTION)
-        .doc(patientId)
-        .get();
+      const doc = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).get();
       return doc.exists ? (doc.data() as PatientProfile) : null;
     } catch (error) {
-      Logger.error(
-        `[AggService] Error fetching patient profile ${patientId}:`,
-        error
-      );
+      Logger.error(`[AggService] Error fetching patient profile ${patientId}:`, error);
       return null;
     }
   }
@@ -1561,9 +1440,7 @@ export class AppointmentAggregationService {
    * @param patientId The ID of the patient to fetch sensitive information for.
    * @returns {Promise<PatientSensitiveInfo | null>} The patient sensitive information or null if not found or an error occurs.
    */
-  private async fetchPatientSensitiveInfo(
-    patientId: string
-  ): Promise<PatientSensitiveInfo | null> {
+  private async fetchPatientSensitiveInfo(patientId: string): Promise<PatientSensitiveInfo | null> {
     try {
       // Assuming sensitive info is in a subcollection PATIENT_SENSITIVE_INFO_COLLECTION
       // under the patient's document, and the sensitive info document ID is the patientId itself.
@@ -1575,17 +1452,12 @@ export class AppointmentAggregationService {
         .doc(patientId) // CONFIRM THIS DOCUMENT ID PATTERN
         .get();
       if (!doc.exists) {
-        Logger.warn(
-          `[AggService] No sensitive info found for patient ${patientId}`
-        );
+        Logger.warn(`[AggService] No sensitive info found for patient ${patientId}`);
         return null;
       }
       return doc.data() as PatientSensitiveInfo;
     } catch (error) {
-      Logger.error(
-        `[AggService] Error fetching patient sensitive info ${patientId}:`,
-        error
-      );
+      Logger.error(`[AggService] Error fetching patient sensitive info ${patientId}:`, error);
       return null;
     }
   }
@@ -1595,32 +1467,20 @@ export class AppointmentAggregationService {
    * @param practitionerId The ID of the practitioner to fetch.
    * @returns {Promise<Practitioner | null>} The practitioner profile or null if not found or an error occurs.
    */
-  private async fetchPractitionerProfile(
-    practitionerId: string
-  ): Promise<Practitioner | null> {
+  private async fetchPractitionerProfile(practitionerId: string): Promise<Practitioner | null> {
     if (!practitionerId) {
-      Logger.warn(
-        "[AggService] fetchPractitionerProfile called with no practitionerId."
-      );
+      Logger.warn('[AggService] fetchPractitionerProfile called with no practitionerId.');
       return null;
     }
     try {
-      const doc = await this.db
-        .collection(PRACTITIONERS_COLLECTION)
-        .doc(practitionerId)
-        .get();
+      const doc = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
       if (!doc.exists) {
-        Logger.warn(
-          `[AggService] No practitioner profile found for ID ${practitionerId}`
-        );
+        Logger.warn(`[AggService] No practitioner profile found for ID ${practitionerId}`);
         return null;
       }
       return doc.data() as Practitioner;
     } catch (error) {
-      Logger.error(
-        `[AggService] Error fetching practitioner profile ${practitionerId}:`,
-        error
-      );
+      Logger.error(`[AggService] Error fetching practitioner profile ${practitionerId}:`, error);
       return null;
     }
   }
@@ -1632,25 +1492,167 @@ export class AppointmentAggregationService {
    */
   private async fetchClinicInfo(clinicId: string): Promise<Clinic | null> {
     if (!clinicId) {
-      Logger.warn("[AggService] fetchClinicInfo called with no clinicId.");
+      Logger.warn('[AggService] fetchClinicInfo called with no clinicId.');
       return null;
     }
     try {
-      const doc = await this.db
-        .collection(CLINICS_COLLECTION)
-        .doc(clinicId)
-        .get();
+      const doc = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
       if (!doc.exists) {
         Logger.warn(`[AggService] No clinic info found for ID ${clinicId}`);
         return null;
       }
       return doc.data() as Clinic;
+    } catch (error) {
+      Logger.error(`[AggService] Error fetching clinic info ${clinicId}:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Checks if zone photos have changed between two appointment states
+   * @param before - The appointment state before update
+   * @param after - The appointment state after update
+   * @returns True if zone photos have changed, false otherwise
+   */
+  private hasZonePhotosChanged(before: Appointment, after: Appointment): boolean {
+    const beforePhotos = before.metadata?.zonePhotos;
+    const afterPhotos = after.metadata?.zonePhotos;
+
+    // If both are null/undefined, no change
+    if (!beforePhotos && !afterPhotos) {
+      return false;
+    }
+
+    // If one is null and the other isn't, there's a change
+    if (!beforePhotos || !afterPhotos) {
+      return true;
+    }
+
+    // Compare the number of zones
+    const beforeZones = Object.keys(beforePhotos);
+    const afterZones = Object.keys(afterPhotos);
+
+    if (beforeZones.length !== afterZones.length) {
+      return true;
+    }
+
+    // Compare each zone's photos
+    for (const zoneId of afterZones) {
+      const beforeZonePhotos = beforePhotos[zoneId];
+      const afterZonePhotos = afterPhotos[zoneId];
+
+      if (!beforeZonePhotos && !afterZonePhotos) {
+        continue;
+      }
+
+      if (!beforeZonePhotos || !afterZonePhotos) {
+        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
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Handles zone photos update notifications and logging
+   * @param before - The appointment state before update
+   * @param after - The appointment state after update
+   */
+  private async handleZonePhotosUpdate(before: Appointment, after: Appointment): Promise<void> {
+    try {
+      Logger.info(`[AggService] Processing zone photos update for appointment ${after.id}`);
+
+      const beforePhotos = before.metadata?.zonePhotos || {};
+      const afterPhotos = after.metadata?.zonePhotos || {};
+
+      // Find zones with new or updated photos
+      const updatedZones: string[] = [];
+      const newPhotoTypes: { zoneId: string; photoType: 'before' | 'after' }[] = [];
+
+      for (const zoneId of Object.keys(afterPhotos)) {
+        const beforeZonePhotos = beforePhotos[zoneId];
+        const afterZonePhotos = afterPhotos[zoneId];
+
+        if (!beforeZonePhotos) {
+          // New zone with photos
+          updatedZones.push(zoneId);
+          if (afterZonePhotos.before) {
+            newPhotoTypes.push({ zoneId, photoType: 'before' });
+          }
+          if (afterZonePhotos.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' });
+          }
+        }
+      }
+
+      if (updatedZones.length > 0) {
+        Logger.info(
+          `[AggService] Zone photos updated for appointment ${after.id}: ${updatedZones.join(
+            ', ',
+          )}`,
+        );
+
+        // Log specific photo types that were added
+        for (const { zoneId, photoType } of newPhotoTypes) {
+          Logger.info(
+            `[AggService] New ${photoType} photo added for zone ${zoneId} in appointment ${after.id}`,
+          );
+        }
+
+        // TODO: Add notifications to practitioners/clinic admins about photo updates
+        // TODO: Add audit logging for photo uploads
+        // TODO: Trigger any business logic related to photo completion (e.g., appointment progress tracking)
+      }
+
+      // Check if all required photos are now complete
+      const selectedZones = after.metadata?.selectedZones || [];
+      if (selectedZones.length > 0) {
+        const completedZones = selectedZones.filter(zoneId => {
+          const zonePhotos = afterPhotos[zoneId];
+          return zonePhotos && (zonePhotos.before || zonePhotos.after);
+        });
+
+        const completionPercentage = (completedZones.length / selectedZones.length) * 100;
+        Logger.info(
+          `[AggService] Photo completion for appointment ${
+            after.id
+          }: ${completionPercentage.toFixed(1)}% (${completedZones.length}/${
+            selectedZones.length
+          } zones)`,
+        );
+
+        // TODO: Trigger notifications when all photos are complete
+        if (completionPercentage === 100) {
+          Logger.info(`[AggService] All zone photos completed for appointment ${after.id}`);
+          // TODO: Send notification to relevant parties
+        }
+      }
     } catch (error) {
       Logger.error(
-        `[AggService] Error fetching clinic info ${clinicId}:`,
-        error
+        `[AggService] Error handling zone photos update for appointment ${after.id}:`,
+        error,
       );
-      return null;
+      // Don't throw - this is a side effect and shouldn't break the main update flow
     }
   }
 }