@blackcode_sa/metaestetics-api 1.7.3 → 1.7.5

package/dist/admin/index.mjs

@@ -2545,23 +2545,81 @@ var CalendarAdminService = class {
     );
     const batch = this.db.batch();
     const serverTimestamp = admin8.firestore.FieldValue.serverTimestamp();
-    const practitionerCalendarEventPath = `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${appointment.calendarEventId}`;
-    if (appointment.calendarEventId) {
-      const practitionerEventRef = this.db.doc(practitionerCalendarEventPath);
+    let updatesAdded = 0;
+    const calendarEventId = appointment.calendarEventId;
+    if (!calendarEventId) {
+      Logger.warn(
+        `[CalendarAdminService] Missing calendar event ID for appointment ${appointment.id}`
+      );
+      return;
+    }
+    if (appointment.practitionerId) {
+      const practitionerEventRef = this.db.doc(
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
       batch.update(practitionerEventRef, {
         status: newStatus,
         updatedAt: serverTimestamp
       });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added practitioner calendar event status update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing practitioner ID for appointment ${appointment.id}`
+      );
     }
-    try {
-      await batch.commit();
-      Logger.info(
-        `[CalendarAdminService] Successfully updated calendar event statuses for appointment ${appointment.id}.`
+    if (appointment.patientId) {
+      const patientEventRef = this.db.doc(
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
       );
-    } catch (error) {
-      Logger.error(
-        `[CalendarAdminService] Error updating calendar event statuses for appointment ${appointment.id}:`,
-        error
+      batch.update(patientEventRef, {
+        status: newStatus,
+        updatedAt: serverTimestamp
+      });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added patient calendar event status update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing patient ID for appointment ${appointment.id}`
+      );
+    }
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = this.db.doc(
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      batch.update(clinicEventRef, {
+        status: newStatus,
+        updatedAt: serverTimestamp
+      });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added clinic calendar event status update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing clinic ID for appointment ${appointment.id}`
+      );
+    }
+    if (updatesAdded > 0) {
+      try {
+        await batch.commit();
+        Logger.info(
+          `[CalendarAdminService] Successfully updated ${updatesAdded} calendar event statuses for appointment ${appointment.id}.`
+        );
+      } catch (error) {
+        Logger.error(
+          `[CalendarAdminService] Error updating calendar event statuses for appointment ${appointment.id}:`,
+          error
+        );
+        throw error;
+      }
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] No calendar event status updates were made for appointment ${appointment.id}`
       );
     }
   }
@@ -2570,7 +2628,7 @@ var CalendarAdminService = class {
    * associated with a given appointment.
    *
    * @param appointment - The appointment object.
-   * @param newEventTime - The new CalendarEventTime object (using FirebaseClientTimestamp).
+   * @param newEventTime - The new CalendarEventTime object (using admin.firestore.Timestamp).
    * @returns {Promise<void>} A promise that resolves when all updates are attempted.
    */
   async updateAppointmentCalendarEventsTime(appointment, newEventTime) {
@@ -2579,28 +2637,85 @@ var CalendarAdminService = class {
     );
     const batch = this.db.batch();
     const serverTimestamp = admin8.firestore.FieldValue.serverTimestamp();
+    let updatesAdded = 0;
+    const calendarEventId = appointment.calendarEventId;
+    if (!calendarEventId) {
+      Logger.warn(
+        `[CalendarAdminService] Missing calendar event ID for appointment ${appointment.id}`
+      );
+      return;
+    }
     const firestoreCompatibleEventTime = {
-      start: TimestampUtils.clientToAdmin(newEventTime.start) || admin8.firestore.Timestamp.now(),
-      end: TimestampUtils.clientToAdmin(newEventTime.end) || admin8.firestore.Timestamp.now()
+      start: newEventTime.start,
+      end: newEventTime.end
     };
-    if (appointment.calendarEventId) {
+    if (appointment.practitionerId) {
       const practitionerEventRef = this.db.doc(
-        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${appointment.calendarEventId}`
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
       );
       batch.update(practitionerEventRef, {
         eventTime: firestoreCompatibleEventTime,
         updatedAt: serverTimestamp
       });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added practitioner calendar event time update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing practitioner ID for appointment ${appointment.id}`
+      );
     }
-    try {
-      await batch.commit();
-      Logger.info(
-        `[CalendarAdminService] Successfully updated calendar event times for appointment ${appointment.id}.`
+    if (appointment.patientId) {
+      const patientEventRef = this.db.doc(
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
       );
-    } catch (error) {
-      Logger.error(
-        `[CalendarAdminService] Error updating calendar event times for appointment ${appointment.id}:`,
-        error
+      batch.update(patientEventRef, {
+        eventTime: firestoreCompatibleEventTime,
+        updatedAt: serverTimestamp
+      });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added patient calendar event time update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing patient ID for appointment ${appointment.id}`
+      );
+    }
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = this.db.doc(
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      batch.update(clinicEventRef, {
+        eventTime: firestoreCompatibleEventTime,
+        updatedAt: serverTimestamp
+      });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added clinic calendar event time update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing clinic ID for appointment ${appointment.id}`
+      );
+    }
+    if (updatesAdded > 0) {
+      try {
+        await batch.commit();
+        Logger.info(
+          `[CalendarAdminService] Successfully updated ${updatesAdded} calendar event times for appointment ${appointment.id}.`
+        );
+      } catch (error) {
+        Logger.error(
+          `[CalendarAdminService] Error updating calendar event times for appointment ${appointment.id}:`,
+          error
+        );
+        throw error;
+      }
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] No calendar event time updates were made for appointment ${appointment.id}`
       );
     }
   }
@@ -2616,21 +2731,72 @@ var CalendarAdminService = class {
       `[CalendarAdminService] Deleting calendar events for appointment ${appointment.id}`
     );
     const batch = this.db.batch();
-    if (appointment.calendarEventId) {
+    let deletesAdded = 0;
+    const calendarEventId = appointment.calendarEventId;
+    if (!calendarEventId) {
+      Logger.warn(
+        `[CalendarAdminService] Missing calendar event ID for appointment ${appointment.id}`
+      );
+      return;
+    }
+    if (appointment.practitionerId) {
       const practitionerEventRef = this.db.doc(
-        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${appointment.calendarEventId}`
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
       );
       batch.delete(practitionerEventRef);
+      deletesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added practitioner calendar event deletion to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing practitioner ID for appointment ${appointment.id}`
+      );
     }
-    try {
-      await batch.commit();
-      Logger.info(
-        `[CalendarAdminService] Successfully deleted calendar events for appointment ${appointment.id}.`
+    if (appointment.patientId) {
+      const patientEventRef = this.db.doc(
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
       );
-    } catch (error) {
-      Logger.error(
-        `[CalendarAdminService] Error deleting calendar events for appointment ${appointment.id}:`,
-        error
+      batch.delete(patientEventRef);
+      deletesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added patient calendar event deletion to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing patient ID for appointment ${appointment.id}`
+      );
+    }
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = this.db.doc(
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      batch.delete(clinicEventRef);
+      deletesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added clinic calendar event deletion to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing clinic ID for appointment ${appointment.id}`
+      );
+    }
+    if (deletesAdded > 0) {
+      try {
+        await batch.commit();
+        Logger.info(
+          `[CalendarAdminService] Successfully deleted ${deletesAdded} calendar events for appointment ${appointment.id}.`
+        );
+      } catch (error) {
+        Logger.error(
+          `[CalendarAdminService] Error deleting calendar events for appointment ${appointment.id}:`,
+          error
+        );
+        throw error;
+      }
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] No calendar event deletions were made for appointment ${appointment.id}`
       );
     }
   }
@@ -2967,7 +3133,6 @@ var AppointmentAggregationService = class {
       `[AggService] Handling CREATE for appointment: ${appointment.id}, patient: ${appointment.patientId}, status: ${appointment.status}`
     );
     try {
-      await this.managePatientClinicPractitionerLinks(appointment, "create");
       const [
         patientProfile,
         patientSensitiveInfo,
@@ -2981,6 +3146,14 @@ var AppointmentAggregationService = class {
         this.fetchClinicInfo(appointment.clinicBranchId)
         // Needed for clinic admin notifications
       ]);
+      if (patientProfile) {
+        await this.managePatientClinicPractitionerLinks(
+          patientProfile,
+          appointment.practitionerId,
+          appointment.clinicBranchId,
+          "create"
+        );
+      }
       if (appointment.status === "confirmed" /* CONFIRMED */) {
         Logger.info(
           `[AggService] Appt ${appointment.id} created as CONFIRMED.`
@@ -3070,7 +3243,7 @@ var AppointmentAggregationService = class {
    * @returns {Promise<void>}
    */
   async handleAppointmentUpdate(before, after) {
-    var _a, _b;
+    var _a, _b, _c;
     Logger.info(
       `[AggService] Handling UPDATE for appointment: ${after.id}. Status ${before.status} -> ${after.status}`
     );
@@ -3095,6 +3268,10 @@ var AppointmentAggregationService = class {
         if (before.status === "pending" /* PENDING */ && after.status === "confirmed" /* CONFIRMED */) {
           Logger.info(`[AggService] Appt ${after.id} PENDING -> CONFIRMED.`);
           await this.createPreAppointmentRequirementInstances(after);
+          await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
+            after,
+            "confirmed" /* CONFIRMED */
+          );
           if ((patientSensitiveInfo == null ? void 0 : patientSensitiveInfo.email) && patientProfile) {
             Logger.info(
               `[AggService] Sending appointment confirmed email to patient ${patientSensitiveInfo.email}`
@@ -3134,7 +3311,53 @@ var AppointmentAggregationService = class {
             };
             await this.appointmentMailingService.sendAppointmentConfirmedEmail(
               practitionerEmailData
-              // TODO: Properly import PractitionerProfileInfo and ensure type compatibility
+            );
+          }
+        } else if (before.status === "rescheduled_by_clinic" /* RESCHEDULED_BY_CLINIC */ && after.status === "confirmed" /* CONFIRMED */) {
+          Logger.info(
+            `[AggService] Appt ${after.id} RESCHEDULED_BY_CLINIC -> CONFIRMED.`
+          );
+          await this.updateRelatedPatientRequirementInstances(
+            before,
+            "supersededReschedule" /* SUPERSEDED_RESCHEDULE */
+          );
+          await this.createPreAppointmentRequirementInstances(after);
+          await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
+            after,
+            "confirmed" /* CONFIRMED */
+          );
+          if ((patientSensitiveInfo == null ? void 0 : patientSensitiveInfo.email) && patientProfile) {
+            Logger.info(
+              `[AggService] Sending appointment confirmed email to patient ${patientSensitiveInfo.email}`
+            );
+            const emailData = {
+              appointment: after,
+              recipientProfile: after.patientInfo,
+              recipientRole: "patient"
+            };
+            await this.appointmentMailingService.sendAppointmentConfirmedEmail(
+              emailData
+            );
+          }
+          if ((patientProfile == null ? void 0 : patientProfile.expoTokens) && patientProfile.expoTokens.length > 0) {
+            await this.notificationsAdmin.sendAppointmentConfirmedPush(
+              after,
+              after.patientId,
+              patientProfile.expoTokens,
+              "patient" /* PATIENT */
+            );
+          }
+          if ((_b = practitionerProfile == null ? void 0 : practitionerProfile.basicInfo) == null ? void 0 : _b.email) {
+            Logger.info(
+              `[AggService] Sending appointment confirmation email to practitioner ${practitionerProfile.basicInfo.email}`
+            );
+            const practitionerEmailData = {
+              appointment: after,
+              recipientProfile: after.practitionerInfo,
+              recipientRole: "practitioner"
+            };
+            await this.appointmentMailingService.sendAppointmentConfirmedEmail(
+              practitionerEmailData
             );
           }
         } else if (after.status === "canceled_clinic" /* CANCELED_CLINIC */ || after.status === "canceled_patient" /* CANCELED_PATIENT */ || after.status === "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */ || after.status === "no_show" /* NO_SHOW */) {
@@ -3145,7 +3368,33 @@ var AppointmentAggregationService = class {
             after,
             "cancelledAppointment" /* CANCELLED_APPOINTMENT */
           );
-          await this.managePatientClinicPractitionerLinks(after, "cancel");
+          if (patientProfile) {
+            await this.managePatientClinicPractitionerLinks(
+              patientProfile,
+              after.practitionerId,
+              after.clinicBranchId,
+              "cancel",
+              after.status
+            );
+          }
+          const calendarStatus = (status) => {
+            switch (status) {
+              case "no_show" /* NO_SHOW */:
+                return "no_show" /* NO_SHOW */;
+              case "canceled_clinic" /* CANCELED_CLINIC */:
+                return "rejected" /* REJECTED */;
+              case "canceled_patient" /* CANCELED_PATIENT */:
+                return "canceled" /* CANCELED */;
+              case "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */:
+                return "rejected" /* REJECTED */;
+              default:
+                return "canceled" /* CANCELED */;
+            }
+          };
+          await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
+            after,
+            calendarStatus(after.status)
+          );
           if ((patientSensitiveInfo == null ? void 0 : patientSensitiveInfo.email) && patientProfile) {
             Logger.info(
               `[AggService] Sending appointment cancellation email to patient ${patientSensitiveInfo.email}`
@@ -3161,7 +3410,7 @@ var AppointmentAggregationService = class {
               // TODO: Properly import types
             );
           }
-          if ((_b = practitionerProfile == null ? void 0 : practitionerProfile.basicInfo) == null ? void 0 : _b.email) {
+          if ((_c = practitionerProfile == null ? void 0 : practitionerProfile.basicInfo) == null ? void 0 : _c.email) {
             Logger.info(
               `[AggService] Sending appointment cancellation email to practitioner ${practitionerProfile.basicInfo.email}`
             );
@@ -3179,6 +3428,10 @@ var AppointmentAggregationService = class {
         } else if (after.status === "completed" /* COMPLETED */) {
           Logger.info(`[AggService] Appt ${after.id} status -> COMPLETED.`);
           await this.createPostAppointmentRequirementInstances(after);
+          await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
+            after,
+            "completed" /* COMPLETED */
+          );
           if ((patientSensitiveInfo == null ? void 0 : patientSensitiveInfo.email) && patientProfile) {
             Logger.info(
               `[AggService] Sending review request email to patient ${patientSensitiveInfo.email}`
@@ -3203,8 +3456,16 @@ var AppointmentAggregationService = class {
             // Pass the 'before' state for old requirements
             "supersededReschedule" /* SUPERSEDED_RESCHEDULE */
           );
-          Logger.info(
-            `[AggService] TODO: Handle RESCHEDULE logic for requirements carefully based on confirmation flow.`
+          await this.calendarAdminService.updateAppointmentCalendarEventsTime(
+            after,
+            {
+              start: after.appointmentStartTime,
+              end: after.appointmentEndTime
+            }
+          );
+          await this.calendarAdminService.updateAppointmentCalendarEventsStatus(
+            after,
+            "pending" /* PENDING */
           );
           if ((patientSensitiveInfo == null ? void 0 : patientSensitiveInfo.email) && patientProfile) {
             Logger.info(
@@ -3229,9 +3490,24 @@ var AppointmentAggregationService = class {
       }
       if (timeChanged && !statusChanged) {
         Logger.info(`[AggService] Appointment ${after.id} time changed.`);
-        Logger.warn(
-          `[AggService] Independent time change detected for ${after.id}. Review implications for requirements and calendar.`
-        );
+        if (after.status === "confirmed" /* CONFIRMED */) {
+          await this.updateRelatedPatientRequirementInstances(
+            before,
+            "supersededReschedule" /* SUPERSEDED_RESCHEDULE */
+          );
+          await this.createPreAppointmentRequirementInstances(after);
+          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.`
+          );
+        }
       }
       Logger.info(
         `[AggService] Successfully processed UPDATE for appointment: ${after.id}`
@@ -3256,9 +3532,19 @@ var AppointmentAggregationService = class {
       deletedAppointment,
       "cancelledAppointment" /* CANCELLED_APPOINTMENT */
     );
-    await this.managePatientClinicPractitionerLinks(
-      deletedAppointment,
-      "cancel"
+    const patientProfile = await this.fetchPatientProfile(
+      deletedAppointment.patientId
+    );
+    if (patientProfile) {
+      await this.managePatientClinicPractitionerLinks(
+        patientProfile,
+        deletedAppointment.practitionerId,
+        deletedAppointment.clinicBranchId,
+        "cancel"
+      );
+    }
+    await this.calendarAdminService.deleteAppointmentCalendarEvents(
+      deletedAppointment
     );
   }
   // --- Helper Methods for Aggregation Logic ---
@@ -3539,18 +3825,47 @@ var AppointmentAggregationService = class {
     try {
       const batch = this.db.batch();
       let instancesCreatedCount = 0;
+      let createdInstances = [];
+      Logger.info(
+        `[AggService] Found ${appointment.postProcedureRequirements.length} post-requirements to process: ${JSON.stringify(
+          appointment.postProcedureRequirements.map((r) => {
+            var _a2, _b;
+            return {
+              id: r.id,
+              name: r.name,
+              type: r.type,
+              isActive: r.isActive,
+              hasTimeframe: !!r.timeframe,
+              notifyAtLength: ((_b = (_a2 = r.timeframe) == null ? void 0 : _a2.notifyAt) == null ? void 0 : _b.length) || 0
+            };
+          })
+        )}`
+      );
       for (const template of appointment.postProcedureRequirements) {
-        if (!template) continue;
+        if (!template) {
+          Logger.warn(
+            `[AggService] Found null/undefined template in postProcedureRequirements array`
+          );
+          continue;
+        }
         if (template.type !== "post" /* POST */ || !template.isActive) {
           Logger.debug(
             `[AggService] Skipping template ${template.id} (${template.name}): not an active POST requirement.`
           );
           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();
+        Logger.debug(
+          `[AggService] Created doc reference: ${newInstanceRef.path}`
+        );
         const instructions = (((_a = template.timeframe) == null ? void 0 : _a.notifyAt) || []).map((notifyAtValue) => {
           let dueTime = appointment.appointmentEndTime;
           if (template.timeframe && typeof notifyAtValue === "number") {
@@ -3565,7 +3880,7 @@ var AppointmentAggregationService = class {
             dueTime = admin10.firestore.Timestamp.fromDate(dueDateTime);
           }
           const actionableWindowHours = template.importance === "high" ? 1 : template.importance === "medium" ? 4 : 15;
-          return {
+          const instructionObject = {
             instructionId: `${template.id}_${notifyAtValue}_${newInstanceRef.id}`.replace(
               /[^a-zA-Z0-9_]/g,
               "_"
@@ -3577,36 +3892,142 @@ var AppointmentAggregationService = class {
             originalNotifyAtValue: notifyAtValue,
             originalTimeframeUnit: template.timeframe.unit,
             updatedAt: admin10.firestore.Timestamp.now(),
-            // Use current server timestamp
             notificationId: void 0,
             actionTakenAt: void 0
           };
+          return instructionObject;
         });
         const newInstanceData = {
+          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
           requirementImportance: template.importance,
           overallStatus: "active" /* ACTIVE */,
           instructions,
           createdAt: admin10.firestore.FieldValue.serverTimestamp(),
           updatedAt: admin10.firestore.FieldValue.serverTimestamp()
         };
+        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);
+        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}.`
+          );
+          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...`
+              );
+              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
+          );
+          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}.`
@@ -3617,6 +4038,7 @@ var AppointmentAggregationService = class {
         `[AggService] Error creating POST_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
         error
       );
+      throw error;
     }
   }
   /**
@@ -3682,75 +4104,165 @@ var AppointmentAggregationService = class {
     }
   }
   /**
-   * 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.
    */
-  async managePatientClinicPractitionerLinks(appointment, action) {
+  async managePatientClinicPractitionerLinks(patientProfile, practitionerId, clinicId, action, cancelStatus) {
     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;
-    const practitionerRef = this.db.collection(PRACTITIONERS_COLLECTION).doc(appointment.practitionerId);
-    const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(appointment.clinicBranchId);
-    if (action === "create") {
-      batch.update(practitionerRef, {
-        patientIds: admin10.firestore.FieldValue.arrayUnion(patientId),
-        // Optionally, update a count or last interaction timestamp
-        updatedAt: admin10.firestore.FieldValue.serverTimestamp()
-      });
-      Logger.debug(
-        `[AggService] Adding patient ${patientId} to practitioner ${appointment.practitionerId} patientIds.`
-      );
-      batch.update(clinicRef, {
-        patientIds: admin10.firestore.FieldValue.arrayUnion(patientId),
-        updatedAt: admin10.firestore.FieldValue.serverTimestamp()
-      });
-      Logger.debug(
-        `[AggService] Adding patient ${patientId} to clinic ${appointment.clinicBranchId} patientIds.`
-      );
-    } else if (action === "cancel") {
-      batch.update(practitionerRef, {
-        patientIds: admin10.firestore.FieldValue.arrayRemove(patientId),
-        updatedAt: admin10.firestore.FieldValue.serverTimestamp()
-      });
-      Logger.debug(
-        `[AggService] Removing patient ${patientId} from practitioner ${appointment.practitionerId} patientIds.`
-      );
-      batch.update(clinicRef, {
-        patientIds: admin10.firestore.FieldValue.arrayRemove(patientId),
-        updatedAt: admin10.firestore.FieldValue.serverTimestamp()
-      });
-      Logger.debug(
-        `[AggService] Removing patient ${patientId} from clinic ${appointment.clinicBranchId} 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.
+   */
+  async addPatientLinks(patientProfile, practitionerId, clinicId) {
+    var _a, _b;
+    try {
+      const hasDoctor = ((_a = patientProfile.doctorIds) == null ? void 0 : _a.includes(practitionerId)) || false;
+      const hasClinic = ((_b = patientProfile.clinicIds) == null ? void 0 : _b.includes(clinicId)) || false;
+      if (!hasDoctor || !hasClinic) {
+        const patientRef = this.db.collection(PATIENTS_COLLECTION).doc(patientProfile.id);
+        const updateData = {
+          updatedAt: admin10.firestore.FieldValue.serverTimestamp()
+        };
+        if (!hasDoctor) {
+          Logger.debug(
+            `[AggService] Adding practitioner ${practitionerId} to patient ${patientProfile.id}`
+          );
+          updateData.doctorIds = admin10.firestore.FieldValue.arrayUnion(practitionerId);
+        }
+        if (!hasClinic) {
+          Logger.debug(
+            `[AggService] Adding clinic ${clinicId} to patient ${patientProfile.id}`
+          );
+          updateData.clinicIds = admin10.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.
+   */
+  async removePatientLinksIfNoActiveAppointments(patientProfile, practitionerId, clinicId) {
+    var _a, _b;
     try {
-      await batch.commit();
+      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}`
       );
+      const patientRef = this.db.collection(PATIENTS_COLLECTION).doc(patientProfile.id);
+      const updateData = {};
+      let updateNeeded = false;
+      if (activePractitionerAppointments === 0 && ((_a = patientProfile.doctorIds) == null ? void 0 : _a.includes(practitionerId))) {
+        Logger.debug(
+          `[AggService] Removing practitioner ${practitionerId} from patient ${patientProfile.id}`
+        );
+        updateData.doctorIds = admin10.firestore.FieldValue.arrayRemove(practitionerId);
+        updateNeeded = true;
+      }
+      if (activeClinicAppointments === 0 && ((_b = patientProfile.clinicIds) == null ? void 0 : _b.includes(clinicId))) {
+        Logger.debug(
+          `[AggService] Removing clinic ${clinicId} from patient ${patientProfile.id}`
+        );
+        updateData.clinicIds = admin10.firestore.FieldValue.arrayRemove(clinicId);
+        updateNeeded = true;
+      }
+      if (updateNeeded) {
+        updateData.updatedAt = admin10.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.
+   */
+  async checkActiveAppointments(patientId, entityField, entityId) {
+    try {
+      const inactiveStatuses = [
+        "canceled_clinic" /* CANCELED_CLINIC */,
+        "canceled_patient" /* CANCELED_PATIENT */,
+        "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */,
+        "no_show" /* 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;
     }
   }
   // --- Data Fetching Helpers (Consider moving to a data access layer or using existing services if available) ---