@blackcode_sa/metaestetics-api 1.10.0 → 1.11.0

package/dist/admin/index.d.mts

@@ -708,6 +708,7 @@ interface ClinicLocation {
     latitude: number;
     longitude: number;
     geohash?: string | null;
+    tz?: string | null;
 }
 /**
  * Interface for working hours
@@ -1582,6 +1583,8 @@ interface Appointment {
     clinicBranchId: string;
     /** Aggregated clinic information (snapshot) */
     clinicInfo: ClinicInfo;
+    /** IANA timezone of the clinic */
+    clinic_tz: string;
     /** ID of the practitioner */
     practitionerId: string;
     /** Aggregated practitioner information (snapshot) */
@@ -2923,6 +2926,8 @@ interface BookingAvailabilityRequest {
     clinicCalendarEvents: CalendarEvent[];
     /** Calendar events for the practitioner during the specified timeframe */
     practitionerCalendarEvents: CalendarEvent[];
+    /** IANA timezone of the clinic */
+    tz: string;
 }
 /**
  * Represents a single available booking slot
@@ -2968,6 +2973,7 @@ declare class BookingAvailabilityCalculator {
      * @param intervals - Current available intervals
      * @param workingHours - Clinic working hours
      * @param timeframe - Overall timeframe being considered
+     * @param tz - IANA timezone of the clinic
      * @returns Intervals filtered by clinic working hours
      */
     private static applyClinicWorkingHours;
@@ -2977,6 +2983,7 @@ declare class BookingAvailabilityCalculator {
      * @param workingHours - Working hours definition
      * @param startDate - Start date of the overall timeframe
      * @param endDate - End date of the overall timeframe
+     * @param tz - IANA timezone of the clinic
      * @returns Array of time intervals representing working hours
      */
     private static createWorkingHoursIntervals;
@@ -2995,6 +3002,7 @@ declare class BookingAvailabilityCalculator {
      * @param practitioner - Practitioner object
      * @param clinicId - ID of the clinic
      * @param timeframe - Overall timeframe being considered
+     * @param tz - IANA timezone of the clinic
      * @returns Intervals filtered by practitioner's working hours
      */
     private static applyPractitionerWorkingHours;
@@ -3004,6 +3012,7 @@ declare class BookingAvailabilityCalculator {
      * @param workingHours - Practitioner's working hours definition
      * @param startDate - Start date of the overall timeframe
      * @param endDate - End date of the overall timeframe
+     * @param tz - IANA timezone of the clinic
      * @returns Array of time intervals representing practitioner's working hours
      */
     private static createPractitionerWorkingHoursIntervals;

package/dist/admin/index.d.ts

@@ -708,6 +708,7 @@ interface ClinicLocation {
     latitude: number;
     longitude: number;
     geohash?: string | null;
+    tz?: string | null;
 }
 /**
  * Interface for working hours
@@ -1582,6 +1583,8 @@ interface Appointment {
     clinicBranchId: string;
     /** Aggregated clinic information (snapshot) */
     clinicInfo: ClinicInfo;
+    /** IANA timezone of the clinic */
+    clinic_tz: string;
     /** ID of the practitioner */
     practitionerId: string;
     /** Aggregated practitioner information (snapshot) */
@@ -2923,6 +2926,8 @@ interface BookingAvailabilityRequest {
     clinicCalendarEvents: CalendarEvent[];
     /** Calendar events for the practitioner during the specified timeframe */
     practitionerCalendarEvents: CalendarEvent[];
+    /** IANA timezone of the clinic */
+    tz: string;
 }
 /**
  * Represents a single available booking slot
@@ -2968,6 +2973,7 @@ declare class BookingAvailabilityCalculator {
      * @param intervals - Current available intervals
      * @param workingHours - Clinic working hours
      * @param timeframe - Overall timeframe being considered
+     * @param tz - IANA timezone of the clinic
      * @returns Intervals filtered by clinic working hours
      */
     private static applyClinicWorkingHours;
@@ -2977,6 +2983,7 @@ declare class BookingAvailabilityCalculator {
      * @param workingHours - Working hours definition
      * @param startDate - Start date of the overall timeframe
      * @param endDate - End date of the overall timeframe
+     * @param tz - IANA timezone of the clinic
      * @returns Array of time intervals representing working hours
      */
     private static createWorkingHoursIntervals;
@@ -2995,6 +3002,7 @@ declare class BookingAvailabilityCalculator {
      * @param practitioner - Practitioner object
      * @param clinicId - ID of the clinic
      * @param timeframe - Overall timeframe being considered
+     * @param tz - IANA timezone of the clinic
      * @returns Intervals filtered by practitioner's working hours
      */
     private static applyPractitionerWorkingHours;
@@ -3004,6 +3012,7 @@ declare class BookingAvailabilityCalculator {
      * @param workingHours - Practitioner's working hours definition
      * @param startDate - Start date of the overall timeframe
      * @param endDate - End date of the overall timeframe
+     * @param tz - IANA timezone of the clinic
      * @returns Array of time intervals representing practitioner's working hours
      */
     private static createPractitionerWorkingHoursIntervals;

package/dist/admin/index.js

@@ -6102,6 +6102,7 @@ var ReviewsAggregationService = class {
 
 // src/admin/booking/booking.calculator.ts
 var import_firestore2 = require("firebase/firestore");
+var import_luxon = require("luxon");
 var BookingAvailabilityCalculator = class {
   /**
    * Calculate available booking slots based on the provided data
@@ -6116,7 +6117,8 @@ var BookingAvailabilityCalculator = class {
       procedure,
       timeframe,
       clinicCalendarEvents,
-      practitionerCalendarEvents
+      practitionerCalendarEvents,
+      tz
     } = request;
     const schedulingIntervalMinutes = clinic.schedulingInterval || this.DEFAULT_INTERVAL_MINUTES;
     const procedureDurationMinutes = procedure.duration;
@@ -6129,7 +6131,8 @@ var BookingAvailabilityCalculator = class {
     availableIntervals = this.applyClinicWorkingHours(
       availableIntervals,
       clinic.workingHours,
-      timeframe
+      timeframe,
+      tz
     );
     availableIntervals = this.subtractBlockingEvents(
       availableIntervals,
@@ -6139,7 +6142,8 @@ var BookingAvailabilityCalculator = class {
       availableIntervals,
       practitioner,
       clinic.id,
-      timeframe
+      timeframe,
+      tz
     );
     availableIntervals = this.subtractPractitionerBusyTimes(
       availableIntervals,
@@ -6161,9 +6165,10 @@ var BookingAvailabilityCalculator = class {
    * @param intervals - Current available intervals
    * @param workingHours - Clinic working hours
    * @param timeframe - Overall timeframe being considered
+   * @param tz - IANA timezone of the clinic
    * @returns Intervals filtered by clinic working hours
    */
-  static applyClinicWorkingHours(intervals, workingHours, timeframe) {
+  static applyClinicWorkingHours(intervals, workingHours, timeframe, tz) {
     if (!intervals.length) return [];
     console.log(
       `Applying clinic working hours to ${intervals.length} intervals`
@@ -6171,7 +6176,8 @@ var BookingAvailabilityCalculator = class {
     const workingIntervals = this.createWorkingHoursIntervals(
       workingHours,
       timeframe.start.toDate(),
-      timeframe.end.toDate()
+      timeframe.end.toDate(),
+      tz
     );
     return this.intersectIntervals(intervals, workingIntervals);
   }
@@ -6181,58 +6187,68 @@ var BookingAvailabilityCalculator = class {
    * @param workingHours - Working hours definition
    * @param startDate - Start date of the overall timeframe
    * @param endDate - End date of the overall timeframe
+   * @param tz - IANA timezone of the clinic
    * @returns Array of time intervals representing working hours
    */
-  static createWorkingHoursIntervals(workingHours, startDate, endDate) {
+  static createWorkingHoursIntervals(workingHours, startDate, endDate, tz) {
     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
-      );
+    let start = import_luxon.DateTime.fromJSDate(startDate, { zone: tz });
+    const end = import_luxon.DateTime.fromJSDate(endDate, { zone: tz });
+    while (start <= end) {
+      const dayOfWeek = start.weekday;
+      const dayName = [
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+        "sunday"
+      ][dayOfWeek - 1];
       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;
+          let workStart = start.set({
+            hour: openHours,
+            minute: openMinutes,
+            second: 0,
+            millisecond: 0
+          });
+          let workEnd = start.set({
+            hour: closeHours,
+            minute: closeMinutes,
+            second: 0,
+            millisecond: 0
+          });
+          if (workEnd.toMillis() > startDate.getTime() && workStart.toMillis() < endDate.getTime()) {
+            const intervalStart = workStart < import_luxon.DateTime.fromJSDate(startDate, { zone: tz }) ? import_luxon.DateTime.fromJSDate(startDate, { zone: tz }) : workStart;
+            const intervalEnd = workEnd > import_luxon.DateTime.fromJSDate(endDate, { zone: tz }) ? import_luxon.DateTime.fromJSDate(endDate, { zone: tz }) : workEnd;
             workingIntervals.push({
-              start: import_firestore2.Timestamp.fromDate(intervalStart),
-              end: import_firestore2.Timestamp.fromDate(intervalEnd)
+              start: import_firestore2.Timestamp.fromMillis(intervalStart.toMillis()),
+              end: import_firestore2.Timestamp.fromMillis(intervalEnd.toMillis())
             });
             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);
+                const breakStart = start.set({
+                  hour: breakStartHours,
+                  minute: breakStartMinutes
+                });
+                const breakEnd = start.set({
+                  hour: breakEndHours,
+                  minute: breakEndMinutes
+                });
                 workingIntervals.splice(
                   -1,
                   1,
                   ...this.subtractInterval(
                     workingIntervals[workingIntervals.length - 1],
                     {
-                      start: import_firestore2.Timestamp.fromDate(breakStart),
-                      end: import_firestore2.Timestamp.fromDate(breakEnd)
+                      start: import_firestore2.Timestamp.fromMillis(breakStart.toMillis()),
+                      end: import_firestore2.Timestamp.fromMillis(breakEnd.toMillis())
                     }
                   )
                 );
@@ -6241,7 +6257,7 @@ var BookingAvailabilityCalculator = class {
           }
         }
       }
-      currentDate.setDate(currentDate.getDate() + 1);
+      start = start.plus({ days: 1 });
     }
     return workingIntervals;
   }
@@ -6281,9 +6297,10 @@ var BookingAvailabilityCalculator = class {
    * @param practitioner - Practitioner object
    * @param clinicId - ID of the clinic
    * @param timeframe - Overall timeframe being considered
+   * @param tz - IANA timezone of the clinic
    * @returns Intervals filtered by practitioner's working hours
    */
-  static applyPractitionerWorkingHours(intervals, practitioner, clinicId, timeframe) {
+  static applyPractitionerWorkingHours(intervals, practitioner, clinicId, timeframe, tz) {
     if (!intervals.length) return [];
     console.log(`Applying practitioner working hours for clinic ${clinicId}`);
     const clinicWorkingHours = practitioner.clinicWorkingHours.find(
@@ -6298,7 +6315,8 @@ var BookingAvailabilityCalculator = class {
     const workingIntervals = this.createPractitionerWorkingHoursIntervals(
       clinicWorkingHours.workingHours,
       timeframe.start.toDate(),
-      timeframe.end.toDate()
+      timeframe.end.toDate(),
+      tz
     );
     return this.intersectIntervals(intervals, workingIntervals);
   }
@@ -6308,46 +6326,45 @@ var BookingAvailabilityCalculator = class {
    * @param workingHours - Practitioner's working hours definition
    * @param startDate - Start date of the overall timeframe
    * @param endDate - End date of the overall timeframe
+   * @param tz - IANA timezone of the clinic
    * @returns Array of time intervals representing practitioner's working hours
    */
-  static createPractitionerWorkingHoursIntervals(workingHours, startDate, endDate) {
+  static createPractitionerWorkingHoursIntervals(workingHours, startDate, endDate, tz) {
     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
-      );
+    let start = import_luxon.DateTime.fromJSDate(startDate, { zone: tz });
+    const end = import_luxon.DateTime.fromJSDate(endDate, { zone: tz });
+    while (start <= end) {
+      const dayOfWeek = start.weekday;
+      const dayName = [
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+        "sunday"
+      ][dayOfWeek - 1];
       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;
+          const workStart = start.set({
+            hour: startHours,
+            minute: startMinutes
+          });
+          const workEnd = start.set({ hour: endHours, minute: endMinutes });
+          if (workEnd.toMillis() > startDate.getTime() && workStart.toMillis() < endDate.getTime()) {
+            const intervalStart = workStart < import_luxon.DateTime.fromJSDate(startDate, { zone: tz }) ? import_luxon.DateTime.fromJSDate(startDate, { zone: tz }) : workStart;
+            const intervalEnd = workEnd > import_luxon.DateTime.fromJSDate(endDate, { zone: tz }) ? import_luxon.DateTime.fromJSDate(endDate, { zone: tz }) : workEnd;
             workingIntervals.push({
-              start: import_firestore2.Timestamp.fromDate(intervalStart),
-              end: import_firestore2.Timestamp.fromDate(intervalEnd)
+              start: import_firestore2.Timestamp.fromMillis(intervalStart.toMillis()),
+              end: import_firestore2.Timestamp.fromMillis(intervalEnd.toMillis())
             });
           }
         }
       }
-      currentDate.setDate(currentDate.getDate() + 1);
+      start = start.plus({ days: 1 });
     }
     return workingIntervals;
   }
@@ -6402,22 +6419,22 @@ var BookingAvailabilityCalculator = class {
     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();
+      let slotStart = import_luxon.DateTime.fromJSDate(intervalStart);
+      const minutesIntoDay = slotStart.hour * 60 + slotStart.minute;
       const minutesRemainder = minutesIntoDay % intervalMinutes;
       if (minutesRemainder > 0) {
-        slotStart.setMinutes(
-          slotStart.getMinutes() + (intervalMinutes - minutesRemainder)
-        );
+        slotStart = slotStart.plus({
+          minutes: intervalMinutes - minutesRemainder
+        });
       }
-      while (slotStart.getTime() + durationMs <= intervalEnd.getTime()) {
-        const slotEnd = new Date(slotStart.getTime() + durationMs);
+      while (slotStart.toMillis() + durationMs <= intervalEnd.getTime()) {
+        const slotEnd = slotStart.plus({ minutes: durationMinutes });
         if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals)) {
           slots.push({
-            start: import_firestore2.Timestamp.fromDate(slotStart)
+            start: import_firestore2.Timestamp.fromMillis(slotStart.toMillis())
           });
         }
-        slotStart = new Date(slotStart.getTime() + intervalMs);
+        slotStart = slotStart.plus({ minutes: intervalMinutes });
       }
     }
     console.log(`Generated ${slots.length} available slots`);
@@ -6433,8 +6450,8 @@ var BookingAvailabilityCalculator = class {
    */
   static isSlotFullyAvailable(slotStart, slotEnd, intervals) {
     return intervals.some((interval) => {
-      const intervalStart = interval.start.toDate();
-      const intervalEnd = interval.end.toDate();
+      const intervalStart = import_luxon.DateTime.fromMillis(interval.start.toMillis());
+      const intervalEnd = import_luxon.DateTime.fromMillis(interval.end.toMillis());
       return slotStart >= intervalStart && slotEnd <= intervalEnd;
     });
   }
@@ -6803,7 +6820,8 @@ var BookingAdmin = class {
         clinicCalendarEvents: this.convertEventsTimestamps(clinicCalendarEvents),
         practitionerCalendarEvents: this.convertEventsTimestamps(
           practitionerCalendarEvents
-        )
+        ),
+        tz: clinic.location.tz || "UTC"
       };
       Logger.info("[BookingAdmin] Calling availability calculator", {
         calculatorInputReady: true,
@@ -7184,6 +7202,7 @@ var BookingAdmin = class {
         calendarEventId: practitionerCalendarEventId,
         clinicBranchId: procedure.clinicBranchId,
         clinicInfo,
+        clinic_tz: clinicData.location.tz || "UTC",
         practitionerId: procedure.practitionerId,
         practitionerInfo,
         patientId: data.patientId,