@blackcode_sa/metaestetics-api 1.5.28 → 1.5.30

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(firestore7) {
     this.expo = new Expo();
-    this.db = firestore2 || admin.firestore();
+    this.db = firestore7 || admin.firestore();
   }
   /**
    * Dohvata notifikaciju po ID-u
@@ -186,6 +186,1663 @@ 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(firestore7) {
+    this.db = firestore7 || 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(firestore7) {
+    this.db = firestore7 || 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(firestore7) {
+    this.db = firestore7 || 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(firestore7) {
+    this.db = firestore7 || 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/admin/mailing/base.mailing.service.ts
+import * as admin6 from "firebase-admin";
+var BaseMailingService = class {
+  // Removed config property as it's no longer managed here
+  // protected config: MailgunConfig;
+  /**
+   * Constructor for BaseMailingService
+   * @param firestore Firestore instance provided by the caller
+   * @param mailgunClient Mailgun client instance provided by the caller
+   */
+  constructor(firestore7, mailgunClient) {
+    this.db = firestore7;
+    this.mailgunClient = mailgunClient;
+  }
+  /**
+   * Sends an email using Mailgun
+   * @param data Email data to send, including the 'from' address
+   * @returns Promise with the sending result
+   */
+  async sendEmail(data) {
+    try {
+      if (!data.from) {
+        throw new Error(
+          "Email 'from' address must be provided in sendEmail data."
+        );
+      }
+      return await new Promise(
+        (resolve, reject) => {
+          this.mailgunClient.messages().send(data, (error, body) => {
+            if (error) {
+              console.error("[BaseMailingService] Error sending email:", error);
+              reject(error);
+            } else {
+              console.log(
+                "[BaseMailingService] Email sent successfully:",
+                body
+              );
+              resolve(body);
+            }
+          });
+        }
+      );
+    } catch (error) {
+      console.error("[BaseMailingService] Error in sendEmail:", error);
+      throw error;
+    }
+  }
+  /**
+   * Logs email sending attempt to Firestore for tracking
+   * @param emailData Email data that was sent
+   * @param success Whether the email was sent successfully
+   * @param error Error object if the email failed to send
+   */
+  async logEmailAttempt(emailData, success, error) {
+    try {
+      const emailLogRef = this.db.collection("email_logs").doc();
+      await emailLogRef.set({
+        to: emailData.to,
+        subject: emailData.subject,
+        templateName: emailData.templateName,
+        success,
+        error: error ? JSON.stringify(error) : null,
+        sentAt: admin6.firestore.FieldValue.serverTimestamp()
+      });
+    } catch (logError) {
+      console.error(
+        "[BaseMailingService] Error logging email attempt:",
+        logError
+      );
+    }
+  }
+  /**
+   * Renders a simple HTML email template with variables
+   * @param template HTML template string
+   * @param variables Key-value pairs to replace in the template
+   * @returns Rendered HTML string
+   */
+  renderTemplate(template, variables) {
+    let rendered = template;
+    Object.entries(variables).forEach(([key, value]) => {
+      const regex = new RegExp(`{{\\s*${key}\\s*}}`, "g");
+      rendered = rendered.replace(regex, value);
+    });
+    return rendered;
+  }
+};
+
+// src/admin/mailing/practitionerInvite/templates/invitation.template.ts
+var practitionerInvitationTemplate = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Join {{clinicName}} as a Practitioner</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      line-height: 1.6;
+      color: #333;
+      margin: 0;
+      padding: 0;
+    }
+    .container {
+      max-width: 600px;
+      margin: 0 auto;
+      padding: 20px;
+    }
+    .header {
+      background-color: #4A90E2;
+      padding: 20px;
+      text-align: center;
+      color: white;
+    }
+    .content {
+      padding: 20px;
+      background-color: #f9f9f9;
+    }
+    .footer {
+      padding: 20px;
+      text-align: center;
+      font-size: 12px;
+      color: #888;
+    }
+    .button {
+      display: inline-block;
+      background-color: #4A90E2;
+      color: white;
+      text-decoration: none;
+      padding: 12px 24px;
+      border-radius: 4px;
+      margin: 20px 0;
+      font-weight: bold;
+    }
+    .token {
+      font-size: 24px;
+      font-weight: bold;
+      color: #4A90E2;
+      padding: 10px;
+      background-color: #e9f0f9;
+      border-radius: 4px;
+      display: inline-block;
+      letter-spacing: 2px;
+      margin: 10px 0;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h1>You've Been Invited</h1>
+    </div>
+    <div class="content">
+      <p>Hello {{practitionerName}},</p>
+      
+      <p>You have been invited to join <strong>{{clinicName}}</strong> as a healthcare practitioner.</p>
+      
+      <p>Your profile has been created and is ready for you to claim. Please use the following token to register:</p>
+      
+      <div style="text-align: center;">
+        <span class="token">{{inviteToken}}</span>
+      </div>
+      
+      <p>This token will expire on <strong>{{expirationDate}}</strong>.</p>
+      
+      <p>To create your account:</p>
+      <ol>
+        <li>Visit {{registrationUrl}}</li>
+        <li>Enter your email and create a password</li>
+        <li>When prompted, enter the token above</li>
+      </ol>
+      
+      <div style="text-align: center;">
+        <a href="{{registrationUrl}}" class="button">Create Your Account</a>
+      </div>
+      
+      <p>If you have any questions, please contact {{contactName}} at {{contactEmail}}.</p>
+    </div>
+    <div class="footer">
+      <p>This is an automated message from {{clinicName}}. Please do not reply to this email.</p>
+      <p>&copy; {{currentYear}} {{clinicName}}. All rights reserved.</p>
+    </div>
+  </div>
+</body>
+</html>
+`;
+
+// src/admin/mailing/practitionerInvite/practitionerInvite.mailing.ts
+var PractitionerInviteMailingService = class extends BaseMailingService {
+  /**
+   * Constructor for PractitionerInviteMailingService
+   * @param firestore Firestore instance provided by the caller
+   * @param mailgunClient Mailgun client instance provided by the caller
+   */
+  constructor(firestore7, mailgunClient) {
+    super(firestore7, mailgunClient);
+    this.DEFAULT_REGISTRATION_URL = "https://app.medclinic.com/register";
+    this.DEFAULT_SUBJECT = "You've Been Invited to Join as a Practitioner";
+    this.DEFAULT_FROM_ADDRESS = "MedClinic <no-reply@your-domain.com>";
+  }
+  /**
+   * Sends a practitioner invitation email
+   * @param data The practitioner invitation data
+   * @returns Promise resolved when email is sent
+   */
+  async sendInvitationEmail(data) {
+    var _a, _b, _c, _d;
+    try {
+      console.log(
+        "[PractitionerInviteMailingService] Sending invitation email to",
+        data.token.email
+      );
+      const expirationDate = data.token.expiresAt.toDate().toLocaleDateString("en-US", {
+        weekday: "long",
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+      const registrationUrl = ((_a = data.options) == null ? void 0 : _a.registrationUrl) || this.DEFAULT_REGISTRATION_URL;
+      const contactName = data.clinic.contactName || "Clinic Administrator";
+      const contactEmail = data.clinic.contactEmail;
+      const subject = ((_b = data.options) == null ? void 0 : _b.customSubject) || this.DEFAULT_SUBJECT;
+      const fromAddress = ((_c = data.options) == null ? void 0 : _c.fromAddress) || this.DEFAULT_FROM_ADDRESS;
+      const currentYear = (/* @__PURE__ */ new Date()).getFullYear().toString();
+      const practitionerName = `${data.practitioner.firstName} ${data.practitioner.lastName}`;
+      const templateVariables = {
+        clinicName: data.clinic.name,
+        practitionerName,
+        inviteToken: data.token.token,
+        expirationDate,
+        registrationUrl,
+        contactName,
+        contactEmail,
+        currentYear
+      };
+      const html = this.renderTemplate(
+        practitionerInvitationTemplate,
+        templateVariables
+      );
+      const emailData = {
+        to: data.token.email,
+        from: fromAddress,
+        subject,
+        html
+      };
+      const result = await this.sendEmail(emailData);
+      await this.logEmailAttempt(
+        {
+          to: data.token.email,
+          subject,
+          templateName: "practitioner_invitation"
+        },
+        true
+      );
+      return result;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteMailingService] Error sending invitation email:",
+        error
+      );
+      await this.logEmailAttempt(
+        {
+          to: data.token.email,
+          subject: ((_d = data.options) == null ? void 0 : _d.customSubject) || this.DEFAULT_SUBJECT,
+          templateName: "practitioner_invitation"
+        },
+        false,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Handles the practitioner token creation event from Cloud Functions
+   * Fetches necessary data using defined types and collection constants,
+   * and sends the invitation email.
+   * @param tokenData The fully typed token object including its id
+   * @param fromAddress The 'from' email address to use, obtained from config
+   * @returns Promise resolved when the email is sent
+   */
+  async handleTokenCreationEvent(tokenData, fromAddress) {
+    try {
+      console.log(
+        "[PractitionerInviteMailingService] Handling token creation event for token:",
+        tokenData.id
+      );
+      const practitionerRef = this.db.collection(PRACTITIONERS_COLLECTION).doc(tokenData.practitionerId);
+      const practitionerDoc = await practitionerRef.get();
+      if (!practitionerDoc.exists) {
+        throw new Error(`Practitioner ${tokenData.practitionerId} not found`);
+      }
+      const practitionerData = practitionerDoc.data();
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(tokenData.clinicId);
+      const clinicDoc = await clinicRef.get();
+      if (!clinicDoc.exists) {
+        throw new Error(`Clinic ${tokenData.clinicId} not found`);
+      }
+      const clinicData = clinicDoc.data();
+      const emailData = {
+        token: {
+          id: tokenData.id,
+          token: tokenData.token,
+          practitionerId: tokenData.practitionerId,
+          email: tokenData.email,
+          clinicId: tokenData.clinicId,
+          expiresAt: tokenData.expiresAt
+        },
+        practitioner: {
+          firstName: practitionerData.basicInfo.firstName || "",
+          lastName: practitionerData.basicInfo.lastName || ""
+        },
+        clinic: {
+          name: clinicData.name || "Medical Clinic",
+          contactEmail: clinicData.contactInfo.email || "contact@medclinic.com"
+        },
+        options: {
+          fromAddress
+        }
+      };
+      await this.sendInvitationEmail(emailData);
+      console.log(
+        "[PractitionerInviteMailingService] Invitation email sent successfully"
+      );
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteMailingService] Error handling token creation event:",
+        error
+      );
+      throw error;
+    }
+  }
+};
+
 // src/types/index.ts
 var UserRole = /* @__PURE__ */ ((UserRole2) => {
   UserRole2["PATIENT"] = "patient";
@@ -194,10 +1851,19 @@ 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 {
+  BaseMailingService,
+  ClinicAggregationService,
   NOTIFICATIONS_COLLECTION,
   NotificationStatus,
   NotificationType,
   NotificationsAdmin,
+  PatientAggregationService,
+  PractitionerAggregationService,
+  PractitionerInviteMailingService,
+  ProcedureAggregationService,
   UserRole
 };