@blackcode_sa/metaestetics-api 1.7.3 → 1.7.5

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

@@ -37,6 +37,7 @@ 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
 
@@ -87,11 +88,7 @@ export class AppointmentAggregationService {
     );
 
     try {
-      // 1. Manage Patient-Clinic-Practitioner Links (non-critical for core flow, can run in parallel or first)
-      // No need to await if other operations don't depend on its immediate completion, but awaiting for simplicity here.
-      await this.managePatientClinicPractitionerLinks(appointment, "create");
-
-      // 2. Fetch necessary profiles for notifications and context
+      // 1. Fetch necessary profiles for notifications and context
       // These can be fetched in parallel
       const [
         patientProfile,
@@ -105,6 +102,17 @@ export class AppointmentAggregationService {
         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
+      if (patientProfile) {
+        await this.managePatientClinicPractitionerLinks(
+          patientProfile,
+          appointment.practitionerId,
+          appointment.clinicBranchId,
+          "create"
+        );
+      }
+
       // 3. Initial State Handling based on appointment status
       if (appointment.status === AppointmentStatus.CONFIRMED) {
         Logger.info(
@@ -252,6 +260,13 @@ export class AppointmentAggregationService {
         ) {
           Logger.info(`[AggService] Appt ${after.id} PENDING -> CONFIRMED.`);
           await this.createPreAppointmentRequirementInstances(after);
+
+          // Update calendar events to CONFIRMED status
+          await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
+            after,
+            CalendarEventStatus.CONFIRMED
+          );
+
           // Send confirmation notifications
           if (patientSensitiveInfo?.email && patientProfile) {
             Logger.info(
@@ -296,10 +311,72 @@ export class AppointmentAggregationService {
               recipientRole: "practitioner" as const,
             };
             await this.appointmentMailingService.sendAppointmentConfirmedEmail(
-              practitionerEmailData as any // TODO: Properly import PractitionerProfileInfo and ensure type compatibility
+              practitionerEmailData as any
+            );
+          }
+        }
+        // --- RESCHEDULED_BY_CLINIC -> CONFIRMED (Reschedule Acceptance) ---
+        else if (
+          before.status === AppointmentStatus.RESCHEDULED_BY_CLINIC &&
+          after.status === AppointmentStatus.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
+          );
+          await this.createPreAppointmentRequirementInstances(after);
+
+          // Update calendar events to CONFIRMED status and update times
+          await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
+            after,
+            CalendarEventStatus.CONFIRMED
+          );
+
+          // Send confirmation notifications (similar to PENDING -> CONFIRMED)
+          if (patientSensitiveInfo?.email && patientProfile) {
+            Logger.info(
+              `[AggService] Sending appointment confirmed email to patient ${patientSensitiveInfo.email}`
+            );
+            const emailData = {
+              appointment: after,
+              recipientProfile: after.patientInfo,
+              recipientRole: "patient" as const,
+            };
+            await this.appointmentMailingService.sendAppointmentConfirmedEmail(
+              emailData as any
+            );
+          }
+
+          if (
+            patientProfile?.expoTokens &&
+            patientProfile.expoTokens.length > 0
+          ) {
+            await this.notificationsAdmin.sendAppointmentConfirmedPush(
+              after,
+              after.patientId,
+              patientProfile.expoTokens,
+              UserRole.PATIENT
+            );
+          }
+
+          if (practitionerProfile?.basicInfo?.email) {
+            Logger.info(
+              `[AggService] Sending appointment confirmation email to practitioner ${practitionerProfile.basicInfo.email}`
+            );
+            const practitionerEmailData = {
+              appointment: after,
+              recipientProfile: after.practitionerInfo,
+              recipientRole: "practitioner" as const,
+            };
+            await this.appointmentMailingService.sendAppointmentConfirmedEmail(
+              practitionerEmailData as any
             );
           }
-          // TODO: Add push notification for practitioner if they have expoTokens
         }
         // --- Any -> CANCELLED_* ---
         else if (
@@ -315,7 +392,37 @@ export class AppointmentAggregationService {
             after,
             PatientRequirementOverallStatus.CANCELLED_APPOINTMENT
           );
-          await this.managePatientClinicPractitionerLinks(after, "cancel");
+
+          // Update patient-clinic-practitioner links if patient profile exists
+          if (patientProfile) {
+            await this.managePatientClinicPractitionerLinks(
+              patientProfile,
+              after.practitionerId,
+              after.clinicBranchId,
+              "cancel",
+              after.status
+            );
+          }
+
+          const calendarStatus = (status: AppointmentStatus) => {
+            switch (status) {
+              case AppointmentStatus.NO_SHOW:
+                return CalendarEventStatus.NO_SHOW;
+              case AppointmentStatus.CANCELED_CLINIC:
+                return CalendarEventStatus.REJECTED;
+              case AppointmentStatus.CANCELED_PATIENT:
+                return CalendarEventStatus.CANCELED;
+              case AppointmentStatus.CANCELED_PATIENT_RESCHEDULED:
+                return CalendarEventStatus.REJECTED;
+              default:
+                return CalendarEventStatus.CANCELED;
+            }
+          };
+
+          await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
+            after,
+            calendarStatus(after.status)
+          );
 
           // Send cancellation email to Patient
           if (patientSensitiveInfo?.email && patientProfile) {
@@ -357,6 +464,12 @@ export class AppointmentAggregationService {
           Logger.info(`[AggService] Appt ${after.id} status -> COMPLETED.`);
           await this.createPostAppointmentRequirementInstances(after);
 
+          // Update calendar events to COMPLETED status
+          await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
+            after,
+            CalendarEventStatus.COMPLETED
+          );
+
           // Send review request email to patient
           if (patientSensitiveInfo?.email && patientProfile) {
             Logger.info(
@@ -382,8 +495,20 @@ export class AppointmentAggregationService {
             before, // Pass the 'before' state for old requirements
             PatientRequirementOverallStatus.SUPERSEDED_RESCHEDULE
           );
-          Logger.info(
-            `[AggService] TODO: Handle RESCHEDULE logic for requirements carefully based on confirmation flow.`
+
+          // First update the calendar event times with new proposed times
+          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
           );
 
           // Send reschedule proposal email to patient
@@ -414,16 +539,29 @@ export class AppointmentAggregationService {
       if (timeChanged && !statusChanged) {
         // Or if status change didn't fully cover reschedule implications
         Logger.info(`[AggService] Appointment ${after.id} time changed.`);
-        // This scenario is tricky. If time changes, pre-requirements might need to be re-evaluated.
-        // Typically, a time change would also involve a status change to some form of "rescheduled".
-        // If it can happen independently while, e.g., staying CONFIRMED, then:
-        // await this.updateRelatedPatientRequirementInstances(before, PatientRequirementOverallStatus.SUPERSEDED_RESCHEDULE);
-        // await this.createPreAppointmentRequirementInstances(after);
-        // TODO: Send reschedule notifications
-        // TODO: Update calendar event via calendarAdminService
-        Logger.warn(
-          `[AggService] Independent time change detected for ${after.id}. Review implications for requirements and calendar.`
-        );
+
+        // If confirmed appointment has time change, we need to update requirements
+        if (after.status === AppointmentStatus.CONFIRMED) {
+          // Update existing requirements as superseded and create new ones
+          await this.updateRelatedPatientRequirementInstances(
+            before,
+            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,
+            }
+          );
+        } else {
+          Logger.warn(
+            `[AggService] Independent time change detected for ${after.id} with status ${after.status}. Review implications for requirements and calendar.`
+          );
+        }
       }
 
       // TODO: Handle Payment Status Change
@@ -461,11 +599,27 @@ export class AppointmentAggregationService {
       deletedAppointment,
       PatientRequirementOverallStatus.CANCELLED_APPOINTMENT
     );
-    // await this.calendarAdminService.deleteAppointmentCalendarEvents(deletedAppointment);
-    await this.managePatientClinicPractitionerLinks(
-      deletedAppointment,
-      "cancel"
+
+    // Fetch patient profile first
+    const patientProfile = await this.fetchPatientProfile(
+      deletedAppointment.patientId
     );
+
+    // Update relationship links if patient profile exists
+    if (patientProfile) {
+      await this.managePatientClinicPractitionerLinks(
+        patientProfile,
+        deletedAppointment.practitionerId,
+        deletedAppointment.clinicBranchId,
+        "cancel"
+      );
+    }
+
+    // Delete all associated calendar events
+    await this.calendarAdminService.deleteAppointmentCalendarEvents(
+      deletedAppointment
+    );
+
     // TODO: Send cancellation/deletion notifications if appropriate (though data is gone)
   }
 
@@ -812,10 +966,34 @@ export class AppointmentAggregationService {
     try {
       const batch = this.db.batch();
       let instancesCreatedCount = 0;
+      // Store created instances for fallback direct creation if needed
+      let createdInstances = [];
+
+      // Log more details about the post-requirements
+      Logger.info(
+        `[AggService] Found ${
+          appointment.postProcedureRequirements.length
+        } post-requirements to process: ${JSON.stringify(
+          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) continue;
+        if (!template) {
+          Logger.warn(
+            `[AggService] Found null/undefined template in postProcedureRequirements array`
+          );
+          continue;
+        }
 
+        // 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.`
@@ -823,25 +1001,40 @@ export class AppointmentAggregationService {
           continue;
         }
 
+        if (
+          !template.timeframe ||
+          !template.timeframe.notifyAt ||
+          template.timeframe.notifyAt.length === 0
+        ) {
+          Logger.warn(
+            `[AggService] Template ${template.id} (${template.name}) has no timeframe.notifyAt values. Creating with empty instructions.`
+          );
+        }
+
         Logger.debug(
-          `[AggService] Processing POST template ${template.id} (${template.name}) for appt ${appointment.id}`
+          `[AggService] Processing template ${template.id} (${template.name}) for appt ${appointment.id}`
         );
 
         const newInstanceRef = this.db
           .collection(PATIENTS_COLLECTION)
           .doc(appointment.patientId)
           .collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME)
-          .doc();
+          .doc(); // Auto-generate ID for the new instance
+
+        // Log the path for debugging
+        Logger.debug(
+          `[AggService] Created doc reference: ${newInstanceRef.path}`
+        );
 
         const instructions: PatientRequirementInstruction[] = (
           template.timeframe?.notifyAt || []
         ).map((notifyAtValue) => {
-          let dueTime: any = appointment.appointmentEndTime; // Default to appointment end time
+          let dueTime: any = appointment.appointmentEndTime;
           if (template.timeframe && typeof notifyAtValue === "number") {
             const dueDateTime = new Date(
               appointment.appointmentEndTime.toMillis()
             );
-            // For POST requirements, notifyAtValue usually means AFTER the event
+            // For POST requirements, notifyAtValue means AFTER the event
             if (template.timeframe.unit === TimeUnit.DAYS) {
               dueDateTime.setDate(dueDateTime.getDate() + notifyAtValue);
             } else if (template.timeframe.unit === TimeUnit.HOURS) {
@@ -855,9 +1048,9 @@ export class AppointmentAggregationService {
               ? 1
               : template.importance === "medium"
               ? 4
-              : 15; // Default to 15 hours for low importance; // Placeholder default, TODO: Define source
+              : 15; // Default to 15 hours for low importance
 
-          return {
+          const instructionObject: PatientRequirementInstruction = {
             instructionId:
               `${template.id}_${notifyAtValue}_${newInstanceRef.id}`.replace(
                 /[^a-zA-Z0-9_]/g,
@@ -869,19 +1062,21 @@ export class AppointmentAggregationService {
             status: PatientInstructionStatus.PENDING_NOTIFICATION,
             originalNotifyAtValue: notifyAtValue,
             originalTimeframeUnit: template.timeframe.unit,
-            updatedAt: admin.firestore.Timestamp.now() as any, // Use current server timestamp
+            updatedAt: admin.firestore.Timestamp.now() as any,
             notificationId: undefined,
             actionTakenAt: undefined,
-          } as PatientRequirementInstruction;
+          };
+          return instructionObject;
         });
 
-        const newInstanceData: Omit<PatientRequirementInstance, "id"> = {
+        const newInstanceData: PatientRequirementInstance = {
+          id: newInstanceRef.id,
           patientId: appointment.patientId,
           appointmentId: appointment.id,
           originalRequirementId: template.id,
           requirementName: template.name,
           requirementDescription: template.description,
-          requirementType: template.type, // Should be RequirementType.POST
+          requirementType: template.type,
           requirementImportance: template.importance,
           overallStatus: PatientRequirementOverallStatus.ACTIVE,
           instructions: instructions,
@@ -889,18 +1084,144 @@ export class AppointmentAggregationService {
           updatedAt: admin.firestore.FieldValue.serverTimestamp() as any,
         };
 
+        // Log the data being set
+        Logger.debug(
+          `[AggService] Setting data for requirement: ${JSON.stringify({
+            id: newInstanceRef.id,
+            patientId: newInstanceData.patientId,
+            appointmentId: newInstanceData.appointmentId,
+            requirementName: newInstanceData.requirementName,
+            instructionsCount: newInstanceData.instructions.length,
+          })}`
+        );
+
         batch.set(newInstanceRef, newInstanceData);
+        // Store for potential fallback
+        createdInstances.push({
+          ref: newInstanceRef,
+          data: newInstanceData,
+        });
+
         instancesCreatedCount++;
         Logger.debug(
-          `[AggService] Added POST PatientRequirementInstance ${newInstanceRef.id} to batch for template ${template.id}.`
+          `[AggService] Added PatientRequirementInstance ${newInstanceRef.id} to batch for template ${template.id}.`
         );
       }
 
       if (instancesCreatedCount > 0) {
-        await batch.commit();
-        Logger.info(
-          `[AggService] Successfully created ${instancesCreatedCount} POST_APPOINTMENT requirement instances for appointment ${appointment.id}.`
-        );
+        try {
+          await batch.commit();
+          Logger.info(
+            `[AggService] Successfully created ${instancesCreatedCount} POST_APPOINTMENT requirement instances for appointment ${appointment.id}.`
+          );
+
+          // Verify creation success
+          try {
+            const verifySnapshot = await this.db
+              .collection(PATIENTS_COLLECTION)
+              .doc(appointment.patientId)
+              .collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME)
+              .where("appointmentId", "==", appointment.id)
+              .get();
+
+            if (verifySnapshot.empty) {
+              Logger.warn(
+                `[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 fallbackResults = await Promise.allSettled(
+                fallbackPromises
+              );
+              const successCount = fallbackResults.filter(
+                (r) => r.status === "fulfilled" && r.value === true
+              ).length;
+
+              if (successCount > 0) {
+                Logger.info(
+                  `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+                );
+              } else {
+                Logger.error(
+                  `[AggService] Both batch and fallback mechanisms failed to create requirements`
+                );
+                throw new Error(
+                  "Failed to create patient requirements through both batch and direct methods"
+                );
+              }
+            } else {
+              Logger.info(
+                `[AggService] Verification confirmed ${verifySnapshot.size} requirement documents created`
+              );
+            }
+          } catch (verifyError) {
+            Logger.error(
+              `[AggService] Error during verification of created requirements:`,
+              verifyError
+            );
+          }
+        } catch (commitError) {
+          Logger.error(
+            `[AggService] Error committing batch for POST_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
+            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 fallbackResults = await Promise.allSettled(fallbackPromises);
+          const successCount = fallbackResults.filter(
+            (r) => r.status === "fulfilled" && r.value === true
+          ).length;
+
+          if (successCount > 0) {
+            Logger.info(
+              `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+            );
+          } else {
+            Logger.error(
+              `[AggService] Both batch and fallback mechanisms failed to create requirements`
+            );
+            throw new Error(
+              "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}.`
@@ -911,6 +1232,7 @@ export class AppointmentAggregationService {
         `[AggService] Error creating POST_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
         error
       );
+      throw error; // Re-throw to ensure the caller knows there was a problem
     }
   }
 
@@ -997,102 +1319,221 @@ export class AppointmentAggregationService {
   }
 
   /**
-   * Manages denormalized links between a patient and the clinic/practitioner associated with an appointment.
-   * Adds patientId to arrays on clinic and practitioner documents on appointment creation.
-   * Removes patientId on appointment cancellation (basic removal, can be enhanced).
+   * Manages relationships between a patient and clinics/practitioners.
+   * Only updates the patient profile with doctorIds and clinicIds.
    *
-   * @param {Appointment} appointment - The appointment object.
-   * @param {"create" | "cancel"} action - 'create' to add links, 'cancel' to remove them.
+   * @param {PatientProfile} patientProfile - The patient profile to update
+   * @param {string} practitionerId - The practitioner ID
+   * @param {string} clinicId - The clinic ID
+   * @param {"create" | "cancel"} action - 'create' to add IDs, 'cancel' to potentially remove them
+   * @param {AppointmentStatus} [cancelStatus] - The appointment status if action is 'cancel'
    * @returns {Promise<void>} A promise that resolves when the operation is complete.
    */
   private async managePatientClinicPractitionerLinks(
-    appointment: Appointment,
-    action: "create" | "cancel"
+    patientProfile: PatientProfile,
+    practitionerId: string,
+    clinicId: string,
+    action: "create" | "cancel",
+    cancelStatus?: AppointmentStatus
   ): Promise<void> {
     Logger.info(
-      `[AggService] Managing patient-clinic-practitioner links for appt ${appointment.id} (patient: ${appointment.patientId}), action: ${action}`
+      `[AggService] Managing patient-clinic-practitioner links for patient ${patientProfile.id}, action: ${action}`
     );
 
-    if (
-      !appointment.patientId ||
-      !appointment.practitionerId ||
-      !appointment.clinicBranchId
-    ) {
+    try {
+      if (action === "create") {
+        await this.addPatientLinks(patientProfile, practitionerId, clinicId);
+      } else if (action === "cancel") {
+        await this.removePatientLinksIfNoActiveAppointments(
+          patientProfile,
+          practitionerId,
+          clinicId
+        );
+      }
+    } catch (error) {
       Logger.error(
-        "[AggService] managePatientClinicPractitionerLinks called with missing IDs.",
-        {
-          patientId: appointment.patientId,
-          practitionerId: appointment.practitionerId,
-          clinicBranchId: appointment.clinicBranchId,
-        }
+        `[AggService] Error managing patient-clinic-practitioner links for patient ${patientProfile.id}:`,
+        error
       );
-      return;
     }
+  }
 
-    const batch = this.db.batch();
-    const patientId = appointment.patientId;
-
-    // Practitioner link
-    const practitionerRef = this.db
-      .collection(PRACTITIONERS_COLLECTION)
-      .doc(appointment.practitionerId);
-    // Clinic link
-    const clinicRef = this.db
-      .collection(CLINICS_COLLECTION)
-      .doc(appointment.clinicBranchId);
-
-    if (action === "create") {
-      // Add patient to practitioner's list of patients (if field exists, e.g., 'patientIds')
-      // Assuming a field named 'patientIds' on the practitioner document
-      batch.update(practitionerRef, {
-        patientIds: admin.firestore.FieldValue.arrayUnion(patientId),
-        // Optionally, update a count or last interaction timestamp
-        updatedAt: admin.firestore.FieldValue.serverTimestamp() as any,
-      });
-      Logger.debug(
-        `[AggService] Adding patient ${patientId} to practitioner ${appointment.practitionerId} patientIds.`
-      );
+  /**
+   * Adds practitioner and clinic IDs to the patient profile.
+   *
+   * @param {PatientProfile} patientProfile - The patient profile to update
+   * @param {string} practitionerId - The practitioner ID to add
+   * @param {string} clinicId - The clinic ID to add
+   * @returns {Promise<void>} A promise that resolves when the operation is complete.
+   */
+  private async addPatientLinks(
+    patientProfile: PatientProfile,
+    practitionerId: string,
+    clinicId: string
+  ): Promise<void> {
+    try {
+      // Check if the IDs already exist in the arrays
+      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 updateData: Record<string, any> = {
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        };
 
-      // Add patient to clinic's list of patients (if field exists, e.g., 'patientIds')
-      // Assuming a field named 'patientIds' on the clinic document
-      batch.update(clinicRef, {
-        patientIds: admin.firestore.FieldValue.arrayUnion(patientId),
-        updatedAt: admin.firestore.FieldValue.serverTimestamp() as any,
-      });
-      Logger.debug(
-        `[AggService] Adding patient ${patientId} to clinic ${appointment.clinicBranchId} patientIds.`
-      );
-    } else if (action === "cancel") {
-      // Basic removal.
-      // TODO: Implement more robust removal logic: only remove if this was the last active/confirmed appointment
-      //       linking this patient to this practitioner/clinic.
-      batch.update(practitionerRef, {
-        patientIds: admin.firestore.FieldValue.arrayRemove(patientId),
-        updatedAt: admin.firestore.FieldValue.serverTimestamp() as any,
-      });
-      Logger.debug(
-        `[AggService] Removing patient ${patientId} from practitioner ${appointment.practitionerId} patientIds.`
-      );
+        if (!hasDoctor) {
+          Logger.debug(
+            `[AggService] Adding practitioner ${practitionerId} to patient ${patientProfile.id}`
+          );
+          updateData.doctorIds =
+            admin.firestore.FieldValue.arrayUnion(practitionerId);
+        }
 
-      batch.update(clinicRef, {
-        patientIds: admin.firestore.FieldValue.arrayRemove(patientId),
-        updatedAt: admin.firestore.FieldValue.serverTimestamp() as any,
-      });
-      Logger.debug(
-        `[AggService] Removing patient ${patientId} from clinic ${appointment.clinicBranchId} patientIds.`
+        if (!hasClinic) {
+          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.`
+        );
+      } else {
+        Logger.info(
+          `[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
       );
+      throw error;
     }
+  }
 
+  /**
+   * Removes practitioner and clinic IDs from the patient profile if there are no more active appointments.
+   *
+   * @param {PatientProfile} patientProfile - The patient profile to update
+   * @param {string} practitionerId - The practitioner ID to remove
+   * @param {string} clinicId - The clinic ID to remove
+   * @returns {Promise<void>} A promise that resolves when the operation is complete.
+   */
+  private async removePatientLinksIfNoActiveAppointments(
+    patientProfile: PatientProfile,
+    practitionerId: string,
+    clinicId: string
+  ): Promise<void> {
     try {
-      await batch.commit();
+      // Check for active appointments with this practitioner and clinic
+      const activePractitionerAppointments = await this.checkActiveAppointments(
+        patientProfile.id,
+        "practitionerId",
+        practitionerId
+      );
+
+      const activeClinicAppointments = await this.checkActiveAppointments(
+        patientProfile.id,
+        "clinicBranchId",
+        clinicId
+      );
+
       Logger.info(
-        `[AggService] Successfully updated patient-clinic-practitioner links for appointment ${appointment.id}, action: ${action}.`
+        `[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 updateData: Record<string, any> = {};
+      let updateNeeded = false;
+
+      if (
+        activePractitionerAppointments === 0 &&
+        patientProfile.doctorIds?.includes(practitionerId)
+      ) {
+        Logger.debug(
+          `[AggService] Removing practitioner ${practitionerId} from patient ${patientProfile.id}`
+        );
+        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}`
+        );
+        updateData.clinicIds = admin.firestore.FieldValue.arrayRemove(clinicId);
+        updateNeeded = true;
+      }
+
+      if (updateNeeded) {
+        updateData.updatedAt = admin.firestore.FieldValue.serverTimestamp();
+        await patientRef.update(updateData);
+        Logger.info(
+          `[AggService] Successfully removed links from patient ${patientProfile.id}`
+        );
+      } else {
+        Logger.info(
+          `[AggService] No links need to be removed from patient ${patientProfile.id}`
+        );
+      }
     } catch (error) {
       Logger.error(
-        `[AggService] Error managing patient-clinic-practitioner links for appointment ${appointment.id}:`,
+        `[AggService] Error removing links from patient profile:`,
         error
       );
+      throw error;
+    }
+  }
+
+  /**
+   * Checks if there are active appointments between a patient and another entity (practitioner or clinic).
+   *
+   * @param {string} patientId - The patient ID.
+   * @param {"practitionerId" | "clinicBranchId"} entityField - The field to check for the entity ID.
+   * @param {string} entityId - The entity ID (practitioner or clinic).
+   * @returns {Promise<number>} The number of active appointments found.
+   */
+  private async checkActiveAppointments(
+    patientId: string,
+    entityField: "practitionerId" | "clinicBranchId",
+    entityId: string
+  ): Promise<number> {
+    try {
+      // Define all cancelled/inactive appointment statuses
+      const inactiveStatuses = [
+        AppointmentStatus.CANCELED_CLINIC,
+        AppointmentStatus.CANCELED_PATIENT,
+        AppointmentStatus.CANCELED_PATIENT_RESCHEDULED,
+        AppointmentStatus.NO_SHOW,
+      ];
+
+      const snapshot = await this.db
+        .collection("appointments")
+        .where("patientId", "==", patientId)
+        .where(entityField, "==", entityId)
+        .where("status", "not-in", inactiveStatuses)
+        .get();
+
+      return snapshot.size;
+    } catch (error) {
+      Logger.error(`[AggService] Error checking active appointments:`, error);
+      throw error;
     }
   }