@blackcode_sa/metaestetics-api 1.13.3 → 1.13.5

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

@@ -1,702 +1,702 @@
-import * as admin from "firebase-admin";
-import { PRACTITIONERS_COLLECTION } from "../../../types/practitioner";
-import { PROCEDURES_COLLECTION } from "../../../types/procedure";
-import { CLINICS_COLLECTION } from "../../../types/clinic";
-import { ProcedureSummaryInfo } from "../../../types/procedure";
-
-const CALENDAR_SUBCOLLECTION_ID = "calendar";
-
-/**
- * @class ProcedureAggregationService
- * @description Handles aggregation tasks related to procedure data updates/deletions.
- */
-export class ProcedureAggregationService {
-  private db: admin.firestore.Firestore;
-
-  constructor(firestore?: admin.firestore.Firestore) {
-    this.db = firestore || admin.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: string,
-    procedureSummary: ProcedureSummaryInfo
-  ): Promise<void> {
-    if (!practitionerId || !procedureSummary) {
-      console.log(
-        "[ProcedureAggregationService] Missing practitionerId or procedureSummary for adding procedure to practitioner. Skipping."
-      );
-      return;
-    }
-
-    const procedureId = procedureSummary.id;
-    const clinicId = procedureSummary.clinicId;
-    const isFreeConsultation =
-      procedureSummary.technologyName === "free-consultation-tech";
-
-    console.log(
-      `[ProcedureAggregationService] Adding procedure ${procedureId} to practitioner ${practitionerId}. ${
-        isFreeConsultation ? "(Free Consultation)" : ""
-      }`
-    );
-
-    const practitionerRef = this.db
-      .collection(PRACTITIONERS_COLLECTION)
-      .doc(practitionerId);
-
-    try {
-      // Prepare the basic update data
-      const updateData: any = {
-        procedureIds: admin.firestore.FieldValue.arrayUnion(procedureId),
-        proceduresInfo: admin.firestore.FieldValue.arrayUnion(procedureSummary),
-        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-      };
-
-      // If this is a free consultation, we need to update the freeConsultations map
-      if (isFreeConsultation) {
-        await this.db.runTransaction(async (transaction) => {
-          const practitionerDoc = await transaction.get(practitionerRef);
-          if (!practitionerDoc.exists) {
-            throw new Error(
-              `Practitioner ${practitionerId} does not exist for adding free consultation`
-            );
-          }
-
-          const practitionerData = practitionerDoc.data();
-          const currentFreeConsultations =
-            practitionerData?.freeConsultations || {};
-
-          // Check if there's already a free consultation for this clinic
-          if (currentFreeConsultations[clinicId]) {
-            console.log(
-              `[ProcedureAggregationService] Warning: Clinic ${clinicId} already has a free consultation ${currentFreeConsultations[clinicId]}. Replacing with new one ${procedureId}.`
-            );
-          }
-
-          // Set the single procedure ID for this clinic (replaces any existing one)
-          const updatedFreeConsultations = {
-            ...currentFreeConsultations,
-            [clinicId]: procedureId,
-          };
-
-          // Apply all updates including freeConsultations
-          transaction.update(practitionerRef, {
-            ...updateData,
-            freeConsultations: updatedFreeConsultations,
-          });
-
-          console.log(
-            `[ProcedureAggregationService] Set free consultation ${procedureId} for practitioner ${practitionerId} at clinic ${clinicId}`
-          );
-        });
-      } else {
-        // For regular procedures, just do the standard update
-        await practitionerRef.update(updateData);
-      }
-
-      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: string,
-    procedureSummary: ProcedureSummaryInfo
-  ): Promise<void> {
-    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: admin.firestore.FieldValue.arrayUnion(procedureId),
-        proceduresInfo: admin.firestore.FieldValue.arrayUnion(procedureSummary),
-        updatedAt: admin.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: string,
-    procedureSummary: ProcedureSummaryInfo
-  ): Promise<void> {
-    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);
-
-    // This requires a transaction to avoid race conditions
-    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`
-          );
-        }
-
-        // Get current procedures info array
-        const proceduresInfo = practitionerData.proceduresInfo || [];
-
-        // Remove the old procedure summary
-        const updatedProceduresInfo = proceduresInfo.filter(
-          (p: ProcedureSummaryInfo) => p.id !== procedureId
-        );
-
-        // Add the updated procedure summary
-        updatedProceduresInfo.push(procedureSummary);
-
-        // Update the practitioner document
-        transaction.update(practitionerRef, {
-          proceduresInfo: updatedProceduresInfo,
-          updatedAt: admin.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: string,
-    procedureSummary: ProcedureSummaryInfo
-  ): Promise<void> {
-    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);
-
-    // This requires a transaction to avoid race conditions
-    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`
-          );
-        }
-
-        // Get current procedures info array
-        const proceduresInfo = clinicData.proceduresInfo || [];
-
-        // Remove the old procedure summary
-        const updatedProceduresInfo = proceduresInfo.filter(
-          (p: ProcedureSummaryInfo) => p.id !== procedureId
-        );
-
-        // Add the updated procedure summary
-        updatedProceduresInfo.push(procedureSummary);
-
-        // Update the clinic document
-        transaction.update(clinicRef, {
-          proceduresInfo: updatedProceduresInfo,
-          updatedAt: admin.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: string,
-    procedureInfo: any
-  ): Promise<void> {
-    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 = admin.firestore.Timestamp.now();
-    // Use a Collection Group query
-    const calendarEventsQuery = this.db
-      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
-      .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: procedureInfo,
-          updatedAt: admin.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: string
-  ): Promise<void> {
-    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 = admin.firestore.Timestamp.now();
-    // Use a Collection Group query
-    const calendarEventsQuery = this.db
-      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
-      .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: admin.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
-   * @param clinicId - Optional clinic ID for free consultation removal
-   * @returns {Promise<void>}
-   */
-  async removeProcedureFromPractitioner(
-    practitionerId: string,
-    procedureId: string,
-    clinicId?: string
-  ): Promise<void> {
-    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`
-          );
-        }
-
-        // Get current procedures info array
-        const proceduresInfo = practitionerData.proceduresInfo || [];
-
-        // Find the procedure being removed to check if it's a free consultation
-        const procedureBeingRemoved = proceduresInfo.find(
-          (p: any) => p.id === procedureId
-        );
-
-        const isFreeConsultation =
-          procedureBeingRemoved?.technologyName === "free-consultation-tech";
-        const procedureClinicId = clinicId || procedureBeingRemoved?.clinicId;
-
-        // Remove the procedure summary
-        const updatedProceduresInfo = proceduresInfo.filter(
-          (p: any) => p.id !== procedureId
-        );
-
-        // Prepare update data
-        const updateData: any = {
-          procedureIds: admin.firestore.FieldValue.arrayRemove(procedureId),
-          proceduresInfo: updatedProceduresInfo,
-          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-        };
-
-        // If this is a free consultation, also remove it from the freeConsultations map
-        if (isFreeConsultation && procedureClinicId) {
-          const currentFreeConsultations =
-            practitionerData.freeConsultations || {};
-
-          // Check if this clinic's free consultation matches the procedure being removed
-          if (currentFreeConsultations[procedureClinicId] === procedureId) {
-            // Remove the clinic entry from the freeConsultations map
-            const updatedFreeConsultations = { ...currentFreeConsultations };
-            delete updatedFreeConsultations[procedureClinicId];
-
-            updateData.freeConsultations = updatedFreeConsultations;
-
-            console.log(
-              `[ProcedureAggregationService] Removed free consultation ${procedureId} from practitioner ${practitionerId} for clinic ${procedureClinicId}`
-            );
-          } else {
-            console.log(
-              `[ProcedureAggregationService] Free consultation mismatch for clinic ${procedureClinicId}: expected ${procedureId}, found ${currentFreeConsultations[procedureClinicId]}`
-            );
-          }
-        }
-
-        // Update the practitioner document
-        transaction.update(practitionerRef, updateData);
-      });
-
-      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: string,
-    procedureId: string
-  ): Promise<void> {
-    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`
-          );
-        }
-
-        // Get current procedures info array
-        const proceduresInfo = clinicData.proceduresInfo || [];
-
-        // Remove the procedure summary
-        const updatedProceduresInfo = proceduresInfo.filter(
-          (p: ProcedureSummaryInfo) => p.id !== procedureId
-        );
-
-        // Update the clinic document
-        transaction.update(clinicRef, {
-          procedures: admin.firestore.FieldValue.arrayRemove(procedureId),
-          proceduresInfo: updatedProceduresInfo,
-          updatedAt: admin.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;
-    }
-  }
-
-  /**
-   * Handles procedure status changes (activation/deactivation) specifically for free consultations
-   * @param practitionerId - ID of the practitioner who performs the procedure
-   * @param procedureId - ID of the procedure
-   * @param clinicId - ID of the clinic where the procedure is performed
-   * @param isActive - New active status of the procedure
-   * @param technologyName - Technology name of the procedure (to check if it's a free consultation)
-   * @returns {Promise<void>}
-   */
-  async handleFreeConsultationStatusChange(
-    practitionerId: string,
-    procedureId: string,
-    clinicId: string,
-    isActive: boolean,
-    technologyName: string
-  ): Promise<void> {
-    if (!practitionerId || !procedureId || !clinicId) {
-      console.log(
-        "[ProcedureAggregationService] Missing required parameters for handling free consultation status change. Skipping."
-      );
-      return;
-    }
-
-    // Only handle free consultations
-    if (technologyName !== "free-consultation-tech") {
-      return;
-    }
-
-    console.log(
-      `[ProcedureAggregationService] Handling free consultation status change: procedure ${procedureId} for practitioner ${practitionerId} in clinic ${clinicId}. New status: ${
-        isActive ? "active" : "inactive"
-      }`
-    );
-
-    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 free consultation status change`
-          );
-        }
-
-        const practitionerData = practitionerDoc.data();
-        if (!practitionerData) {
-          throw new Error(
-            `Practitioner ${practitionerId} data is empty for free consultation status change`
-          );
-        }
-
-        const currentFreeConsultations =
-          practitionerData.freeConsultations || {};
-        let updatedFreeConsultations = { ...currentFreeConsultations };
-
-        if (isActive) {
-          // If procedure is being activated, set it as the free consultation for this clinic
-          if (
-            currentFreeConsultations[clinicId] &&
-            currentFreeConsultations[clinicId] !== procedureId
-          ) {
-            console.log(
-              `[ProcedureAggregationService] Warning: Clinic ${clinicId} already has a different free consultation ${currentFreeConsultations[clinicId]}. Replacing with ${procedureId}.`
-            );
-          }
-
-          updatedFreeConsultations[clinicId] = procedureId;
-
-          console.log(
-            `[ProcedureAggregationService] Set free consultation ${procedureId} for practitioner ${practitionerId} at clinic ${clinicId} (activated)`
-          );
-        } else {
-          // If procedure is being deactivated, remove it from the free consultations map
-          if (currentFreeConsultations[clinicId] === procedureId) {
-            delete updatedFreeConsultations[clinicId];
-
-            console.log(
-              `[ProcedureAggregationService] Removed free consultation ${procedureId} from practitioner ${practitionerId} for clinic ${clinicId} (deactivated)`
-            );
-          } else {
-            console.log(
-              `[ProcedureAggregationService] Free consultation mismatch for clinic ${clinicId}: expected ${procedureId}, found ${currentFreeConsultations[clinicId]}`
-            );
-          }
-        }
-
-        // Update the practitioner document with the new freeConsultations map
-        transaction.update(practitionerRef, {
-          freeConsultations: updatedFreeConsultations,
-          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-        });
-      });
-
-      console.log(
-        `[ProcedureAggregationService] Successfully handled free consultation status change for procedure ${procedureId} of practitioner ${practitionerId}.`
-      );
-    } catch (error) {
-      console.error(
-        `[ProcedureAggregationService] Error handling free consultation status change for procedure ${procedureId} of practitioner ${practitionerId}:`,
-        error
-      );
-      throw error;
-    }
-  }
-}
+import * as admin from "firebase-admin";
+import { PRACTITIONERS_COLLECTION } from "../../../types/practitioner";
+import { PROCEDURES_COLLECTION } from "../../../types/procedure";
+import { CLINICS_COLLECTION } from "../../../types/clinic";
+import { ProcedureSummaryInfo } from "../../../types/procedure";
+
+const CALENDAR_SUBCOLLECTION_ID = "calendar";
+
+/**
+ * @class ProcedureAggregationService
+ * @description Handles aggregation tasks related to procedure data updates/deletions.
+ */
+export class ProcedureAggregationService {
+  private db: admin.firestore.Firestore;
+
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.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: string,
+    procedureSummary: ProcedureSummaryInfo
+  ): Promise<void> {
+    if (!practitionerId || !procedureSummary) {
+      console.log(
+        "[ProcedureAggregationService] Missing practitionerId or procedureSummary for adding procedure to practitioner. Skipping."
+      );
+      return;
+    }
+
+    const procedureId = procedureSummary.id;
+    const clinicId = procedureSummary.clinicId;
+    const isFreeConsultation =
+      procedureSummary.technologyName === "free-consultation-tech";
+
+    console.log(
+      `[ProcedureAggregationService] Adding procedure ${procedureId} to practitioner ${practitionerId}. ${
+        isFreeConsultation ? "(Free Consultation)" : ""
+      }`
+    );
+
+    const practitionerRef = this.db
+      .collection(PRACTITIONERS_COLLECTION)
+      .doc(practitionerId);
+
+    try {
+      // Prepare the basic update data
+      const updateData: any = {
+        procedureIds: admin.firestore.FieldValue.arrayUnion(procedureId),
+        proceduresInfo: admin.firestore.FieldValue.arrayUnion(procedureSummary),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      };
+
+      // If this is a free consultation, we need to update the freeConsultations map
+      if (isFreeConsultation) {
+        await this.db.runTransaction(async (transaction) => {
+          const practitionerDoc = await transaction.get(practitionerRef);
+          if (!practitionerDoc.exists) {
+            throw new Error(
+              `Practitioner ${practitionerId} does not exist for adding free consultation`
+            );
+          }
+
+          const practitionerData = practitionerDoc.data();
+          const currentFreeConsultations =
+            practitionerData?.freeConsultations || {};
+
+          // Check if there's already a free consultation for this clinic
+          if (currentFreeConsultations[clinicId]) {
+            console.log(
+              `[ProcedureAggregationService] Warning: Clinic ${clinicId} already has a free consultation ${currentFreeConsultations[clinicId]}. Replacing with new one ${procedureId}.`
+            );
+          }
+
+          // Set the single procedure ID for this clinic (replaces any existing one)
+          const updatedFreeConsultations = {
+            ...currentFreeConsultations,
+            [clinicId]: procedureId,
+          };
+
+          // Apply all updates including freeConsultations
+          transaction.update(practitionerRef, {
+            ...updateData,
+            freeConsultations: updatedFreeConsultations,
+          });
+
+          console.log(
+            `[ProcedureAggregationService] Set free consultation ${procedureId} for practitioner ${practitionerId} at clinic ${clinicId}`
+          );
+        });
+      } else {
+        // For regular procedures, just do the standard update
+        await practitionerRef.update(updateData);
+      }
+
+      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: string,
+    procedureSummary: ProcedureSummaryInfo
+  ): Promise<void> {
+    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: admin.firestore.FieldValue.arrayUnion(procedureId),
+        proceduresInfo: admin.firestore.FieldValue.arrayUnion(procedureSummary),
+        updatedAt: admin.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: string,
+    procedureSummary: ProcedureSummaryInfo
+  ): Promise<void> {
+    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);
+
+    // This requires a transaction to avoid race conditions
+    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`
+          );
+        }
+
+        // Get current procedures info array
+        const proceduresInfo = practitionerData.proceduresInfo || [];
+
+        // Remove the old procedure summary
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p: ProcedureSummaryInfo) => p.id !== procedureId
+        );
+
+        // Add the updated procedure summary
+        updatedProceduresInfo.push(procedureSummary);
+
+        // Update the practitioner document
+        transaction.update(practitionerRef, {
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin.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: string,
+    procedureSummary: ProcedureSummaryInfo
+  ): Promise<void> {
+    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);
+
+    // This requires a transaction to avoid race conditions
+    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`
+          );
+        }
+
+        // Get current procedures info array
+        const proceduresInfo = clinicData.proceduresInfo || [];
+
+        // Remove the old procedure summary
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p: ProcedureSummaryInfo) => p.id !== procedureId
+        );
+
+        // Add the updated procedure summary
+        updatedProceduresInfo.push(procedureSummary);
+
+        // Update the clinic document
+        transaction.update(clinicRef, {
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin.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: string,
+    procedureInfo: any
+  ): Promise<void> {
+    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 = admin.firestore.Timestamp.now();
+    // Use a Collection Group query
+    const calendarEventsQuery = this.db
+      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
+      .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: procedureInfo,
+          updatedAt: admin.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: string
+  ): Promise<void> {
+    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 = admin.firestore.Timestamp.now();
+    // Use a Collection Group query
+    const calendarEventsQuery = this.db
+      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
+      .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: admin.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
+   * @param clinicId - Optional clinic ID for free consultation removal
+   * @returns {Promise<void>}
+   */
+  async removeProcedureFromPractitioner(
+    practitionerId: string,
+    procedureId: string,
+    clinicId?: string
+  ): Promise<void> {
+    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`
+          );
+        }
+
+        // Get current procedures info array
+        const proceduresInfo = practitionerData.proceduresInfo || [];
+
+        // Find the procedure being removed to check if it's a free consultation
+        const procedureBeingRemoved = proceduresInfo.find(
+          (p: any) => p.id === procedureId
+        );
+
+        const isFreeConsultation =
+          procedureBeingRemoved?.technologyName === "free-consultation-tech";
+        const procedureClinicId = clinicId || procedureBeingRemoved?.clinicId;
+
+        // Remove the procedure summary
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p: any) => p.id !== procedureId
+        );
+
+        // Prepare update data
+        const updateData: any = {
+          procedureIds: admin.firestore.FieldValue.arrayRemove(procedureId),
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        };
+
+        // If this is a free consultation, also remove it from the freeConsultations map
+        if (isFreeConsultation && procedureClinicId) {
+          const currentFreeConsultations =
+            practitionerData.freeConsultations || {};
+
+          // Check if this clinic's free consultation matches the procedure being removed
+          if (currentFreeConsultations[procedureClinicId] === procedureId) {
+            // Remove the clinic entry from the freeConsultations map
+            const updatedFreeConsultations = { ...currentFreeConsultations };
+            delete updatedFreeConsultations[procedureClinicId];
+
+            updateData.freeConsultations = updatedFreeConsultations;
+
+            console.log(
+              `[ProcedureAggregationService] Removed free consultation ${procedureId} from practitioner ${practitionerId} for clinic ${procedureClinicId}`
+            );
+          } else {
+            console.log(
+              `[ProcedureAggregationService] Free consultation mismatch for clinic ${procedureClinicId}: expected ${procedureId}, found ${currentFreeConsultations[procedureClinicId]}`
+            );
+          }
+        }
+
+        // Update the practitioner document
+        transaction.update(practitionerRef, updateData);
+      });
+
+      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: string,
+    procedureId: string
+  ): Promise<void> {
+    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`
+          );
+        }
+
+        // Get current procedures info array
+        const proceduresInfo = clinicData.proceduresInfo || [];
+
+        // Remove the procedure summary
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p: ProcedureSummaryInfo) => p.id !== procedureId
+        );
+
+        // Update the clinic document
+        transaction.update(clinicRef, {
+          procedures: admin.firestore.FieldValue.arrayRemove(procedureId),
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin.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;
+    }
+  }
+
+  /**
+   * Handles procedure status changes (activation/deactivation) specifically for free consultations
+   * @param practitionerId - ID of the practitioner who performs the procedure
+   * @param procedureId - ID of the procedure
+   * @param clinicId - ID of the clinic where the procedure is performed
+   * @param isActive - New active status of the procedure
+   * @param technologyName - Technology name of the procedure (to check if it's a free consultation)
+   * @returns {Promise<void>}
+   */
+  async handleFreeConsultationStatusChange(
+    practitionerId: string,
+    procedureId: string,
+    clinicId: string,
+    isActive: boolean,
+    technologyName: string
+  ): Promise<void> {
+    if (!practitionerId || !procedureId || !clinicId) {
+      console.log(
+        "[ProcedureAggregationService] Missing required parameters for handling free consultation status change. Skipping."
+      );
+      return;
+    }
+
+    // Only handle free consultations
+    if (technologyName !== "free-consultation-tech") {
+      return;
+    }
+
+    console.log(
+      `[ProcedureAggregationService] Handling free consultation status change: procedure ${procedureId} for practitioner ${practitionerId} in clinic ${clinicId}. New status: ${
+        isActive ? "active" : "inactive"
+      }`
+    );
+
+    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 free consultation status change`
+          );
+        }
+
+        const practitionerData = practitionerDoc.data();
+        if (!practitionerData) {
+          throw new Error(
+            `Practitioner ${practitionerId} data is empty for free consultation status change`
+          );
+        }
+
+        const currentFreeConsultations =
+          practitionerData.freeConsultations || {};
+        let updatedFreeConsultations = { ...currentFreeConsultations };
+
+        if (isActive) {
+          // If procedure is being activated, set it as the free consultation for this clinic
+          if (
+            currentFreeConsultations[clinicId] &&
+            currentFreeConsultations[clinicId] !== procedureId
+          ) {
+            console.log(
+              `[ProcedureAggregationService] Warning: Clinic ${clinicId} already has a different free consultation ${currentFreeConsultations[clinicId]}. Replacing with ${procedureId}.`
+            );
+          }
+
+          updatedFreeConsultations[clinicId] = procedureId;
+
+          console.log(
+            `[ProcedureAggregationService] Set free consultation ${procedureId} for practitioner ${practitionerId} at clinic ${clinicId} (activated)`
+          );
+        } else {
+          // If procedure is being deactivated, remove it from the free consultations map
+          if (currentFreeConsultations[clinicId] === procedureId) {
+            delete updatedFreeConsultations[clinicId];
+
+            console.log(
+              `[ProcedureAggregationService] Removed free consultation ${procedureId} from practitioner ${practitionerId} for clinic ${clinicId} (deactivated)`
+            );
+          } else {
+            console.log(
+              `[ProcedureAggregationService] Free consultation mismatch for clinic ${clinicId}: expected ${procedureId}, found ${currentFreeConsultations[clinicId]}`
+            );
+          }
+        }
+
+        // Update the practitioner document with the new freeConsultations map
+        transaction.update(practitionerRef, {
+          freeConsultations: updatedFreeConsultations,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      console.log(
+        `[ProcedureAggregationService] Successfully handled free consultation status change for procedure ${procedureId} of practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error handling free consultation status change for procedure ${procedureId} of practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+}