@blackcode_sa/metaestetics-api 1.5.32 → 1.5.33

package/dist/admin/index.js

@@ -31,6 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   BaseMailingService: () => BaseMailingService,
+  BookingAdmin: () => BookingAdmin,
+  BookingAvailabilityCalculator: () => BookingAvailabilityCalculator,
   ClinicAggregationService: () => ClinicAggregationService,
   NOTIFICATIONS_COLLECTION: () => NOTIFICATIONS_COLLECTION,
   NotificationStatus: () => NotificationStatus,
@@ -66,9 +68,9 @@ var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
 var admin = __toESM(require("firebase-admin"));
 var import_expo_server_sdk = require("expo-server-sdk");
 var NotificationsAdmin = class {
-  constructor(firestore7) {
+  constructor(firestore8) {
     this.expo = new import_expo_server_sdk.Expo();
-    this.db = firestore7 || admin.firestore();
+    this.db = firestore8 || admin.firestore();
   }
   /**
    * Dohvata notifikaciju po ID-u
@@ -255,8 +257,8 @@ 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();
+  constructor(firestore8) {
+    this.db = firestore8 || admin2.firestore();
   }
   /**
    * Adds clinic information to a clinic group when a new clinic is created
@@ -730,8 +732,8 @@ var ClinicAggregationService = class {
 var admin3 = __toESM(require("firebase-admin"));
 var CALENDAR_SUBCOLLECTION_ID2 = "calendar";
 var PractitionerAggregationService = class {
-  constructor(firestore7) {
-    this.db = firestore7 || admin3.firestore();
+  constructor(firestore8) {
+    this.db = firestore8 || admin3.firestore();
   }
   /**
    * Adds practitioner information to a clinic when a new practitioner is created
@@ -1066,8 +1068,8 @@ var PractitionerAggregationService = class {
 var admin4 = __toESM(require("firebase-admin"));
 var CALENDAR_SUBCOLLECTION_ID3 = "calendar";
 var ProcedureAggregationService = class {
-  constructor(firestore7) {
-    this.db = firestore7 || admin4.firestore();
+  constructor(firestore8) {
+    this.db = firestore8 || admin4.firestore();
   }
   /**
    * Adds procedure information to a practitioner when a new procedure is created
@@ -1451,8 +1453,8 @@ var ProcedureAggregationService = class {
 var admin5 = __toESM(require("firebase-admin"));
 var CALENDAR_SUBCOLLECTION_ID4 = "calendar";
 var PatientAggregationService = class {
-  constructor(firestore7) {
-    this.db = firestore7 || admin5.firestore();
+  constructor(firestore8) {
+    this.db = firestore8 || admin5.firestore();
   }
   // --- Methods for Patient Creation --- >
   // No specific aggregations defined for patient creation in the plan.
@@ -1566,8 +1568,8 @@ var BaseMailingService = class {
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance provided by the caller
    */
-  constructor(firestore7, mailgunClient) {
-    this.db = firestore7;
+  constructor(firestore8, mailgunClient) {
+    this.db = firestore8;
     this.mailgunClient = mailgunClient;
   }
   /**
@@ -1750,8 +1752,8 @@ var PractitionerInviteMailingService = class extends BaseMailingService {
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance provided by the caller
    */
-  constructor(firestore7, mailgunClient) {
-    super(firestore7, mailgunClient);
+  constructor(firestore8, mailgunClient) {
+    super(firestore8, 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>";
@@ -1898,11 +1900,592 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
   return UserRole2;
 })(UserRole || {});
 
+// src/admin/booking/booking.calculator.ts
+var import_firestore = require("firebase/firestore");
+var BookingAvailabilityCalculator = class {
+  /**
+   * Calculate available booking slots based on the provided data
+   *
+   * @param request - The request containing all necessary data for calculation
+   * @returns Response with available booking slots
+   */
+  static calculateSlots(request) {
+    const {
+      clinic,
+      practitioner,
+      procedure,
+      timeframe,
+      clinicCalendarEvents,
+      practitionerCalendarEvents
+    } = request;
+    const schedulingIntervalMinutes = clinic.schedulingInterval || this.DEFAULT_INTERVAL_MINUTES;
+    const procedureDurationMinutes = procedure.duration;
+    console.log(
+      `Calculating slots with interval: ${schedulingIntervalMinutes}min and procedure duration: ${procedureDurationMinutes}min`
+    );
+    let availableIntervals = [
+      { start: timeframe.start, end: timeframe.end }
+    ];
+    availableIntervals = this.applyClinicWorkingHours(
+      availableIntervals,
+      clinic.workingHours,
+      timeframe
+    );
+    availableIntervals = this.subtractBlockingEvents(
+      availableIntervals,
+      clinicCalendarEvents
+    );
+    availableIntervals = this.applyPractitionerWorkingHours(
+      availableIntervals,
+      practitioner,
+      clinic.id,
+      timeframe
+    );
+    availableIntervals = this.subtractPractitionerBusyTimes(
+      availableIntervals,
+      practitionerCalendarEvents
+    );
+    console.log(
+      `After all filters, have ${availableIntervals.length} available intervals`
+    );
+    const availableSlots = this.generateAvailableSlots(
+      availableIntervals,
+      schedulingIntervalMinutes,
+      procedureDurationMinutes
+    );
+    return { availableSlots };
+  }
+  /**
+   * Apply clinic working hours to available intervals
+   *
+   * @param intervals - Current available intervals
+   * @param workingHours - Clinic working hours
+   * @param timeframe - Overall timeframe being considered
+   * @returns Intervals filtered by clinic working hours
+   */
+  static applyClinicWorkingHours(intervals, workingHours, timeframe) {
+    if (!intervals.length) return [];
+    console.log(
+      `Applying clinic working hours to ${intervals.length} intervals`
+    );
+    const workingIntervals = this.createWorkingHoursIntervals(
+      workingHours,
+      timeframe.start.toDate(),
+      timeframe.end.toDate()
+    );
+    return this.intersectIntervals(intervals, workingIntervals);
+  }
+  /**
+   * Create time intervals for working hours across multiple days
+   *
+   * @param workingHours - Working hours definition
+   * @param startDate - Start date of the overall timeframe
+   * @param endDate - End date of the overall timeframe
+   * @returns Array of time intervals representing working hours
+   */
+  static createWorkingHoursIntervals(workingHours, startDate, endDate) {
+    const workingIntervals = [];
+    const currentDate = new Date(startDate);
+    currentDate.setHours(0, 0, 0, 0);
+    const dayNameToNumber = {
+      sunday: 0,
+      monday: 1,
+      tuesday: 2,
+      wednesday: 3,
+      thursday: 4,
+      friday: 5,
+      saturday: 6
+    };
+    while (currentDate <= endDate) {
+      const dayOfWeek = currentDate.getDay();
+      const dayName = Object.keys(dayNameToNumber).find(
+        (key) => dayNameToNumber[key] === dayOfWeek
+      );
+      if (dayName && workingHours[dayName]) {
+        const daySchedule = workingHours[dayName];
+        if (daySchedule) {
+          const [openHours, openMinutes] = daySchedule.open.split(":").map(Number);
+          const [closeHours, closeMinutes] = daySchedule.close.split(":").map(Number);
+          const workStart = new Date(currentDate);
+          workStart.setHours(openHours, openMinutes, 0, 0);
+          const workEnd = new Date(currentDate);
+          workEnd.setHours(closeHours, closeMinutes, 0, 0);
+          if (workEnd > startDate && workStart < endDate) {
+            const intervalStart = workStart < startDate ? startDate : workStart;
+            const intervalEnd = workEnd > endDate ? endDate : workEnd;
+            workingIntervals.push({
+              start: import_firestore.Timestamp.fromDate(intervalStart),
+              end: import_firestore.Timestamp.fromDate(intervalEnd)
+            });
+            if (daySchedule.breaks && daySchedule.breaks.length > 0) {
+              for (const breakTime of daySchedule.breaks) {
+                const [breakStartHours, breakStartMinutes] = breakTime.start.split(":").map(Number);
+                const [breakEndHours, breakEndMinutes] = breakTime.end.split(":").map(Number);
+                const breakStart = new Date(currentDate);
+                breakStart.setHours(breakStartHours, breakStartMinutes, 0, 0);
+                const breakEnd = new Date(currentDate);
+                breakEnd.setHours(breakEndHours, breakEndMinutes, 0, 0);
+                workingIntervals.splice(
+                  -1,
+                  1,
+                  ...this.subtractInterval(
+                    workingIntervals[workingIntervals.length - 1],
+                    {
+                      start: import_firestore.Timestamp.fromDate(breakStart),
+                      end: import_firestore.Timestamp.fromDate(breakEnd)
+                    }
+                  )
+                );
+              }
+            }
+          }
+        }
+      }
+      currentDate.setDate(currentDate.getDate() + 1);
+    }
+    return workingIntervals;
+  }
+  /**
+   * Subtract blocking events from available intervals
+   *
+   * @param intervals - Current available intervals
+   * @param events - Calendar events to subtract
+   * @returns Available intervals after removing blocking events
+   */
+  static subtractBlockingEvents(intervals, events) {
+    if (!intervals.length) return [];
+    console.log(`Subtracting ${events.length} blocking events`);
+    const blockingEvents = events.filter(
+      (event) => event.eventType === "blocking" /* BLOCKING */ || event.eventType === "break" /* BREAK */ || event.eventType === "free_day" /* FREE_DAY */
+    );
+    let result = [...intervals];
+    for (const event of blockingEvents) {
+      const { start, end } = event.eventTime;
+      const blockingInterval = { start, end };
+      const newResult = [];
+      for (const interval of result) {
+        const remainingIntervals = this.subtractInterval(
+          interval,
+          blockingInterval
+        );
+        newResult.push(...remainingIntervals);
+      }
+      result = newResult;
+    }
+    return result;
+  }
+  /**
+   * Apply practitioner's specific working hours for the given clinic
+   *
+   * @param intervals - Current available intervals
+   * @param practitioner - Practitioner object
+   * @param clinicId - ID of the clinic
+   * @param timeframe - Overall timeframe being considered
+   * @returns Intervals filtered by practitioner's working hours
+   */
+  static applyPractitionerWorkingHours(intervals, practitioner, clinicId, timeframe) {
+    if (!intervals.length) return [];
+    console.log(`Applying practitioner working hours for clinic ${clinicId}`);
+    const clinicWorkingHours = practitioner.clinicWorkingHours.find(
+      (hours) => hours.clinicId === clinicId && hours.isActive
+    );
+    if (!clinicWorkingHours) {
+      console.log(
+        `No working hours found for practitioner at clinic ${clinicId}`
+      );
+      return [];
+    }
+    const workingIntervals = this.createPractitionerWorkingHoursIntervals(
+      clinicWorkingHours.workingHours,
+      timeframe.start.toDate(),
+      timeframe.end.toDate()
+    );
+    return this.intersectIntervals(intervals, workingIntervals);
+  }
+  /**
+   * Create time intervals for practitioner's working hours across multiple days
+   *
+   * @param workingHours - Practitioner's working hours definition
+   * @param startDate - Start date of the overall timeframe
+   * @param endDate - End date of the overall timeframe
+   * @returns Array of time intervals representing practitioner's working hours
+   */
+  static createPractitionerWorkingHoursIntervals(workingHours, startDate, endDate) {
+    const workingIntervals = [];
+    const currentDate = new Date(startDate);
+    currentDate.setHours(0, 0, 0, 0);
+    const dayNameToNumber = {
+      sunday: 0,
+      monday: 1,
+      tuesday: 2,
+      wednesday: 3,
+      thursday: 4,
+      friday: 5,
+      saturday: 6
+    };
+    while (currentDate <= endDate) {
+      const dayOfWeek = currentDate.getDay();
+      const dayName = Object.keys(dayNameToNumber).find(
+        (key) => dayNameToNumber[key] === dayOfWeek
+      );
+      if (dayName && workingHours[dayName]) {
+        const daySchedule = workingHours[dayName];
+        if (daySchedule) {
+          const [startHours, startMinutes] = daySchedule.start.split(":").map(Number);
+          const [endHours, endMinutes] = daySchedule.end.split(":").map(Number);
+          const workStart = new Date(currentDate);
+          workStart.setHours(startHours, startMinutes, 0, 0);
+          const workEnd = new Date(currentDate);
+          workEnd.setHours(endHours, endMinutes, 0, 0);
+          if (workEnd > startDate && workStart < endDate) {
+            const intervalStart = workStart < startDate ? startDate : workStart;
+            const intervalEnd = workEnd > endDate ? endDate : workEnd;
+            workingIntervals.push({
+              start: import_firestore.Timestamp.fromDate(intervalStart),
+              end: import_firestore.Timestamp.fromDate(intervalEnd)
+            });
+          }
+        }
+      }
+      currentDate.setDate(currentDate.getDate() + 1);
+    }
+    return workingIntervals;
+  }
+  /**
+   * Subtract practitioner's busy times from available intervals
+   *
+   * @param intervals - Current available intervals
+   * @param events - Practitioner's calendar events
+   * @returns Available intervals after removing busy times
+   */
+  static subtractPractitionerBusyTimes(intervals, events) {
+    if (!intervals.length) return [];
+    console.log(`Subtracting ${events.length} practitioner events`);
+    const busyEvents = events.filter(
+      (event) => (
+        // Include all blocking events
+        event.eventType === "blocking" /* BLOCKING */ || event.eventType === "break" /* BREAK */ || event.eventType === "free_day" /* FREE_DAY */ || // Include appointments that are pending, confirmed, or rescheduled
+        event.eventType === "appointment" /* APPOINTMENT */ && (event.status === "pending" /* PENDING */ || event.status === "confirmed" /* CONFIRMED */ || event.status === "rescheduled" /* RESCHEDULED */)
+      )
+    );
+    let result = [...intervals];
+    for (const event of busyEvents) {
+      const { start, end } = event.eventTime;
+      const busyInterval = { start, end };
+      const newResult = [];
+      for (const interval of result) {
+        const remainingIntervals = this.subtractInterval(
+          interval,
+          busyInterval
+        );
+        newResult.push(...remainingIntervals);
+      }
+      result = newResult;
+    }
+    return result;
+  }
+  /**
+   * Generate available booking slots based on the final available intervals
+   *
+   * @param intervals - Final available intervals
+   * @param intervalMinutes - Scheduling interval in minutes
+   * @param durationMinutes - Procedure duration in minutes
+   * @returns Array of available booking slots
+   */
+  static generateAvailableSlots(intervals, intervalMinutes, durationMinutes) {
+    const slots = [];
+    console.log(
+      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure`
+    );
+    const durationMs = durationMinutes * 60 * 1e3;
+    const intervalMs = intervalMinutes * 60 * 1e3;
+    for (const interval of intervals) {
+      const intervalStart = interval.start.toDate();
+      const intervalEnd = interval.end.toDate();
+      let slotStart = new Date(intervalStart);
+      const minutesIntoDay = slotStart.getHours() * 60 + slotStart.getMinutes();
+      const minutesRemainder = minutesIntoDay % intervalMinutes;
+      if (minutesRemainder > 0) {
+        slotStart.setMinutes(
+          slotStart.getMinutes() + (intervalMinutes - minutesRemainder)
+        );
+      }
+      while (slotStart.getTime() + durationMs <= intervalEnd.getTime()) {
+        const slotEnd = new Date(slotStart.getTime() + durationMs);
+        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals)) {
+          slots.push({
+            start: import_firestore.Timestamp.fromDate(slotStart)
+          });
+        }
+        slotStart = new Date(slotStart.getTime() + intervalMs);
+      }
+    }
+    console.log(`Generated ${slots.length} available slots`);
+    return slots;
+  }
+  /**
+   * Check if a time slot is fully available within the given intervals
+   *
+   * @param slotStart - Start time of the slot
+   * @param slotEnd - End time of the slot
+   * @param intervals - Available intervals
+   * @returns True if the slot is fully contained within an available interval
+   */
+  static isSlotFullyAvailable(slotStart, slotEnd, intervals) {
+    return intervals.some((interval) => {
+      const intervalStart = interval.start.toDate();
+      const intervalEnd = interval.end.toDate();
+      return slotStart >= intervalStart && slotEnd <= intervalEnd;
+    });
+  }
+  /**
+   * Intersect two sets of time intervals
+   *
+   * @param intervalsA - First set of intervals
+   * @param intervalsB - Second set of intervals
+   * @returns Intersection of the two sets of intervals
+   */
+  static intersectIntervals(intervalsA, intervalsB) {
+    const result = [];
+    for (const intervalA of intervalsA) {
+      for (const intervalB of intervalsB) {
+        const intersectionStart = intervalA.start.toMillis() > intervalB.start.toMillis() ? intervalA.start : intervalB.start;
+        const intersectionEnd = intervalA.end.toMillis() < intervalB.end.toMillis() ? intervalA.end : intervalB.end;
+        if (intersectionStart.toMillis() < intersectionEnd.toMillis()) {
+          result.push({
+            start: intersectionStart,
+            end: intersectionEnd
+          });
+        }
+      }
+    }
+    return this.mergeOverlappingIntervals(result);
+  }
+  /**
+   * Subtract one interval from another, potentially resulting in 0, 1, or 2 intervals
+   *
+   * @param interval - Interval to subtract from
+   * @param subtrahend - Interval to subtract
+   * @returns Array of remaining intervals after subtraction
+   */
+  static subtractInterval(interval, subtrahend) {
+    if (interval.end.toMillis() <= subtrahend.start.toMillis() || interval.start.toMillis() >= subtrahend.end.toMillis()) {
+      return [interval];
+    }
+    if (subtrahend.start.toMillis() <= interval.start.toMillis() && subtrahend.end.toMillis() >= interval.end.toMillis()) {
+      return [];
+    }
+    if (subtrahend.start.toMillis() > interval.start.toMillis() && subtrahend.end.toMillis() < interval.end.toMillis()) {
+      return [
+        {
+          start: interval.start,
+          end: subtrahend.start
+        },
+        {
+          start: subtrahend.end,
+          end: interval.end
+        }
+      ];
+    }
+    if (subtrahend.start.toMillis() <= interval.start.toMillis() && subtrahend.end.toMillis() > interval.start.toMillis()) {
+      return [
+        {
+          start: subtrahend.end,
+          end: interval.end
+        }
+      ];
+    }
+    return [
+      {
+        start: interval.start,
+        end: subtrahend.start
+      }
+    ];
+  }
+  /**
+   * Merge overlapping intervals to simplify the result
+   *
+   * @param intervals - Intervals to merge
+   * @returns Merged intervals
+   */
+  static mergeOverlappingIntervals(intervals) {
+    if (intervals.length <= 1) return intervals;
+    const sorted = [...intervals].sort(
+      (a, b) => a.start.toMillis() - b.start.toMillis()
+    );
+    const result = [sorted[0]];
+    for (let i = 1; i < sorted.length; i++) {
+      const current = sorted[i];
+      const lastResult = result[result.length - 1];
+      if (current.start.toMillis() <= lastResult.end.toMillis()) {
+        if (current.end.toMillis() > lastResult.end.toMillis()) {
+          lastResult.end = current.end;
+        }
+      } else {
+        result.push(current);
+      }
+    }
+    return result;
+  }
+};
+/** Default scheduling interval in minutes if not specified by the clinic */
+BookingAvailabilityCalculator.DEFAULT_INTERVAL_MINUTES = 15;
+
+// src/admin/booking/booking.admin.ts
+var admin7 = __toESM(require("firebase-admin"));
+var BookingAdmin = class {
+  /**
+   * Creates a new BookingAdmin instance
+   * @param firestore - Firestore instance provided by the caller
+   */
+  constructor(firestore8) {
+    this.db = firestore8 || admin7.firestore();
+  }
+  /**
+   * Gets available booking time slots for a specific clinic, practitioner, and procedure
+   *
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param procedureId - ID of the procedure
+   * @param timeframe - Time range to check for availability
+   * @returns Promise resolving to an array of available booking slots
+   */
+  async getAvailableBookingSlots(clinicId, practitionerId, procedureId, timeframe) {
+    try {
+      console.log(
+        `[BookingAdmin] Getting available slots for clinic ${clinicId}, practitioner ${practitionerId}, procedure ${procedureId}`
+      );
+      const start = timeframe.start instanceof Date ? admin7.firestore.Timestamp.fromDate(timeframe.start) : timeframe.start;
+      const end = timeframe.end instanceof Date ? admin7.firestore.Timestamp.fromDate(timeframe.end) : timeframe.end;
+      const clinicDoc = await this.db.collection("clinics").doc(clinicId).get();
+      if (!clinicDoc.exists) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+      const clinic = clinicDoc.data();
+      const practitionerDoc = await this.db.collection("practitioners").doc(practitionerId).get();
+      if (!practitionerDoc.exists) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+      const practitioner = practitionerDoc.data();
+      const procedureDoc = await this.db.collection("procedures").doc(procedureId).get();
+      if (!procedureDoc.exists) {
+        throw new Error(`Procedure ${procedureId} not found`);
+      }
+      const procedure = procedureDoc.data();
+      const clinicCalendarEvents = await this.getClinicCalendarEvents(
+        clinicId,
+        start,
+        end
+      );
+      const practitionerCalendarEvents = await this.getPractitionerCalendarEvents(practitionerId, start, end);
+      const convertedTimeframe = {
+        start: this.adminTimestampToClientTimestamp(start),
+        end: this.adminTimestampToClientTimestamp(end)
+      };
+      const request = {
+        clinic,
+        practitioner,
+        procedure,
+        timeframe: convertedTimeframe,
+        clinicCalendarEvents: this.convertEventsTimestamps(clinicCalendarEvents),
+        practitionerCalendarEvents: this.convertEventsTimestamps(
+          practitionerCalendarEvents
+        )
+      };
+      const result = BookingAvailabilityCalculator.calculateSlots(request);
+      return {
+        availableSlots: result.availableSlots.map((slot) => ({
+          start: admin7.firestore.Timestamp.fromMillis(slot.start.toMillis())
+        }))
+      };
+    } catch (error) {
+      console.error("[BookingAdmin] Error getting available slots:", error);
+      throw error;
+    }
+  }
+  /**
+   * Converts an admin Firestore Timestamp to a client Firestore Timestamp
+   */
+  adminTimestampToClientTimestamp(timestamp) {
+    return {
+      seconds: timestamp.seconds,
+      nanoseconds: timestamp.nanoseconds,
+      toDate: () => timestamp.toDate(),
+      toMillis: () => timestamp.toMillis(),
+      valueOf: () => timestamp.valueOf()
+      // Add any other required methods/properties
+    };
+  }
+  /**
+   * Converts timestamps in calendar events from admin Firestore Timestamps to client Firestore Timestamps
+   */
+  convertEventsTimestamps(events) {
+    return events.map((event) => ({
+      ...event,
+      eventTime: {
+        start: this.adminTimestampToClientTimestamp(event.eventTime.start),
+        end: this.adminTimestampToClientTimestamp(event.eventTime.end)
+      }
+      // Convert any other timestamps in the event if needed
+    }));
+  }
+  /**
+   * Fetches clinic calendar events for a specific time range
+   *
+   * @param clinicId - ID of the clinic
+   * @param start - Start time of the range
+   * @param end - End time of the range
+   * @returns Promise resolving to an array of calendar events
+   */
+  async getClinicCalendarEvents(clinicId, start, end) {
+    try {
+      const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
+      const snapshot = await eventsRef.get();
+      return snapshot.docs.map((doc) => ({
+        ...doc.data(),
+        id: doc.id
+      }));
+    } catch (error) {
+      console.error(
+        `[BookingAdmin] Error fetching clinic calendar events:`,
+        error
+      );
+      return [];
+    }
+  }
+  /**
+   * Fetches practitioner calendar events for a specific time range
+   *
+   * @param practitionerId - ID of the practitioner
+   * @param start - Start time of the range
+   * @param end - End time of the range
+   * @returns Promise resolving to an array of calendar events
+   */
+  async getPractitionerCalendarEvents(practitionerId, start, end) {
+    try {
+      const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
+      const snapshot = await eventsRef.get();
+      return snapshot.docs.map((doc) => ({
+        ...doc.data(),
+        id: doc.id
+      }));
+    } catch (error) {
+      console.error(
+        `[BookingAdmin] Error fetching practitioner calendar events:`,
+        error
+      );
+      return [];
+    }
+  }
+};
+
 // src/admin/index.ts
 console.log("[Admin Module] Initialized and services exported.");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseMailingService,
+  BookingAdmin,
+  BookingAvailabilityCalculator,
   ClinicAggregationService,
   NOTIFICATIONS_COLLECTION,
   NotificationStatus,