@blackcode_sa/metaestetics-api 1.5.28 → 1.5.29

package/dist/admin/index.mjs

@@ -20,9 +20,9 @@ var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
 import * as admin from "firebase-admin";
 import { Expo } from "expo-server-sdk";
 var NotificationsAdmin = class {
-  constructor(firestore2) {
+  constructor(firestore6) {
     this.expo = new Expo();
-    this.db = firestore2 || admin.firestore();
+    this.db = firestore6 || admin.firestore();
   }
   /**
    * Dohvata notifikaciju po ID-u
@@ -186,6 +186,1330 @@ var NotificationsAdmin = class {
   }
 };
 
+// src/admin/aggregation/clinic/clinic.aggregation.service.ts
+import * as admin2 from "firebase-admin";
+
+// src/types/practitioner/index.ts
+var PRACTITIONERS_COLLECTION = "practitioners";
+
+// src/types/procedure/index.ts
+var PROCEDURES_COLLECTION = "procedures";
+
+// src/types/clinic/index.ts
+var CLINIC_GROUPS_COLLECTION = "clinic_groups";
+var CLINICS_COLLECTION = "clinics";
+
+// src/types/patient/index.ts
+var PATIENTS_COLLECTION = "patients";
+
+// src/admin/aggregation/clinic/clinic.aggregation.service.ts
+var CALENDAR_SUBCOLLECTION_ID = "calendar";
+var ClinicAggregationService = class {
+  /**
+   * Constructor for ClinicAggregationService.
+   * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
+   */
+  constructor(firestore6) {
+    this.db = firestore6 || admin2.firestore();
+  }
+  /**
+   * Adds clinic information to a clinic group when a new clinic is created
+   * @param clinicGroupId - ID of the parent clinic group
+   * @param clinicInfo - The clinic information to add to the group
+   * @returns {Promise<void>}
+   * @throws Will throw an error if the batch write fails
+   */
+  async addClinicToClinicGroup(clinicGroupId, clinicInfo) {
+    if (!clinicGroupId) {
+      console.log(
+        "[ClinicAggregationService] No Clinic Group ID provided for clinic addition. Skipping."
+      );
+      return;
+    }
+    const clinicId = clinicInfo.id;
+    const groupRef = this.db.collection(CLINIC_GROUPS_COLLECTION).doc(clinicGroupId);
+    console.log(
+      `[ClinicAggregationService] Adding ClinicInfo (ID: ${clinicId}) to Clinic Group ${clinicGroupId}.`
+    );
+    try {
+      await groupRef.update({
+        clinicsInfo: admin2.firestore.FieldValue.arrayUnion(clinicInfo),
+        clinicIds: admin2.firestore.FieldValue.arrayUnion(clinicId),
+        updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+      });
+      console.log(
+        `[ClinicAggregationService] Successfully added ClinicInfo (ID: ${clinicId}) to Clinic Group ${clinicGroupId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error adding ClinicInfo (ID: ${clinicId}) to Clinic Group ${clinicGroupId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates the ClinicInfo within the clinicsInfo array for multiple practitioners.
+   * This method is designed to be called when a clinic's core information changes.
+   * @param practitionerIds - IDs of practitioners associated with the clinic.
+   * @param clinicInfo - The updated ClinicInfo object to aggregate.
+   * @returns {Promise<void>}
+   * @throws Will throw an error if the batch write fails.
+   */
+  async updateClinicInfoInPractitioners(practitionerIds, clinicInfo) {
+    if (!practitionerIds || practitionerIds.length === 0) {
+      console.log(
+        "[ClinicAggregationService] No practitioner IDs provided for clinic info update. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    const clinicId = clinicInfo.id;
+    console.log(
+      `[ClinicAggregationService] Starting batch update of ClinicInfo (ID: ${clinicId}) in ${practitionerIds.length} practitioners.`
+    );
+    for (const practitionerId of practitionerIds) {
+      const practitionerRef = this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId);
+      batch.update(practitionerRef, {
+        clinicsInfo: admin2.firestore.FieldValue.arrayRemove({ id: clinicId }),
+        updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+      });
+      batch.update(practitionerRef, {
+        clinicsInfo: admin2.firestore.FieldValue.arrayUnion(clinicInfo),
+        updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[ClinicAggregationService] Successfully updated ClinicInfo (ID: ${clinicId}) in ${practitionerIds.length} practitioners.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error committing batch update for ClinicInfo (ID: ${clinicId}) in practitioners:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates the aggregated clinicInfo field within relevant Procedure documents.
+   * @param procedureIds IDs of procedures performed at the clinic.
+   * @param clinicInfo The updated ClinicInfo object.
+   */
+  async updateClinicInfoInProcedures(procedureIds, clinicInfo) {
+    if (!procedureIds || procedureIds.length === 0) {
+      console.log(
+        "[ClinicAggregationService] No procedure IDs provided for clinic info update. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    const clinicId = clinicInfo.id;
+    console.log(
+      `[ClinicAggregationService] Starting batch update of clinicInfo field (for Clinic ID: ${clinicId}) in ${procedureIds.length} procedures.`
+    );
+    for (const procedureId of procedureIds) {
+      const procedureRef = this.db.collection(PROCEDURES_COLLECTION).doc(procedureId);
+      batch.update(procedureRef, {
+        clinicInfo,
+        updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[ClinicAggregationService] Successfully updated clinicInfo field in ${procedureIds.length} procedures for clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error committing batch update for clinicInfo field in procedures (Clinic ID: ${clinicId}):`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates the aggregated clinicsInfo array within the parent ClinicGroup document.
+   * @param clinicGroupId The ID of the parent clinic group.
+   * @param clinicInfo The updated ClinicInfo object.
+   */
+  async updateClinicInfoInClinicGroup(clinicGroupId, clinicInfo) {
+    if (!clinicGroupId) {
+      console.log(
+        "[ClinicAggregationService] No Clinic Group ID provided for clinic info update. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    const clinicId = clinicInfo.id;
+    const groupRef = this.db.collection(CLINIC_GROUPS_COLLECTION).doc(clinicGroupId);
+    console.log(
+      `[ClinicAggregationService] Starting update of ClinicInfo (ID: ${clinicId}) in Clinic Group ${clinicGroupId}.`
+    );
+    batch.update(groupRef, {
+      clinicsInfo: admin2.firestore.FieldValue.arrayRemove({ id: clinicId }),
+      updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+    });
+    batch.update(groupRef, {
+      clinicsInfo: admin2.firestore.FieldValue.arrayUnion(clinicInfo),
+      updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+    });
+    try {
+      await batch.commit();
+      console.log(
+        `[ClinicAggregationService] Successfully updated ClinicInfo (ID: ${clinicId}) in Clinic Group ${clinicGroupId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error committing update for ClinicInfo (ID: ${clinicId}) in Clinic Group ${clinicGroupId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates relevant clinic information within Patient documents.
+   * NOTE: PatientProfile stores an array of PatientClinic objects, which only contain
+   * clinicId, assignedAt, assignedBy, isActive, notes. It does *not* store aggregated
+   * ClinicInfo (like name, photo). Therefore, this method currently has limited use
+   * for general clinic info updates. It might be relevant if Clinic.isActive status changes.
+   *
+   * @param patientIds IDs of patients associated with the clinic (e.g., from PatientProfile.clinicIds).
+   * @param clinicInfo The updated ClinicInfo object (primarily for logging/context).
+   * @param clinicIsActive The current active status of the updated clinic.
+   */
+  async updateClinicInfoInPatients(patientIds, clinicInfo, clinicIsActive) {
+    if (!patientIds || patientIds.length === 0) {
+      console.log(
+        "[ClinicAggregationService] No patient IDs provided for clinic info update. Skipping."
+      );
+      return;
+    }
+    const clinicId = clinicInfo.id;
+    console.warn(
+      `[ClinicAggregationService] updateClinicInfoInPatients called for clinic ${clinicId}. Current PatientProfile structure doesn't store full ClinicInfo per patient clinic entry. Consider specific logic if Clinic active status changes or if structure evolves. No direct patient updates performed by this method for info changes. Clinic isActive: ${clinicIsActive}`,
+      { patientIds, clinicInfo }
+    );
+  }
+  /**
+   * Updates the eventLocation for upcoming calendar events associated with a specific clinic.
+   * Uses a collection group query to find relevant events across all potential parent collections.
+   *
+   * @param clinicId The ID of the clinic whose location might have changed.
+   * @param newLocation The new ClinicLocation object.
+   */
+  async updateClinicLocationInCalendarEvents(clinicId, newLocation) {
+    if (!clinicId || !newLocation) {
+      console.log(
+        "[ClinicAggregationService] Missing clinicId or newLocation for calendar update. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[ClinicAggregationService] Querying upcoming calendar events via collection group '${CALENDAR_SUBCOLLECTION_ID}' for clinic ${clinicId} to update location.`
+    );
+    const now = admin2.firestore.Timestamp.now();
+    const calendarEventsQuery = this.db.collectionGroup(CALENDAR_SUBCOLLECTION_ID).where("clinicBranchId", "==", clinicId).where("eventTime.start", ">", now);
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[ClinicAggregationService] No upcoming calendar events found via collection group for clinic ${clinicId}. No location updates needed.`
+        );
+        return;
+      }
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[ClinicAggregationService] Updating location for calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          eventLocation: newLocation,
+          updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      await batch.commit();
+      console.log(
+        `[ClinicAggregationService] Successfully updated location in ${snapshot.size} upcoming calendar events via collection group for clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error updating location in calendar events via collection group for clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates clinic info in all upcoming calendar events associated with a specific clinic.
+   * @param clinicId The ID of the clinic whose info has been updated.
+   * @param clinicInfo The updated ClinicInfo object.
+   */
+  async updateClinicInfoInCalendarEvents(clinicId, clinicInfo) {
+    if (!clinicId || !clinicInfo) {
+      console.log(
+        "[ClinicAggregationService] Missing clinicId or clinicInfo for calendar update. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[ClinicAggregationService] Querying upcoming calendar events for clinic ${clinicId} to update clinic info.`
+    );
+    const now = admin2.firestore.Timestamp.now();
+    const calendarEventsQuery = this.db.collectionGroup(CALENDAR_SUBCOLLECTION_ID).where("clinicBranchId", "==", clinicId).where("eventTime.start", ">", now);
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[ClinicAggregationService] No upcoming calendar events found for clinic ${clinicId}. No clinic info updates needed.`
+        );
+        return;
+      }
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[ClinicAggregationService] Updating clinic info for calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          clinicInfo,
+          updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      await batch.commit();
+      console.log(
+        `[ClinicAggregationService] Successfully updated clinic info in ${snapshot.size} upcoming calendar events for clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error updating clinic info in calendar events for clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Removes clinic from practitioners when a clinic is deleted.
+   * @param practitionerIds IDs of practitioners associated with the clinic.
+   * @param clinicId The ID of the deleted clinic.
+   */
+  async removeClinicFromPractitioners(practitionerIds, clinicId) {
+    if (!practitionerIds || practitionerIds.length === 0) {
+      console.log(
+        "[ClinicAggregationService] No practitioner IDs provided for clinic removal. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    console.log(
+      `[ClinicAggregationService] Starting batch removal of Clinic (ID: ${clinicId}) from ${practitionerIds.length} practitioners.`
+    );
+    for (const practitionerId of practitionerIds) {
+      const practitionerRef = this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId);
+      batch.update(practitionerRef, {
+        clinicIds: admin2.firestore.FieldValue.arrayRemove(clinicId),
+        // Remove all clinic info objects where id matches the clinic ID
+        clinicsInfo: admin2.firestore.FieldValue.arrayRemove({ id: clinicId }),
+        updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[ClinicAggregationService] Successfully removed Clinic (ID: ${clinicId}) from ${practitionerIds.length} practitioners.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error committing batch removal for Clinic (ID: ${clinicId}) from practitioners:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Inactivates all procedures associated with a deleted clinic
+   * @param procedureIds IDs of procedures associated with the clinic
+   */
+  async inactivateProceduresForClinic(procedureIds) {
+    if (!procedureIds || procedureIds.length === 0) {
+      console.log(
+        "[ClinicAggregationService] No procedure IDs provided for inactivation. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    console.log(
+      `[ClinicAggregationService] Starting inactivation of ${procedureIds.length} procedures.`
+    );
+    for (const procedureId of procedureIds) {
+      const procedureRef = this.db.collection(PROCEDURES_COLLECTION).doc(procedureId);
+      batch.update(procedureRef, {
+        isActive: false,
+        updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[ClinicAggregationService] Successfully inactivated ${procedureIds.length} procedures.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error committing batch inactivation of procedures:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Removes clinic from clinic group when a clinic is deleted
+   * @param clinicGroupId ID of the parent clinic group
+   * @param clinicId ID of the deleted clinic
+   */
+  async removeClinicFromClinicGroup(clinicGroupId, clinicId) {
+    if (!clinicGroupId) {
+      console.log(
+        "[ClinicAggregationService] No Clinic Group ID provided for clinic removal. Skipping."
+      );
+      return;
+    }
+    const groupRef = this.db.collection(CLINIC_GROUPS_COLLECTION).doc(clinicGroupId);
+    console.log(
+      `[ClinicAggregationService] Removing Clinic (ID: ${clinicId}) from Clinic Group ${clinicGroupId}.`
+    );
+    try {
+      await groupRef.update({
+        clinicIds: admin2.firestore.FieldValue.arrayRemove(clinicId),
+        // Remove all clinic info objects where id matches the clinic ID
+        clinicsInfo: admin2.firestore.FieldValue.arrayRemove({ id: clinicId }),
+        updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+      });
+      console.log(
+        `[ClinicAggregationService] Successfully removed Clinic (ID: ${clinicId}) from Clinic Group ${clinicGroupId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error removing Clinic (ID: ${clinicId}) from Clinic Group ${clinicGroupId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Removes clinic from patients when a clinic is deleted
+   * @param patientIds IDs of patients associated with the clinic
+   * @param clinicId ID of the deleted clinic
+   */
+  async removeClinicFromPatients(patientIds, clinicId) {
+    if (!patientIds || patientIds.length === 0) {
+      console.log(
+        "[ClinicAggregationService] No patient IDs provided for clinic removal. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    console.log(
+      `[ClinicAggregationService] Starting batch removal of Clinic (ID: ${clinicId}) from ${patientIds.length} patients.`
+    );
+    for (const patientId of patientIds) {
+      const patientRef = this.db.collection(PATIENTS_COLLECTION).doc(patientId);
+      batch.update(patientRef, {
+        clinicIds: admin2.firestore.FieldValue.arrayRemove(clinicId),
+        updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[ClinicAggregationService] Successfully removed Clinic (ID: ${clinicId}) from ${patientIds.length} patients.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error committing batch removal for Clinic (ID: ${clinicId}) from patients:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Cancels all upcoming calendar events associated with a deleted clinic
+   * @param clinicId ID of the deleted clinic
+   */
+  async cancelUpcomingCalendarEventsForClinic(clinicId) {
+    if (!clinicId) {
+      console.log(
+        "[ClinicAggregationService] No clinic ID provided for canceling calendar events. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[ClinicAggregationService] Querying upcoming calendar events for clinic ${clinicId} to cancel.`
+    );
+    const now = admin2.firestore.Timestamp.now();
+    const calendarEventsQuery = this.db.collectionGroup(CALENDAR_SUBCOLLECTION_ID).where("clinicBranchId", "==", clinicId).where("eventTime.start", ">", now);
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[ClinicAggregationService] No upcoming calendar events found for clinic ${clinicId}. No events to cancel.`
+        );
+        return;
+      }
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[ClinicAggregationService] Canceling calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          status: "CANCELED",
+          cancelReason: "Clinic deleted",
+          updatedAt: admin2.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      await batch.commit();
+      console.log(
+        `[ClinicAggregationService] Successfully canceled ${snapshot.size} upcoming calendar events for clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ClinicAggregationService] Error canceling calendar events for clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+};
+
+// src/admin/aggregation/practitioner/practitioner.aggregation.service.ts
+import * as admin3 from "firebase-admin";
+var CALENDAR_SUBCOLLECTION_ID2 = "calendar";
+var PractitionerAggregationService = class {
+  constructor(firestore6) {
+    this.db = firestore6 || admin3.firestore();
+  }
+  /**
+   * Adds practitioner information to a clinic when a new practitioner is created
+   * @param clinicId - ID of the clinic to update
+   * @param doctorInfo - Doctor information to add to the clinic
+   * @returns {Promise<void>}
+   */
+  async addPractitionerToClinic(clinicId, doctorInfo) {
+    if (!clinicId || !doctorInfo) {
+      console.log(
+        "[PractitionerAggregationService] Missing clinicId or doctorInfo for adding practitioner to clinic. Skipping."
+      );
+      return;
+    }
+    const practitionerId = doctorInfo.id;
+    console.log(
+      `[PractitionerAggregationService] Adding practitioner ${practitionerId} to clinic ${clinicId}.`
+    );
+    const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+    try {
+      await clinicRef.update({
+        doctors: admin3.firestore.FieldValue.arrayUnion(practitionerId),
+        doctorsInfo: admin3.firestore.FieldValue.arrayUnion(doctorInfo),
+        updatedAt: admin3.firestore.FieldValue.serverTimestamp()
+      });
+      console.log(
+        `[PractitionerAggregationService] Successfully added practitioner ${practitionerId} to clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error adding practitioner ${practitionerId} to clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates practitioner information in associated clinics
+   * @param clinicIds - IDs of clinics associated with the practitioner
+   * @param doctorInfo - Updated doctor information
+   * @returns {Promise<void>}
+   */
+  async updatePractitionerInfoInClinics(clinicIds, doctorInfo) {
+    if (!clinicIds || clinicIds.length === 0 || !doctorInfo) {
+      console.log(
+        "[PractitionerAggregationService] Missing clinicIds or doctorInfo for updating practitioner in clinics. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    const practitionerId = doctorInfo.id;
+    console.log(
+      `[PractitionerAggregationService] Starting batch update of practitioner ${practitionerId} in ${clinicIds.length} clinics.`
+    );
+    for (const clinicId of clinicIds) {
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+      batch.update(clinicRef, {
+        doctorsInfo: admin3.firestore.FieldValue.arrayRemove({
+          id: practitionerId
+        }),
+        updatedAt: admin3.firestore.FieldValue.serverTimestamp()
+      });
+      batch.update(clinicRef, {
+        doctorsInfo: admin3.firestore.FieldValue.arrayUnion(doctorInfo),
+        updatedAt: admin3.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully updated practitioner ${practitionerId} info in ${clinicIds.length} clinics.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error updating practitioner ${practitionerId} info in clinics:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates practitioner information in associated procedures
+   * @param procedureIds - IDs of procedures associated with the practitioner
+   * @param doctorInfo - Updated doctor information
+   * @returns {Promise<void>}
+   */
+  async updatePractitionerInfoInProcedures(procedureIds, doctorInfo) {
+    if (!procedureIds || procedureIds.length === 0 || !doctorInfo) {
+      console.log(
+        "[PractitionerAggregationService] Missing procedureIds or doctorInfo for updating practitioner in procedures. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    const practitionerId = doctorInfo.id;
+    console.log(
+      `[PractitionerAggregationService] Starting batch update of practitioner ${practitionerId} in ${procedureIds.length} procedures.`
+    );
+    for (const procedureId of procedureIds) {
+      const procedureRef = this.db.collection(PROCEDURES_COLLECTION).doc(procedureId);
+      batch.update(procedureRef, {
+        doctorInfo,
+        updatedAt: admin3.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully updated practitioner ${practitionerId} info in ${procedureIds.length} procedures.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error updating practitioner ${practitionerId} info in procedures:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates practitioner information in calendar events
+   * @param practitionerId - ID of the practitioner
+   * @param practitionerInfo - Updated practitioner information
+   * @returns {Promise<void>}
+   */
+  async updatePractitionerInfoInCalendarEvents(practitionerId, practitionerInfo) {
+    if (!practitionerId || !practitionerInfo) {
+      console.log(
+        "[PractitionerAggregationService] Missing practitionerId or practitionerInfo for calendar update. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[PractitionerAggregationService] Querying upcoming calendar events for practitioner ${practitionerId} to update practitioner info.`
+    );
+    const now = admin3.firestore.Timestamp.now();
+    const calendarEventsQuery = this.db.collectionGroup(CALENDAR_SUBCOLLECTION_ID2).where("practitionerId", "==", practitionerId).where("eventTime.start", ">", now);
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[PractitionerAggregationService] No upcoming calendar events found for practitioner ${practitionerId}. No doctor info updates needed.`
+        );
+        return;
+      }
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[PractitionerAggregationService] Updating practitioner info for calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          practitionerInfo,
+          updatedAt: admin3.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully updated practitioner info in ${snapshot.size} upcoming calendar events for practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error updating practitioner info in calendar events for practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Removes practitioner from clinics when a practitioner is deleted
+   * @param clinicIds - IDs of clinics associated with the practitioner
+   * @param practitionerId - ID of the deleted practitioner
+   * @returns {Promise<void>}
+   */
+  async removePractitionerFromClinics(clinicIds, practitionerId) {
+    if (!clinicIds || clinicIds.length === 0 || !practitionerId) {
+      console.log(
+        "[PractitionerAggregationService] Missing clinicIds or practitionerId for removing practitioner from clinics. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    console.log(
+      `[PractitionerAggregationService] Starting batch removal of practitioner ${practitionerId} from ${clinicIds.length} clinics.`
+    );
+    for (const clinicId of clinicIds) {
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+      batch.update(clinicRef, {
+        doctors: admin3.firestore.FieldValue.arrayRemove(practitionerId),
+        // Remove all doctor info objects where id matches the practitioner ID
+        doctorsInfo: admin3.firestore.FieldValue.arrayRemove({
+          id: practitionerId
+        }),
+        updatedAt: admin3.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully removed practitioner ${practitionerId} from ${clinicIds.length} clinics.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error removing practitioner ${practitionerId} from clinics:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Cancels all upcoming calendar events for a deleted practitioner
+   * @param practitionerId - ID of the deleted practitioner
+   * @returns {Promise<void>}
+   */
+  async cancelUpcomingCalendarEventsForPractitioner(practitionerId) {
+    if (!practitionerId) {
+      console.log(
+        "[PractitionerAggregationService] Missing practitionerId for canceling calendar events. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[PractitionerAggregationService] Querying upcoming calendar events for practitioner ${practitionerId} to cancel.`
+    );
+    const now = admin3.firestore.Timestamp.now();
+    const calendarEventsQuery = this.db.collectionGroup(CALENDAR_SUBCOLLECTION_ID2).where("practitionerId", "==", practitionerId).where("eventTime.start", ">", now);
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[PractitionerAggregationService] No upcoming calendar events found for practitioner ${practitionerId}. No events to cancel.`
+        );
+        return;
+      }
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[PractitionerAggregationService] Canceling calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          status: "CANCELED",
+          cancelReason: "Practitioner deleted",
+          updatedAt: admin3.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully canceled ${snapshot.size} upcoming calendar events for practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error canceling calendar events for practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Removes practitioner from patients when a practitioner is deleted
+   * @param patientIds - IDs of patients associated with the practitioner
+   * @param practitionerId - ID of the deleted practitioner
+   * @returns {Promise<void>}
+   */
+  async removePractitionerFromPatients(patientIds, practitionerId) {
+    if (!patientIds || patientIds.length === 0 || !practitionerId) {
+      console.log(
+        "[PractitionerAggregationService] Missing patientIds or practitionerId for removing practitioner from patients. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    console.log(
+      `[PractitionerAggregationService] Starting batch removal of practitioner ${practitionerId} from ${patientIds.length} patients.`
+    );
+    for (const patientId of patientIds) {
+      const patientRef = this.db.collection(PATIENTS_COLLECTION).doc(patientId);
+      batch.update(patientRef, {
+        doctorIds: admin3.firestore.FieldValue.arrayRemove(practitionerId),
+        updatedAt: admin3.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully removed practitioner ${practitionerId} from ${patientIds.length} patients.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error removing practitioner ${practitionerId} from patients:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Inactivates all procedures associated with a deleted practitioner
+   * @param procedureIds - IDs of procedures provided by the practitioner
+   * @returns {Promise<void>}
+   */
+  async inactivateProceduresForPractitioner(procedureIds) {
+    if (!procedureIds || procedureIds.length === 0) {
+      console.log(
+        "[PractitionerAggregationService] No procedure IDs provided for inactivation. Skipping."
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    console.log(
+      `[PractitionerAggregationService] Starting inactivation of ${procedureIds.length} procedures.`
+    );
+    for (const procedureId of procedureIds) {
+      const procedureRef = this.db.collection(PROCEDURES_COLLECTION).doc(procedureId);
+      batch.update(procedureRef, {
+        isActive: false,
+        updatedAt: admin3.firestore.FieldValue.serverTimestamp()
+      });
+    }
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully inactivated ${procedureIds.length} procedures.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error committing batch inactivation of procedures:`,
+        error
+      );
+      throw error;
+    }
+  }
+};
+
+// src/admin/aggregation/procedure/procedure.aggregation.service.ts
+import * as admin4 from "firebase-admin";
+var CALENDAR_SUBCOLLECTION_ID3 = "calendar";
+var ProcedureAggregationService = class {
+  constructor(firestore6) {
+    this.db = firestore6 || admin4.firestore();
+  }
+  /**
+   * Adds procedure information to a practitioner when a new procedure is created
+   * @param practitionerId - ID of the practitioner who performs the procedure
+   * @param procedureSummary - Summary information about the procedure
+   * @returns {Promise<void>}
+   */
+  async addProcedureToPractitioner(practitionerId, procedureSummary) {
+    if (!practitionerId || !procedureSummary) {
+      console.log(
+        "[ProcedureAggregationService] Missing practitionerId or procedureSummary for adding procedure to practitioner. Skipping."
+      );
+      return;
+    }
+    const procedureId = procedureSummary.id;
+    console.log(
+      `[ProcedureAggregationService] Adding procedure ${procedureId} to practitioner ${practitionerId}.`
+    );
+    const practitionerRef = this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId);
+    try {
+      await practitionerRef.update({
+        procedureIds: admin4.firestore.FieldValue.arrayUnion(procedureId),
+        proceduresInfo: admin4.firestore.FieldValue.arrayUnion(procedureSummary),
+        updatedAt: admin4.firestore.FieldValue.serverTimestamp()
+      });
+      console.log(
+        `[ProcedureAggregationService] Successfully added procedure ${procedureId} to practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error adding procedure ${procedureId} to practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Adds procedure information to a clinic when a new procedure is created
+   * @param clinicId - ID of the clinic where the procedure is performed
+   * @param procedureSummary - Summary information about the procedure
+   * @returns {Promise<void>}
+   */
+  async addProcedureToClinic(clinicId, procedureSummary) {
+    if (!clinicId || !procedureSummary) {
+      console.log(
+        "[ProcedureAggregationService] Missing clinicId or procedureSummary for adding procedure to clinic. Skipping."
+      );
+      return;
+    }
+    const procedureId = procedureSummary.id;
+    console.log(
+      `[ProcedureAggregationService] Adding procedure ${procedureId} to clinic ${clinicId}.`
+    );
+    const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+    try {
+      await clinicRef.update({
+        procedures: admin4.firestore.FieldValue.arrayUnion(procedureId),
+        proceduresInfo: admin4.firestore.FieldValue.arrayUnion(procedureSummary),
+        updatedAt: admin4.firestore.FieldValue.serverTimestamp()
+      });
+      console.log(
+        `[ProcedureAggregationService] Successfully added procedure ${procedureId} to clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error adding procedure ${procedureId} to clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates procedure information in a practitioner document
+   * @param practitionerId - ID of the practitioner who performs the procedure
+   * @param procedureSummary - Updated summary information about the procedure
+   * @returns {Promise<void>}
+   */
+  async updateProcedureInfoInPractitioner(practitionerId, procedureSummary) {
+    if (!practitionerId || !procedureSummary) {
+      console.log(
+        "[ProcedureAggregationService] Missing practitionerId or procedureSummary for updating procedure in practitioner. Skipping."
+      );
+      return;
+    }
+    const procedureId = procedureSummary.id;
+    console.log(
+      `[ProcedureAggregationService] Updating procedure ${procedureId} info in practitioner ${practitionerId}.`
+    );
+    const practitionerRef = this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId);
+    try {
+      await this.db.runTransaction(async (transaction) => {
+        const practitionerDoc = await transaction.get(practitionerRef);
+        if (!practitionerDoc.exists) {
+          throw new Error(
+            `Practitioner ${practitionerId} does not exist for procedure update`
+          );
+        }
+        const practitionerData = practitionerDoc.data();
+        if (!practitionerData) {
+          throw new Error(
+            `Practitioner ${practitionerId} data is empty for procedure update`
+          );
+        }
+        const proceduresInfo = practitionerData.proceduresInfo || [];
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p) => p.id !== procedureId
+        );
+        updatedProceduresInfo.push(procedureSummary);
+        transaction.update(practitionerRef, {
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin4.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      console.log(
+        `[ProcedureAggregationService] Successfully updated procedure ${procedureId} info in practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error updating procedure ${procedureId} info in practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates procedure information in a clinic document
+   * @param clinicId - ID of the clinic where the procedure is performed
+   * @param procedureSummary - Updated summary information about the procedure
+   * @returns {Promise<void>}
+   */
+  async updateProcedureInfoInClinic(clinicId, procedureSummary) {
+    if (!clinicId || !procedureSummary) {
+      console.log(
+        "[ProcedureAggregationService] Missing clinicId or procedureSummary for updating procedure in clinic. Skipping."
+      );
+      return;
+    }
+    const procedureId = procedureSummary.id;
+    console.log(
+      `[ProcedureAggregationService] Updating procedure ${procedureId} info in clinic ${clinicId}.`
+    );
+    const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+    try {
+      await this.db.runTransaction(async (transaction) => {
+        const clinicDoc = await transaction.get(clinicRef);
+        if (!clinicDoc.exists) {
+          throw new Error(
+            `Clinic ${clinicId} does not exist for procedure update`
+          );
+        }
+        const clinicData = clinicDoc.data();
+        if (!clinicData) {
+          throw new Error(
+            `Clinic ${clinicId} data is empty for procedure update`
+          );
+        }
+        const proceduresInfo = clinicData.proceduresInfo || [];
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p) => p.id !== procedureId
+        );
+        updatedProceduresInfo.push(procedureSummary);
+        transaction.update(clinicRef, {
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin4.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      console.log(
+        `[ProcedureAggregationService] Successfully updated procedure ${procedureId} info in clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error updating procedure ${procedureId} info in clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates procedure information in calendar events
+   * @param procedureId - ID of the procedure
+   * @param procedureInfo - Updated procedure information
+   * @returns {Promise<void>}
+   */
+  async updateProcedureInfoInCalendarEvents(procedureId, procedureInfo) {
+    if (!procedureId || !procedureInfo) {
+      console.log(
+        "[ProcedureAggregationService] Missing procedureId or procedureInfo for calendar update. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[ProcedureAggregationService] Querying upcoming calendar events for procedure ${procedureId} to update procedure info.`
+    );
+    const now = admin4.firestore.Timestamp.now();
+    const calendarEventsQuery = this.db.collectionGroup(CALENDAR_SUBCOLLECTION_ID3).where("procedureId", "==", procedureId).where("eventTime.start", ">", now);
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[ProcedureAggregationService] No upcoming calendar events found for procedure ${procedureId}. No procedure info updates needed.`
+        );
+        return;
+      }
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[ProcedureAggregationService] Updating procedure info for calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          procedureInfo,
+          updatedAt: admin4.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      await batch.commit();
+      console.log(
+        `[ProcedureAggregationService] Successfully updated procedure info in ${snapshot.size} upcoming calendar events for procedure ${procedureId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error updating procedure info in calendar events for procedure ${procedureId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Cancels all upcoming calendar events for a procedure
+   * @param procedureId - ID of the procedure
+   * @returns {Promise<void>}
+   */
+  async cancelUpcomingCalendarEventsForProcedure(procedureId) {
+    if (!procedureId) {
+      console.log(
+        "[ProcedureAggregationService] Missing procedureId for canceling calendar events. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[ProcedureAggregationService] Querying upcoming calendar events for procedure ${procedureId} to cancel.`
+    );
+    const now = admin4.firestore.Timestamp.now();
+    const calendarEventsQuery = this.db.collectionGroup(CALENDAR_SUBCOLLECTION_ID3).where("procedureId", "==", procedureId).where("eventTime.start", ">", now);
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[ProcedureAggregationService] No upcoming calendar events found for procedure ${procedureId}. No events to cancel.`
+        );
+        return;
+      }
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[ProcedureAggregationService] Canceling calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          status: "CANCELED",
+          cancelReason: "Procedure deleted or inactivated",
+          updatedAt: admin4.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      await batch.commit();
+      console.log(
+        `[ProcedureAggregationService] Successfully canceled ${snapshot.size} upcoming calendar events for procedure ${procedureId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error canceling calendar events for procedure ${procedureId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Removes procedure from a practitioner when a procedure is deleted or inactivated
+   * @param practitionerId - ID of the practitioner who performs the procedure
+   * @param procedureId - ID of the procedure
+   * @returns {Promise<void>}
+   */
+  async removeProcedureFromPractitioner(practitionerId, procedureId) {
+    if (!practitionerId || !procedureId) {
+      console.log(
+        "[ProcedureAggregationService] Missing practitionerId or procedureId for removing procedure from practitioner. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[ProcedureAggregationService] Removing procedure ${procedureId} from practitioner ${practitionerId}.`
+    );
+    const practitionerRef = this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId);
+    try {
+      await this.db.runTransaction(async (transaction) => {
+        const practitionerDoc = await transaction.get(practitionerRef);
+        if (!practitionerDoc.exists) {
+          throw new Error(
+            `Practitioner ${practitionerId} does not exist for procedure removal`
+          );
+        }
+        const practitionerData = practitionerDoc.data();
+        if (!practitionerData) {
+          throw new Error(
+            `Practitioner ${practitionerId} data is empty for procedure removal`
+          );
+        }
+        const proceduresInfo = practitionerData.proceduresInfo || [];
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p) => p.id !== procedureId
+        );
+        transaction.update(practitionerRef, {
+          procedureIds: admin4.firestore.FieldValue.arrayRemove(procedureId),
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin4.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      console.log(
+        `[ProcedureAggregationService] Successfully removed procedure ${procedureId} from practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error removing procedure ${procedureId} from practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Removes procedure from a clinic when a procedure is deleted or inactivated
+   * @param clinicId - ID of the clinic where the procedure is performed
+   * @param procedureId - ID of the procedure
+   * @returns {Promise<void>}
+   */
+  async removeProcedureFromClinic(clinicId, procedureId) {
+    if (!clinicId || !procedureId) {
+      console.log(
+        "[ProcedureAggregationService] Missing clinicId or procedureId for removing procedure from clinic. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[ProcedureAggregationService] Removing procedure ${procedureId} from clinic ${clinicId}.`
+    );
+    const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+    try {
+      await this.db.runTransaction(async (transaction) => {
+        const clinicDoc = await transaction.get(clinicRef);
+        if (!clinicDoc.exists) {
+          throw new Error(
+            `Clinic ${clinicId} does not exist for procedure removal`
+          );
+        }
+        const clinicData = clinicDoc.data();
+        if (!clinicData) {
+          throw new Error(
+            `Clinic ${clinicId} data is empty for procedure removal`
+          );
+        }
+        const proceduresInfo = clinicData.proceduresInfo || [];
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p) => p.id !== procedureId
+        );
+        transaction.update(clinicRef, {
+          procedures: admin4.firestore.FieldValue.arrayRemove(procedureId),
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin4.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      console.log(
+        `[ProcedureAggregationService] Successfully removed procedure ${procedureId} from clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error removing procedure ${procedureId} from clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+};
+
+// src/admin/aggregation/patient/patient.aggregation.service.ts
+import * as admin5 from "firebase-admin";
+var CALENDAR_SUBCOLLECTION_ID4 = "calendar";
+var PatientAggregationService = class {
+  constructor(firestore6) {
+    this.db = firestore6 || admin5.firestore();
+  }
+  // --- Methods for Patient Creation --- >
+  // No specific aggregations defined for patient creation in the plan.
+  // --- Methods for Patient Update --- >
+  /**
+   * Updates patient information in calendar events
+   * @param patientId - ID of the patient
+   * @param patientInfo - Updated patient information
+   * @returns {Promise<void>}
+   */
+  async updatePatientInfoInCalendarEvents(patientId, patientInfo) {
+    if (!patientId || !patientInfo) {
+      console.log(
+        "[PatientAggregationService] Missing patientId or patientInfo for calendar update. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[PatientAggregationService] Querying upcoming calendar events for patient ${patientId} to update patient info.`
+    );
+    const now = admin5.firestore.Timestamp.now();
+    const calendarEventsQuery = this.db.collectionGroup(CALENDAR_SUBCOLLECTION_ID4).where("patientId", "==", patientId).where("eventTime.start", ">", now);
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[PatientAggregationService] No upcoming calendar events found for patient ${patientId}. No patient info updates needed.`
+        );
+        return;
+      }
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[PatientAggregationService] Updating patient info for calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          patientInfo,
+          updatedAt: admin5.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      await batch.commit();
+      console.log(
+        `[PatientAggregationService] Successfully updated patient info in ${snapshot.size} upcoming calendar events for patient ${patientId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PatientAggregationService] Error updating patient info in calendar events for patient ${patientId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  // --- Methods for Patient Deletion --- >
+  /**
+   * Cancels all upcoming calendar events associated with a deleted patient
+   * @param patientId - ID of the deleted patient
+   * @returns {Promise<void>}
+   */
+  async cancelUpcomingCalendarEventsForPatient(patientId) {
+    if (!patientId) {
+      console.log(
+        "[PatientAggregationService] Missing patientId for canceling calendar events. Skipping."
+      );
+      return;
+    }
+    console.log(
+      `[PatientAggregationService] Querying upcoming calendar events for patient ${patientId} to cancel.`
+    );
+    const now = admin5.firestore.Timestamp.now();
+    const calendarEventsQuery = this.db.collectionGroup(CALENDAR_SUBCOLLECTION_ID4).where("patientId", "==", patientId).where("eventTime.start", ">", now);
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[PatientAggregationService] No upcoming calendar events found for patient ${patientId}. No events to cancel.`
+        );
+        return;
+      }
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[PatientAggregationService] Canceling calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          status: "CANCELED",
+          cancelReason: "Patient deleted",
+          updatedAt: admin5.firestore.FieldValue.serverTimestamp()
+        });
+      });
+      await batch.commit();
+      console.log(
+        `[PatientAggregationService] Successfully canceled ${snapshot.size} upcoming calendar events for patient ${patientId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PatientAggregationService] Error canceling calendar events for patient ${patientId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+};
+
 // src/types/index.ts
 var UserRole = /* @__PURE__ */ ((UserRole2) => {
   UserRole2["PATIENT"] = "patient";
@@ -194,10 +1518,17 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
   UserRole2["CLINIC_ADMIN"] = "clinic_admin";
   return UserRole2;
 })(UserRole || {});
+
+// src/admin/index.ts
+console.log("[Admin Module] Initialized and services exported.");
 export {
+  ClinicAggregationService,
   NOTIFICATIONS_COLLECTION,
   NotificationStatus,
   NotificationType,
   NotificationsAdmin,
+  PatientAggregationService,
+  PractitionerAggregationService,
+  ProcedureAggregationService,
   UserRole
 };